@ngockhoale/ukit 3.4.30 → 3.4.32

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

@@ -7,6 +7,8 @@ import fsSync from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { withAsyncLock, LOCK_MAX_SLICE_MS } from './async-lock.mjs';
+import { cronOperationReceipt } from './cron-operation-adapter.mjs';
+import { operationCompletionPolicy, foldOperationEvidence, compactOperation } from './operation-evidence.mjs';
 
 // Hook-context self-deadline (2.4.1 orphan-leak class): armed ONLY on direct
 // CLI invocation (see isDirectRun below) — never at import time. An import-time
@@ -345,7 +347,11 @@ function explicitPromptKey(routeState = {}) {
   return promptKeyFromText(routeState?.routingContext?.lastExplicitUserPromptText);
 }
 
-function hasUnfinishedCompletion(state = {}, ledger = {}) {
+export function hasUnfinishedCompletion(state = {}, ledger = {}, { cwd } = {}) {
+  if (state?.routeSummary?.executionContract?.taskKind) {
+    const result = evaluateCompletion({ state, ledger, cwd });
+    return result.complete !== true && (result.missingEvidence || []).length > 0 && !ledger.blocker;
+  }
   if (ledger?.blocker) return false;
   const mode = state?.routeSummary?.executionMode || state?.routeSummary?.approachSelector?.executionMode;
   if (!IMPLEMENT_MODES.has(mode)) return false;
@@ -384,7 +390,7 @@ export async function readResumableExecution(projectRoot, payload = {}) {
   if (!state || !ledger || !ledger.sessionId || ledger.sessionId !== sessionId
     || ledger.sessionKey !== safeSegment(sessionId) || !ledger.requestKey
     || !ledger.promptKey || !promptKey || ledger.promptKey !== promptKey
-    || !hasUnfinishedCompletion(state, ledger)) {
+    || !hasUnfinishedCompletion(state, ledger, { cwd: projectRoot })) {
     return null;
   }
   return { state, ledger, sessionId };
@@ -410,9 +416,11 @@ export async function readResumeIntent(projectRoot, payload = {}, { consume = fa
   // resumes; a genuinely different prompt produces a different promptKey and stays dead.
   if (!state || !ledger || ledger.sessionId !== sessionId
     || ledger.sessionKey !== safeSegment(sessionId)
+    || ((state.taskInstanceId || intent.taskInstanceId)
+      && (!state.taskInstanceId || state.taskInstanceId !== intent.taskInstanceId || ledger.taskInstanceId !== intent.taskInstanceId))
     || promptKey !== intent.promptKey
     || ledger.promptKey !== intent.promptKey
-    || !hasUnfinishedCompletion(state, ledger)) {
+    || !hasUnfinishedCompletion(state, ledger, { cwd: projectRoot })) {
     return null;
   }
   if (consume) {
@@ -428,7 +436,7 @@ export async function writeResumeIntent(projectRoot, payload = {}, { now = Date.
   const ledger = await readExecutionLedger(projectRoot, payload);
   const promptKey = explicitPromptKey(state || {});
   if (!state || !ledger || ledger.sessionId !== sessionId || !promptKey
-    || ledger.promptKey !== promptKey || !ledger.requestKey || !hasUnfinishedCompletion(state, ledger)) {
+    || ledger.promptKey !== promptKey || !ledger.requestKey || !hasUnfinishedCompletion(state, ledger, { cwd: projectRoot })) {
     return null;
   }
   const intent = {
@@ -436,6 +444,7 @@ export async function writeResumeIntent(projectRoot, payload = {}, { now = Date.
     sessionKey: safeSegment(sessionId),
     sessionHash: resumeSessionHash(sessionId),
     promptKey,
+    taskInstanceId: state.taskInstanceId || null,
     requestKey: ledger.requestKey,
     routeFingerprint: state.fingerprint || null,
     createdAt: now,
@@ -649,9 +658,9 @@ 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', 'exitStatusUnproven']) {
+  for (const key of ['toolName', 'toolUseId', 'file', 'command', 'exitCode', 'scope', 'error', 'verdict', 'evidence', 'evidenceSurface', 'class', 'status', 'detail', 'operation', 'transportSuccess', 'taskInstanceId', 'sessionKey', 'sequence', 'exitStatusUnproven']) {
     if (receipt[key] !== undefined && receipt[key] !== null && receipt[key] !== '') {
-      compact[key] = receipt[key];
+      compact[key] = key === 'operation' ? compactOperation(receipt[key]) : receipt[key];
     }
   }
   return compact;
@@ -731,6 +740,27 @@ function workspaceFingerprint(cwd) {
   }
 }
 
+// Verification currency excludes UKit's mutable receipts/router state, not source files.
+function verificationDirtyFingerprint(cwd) {
+  try {
+    const paths = ['.', ':(exclude).ukit/storage/**', ':(exclude).claude/ukit/skill-router-state.json'];
+    const options = { cwd, stdio: ['ignore', 'pipe', 'ignore'], timeout: 1500, maxBuffer: 16 * 1024 * 1024 };
+    const diff = execFileSync('git', ['diff', 'HEAD', '--no-ext-diff', '--', ...paths], options);
+    const untracked = execFileSync('git', ['ls-files', '--others', '--exclude-standard', '-z', '--', ...paths], options);
+    const hash = crypto.createHash('sha256').update(diff);
+    let bytes = diff.length + untracked.length;
+    for (const file of untracked.toString('utf8').split('\0').filter(Boolean).sort()) {
+      const absolute = path.resolve(cwd, file);
+      const stat = fsSync.lstatSync(absolute);
+      bytes += stat.size;
+      if (bytes > options.maxBuffer || (!stat.isFile() && !stat.isSymbolicLink())) return null;
+      const content = stat.isSymbolicLink() ? fsSync.readlinkSync(absolute) : fsSync.readFileSync(absolute);
+      hash.update(`\0${file}\0`).update(content);
+    }
+    return hash.digest('hex');
+  } catch { return null; }
+}
+
 // A workspace delta cannot be attributed to the Bash call that happened to observe it: a
 // background process or a subagent may have changed the tree in between. The classifier below
 // only ever REMOVES credit — a command it recognises as strictly read-only never receives a
@@ -794,7 +824,8 @@ function gitPatchId(diffText) {
 // SPEC §2.2 — is this verdict still valid at the current head?
 // Returns { status, current, headSha } where status is one of:
 //   'current' | 'stale' | 'stale-recoverable' | 'untracked' (no git / no sha data).
-// Cost: one `rev-parse` fast path; when head moved, one `git diff` + one `patch-id`.
+// Cost: rev-parse plus a bounded diff/untracked snapshot for new verdicts;
+// when head moved, the existing diff/patch-id comparison also applies.
 export function verdictCurrent(verdict, { cwd = process.cwd() } = {}) {
   if (!verdict || typeof verdict !== 'object') {
     return { status: 'untracked', current: false, headSha: null };
@@ -808,6 +839,9 @@ export function verdictCurrent(verdict, { cwd = process.cwd() } = {}) {
     cwd = verdict.workspaceRoot;
   }
   const currentHead = gitOutput(['rev-parse', 'HEAD'], cwd);
+  if (verdict.headSha && Object.hasOwn(verdict, 'dirtyFp') && (!verdict.dirtyFp || verificationDirtyFingerprint(cwd) !== verdict.dirtyFp)) {
+    return { status: 'stale', current: false, headSha: currentHead };
+  }
   if (!currentHead) {
     // No git repo (or git unavailable): currency cannot be proven either way —
     // null-safe per spec non-goals; do not invent staleness on lanes without git.
@@ -885,6 +919,7 @@ function mintVerificationVerdict(receipt, payload, projectRoot, sessionRoot = pr
     headSha: headSha || null,
     baseSha: baseSha || null,
     patchId,
+    ...(headSha ? { dirtyFp: verificationDirtyFingerprint(cwd) } : {}),
     ts: supplied.ts || new Date().toISOString(),
   };
 }
@@ -1116,11 +1151,15 @@ function progressDigest(ledger = {}) {
 // A genuinely different prompt keeps a clean slate so old work never satisfies a new
 // request's completion gate.
 function carriedEvidenceLedger(fresh, current) {
-  if (!current || !fresh.promptKey || !current.promptKey || current.promptKey !== fresh.promptKey) {
+  if (!current || (fresh.taskInstanceId || current.taskInstanceId
+    ? !fresh.taskInstanceId || fresh.taskInstanceId !== current.taskInstanceId
+    : !fresh.promptKey || !current.promptKey || current.promptKey !== fresh.promptKey)) {
     return fresh;
   }
   return {
     ...fresh,
+    operationBank: current.operationBank || {},
+    receiptSequence: current.receiptSequence || 0,
     sourceSucceeded: fresh.sourceSucceeded || current.sourceSucceeded === true,
     // targeted-verification evidence (2.3.0) must survive the same re-key carry as the
     // coarse flags, or the stricter gates re-demand evidence mid-request — the exact
@@ -1213,6 +1252,7 @@ function freshLedger(payload, routeState, harness) {
     harness,
     requestKey: routeState?.requestKey || null,
     promptKey: evidencePromptKey(routeState),
+    taskInstanceId: routeState?.taskInstanceId || null,
     routeFingerprint: routeState?.fingerprint || null,
     // TASK-009 (BL-011): the routed playbook rides the ledger so the bug-fix
     // completion floor can classify repro receipts at apply time — including
@@ -1238,6 +1278,8 @@ function freshLedger(payload, routeState, harness) {
     verificationSucceeded: false,
     verificationFailed: false,
     receipts: [],
+    receiptSequence: 0,
+    operationBank: {},
     blocker: null,
     verdict: null,
     verdictHistory: [],
@@ -1278,7 +1320,7 @@ const MAX_JOURNAL_SEEN = 64;
 const MAX_JOURNAL_RECORDS = 128;
 const MAX_JOURNAL_QUARANTINE_LINES = 32;
 const LEDGER_EVENT_TYPES = new Set(['receipt', 'continuation', 'notified', 'stop-progress', 'resumable-run']);
-const RECEIPT_KINDS = new Set(['source', 'write', 'verification', 'playbook-finding', 'workspace']);
+const RECEIPT_KINDS = new Set(['source', 'write', 'verification', 'playbook-finding', 'workspace', 'operation']);
 
 function journalPathFor(target) {
   return `${target}.journal`;
@@ -1313,6 +1355,8 @@ async function mergeContinuationSidecar(ledger, target) {
     return ledger;
   }
   if (!sidecar || typeof sidecar !== 'object') return ledger;
+  if (ledger && (ledger.taskInstanceId || sidecar.taskInstanceId)
+    && (!ledger.taskInstanceId || ledger.taskInstanceId !== sidecar.taskInstanceId)) return ledger;
   const sidecarAt = Number(sidecar.lastContinuationAt) || 0;
   if (!ledger) {
     const hasState = sidecarAt > 0
@@ -1321,6 +1365,7 @@ async function mergeContinuationSidecar(ledger, target) {
     if (!hasState) return null;
     return {
       requestKey: sidecar.requestKey ?? null,
+      taskInstanceId: sidecar.taskInstanceId || null,
       promptKey: sidecar.promptKey ?? null,
       continuationRequestKey: sidecar.requestKey ?? null,
       continuationCount: Number(sidecar.continuationCount) || 0,
@@ -1363,7 +1408,9 @@ async function bumpContinuationSidecar(target, event, { signal, deadlineMs } = {
     { signal, deadlineMs: deadlineMs ?? LOCK_MAX_SLICE_MS },
     async () => {
       try {
-        const base = (await mergeContinuationSidecar(await readJson(target, null), target)) || {};
+        const stored = (await mergeContinuationSidecar(await readJson(target, null), target)) || {};
+        const base = event.taskInstanceId && stored.taskInstanceId !== event.taskInstanceId
+          ? { taskInstanceId: event.taskInstanceId } : stored;
         const applied = event.type === 'notified'
           ? { ...base, notified: true, updatedAt: Date.now() }
           : applyContinuationToLedger(base, event);
@@ -1377,6 +1424,7 @@ async function bumpContinuationSidecar(target, event, { signal, deadlineMs } = {
         await writeJsonAtomic(sidecarPath, {
           requestKey: event?.requestKey ?? applied.requestKey ?? applied.continuationRequestKey ?? null,
           promptKey: event?.promptKey ?? applied.promptKey ?? null,
+          taskInstanceId: event?.taskInstanceId || applied.taskInstanceId || null,
           continuationCount: Number(applied.continuationCount) || 0,
           noProgressCount: Number(applied.noProgressCount) || 0,
           lastProgressDigest: applied.lastProgressDigest ?? null,
@@ -1397,7 +1445,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'];
+const JOURNAL_RECEIPT_FIELDS = ['ts', 'kind', 'toolName', 'toolUseId', 'success', 'exitCode', 'file', 'command', 'scope', 'workspaceFp', 'workspaceRoot', 'workspaceHeadTs', 'bashReadOnly', 'exitStatusUnproven', 'detail', 'operation', 'transportSuccess', 'taskInstanceId', 'sessionKey', 'sequence'];
 
 // TASK-009 (BL-011): evidence attestations are whitelisted verbatim — class /
 // surface / result / claim, the ARCH §Evidence Schema fields a receipt may
@@ -1421,7 +1469,7 @@ function sanitizeReceiptForJournal(receipt) {
   const clean = {};
   for (const key of JOURNAL_RECEIPT_FIELDS) {
     if (receipt && receipt[key] !== undefined && receipt[key] !== null && receipt[key] !== '') {
-      clean[key] = receipt[key];
+      clean[key] = key === 'operation' ? compactOperation(receipt[key]) : receipt[key];
     }
   }
   const evidence = sanitizeEvidenceForJournal(receipt && receipt.evidence);
@@ -1459,6 +1507,7 @@ function buildJournalRecord({ event, eventId, payload, routeState }) {
     sessionKey: sessionIdentity(payload),
     sessionId: explicitSessionId(payload),
     requestKey: routeState?.requestKey ?? null,
+    taskInstanceId: routeState?.taskInstanceId || null,
     promptKey: evidencePromptKey(routeState),
     type: event.type,
     event: event.type === 'receipt'
@@ -1555,6 +1604,10 @@ 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) {
+  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 });
   }
@@ -2097,7 +2150,11 @@ function applyReceiptToLedger(ledger, receipt, options = {}) {
 
 function applyReceiptCore(ledger, receipt, { vibecode = false } = {}) {
   if (!receipt || typeof receipt !== 'object' || !RECEIPT_KINDS.has(receipt.kind)) return null;
-  const next = { ...ledger };
+  const next = { ...ledger, receiptSequence: Number(ledger.receiptSequence || 0) + 1 };
+  if (receipt.kind === 'operation') receipt = { ...receipt, sequence: next.receiptSequence };
+  if (receipt.kind === 'operation') {
+    next.operationBank = foldOperationEvidence(ledger.operationBank, receipt, ledger);
+  }
   if (receipt.kind === 'source') {
     next.sourceSucceeded = next.sourceSucceeded || receipt.success;
     if (receipt.success && receipt.file) {
@@ -2329,12 +2386,16 @@ function liveBaseLedger(event, current, payload, routeState, harness, fallbackLe
     // live requestKey the only safe move is to keep appending to the current ledger.
     const nextRequestKey = routeState?.requestKey || null;
     if (current && !nextRequestKey) return { ...current, harness: current.harness || harness };
-    if (!current || current.requestKey !== nextRequestKey) {
+    if (!current || current.requestKey !== nextRequestKey
+      || (current.taskInstanceId || null) !== (routeState?.taskInstanceId || null)) {
       return carriedEvidenceLedger(freshLedger(payload, routeState, harness), current);
     }
     return { ...current, harness: current.harness || harness };
   }
-  return current || fallbackLedger || freshLedger(payload, null, 'unknown');
+  if (current && routeState?.taskInstanceId && current.taskInstanceId !== routeState.taskInstanceId) {
+    return freshLedger(payload, routeState, harness);
+  }
+  return current || (fallbackLedger?.sessionKey ? fallbackLedger : null) || freshLedger(payload, routeState, harness);
 }
 
 // --- TASK-005 (FR-005, BL-007): outcome.observed terminal emissions ---------
@@ -2424,12 +2485,24 @@ export async function recordLedgerEvent(event, {
   const target = ledgerPath(projectRoot, payload);
   // Hoisted so the post-commit outcome emitter sees the same state snapshot
   // the lock callback evaluated (a fresh read could observe a re-route).
-  let lockedRouteState = routeState || null;
+  let lockedRouteState = routeState || await readRouteState(projectRoot, payload);
+  if (event.type === 'receipt' && event.receipt?.kind === 'operation') {
+    if (event.receipt.taskInstanceId && event.receipt.taskInstanceId !== lockedRouteState?.taskInstanceId) {
+      return { rejected: true, eventId, reason: 'receipt-task-mismatch' };
+    }
+    event = { ...event, receipt: { ...event.receipt,
+      taskInstanceId: lockedRouteState?.taskInstanceId || null, sessionKey: sessionIdentity(payload) } };
+  }
   // The descriptor the post-commit emitter must fire (lock-local `value` is
   // nested two levels deep in the lock result — a hoisted ref is clearer).
   let emittedOutcome = null;
   const outcome = await withLedgerLock(target, { signal, deadlineMs }, async () => {
-    const state = routeState || await readRouteState(projectRoot, payload);
+    const liveState = await readRouteState(projectRoot, payload);
+    if (lockedRouteState?.taskInstanceId && liveState?.taskInstanceId
+      && lockedRouteState.taskInstanceId !== liveState.taskInstanceId) {
+      return { committed: false, rejected: true, eventId, reason: 'active-task-changed' };
+    }
+    const state = liveState || lockedRouteState;
     lockedRouteState = state || null;
     const current = await readExecutionLedger(projectRoot, payload);
     let ledger = liveBaseLedger(event, current, payload, state, harness, fallbackLedger);
@@ -2458,7 +2531,13 @@ export async function recordLedgerEvent(event, {
       if (state && routeTaskType && ledger.taskType !== routeTaskType) {
         ledger = { ...ledger, taskType: routeTaskType };
       }
-      const applied = applyReceiptToLedger(ledger, event.receipt, { vibecode: event.vibecode === true });
+      if (event.receipt.taskInstanceId && event.receipt.taskInstanceId !== state?.taskInstanceId) {
+        return { committed: false, rejected: true, eventId, reason: 'receipt-task-mismatch' };
+      }
+      const stampedReceipt = event.receipt.kind === 'operation'
+        ? { ...event.receipt, taskInstanceId: state?.taskInstanceId || null, sessionKey: sessionIdentity(payload) }
+        : event.receipt;
+      const applied = applyReceiptToLedger(ledger, stampedReceipt, { vibecode: event.vibecode === true });
       if (!applied) return { committed: false, eventId, reason: 'invalid-receipt' };
       ledger = applied.ledger;
       // TASK-005 (FR-005): completion receipts (write/verification terminal
@@ -2597,7 +2676,7 @@ export async function recordLedgerEvent(event, {
 
   // Fail-closed: the acquisition budget expired or the wait aborted. The main ledger is
   // NEVER mutated unlocked — journal the event once; the next acquired lock reconciles it.
-  const record = buildJournalRecord({ event, eventId, payload, routeState: routeState || null });
+  const record = buildJournalRecord({ event, eventId, payload, routeState: lockedRouteState || null });
   const journalResult = await appendJournalRecord(target, record, { signal, deadlineMs });
   if (journalResult.ok) return { journaled: true, eventId };
   // F-4: continuation/notified are counter state, not journal rows — a journal-full
@@ -2605,7 +2684,7 @@ export async function recordLedgerEvent(event, {
   // MAX_CONTINUATIONS fires late/never. Land the tick in the sidecar the evaluator
   // merges; only a sidecar write failure is a real rejection.
   if (event.type === 'continuation' || event.type === 'notified') {
-    const sidecar = await bumpContinuationSidecar(target, event);
+    const sidecar = await bumpContinuationSidecar(target, { ...event, taskInstanceId: lockedRouteState?.taskInstanceId || null });
     if (sidecar.ok) return { counted: true, eventId, reason: journalResult.reason };
   }
   return { rejected: true, eventId, reason: journalResult.reason };
@@ -2681,7 +2760,7 @@ export async function recordExecutionReceipt({
 } = {}) {
   if (!projectRoot || !toolName) return { rejected: true, eventId: null };
   const routeState = await readRouteState(projectRoot, payload);
-  const failed = explicitError(payload);
+  const failed = payload.hook_event_name === 'PostToolUseFailure' || explicitError(payload);
   const exitCode = extractExitCode(payload);
   const success = !failed && (exitCode === null || exitCode === 0);
   const toolInput = payload.tool_input || {};
@@ -2699,7 +2778,10 @@ export async function recordExecutionReceipt({
     exitCode,
   };
 
-  if (toolName === 'Read' || toolName === 'Grep' || toolName === 'Glob') {
+  const operationReceipt = cronOperationReceipt(toolName, toolInput, payload.tool_response ?? payload.tool_output ?? payload.tool_result, success, { sessionId: explicitSessionId(payload), harness });
+  if (operationReceipt) {
+    Object.assign(receipt, operationReceipt);
+  } else if (toolName === 'Read' || toolName === 'Grep' || toolName === 'Glob') {
     receipt.kind = 'source';
     receipt.file = toolInput.file_path || toolInput.path || null;
   } else if (toolName === 'Edit' || toolName === 'Write') {
@@ -2818,6 +2900,9 @@ function requiredEvidence(state = {}) {
   const required = Array.isArray(contractEvidence) && contractEvidence.length > 0
     ? [...contractEvidence]
     : [...(routeSummary.completionState?.missingEvidence || [])];
+  const contract = routeSummary.executionContract;
+  const operationOnly = contract?.taskKind === 'OPERATIONAL'
+    || (contract?.taskKind === 'CONFIGURATION' && contract.configurationScope === 'external');
   // FR-006 (M01.4' tail): a route persisted with a high riskEscalation must re-verify at
   // Stop even when its own contract only demands write evidence. The route state is the
   // carrier — no config read here; absent/malformed/non-high fields are a no-op.
@@ -2825,7 +2910,7 @@ function requiredEvidence(state = {}) {
   // verification-evidence; a missing or malformed stage fails closed (enforcing) so
   // pre-C48 persisted records keep re-verifying until re-stamped.
   if (routeSummary.riskEscalation?.level === 'high' && routeSummary.riskEscalation?.stage !== 'shadow') {
-    required.push('verification-evidence');
+    required.push(operationOnly ? 'operation-verification' : 'verification-evidence');
   }
   // TASK-C85-014 (BL-014): a resolved verification-map recipe rides the route
   // summary (stamped by stop-coordinator's recipe consult). Its
@@ -2843,7 +2928,20 @@ function requiredEvidence(state = {}) {
 
 function evidenceSatisfied(evidence, ledger = {}, state = {}, { cwd } = {}) {
   const routeSummary = state?.routeSummary || {};
-  if (evidence === 'write-evidence') return ledger.writeSucceeded === true;
+  if (evidence === 'operation-verification') {
+    return operationCompletionPolicy(scopedContract(state, ledger), null, ledger)?.complete === true;
+  }
+  if (evidence === 'write-evidence') {
+    const expected = routeSummary.expectedSourceFiles || [];
+    if (routeSummary.executionContract?.taskKind && expected.length) {
+      const bank = evidenceBank(ledger, 'bankedWrites');
+      return expected.some((file) => typeof file === 'string' && (
+        bank[evidenceBankKey(file)] === true
+        || (cwd && bank[evidenceBankKey(path.resolve(cwd, file))] === true)
+      ));
+    }
+    return ledger.writeSucceeded === true;
+  }
   if (evidence === 'verification-evidence') {
     // SPEC-typed-verdicts §2.3: when a verdict record exists it governs — only a
     // CURRENT test-verified/live-verified verdict satisfies the gate. A stale or
@@ -3088,7 +3186,19 @@ function phaseRelease(phase, ledger, missingEvidence) {
 // continuation budget — the request already accumulated. A different prompt keeps a clean slate.
 // Shared by the completion contract and the playbook advisory so both judge the same
 // request-scoped ledger (another prompt's evidence never counts).
+function scopedContract(state, ledger) {
+  const contract = state?.routeSummary?.executionContract;
+  if (!contract?.operationGoal) return contract;
+  const session = state?.sessionId || ledger?.sessionId;
+  return { ...contract, operationGoal: { ...contract.operationGoal,
+    scope: contract.operationGoal.scope || (session ? `session:${session}` : null) } };
+}
+
 function effectiveRequestLedger(state = {}, ledger = {}) {
+  if (state?.sessionId && ledger?.sessionId && state.sessionId !== ledger.sessionId) return {};
+  if (state?.taskInstanceId || ledger?.taskInstanceId) {
+    return state?.taskInstanceId && state.taskInstanceId === ledger?.taskInstanceId ? ledger : {};
+  }
   const sameRequest = !ledger?.requestKey || !state?.requestKey
     || ledger.requestKey === state.requestKey
     || (ledger.promptKey && evidencePromptKey(state) === ledger.promptKey);
@@ -3130,7 +3240,13 @@ function evaluateCompletionContract({ state = {}, ledger = {}, cwd, phase = null
     // success — there is nothing to report. The CLI's lost-route path handles the case where
     // THIS session has ledger activity but the state vanished; callers that pass no state
     // (e.g. the omp bridge for a session it does not own) must not be force-notified.
-    return { continue: false, notify: false, missingEvidence: [] };
+    // A prompt that ORDERED a mutation but routed no contract (no skill matched) was never
+    // verified — release, but say so; read-only/informational prompts stay silent.
+    if (state?.routingContext?.mutationOrder === true) {
+      return { continue: false, notify: true, complete: false, gateRelease: 'no-routable-contract', missingEvidence: [],
+        reason: 'UKit completion gate: this request ordered a change but no completion contract was routed, so nothing was verified. Treat the work as unverified; if it is unfinished, re-send the task in a new message.' };
+    }
+    return { continue: false, notify: false, complete: false, gateRelease: 'no-routable-contract', missingEvidence: [] };
   }
   // An informational turn carries no completion contract of its own. Two paths land here:
   // a fully-routed informational prompt (routeSummary.executionMode === 'informational',
@@ -3143,8 +3259,8 @@ function evaluateCompletionContract({ state = {}, ledger = {}, cwd, phase = null
   // evidence the old contract demands. Release silently — the carried routeSummary stays
   // on disk, so the previous contract still survives until a real route replaces it.
   if (
-    mode === 'informational'
-    || state?.routingContext?.executionMode === 'informational'
+    !routeSummary.executionContract?.taskKind && (mode === 'informational'
+    || state?.routingContext?.executionMode === 'informational')
   ) {
     return { continue: false, notify: false, complete: true, missingEvidence: [] };
   }
@@ -3163,7 +3279,11 @@ function evaluateCompletionContract({ state = {}, ledger = {}, cwd, phase = null
   // every Edit/Write, so a requestKey mismatch alone must not discard the evidence — and the
   // continuation budget — the request already accumulated. A different prompt keeps a clean slate.
   const effectiveLedger = effectiveRequestLedger(state, ledger);
+  const operationStatus = operationCompletionPolicy(scopedContract(state, effectiveLedger),
+    null, effectiveLedger);
+  const operationalTask = operationStatus !== null;
   const missingEvidence = evidence.filter((item) => !evidenceSatisfied(item, effectiveLedger, state, { cwd }));
+  if (operationalTask && !operationStatus.complete && !missingEvidence.includes('operation-verification')) missingEvidence.push('operation-verification');
   // TASK-009 (BL-011): the bug-fix floor. On a `playbookId: bug-fix` route a
   // green verdict requires verbatim repro-before (fail) + repro-after (pass)
   // receipts on the same surface plus a named root cause in the exec-ledger —
@@ -3207,10 +3327,11 @@ function evaluateCompletionContract({ state = {}, ledger = {}, cwd, phase = null
     // Silent success: the route is present and every required evidence is satisfied. Marked
     // `complete` so the CLI dispatch recognizes it BEFORE the loud final else — otherwise a
     // bare loud else would turn a clean stop into user-visible noise.
-    return { continue: false, notify: false, complete: true, missingEvidence: [], ...writeEvidenceTier(effectiveLedger) };
+    return { continue: false, notify: false, complete: true, missingEvidence: [], ...(operationalTask ? { gateRelease: 'native-operation-verified', operationProof: operationStatus.operationProof } : writeEvidenceTier(effectiveLedger)) };
   }
 
-  const released = phaseRelease(phase, effectiveLedger, missingEvidence);
+  const released = routeSummary.executionContract?.taskKind
+    ? null : phaseRelease(phase, effectiveLedger, missingEvidence);
   if (released) return released;
 
   // `find-cause` can validly end clean: an investigation may establish that no actionable
@@ -3233,6 +3354,7 @@ function evaluateCompletionContract({ state = {}, ledger = {}, cwd, phase = null
       || routeSummary.executionContract.completionRule === 'never-claim-fixed-without-write-and-verification');
   if (
     findCauseNoMutationContract
+    && !routeSummary.executionContract?.taskKind
     && playbookId !== BUGFIX_PLAYBOOK_ID
     && !effectiveLedger.writeAttempted
     && !effectiveLedger.verificationFailed
@@ -3255,7 +3377,8 @@ function evaluateCompletionContract({ state = {}, ledger = {}, cwd, phase = null
   // satisfied), no mutation was attempted, and no verification failed; anything less has
   // concrete unfinished work and keeps recovering.
   if (
-    mode === 'map-impact'
+    !routeSummary.executionContract?.taskKind
+    && mode === 'map-impact'
     && !missingEvidence.includes('impact-evidence')
     && effectiveLedger.writeAttempted !== true
     && effectiveLedger.verificationFailed !== true
@@ -3282,7 +3405,8 @@ function evaluateCompletionContract({ state = {}, ledger = {}, cwd, phase = null
   const readOnlyPrompt = state?.routingContext?.mutationOrder === false
     || state?.routingContext?.planOnly === true;
   if (
-    readOnlyPrompt
+    !routeSummary.executionContract?.taskKind
+    && readOnlyPrompt
     && !effectiveLedger.writeAttempted
     && missingEvidence.some((item) => item === 'write-evidence' || item === 'verification-evidence')
   ) {
@@ -3295,7 +3419,7 @@ function evaluateCompletionContract({ state = {}, ledger = {}, cwd, phase = null
     };
   }
 
-  const gated = IMPLEMENT_MODES.has(mode);
+  const gated = Boolean(routeSummary.executionContract?.taskKind) || IMPLEMENT_MODES.has(mode);
   if (!gated) {
     // Advisory, not a gate message: nothing was written, so verification was never owed.
     const noWriteAdvisory = !effectiveLedger.writeAttempted && missingEvidence.every((item) => item === 'verification-evidence');
@@ -3375,7 +3499,9 @@ function evaluateCompletionContract({ state = {}, ledger = {}, cwd, phase = null
   }
 
   const finalAttempt = !vibecode && continuationCount === MAX_CONTINUATIONS - 1;
-  const instruction = recoveryInstruction(missingEvidence, effectiveLedger, routeSummary, { cwd });
+  const instruction = operationalTask
+    ? 'Inspect native mutation receipts and verify the requested operational state; do not fabricate source edits or source-test evidence.'
+    : recoveryInstruction(missingEvidence, effectiveLedger, routeSummary, { cwd });
   return {
     continue: true,
     missingEvidence,
@@ -3646,6 +3772,7 @@ async function runEvaluateStop() {
     }
     return; // silent success: route present, all evidence satisfied
   }
+  if (result.gateRelease === 'no-routable-contract') return; // Advisory release, never VERIFIED.
   // Defensive final else: no evaluation result may ever end a routed stop silently.
   const fallback = `UKit completion gate: the stop was evaluated without a decision (missing evidence: ${(result.missingEvidence || []).join(', ') || 'none'}). If work is unfinished, re-send the task in a new message.`;
   process.stderr.write(`[ukit-completion] ${fallback}\n`);

package/template_project/.claude/ukit/runtime/loop-state.mjs

@@ -124,7 +124,7 @@ export async function applyLoopBreak({ merged, projectRoot, runRoot, payload, se
   const note = [
     `[ukit-loop-breaker] BLOCKED/ESCALATED: ${merged.policyOwner} refused this stop ${res.attemptCount - 1} consecutive times with no change in the work state (~${minutes} min, mode ${mode || 'UNKNOWN'}).`,
     `Unresolved blocker: ${String(merged.reason || '').split('\n', 1)[0].slice(0, 200)}`,
-    'Stop released. This is NOT approval: nothing was verified and no safety/permission denial is lifted.',
+    'Stop released. This is NOT approval: completion evidence was not accepted by the blocking policy; this does not mean no verification ran; no safety/permission denial is lifted.',
     'Report it verbatim; do not retry, wake up, or resume any handoff.',
   ].join('\n');
   return { ...merged, decision: null, reason: undefined, loopBreak: true, policyOwner: 'loop-breaker', systemMessage: merged.systemMessage ? `${note}\n${merged.systemMessage}` : note };

package/template_project/.claude/ukit/runtime/operation-evidence.mjs

@@ -0,0 +1,87 @@
+// Adapter-normalized proof only; neither native output nor agent prose is evidence here.
+const MAX_OPERATIONS = 16;
+export function compactOperation(operation) {
+  if (!operation || typeof operation !== 'object' || Array.isArray(operation)) return { invalid: true };
+  const bounded = (value) => typeof value === 'string' && value.length > 0 && value.length <= 256;
+  if (!bounded(operation.domain) || !bounded(operation.scope)
+    || !['mutation', 'state'].includes(operation.role)
+    || (operation.target !== null && !bounded(operation.target))
+    || (operation.state !== undefined && !bounded(operation.state))
+    || (operation.presentTargets != null && (!Array.isArray(operation.presentTargets)
+      || operation.presentTargets.length > 256 || !operation.presentTargets.every(bounded)))) return { invalid: true };
+  return { domain: operation.domain, scope: operation.scope, role: operation.role, target: operation.target,
+    ...(operation.state !== undefined ? { state: operation.state } : {}),
+    ...(operation.presentTargets !== undefined ? { presentTargets: operation.presentTargets === null ? null : [...operation.presentTargets] } : {}),
+    complete: operation.complete === true };
+}
+export function foldOperationEvidence(bank = {}, receipt, ledger) {
+  const raw = receipt?.operation;
+  if (raw?.invalid === true) return { ...bank, overflow: true };
+  const op = raw?.presentTargets === null && receipt.success !== true
+    ? { ...raw, presentTargets: undefined } : raw;
+  if (!op || !ledger.taskInstanceId || receipt.taskInstanceId !== ledger.taskInstanceId
+    || receipt.sessionKey !== ledger.sessionKey || typeof op.domain !== 'string'
+    || typeof op.scope !== 'string' || !['mutation', 'state'].includes(op.role)) return bank;
+  const bounded = (value) => typeof value === 'string' && value.length > 0 && value.length <= 256;
+  if (!bounded(op.domain) || !bounded(op.scope)
+    || (op.target !== null && !bounded(op.target))
+    || (op.state !== undefined && !bounded(op.state))
+    || (op.presentTargets !== undefined && (!Array.isArray(op.presentTargets)
+      || op.presentTargets.length > 256 || !op.presentTargets.every(bounded)))) {
+    return { ...bank, overflow: true };
+  }
+  const key = JSON.stringify([op.domain, op.scope, op.role === 'state' ? null : op.target]);
+  if (!Object.hasOwn(bank, key) && Object.keys(bank).filter((entry) => !['overflow', 'seenToolUseIds'].includes(entry)).length >= MAX_OPERATIONS) {
+    return { ...bank, overflow: true }; // Never evict a known failure to make room for success.
+  }
+  const prior = bank[key] || {};
+  const seen = Array.isArray(bank.seenToolUseIds) ? bank.seenToolUseIds : [];
+  if (receipt.toolUseId && (seen.includes(receipt.toolUseId) || Object.values(bank).some((entry) =>
+    [entry?.mutation, entry?.state].some((proof) => proof?.toolUseId === receipt.toolUseId)))) return bank;
+  if (receipt.toolUseId && (!bounded(receipt.toolUseId) || seen.length >= 256)) return { ...bank, overflow: true };
+  const proof = { success: receipt.success === true, sequence: receipt.sequence,
+    toolUseId: receipt.toolUseId, taskInstanceId: receipt.taskInstanceId,
+    sessionKey: receipt.sessionKey, operation: {
+      domain: op.domain, scope: op.scope, role: op.role, target: op.target,
+      ...(op.state !== undefined ? { state: op.state } : {}),
+      ...(op.presentTargets !== undefined ? { presentTargets: [...op.presentTargets] } : {}),
+      complete: op.complete === true,
+    } };
+  return { ...bank, seenToolUseIds: receipt.toolUseId ? [...seen, receipt.toolUseId] : seen,
+    [key]: { ...prior, [op.role]: proof } };
+}
+
+export function operationEvidenceStatus(goal, ledger = {}) {
+  if (!goal || typeof goal.domain !== 'string' || !goal.domain || typeof goal.desiredState !== 'string'
+    || !goal.desiredState || (goal.target !== null && (typeof goal.target !== 'string' || !goal.target))
+    || !['ensure-state', 'execute-and-verify'].includes(goal.completionSemantics)) return null;
+  const incomplete = { complete: false, operationProof: null };
+  if (!ledger.taskInstanceId || !ledger.sessionKey || !goal.scope || ledger.operationBank?.overflow) return incomplete;
+  const entries = Object.values(ledger.operationBank || {});
+  const matches = (r) => r?.taskInstanceId === ledger.taskInstanceId && r.sessionKey === ledger.sessionKey
+    && r.operation?.domain === goal.domain && r.operation.scope === goal.scope;
+  const attempts = entries.map((e) => e.mutation).filter(matches);
+  const attempt = attempts.filter((r) => r.operation.target === goal.target).sort((a, b) => b.sequence - a.sequence)[0];
+  const observation = entries.map((e) => e.state).filter(matches).sort((a, b) => b.sequence - a.sequence)[0];
+  const op = observation?.operation;
+  const absent = goal.desiredState === 'absent' && Array.isArray(op?.presentTargets)
+    && op.presentTargets.every((id) => typeof id === 'string')
+    && (goal.target === null ? op.presentTargets.length === 0 : !op.presentTargets.includes(goal.target));
+  const stateMatches = op?.state === goal.desiredState
+    && (absent || (!Object.hasOwn(op || {}, 'presentTargets') && op?.target === goal.target));
+  if (!observation?.success || !observation.toolUseId || !Number.isSafeInteger(observation.sequence)
+    || op.complete !== true || !stateMatches) return incomplete;
+  if (goal.completionSemantics === 'ensure-state' && attempts.length === 0) {
+    return { complete: true, operationProof: 'desired-state-only' };
+  }
+  if (!attempt?.success || !attempt.toolUseId || !observation.toolUseId
+    || !(observation.sequence > attempt.sequence)) return incomplete;
+  return { complete: true, operationProof: 'executed-and-verified' };
+}
+
+export function operationCompletionPolicy(contract, _adapterGoal, ledger) {
+  const kind = String(contract?.taskKind || '').toUpperCase();
+  if (!['OPERATIONAL', 'MIXED', 'CONFIGURATION'].includes(kind)
+    || (kind === 'CONFIGURATION' && contract.configurationScope !== 'external')) return null;
+  return operationEvidenceStatus(contract.operationGoal, ledger) || { complete: false, operationProof: null };
+}