@ngockhoale/ukit 3.4.29 → 3.4.31

package/template_project/.claude/ukit/runtime/handoff-intent.mjs

@@ -28,7 +28,9 @@
 //        could not complete (missing/unreadable path, budget overrun) — callers keep
 //        their fail-closed posture on `known=false`.
 //
-// Intent values stay the historical pair 'create' | 'fullstack': an exact
+// Intent values: 'create' | 'fullstack' | 'review' | 'neutral' (status/clear); every
+// consumer compares by equality with 'create' / 'fullstack', so the added values are
+// non-matching by construction. An exact
 // `handoff-implement` invocation CLAIMS the run (the fullstack command says so
 // itself), so it maps onto the existing 'fullstack' intent instead of adding a
 // new enum every consumer would have to learn (TASK-C97-004).
@@ -48,7 +50,7 @@ export const HANDOFF_RESUME_BANNER = 'UKIT HANDOFF RESUME — an unfinished hand
 
 // Sweeper for "which command tag came LAST in this entry": finds every exact
 // command-name tag occurrence with its position so the newest one wins.
-const COMMAND_TAG_SWEEP = /<command-name>\/?(?:ukit:)?handoff-(create|fullstack|implement)(?![\w-])/g;
+const COMMAND_TAG_SWEEP = /<command-name>\/?(?:ukit:)?handoff-(create|fullstack|implement|review|status|clear)(?![\w-])/g;
 
 // omp and Codex do NOT wrap a slash command in `<command-name>` tags the way
 // Claude Code's user turn does. Their native evidence is the command *expansion*:
@@ -58,7 +60,7 @@ const COMMAND_TAG_SWEEP = /<command-name>\/?(?:ukit:)?handoff-(create|fullstack|
 // the FIRST line only (not any heading in the body) keeps prose references to the
 // command inside the document from being mistaken for an invocation. The same
 // exact token boundary applies: `-custom` suffixed headings are not commands.
-const NATIVE_COMMAND_HEADING = /^\s{0,3}#{1,3}\s+\/?(?:ukit:)?(handoff-create|handoff-fullstack|handoff-implement)(?![\w-])/;
+const NATIVE_COMMAND_HEADING = /^\s{0,3}#{1,3}\s+\/?(?:ukit:)?(handoff-create|handoff-fullstack|handoff-implement|handoff-review|handoff-status|handoff-clear)(?![\w-])/;
 
 // The unique customType the omp bridge stamps on host-injected UKit hook context
 // (`sendContext` → `hookContextMessage`). A resume banner only counts as intent
@@ -89,6 +91,10 @@ function commandTokenIntent(token) {
   const t = String(token).toLowerCase().replace(/^handoff-/, '');
   if (t === 'create') return 'create';
   if (t === 'fullstack' || t === 'implement') return 'fullstack';
+  // review is its own phase (scoped fix + re-review); status/clear are neutral. They
+  // must SUPERSEDE an older create, otherwise the create-scope guard leaks forward.
+  if (t === 'review') return 'review';
+  if (t === 'status' || t === 'clear') return 'neutral';
   return null;
 }
 
@@ -182,14 +188,14 @@ function classifyAssistantBlocks(blocks) {
     if (!b || typeof b !== 'object') continue;
     if (b.type === 'tool_use' && b.name === 'Skill') {
       const skill = String(b.input?.skill ?? '');
-      const m = /^(?:ukit:)?handoff-(create|fullstack|implement)$/.exec(skill);
+      const m = /^(?:ukit:)?handoff-(create|fullstack|implement|review|status|clear)$/.exec(skill);
       if (m) latest = commandTokenIntent(m[1]);
       continue;
     }
     if (b.type === 'toolCall') {
       const name = String(b.name ?? '');
       const skill = String(b.arguments?.skill ?? '');
-      const m = /^(?:ukit:)?handoff-(create|fullstack|implement)$/i.exec(name) || /^(?:ukit:)?handoff-(create|fullstack|implement)$/.exec(skill);
+      const m = /^(?:ukit:)?handoff-(create|fullstack|implement|review|status|clear)$/i.exec(name) || /^(?:ukit:)?handoff-(create|fullstack|implement|review|status|clear)$/.exec(skill);
       if (m) latest = commandTokenIntent(m[1]);
     }
   }
@@ -307,7 +313,7 @@ export async function transcriptHandoffIntent(transcriptPath, {
       // Cheap prefilter — skip JSON.parse for lines that cannot be evidence.
       // `handoff-implement` is included: an implement invocation after a create
       // must be seen as the NEWEST intent, not lost to the older create line.
-      if (!line.includes('handoff-create') && !line.includes('handoff-fullstack') && !line.includes('handoff-implement') && !line.includes('HANDOFF RESUME')) {
+      if (!line.includes('handoff-create') && !line.includes('handoff-fullstack') && !line.includes('handoff-implement') && !line.includes('handoff-review') && !line.includes('handoff-status') && !line.includes('handoff-clear') && !line.includes('HANDOFF RESUME')) {
         continue;
       }
       // This is the NEWEST line carrying intent evidence. A host append can be
@@ -410,3 +416,113 @@ export function runCursorPaused(text) {
   if (/^paused\b/i.test(field('Phase'))) return true;
   return /\bPAUSED\b/.test(field('Cursor')) || /\bPAUSED\b/.test(field('Next'));
 }
+
+// ─── Run-all intent (goal-level loop phrase) ──────────────────────────────
+// A run-all instruction ("run all remaining tasks", "finish everything",
+// "chạy hết các task còn lại") binds the GOAL, not one cycle: the executor
+// keeps cycling until no in-scope task remains. This is TEXT evidence for the
+// goal loop ONLY — it never feeds classifyHandoffEntry, whose structured-only
+// rule (TASK-007) keeps raw phrases from minting command ownership, so
+// "handoff-create + run-all" stays planning. Every alternative below demands a
+// totality quantifier (all/every/everything/hết/toàn bộ/…) next to the task
+// word, so a single-task prompt ("run task 3", "TASK-003") never matches.
+export const RUN_ALL_RE = new RegExp(
+  [
+    // EN verb … all/every … tasks ("run all remaining tasks", "execute every open task").
+    String.raw`\b(?:run|execute|do|process|implement|finish|complete|handle|work\s+through)\b[^.\n]{0,40}?\b(?:all|every)\b[^.\n]{0,40}?\btasks?\b`,
+    // EN bare quantifier over tasks ("all remaining tasks", "every queued task", "all of the tasks").
+    String.raw`\b(?:all|every)\s+(?:the\s+)?(?:(?:remaining|pending|open|unfinished|authorized|queued|outstanding|in-scope)\s+)?tasks?\b|\b(?:all|every)\b[^.\n]{0,20}?\bof\s+the\b[^.\n]{0,20}?\btasks?\b`,
+    // EN totality idioms ("run all", "finish everything", "complete the whole goal",
+    // "continue until no tasks remain", "until all tasks are done").
+    String.raw`\brun\s+(?:all|everything)\b(?!\s+(?:of\s+)?(?:the\s+)?(?:(?:unit|e2e|integration|smoke)\s+)?(?:tests?|specs?|checks?|lint|builds?|suites?|migrations?)\b)|\b(?:finish|complete|do)\s+(?:everything|all\s+of\s+it|the\s+(?:whole|entire)\s+(?:goal|backlog|list|plan))\b|\b(?:continue|keep\s+going|work)\s+until\s+(?:all\s+tasks?\s+(?:are\s+)?done|no\s+tasks?\s+(?:remain|are\s+left))\b|\buntil\s+(?:all\s+)?tasks?\s+(?:are\s+)?(?:done|complete[d]?|finished)\b|\bcontinue\s+until\s+nothing\s+(?:is\s+)?left\b`,
+    // VN (diacritic + ascii fallbacks): chạy hết / chạy tất cả task / làm hết các task còn lại /
+    // hoàn thành toàn bộ / cho đến khi không còn task.
+    String.raw`ch(?:ạy|ay)\s+h(?:ế|e)t|ch(?:ạy|ay)\s+t(?:ấ|a)t\s+c(?:ả|a)|l(?:à|a)m\s+h(?:ế|e)t|ho(?:à|a)n\s+th(?:à|a)nh\s+(?:to(?:à|a)n\s+b(?:ộ|o)|h(?:ế|e)t)|t(?:ấ|a)t\s+c(?:ả|a)\s+(?:c(?:á|a)c\s+)?tasks?|to(?:à|a)n\s+b(?:ộ|o)\s+(?:c(?:á|a)c\s+)?tasks?|cho\s+đ(?:ế|e)n\s+khi\s+kh(?:ô|o)ng\s+c(?:ò|o)n\s+tasks?`,
+  ].join('|'),
+  'iu',
+);
+
+/**
+ * Goal-level loop phrase detector. Pure text matching — deliberately separate
+ * from the structured intent classification above.
+ * @returns {boolean}
+ */
+export function isRunAllRequest(text) {
+  const t = String(text ?? '');
+  if (!t.trim()) return false;
+  // Read/list requests and plan-only / negated asks never authorize a backlog run.
+  if (RUN_ALL_READ_RE.test(t) || RUN_ALL_VETO_RE.test(t)) return false;
+  if (SINGLE_TASK_REF_RE.test(t)) return false;
+  return RUN_ALL_RE.test(t);
+}
+
+const RUN_ALL_READ_RE = /^\s*(?:please\s+)?(?:show|list|view|display|print|count|xem|liệt\s+kê|hiển\s+thị)\b/iu;
+const RUN_ALL_VETO_RE = new RegExp(
+  [
+    String.raw`\b(?:do\s+not|don'?t|dont|never|no\s+need\s+to|without|not)\b[^.\n]{0,30}?\b(?:run|execute|do|process|implement|finish|complete|handle)\b`,
+    String.raw`\b(?:plan|planning)[\s-]+only\b|\bonly\s+(?:create|write|make|draft)\s+(?:a\s+|the\s+)?plan`,
+    String.raw`(?:kh(?:ô|o)ng|đ(?:ừ|u)ng|dung|ch(?:ư|u)a)\s+(?:được\s+|duoc\s+|cần\s+|can\s+)?(?:ch(?:ạ|a)y|l(?:à|a)m|th(?:ự|u)c\s+hi(?:ệ|e)n|implement)`,
+    String.raw`ch(?:ỉ|i)\s+(?:t(?:ạ|a)o|vi(?:ế|e)t|l(?:ậ|a)p)\s+(?:plan|k(?:ế|e)\s+ho(?:ạ|a)ch)`,
+  ].join('|'),
+  'iu',
+);
+const SINGLE_TASK_REF_RE = /\b(?:task|việc|viec)[\s_-]*#?\d+\b|\bTASK-\d+\b/i;
+
+/**
+ * Shared phase lookup for BOTH Stop paths (Claude `execution-ledger --evaluate-stop` and the
+ * omp bridge's in-process `runSessionStop`). Returns the current intent only when the scan
+ * is conclusive and it is one of create/review/neutral — the phases that change what the
+ * completion gate may demand. fullstack/implement, unknown and unreadable all return null,
+ * which keeps the normal (strict) gate: a lost read never relaxes enforcement.
+ */
+export async function resolveStopPhase(transcriptPath, opts = {}) {
+  try {
+    const { intent, known } = await transcriptHandoffIntent(transcriptPath, opts);
+    if (!known) return null;
+    return intent === 'create' || intent === 'review' || intent === 'neutral' ? intent : null;
+  } catch {
+    return null;
+  }
+}
+
+// Subagent inheritance. A delegated omp session is its own transcript (own session id, no command
+// tag) whose first record is `{type:"session", parentSession:<parent transcript path>}`; the
+// parent's command authority must follow the delegation. Walks at most `maxDepth` parents, each
+// scan bounded by the normal budget; a missing/unreadable link is `known:false` (never relaxed).
+export async function transcriptHandoffIntentInherited(transcriptPath, { maxDepth = 3, ...opts } = {}) {
+  let current = transcriptPath;
+  for (let depth = 0; depth <= maxDepth; depth += 1) {
+    const scan = await transcriptHandoffIntent(current, opts);
+    // A parent link that cannot be read is reported (never relaxed): the caller fails closed
+    // against the parent's session marker instead of treating the child as unrestricted.
+    if (!scan.known) return depth > 0 ? { ...scan, unresolvedParent: current } : scan;
+    if (scan.intent) return scan;
+    const parent = await readParentSession(current);
+    if (!parent) return scan;
+    current = parent;
+  }
+  return { intent: null, known: false, unresolvedParent: current };
+}
+
+async function readParentSession(transcriptPath) {
+  let handle;
+  try {
+    handle = await fs.open(transcriptPath, 'r');
+    const buf = Buffer.allocUnsafe(8192);
+    const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+    for (const line of buf.toString('utf8', 0, bytesRead).split('\n').slice(0, 4)) {
+      if (!line.includes('"parentSession"')) continue;
+      try {
+        const rec = JSON.parse(line);
+        if (rec?.type === 'session' && typeof rec.parentSession === 'string' && rec.parentSession.trim()) {
+          return rec.parentSession;
+        }
+      } catch { /* header larger than the probe window: treat as no link */ }
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}

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 };
+}