@ngockhoale/ukit 2.3.9 → 2.3.11

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

@@ -121,6 +121,23 @@ const { pathToFileURL } = require('url');
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
   }
 
+  function writeJsonFileAtomic(filePath, text) {
+    // tmp+rename: readers see old-or-new, never a torn/half file. A truncated
+    // skill-router-state.json parses as `{}` downstream and completion-gate.sh then
+    // releases a premature Stop with no message — the mid-run silent-stop class.
+    ensureDir(filePath);
+    const tempPath = `${filePath}.tmp-${process.pid}-${crypto.randomBytes(6).toString('hex')}`;
+    try {
+      fs.writeFileSync(tempPath, text);
+      fs.renameSync(tempPath, filePath);
+    } catch (error) {
+      try {
+        fs.rmSync(tempPath, { force: true });
+      } catch {}
+      throw error;
+    }
+  }
+
   function defaultRuntimeConfig() {
     return {
       memory: {
@@ -544,7 +561,7 @@ const { pathToFileURL } = require('url');
     routingContext = {},
     previousContextFingerprint = null,
   }) {
-    return buildCompactMachineKey('route-v2', {
+    return buildCompactMachineKey('route-v3', {
       commandNamespace,
       indexGeneratedAtMs,
       projectFingerprint,
@@ -1577,8 +1594,10 @@ const { pathToFileURL } = require('url');
     intentMode = null,
     executionScores = {},
     executionCandidates = null,
+    signalText = '',
   } = {}) {
     const raw = `${promptText || ''}\n${commandText || ''}`.toLowerCase();
+    const signalRaw = `${raw}\n${String(signalText || '').toLowerCase()}`;
     const scores = executionScores;
     const candidates = executionCandidates ?? buildExecutionModeCandidates({
       promptText,
@@ -1591,15 +1610,45 @@ const { pathToFileURL } = require('url');
     const strongImpactLead = scores.sharedRisk
       && (scores.impactSignal || /\b(check all affected|map all affected|across all affected)\b/.test(raw));
     const boundedLocalBuildCandidate = scores.buildSignal && scores.boundedEditSignal && scores.explicitTarget && !scores.sharedRisk;
+    const releaseVerificationContinuation = /\b(?:pending\s+diff[- ]review|self-install|verify\s+(?:consistency|release)|release\s+(?:verification|readiness))\b/.test(raw)
+      && /\b(?:release|tag|publish|push|report)\b/.test(raw);
+    // A bare delivery command ("push this to git", "đẩy bộ này lên git") performs no
+    // repository mutation the ledger could ever receipt. With no edit/review/debug/
+    // build signal present, routing it to an investigation lane fabricates write debt
+    // and the completion gate then demands an edit that cannot exist. Delivery-only
+    // requests carry no completion contract instead.
+    const deliveryWordSignal = /\bgit\s+push\b/.test(signalRaw)
+      || /\bpush\b[^\n]{0,60}\b(?:git|github|gitlab|remote|origin|repo)\b/.test(signalRaw)
+      || /\b(?:git|github|gitlab|remote|origin|repo)\b[^\n]{0,60}\bpush\b/.test(signalRaw)
+      || /\bday\b(?:\s+\S+){0,3}?\s+len\b/.test(signalRaw);
+    const deliveryOnlySignal = deliveryWordSignal
+      && scores.editCertainty === 0
+      && !scores.implementSignal
+      && !scores.reviewSignal
+      && !scores.debugSignal
+      && !scores.failureSignal
+      && !scores.impactSignal
+      && !scores.buildSignal
+      && !scores.directTransformSignal
+      && !scores.smallFixSignal
+      && !scores.sharedRisk
+      && !targetFile;
 
     if (isInformationalPrompt({ promptText, commandText, scores })) {
       return 'informational';
     }
 
-    if ((intentMode === 'review-specific' || explicitReviewLead) && !scores.implementSignal) {
+    if (
+      releaseVerificationContinuation
+      || ((intentMode === 'review-specific' || explicitReviewLead) && !scores.implementSignal)
+    ) {
       return 'review-release';
     }
 
+    if (deliveryOnlySignal) {
+      return 'informational';
+    }
+
     if (strongImpactLead || (scores.blastRadius >= 3 && (scores.ambiguity >= 2 || scores.investigationNeed >= 2))) {
       return 'map-impact';
     }
@@ -1699,7 +1748,7 @@ const { pathToFileURL } = require('url');
       ),
       'map-impact': (
         (scores.sharedRisk ? 7 : 0)
-        + (scores.impactSignal ? 5 : 0)
+        + (scores.impactSignal ? 5 : -5)
         + (scores.ambiguity * 2)
         + scores.investigationNeed
       ),
@@ -2254,45 +2303,124 @@ const { pathToFileURL } = require('url');
     };
   }
 
-  function appendRouteAuditEntry(filePath, entry) {
-    if (!entry || typeof entry !== 'object') {
-      return;
+  // Owner-token lock protocol, protocol-compatible with runtime token-utils withFileLock
+  // and the advisory permission hooks (mkdir-based `<file>.lock` + owner liveness).
+  // route-audit.json is a read-modify-write merge: without the lock, 16 concurrent
+  // router invocations were verified to keep only 13/16 entries (lost updates).
+  function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error?.code === 'EPERM';
     }
+  }
 
-    let parsed = { entries: [] };
-    if (fs.existsSync(filePath)) {
+  function readLockOwner(lockPath) {
+    const owner = readJson(path.join(lockPath, 'owner'), null);
+    return owner && Number.isInteger(owner.pid) && typeof owner.token === 'string'
+      ? owner
+      : null;
+  }
+
+  async function withStateLock(lockPath, fn) {
+    // Advisory bookkeeping: liveness over strictness — if the lock cannot be acquired
+    // within maxWaitMs the merge runs unlocked (pre-lock behaviour) rather than hanging
+    // or dropping the entry.
+    const staleMs = 10000;
+    const maxWaitMs = 5000;
+    const startedAt = Date.now();
+    const ownerToken = `${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
+    let held = false;
+    while (!held) {
       try {
-        parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-      } catch {
-        parsed = { entries: [] };
+        fs.mkdirSync(lockPath);
+        try {
+          fs.writeFileSync(path.join(lockPath, 'owner'), JSON.stringify({
+            pid: process.pid,
+            token: ownerToken,
+            ts: Date.now(),
+          }));
+        } catch (error) {
+          try {
+            fs.rmSync(lockPath, { recursive: true, force: true });
+          } catch {}
+          throw error;
+        }
+        held = true;
+      } catch (error) {
+        if (!error || error.code !== 'EEXIST') return fn();
+        try {
+          const stat = fs.statSync(lockPath);
+          if (Date.now() - stat.mtimeMs > staleMs) {
+            const owner = readLockOwner(lockPath);
+            if (!owner || !isPidAlive(owner.pid)) {
+              try {
+                fs.rmSync(lockPath, { recursive: true, force: true });
+                continue;
+              } catch {}
+            }
+          }
+        } catch {}
+        if (Date.now() - startedAt > maxWaitMs) break;
+        await new Promise((resolve) => setTimeout(resolve, 3 + Math.floor(Math.random() * 9)));
+      }
+    }
+    try {
+      return await fn();
+    } finally {
+      if (held) {
+        const owner = readLockOwner(lockPath);
+        if (owner?.token === ownerToken) {
+          try {
+            fs.rmSync(lockPath, { recursive: true, force: true });
+          } catch {}
+        }
       }
     }
+  }
 
-    const entries = Array.isArray(parsed?.entries) ? parsed.entries : [];
-    const dedupeKey = stableMachineDigest({
-      requestKey: entry.requestKey,
-      executionMode: entry.executionMode,
-      nextActionType: entry.nextActionType,
-      nextMilestone: entry.nextMilestone,
-      repeatCount: entry.repeatCount,
-      rescueMode: entry.rescueMode,
-    });
-    const filtered = entries.filter((item) => {
-      const itemKey = stableMachineDigest({
-        requestKey: item?.requestKey || null,
-        executionMode: item?.executionMode || null,
-        nextActionType: item?.nextActionType || null,
-        nextMilestone: item?.nextMilestone || null,
-        repeatCount: item?.repeatCount || null,
-        rescueMode: item?.rescueMode || null,
+  async function appendRouteAuditEntry(filePath, entry) {
+    if (!entry || typeof entry !== 'object') {
+      return;
+    }
+
+    await withStateLock(`${filePath}.lock`, () => {
+      let parsed = { entries: [] };
+      if (fs.existsSync(filePath)) {
+        try {
+          parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        } catch {
+          parsed = { entries: [] };
+        }
+      }
+
+      const entries = Array.isArray(parsed?.entries) ? parsed.entries : [];
+      const dedupeKey = stableMachineDigest({
+        requestKey: entry.requestKey,
+        executionMode: entry.executionMode,
+        nextActionType: entry.nextActionType,
+        nextMilestone: entry.nextMilestone,
+        repeatCount: entry.repeatCount,
+        rescueMode: entry.rescueMode,
+      });
+      const filtered = entries.filter((item) => {
+        const itemKey = stableMachineDigest({
+          requestKey: item?.requestKey || null,
+          executionMode: item?.executionMode || null,
+          nextActionType: item?.nextActionType || null,
+          nextMilestone: item?.nextMilestone || null,
+          repeatCount: item?.repeatCount || null,
+          rescueMode: item?.rescueMode || null,
+        });
+        return itemKey !== dedupeKey;
       });
-      return itemKey !== dedupeKey;
-    });
 
-    ensureDir(filePath);
-    fs.writeFileSync(filePath, JSON.stringify({
-      entries: [entry, ...filtered].slice(0, 40),
-    }));
+      writeJsonFileAtomic(filePath, JSON.stringify({
+        entries: [entry, ...filtered].slice(0, 40),
+      }));
+    });
   }
 
   function shouldIncludePreviousContext({ routingContext = {}, useIndexedContext = true } = {}) {
@@ -2445,6 +2573,39 @@ const { pathToFileURL } = require('url');
   const debounceMs = 10 * 60 * 1000;
   const previousTs = Number(previous?.ts || 0);
   const informationalNoTargetPrompt = isInformationalPrompt({ promptText, commandText }) && !filePath;
+  // A delivery-only prompt ("push this to git", "đẩy bộ này lên git") starts a new,
+  // mutation-free action and typically matches no skill. It must not inherit the
+  // previous request's completion contract — carrying find-cause/map-impact debt
+  // forward here made the Stop gate demand an edit that a push can never produce.
+  const noRouteScores = deriveExecutionScores({
+    promptText,
+    commandText,
+    targetFile: filePath,
+    intentMode,
+    taskType: '',
+  });
+  const noRouteSignalRaw = [
+    routeSignals.promptRawText || '',
+    routeSignals.promptNormalizedText || '',
+    routeSignals.commandRawText || '',
+    routeSignals.commandNormalizedText || '',
+  ].join('\n');
+  const deliveryWordSignal = /\bgit\s+push\b/.test(noRouteSignalRaw)
+    || /\bpush\b[^\n]{0,60}\b(?:git|github|gitlab|remote|origin|repo)\b/.test(noRouteSignalRaw)
+    || /\b(?:git|github|gitlab|remote|origin|repo)\b[^\n]{0,60}\bpush\b/.test(noRouteSignalRaw)
+    || /\bday\b(?:\s+\S+){0,3}?\s+len\b/.test(noRouteSignalRaw);
+  const deliveryOnlyNoRoute = deliveryWordSignal
+    && noRouteScores.editCertainty === 0
+    && !noRouteScores.implementSignal
+    && !noRouteScores.reviewSignal
+    && !noRouteScores.debugSignal
+    && !noRouteScores.failureSignal
+    && !noRouteScores.impactSignal
+    && !noRouteScores.buildSignal
+    && !noRouteScores.directTransformSignal
+    && !noRouteScores.smallFixSignal
+    && !noRouteScores.sharedRisk
+    && !filePath;
 
   if (active.length === 0 || informationalNoTargetPrompt) {
     const lastExplicitUserPromptText = promptText.trim()
@@ -2457,7 +2618,7 @@ const { pathToFileURL } = require('url');
       targetFile: filePath,
       contextIntent: '',
       taskType: '',
-      ...(informationalNoTargetPrompt ? { executionMode: 'informational' } : {}),
+      ...((informationalNoTargetPrompt || deliveryOnlyNoRoute) ? { executionMode: 'informational' } : {}),
     };
     const previousContext = buildPreviousContextSnapshot({
       projectRoot,
@@ -2486,7 +2647,7 @@ const { pathToFileURL } = require('url');
     // route: completion-gate.sh reads routeSummary/requestKey from this state to decide
     // whether a Stop is premature. Downgrading to a route-less state here silently disarms
     // the gate mid-task, so carry the previous route forward until a real route replaces it.
-    fs.writeFileSync(statePath, JSON.stringify({
+    writeJsonFileAtomic(statePath, JSON.stringify({
       ...(sessionId ? { sessionId } : {}),
       fingerprint,
       ts: now,
@@ -2494,8 +2655,8 @@ const { pathToFileURL } = require('url');
       activeSkills: [],
       routingContext: compactRoutingContext(routingContext),
       ...(previousContext ? { previousContext: compactPreviousContext(previousContext) } : {}),
-      ...(previous?.routeSummary ? { routeSummary: previous.routeSummary } : {}),
-      ...(previous?.requestKey ? { requestKey: previous.requestKey } : {}),
+      ...(previous?.routeSummary && !deliveryOnlyNoRoute ? { routeSummary: previous.routeSummary } : {}),
+      ...(previous?.requestKey && !deliveryOnlyNoRoute ? { requestKey: previous.requestKey } : {}),
     }));
     process.exit(0);
   }
@@ -2536,6 +2697,7 @@ const { pathToFileURL } = require('url');
     intentMode,
     executionScores,
     executionCandidates,
+    signalText: `${routeSignals.promptNormalizedText || ''}\n${routeSignals.commandNormalizedText || ''}`,
   });
   const lastExplicitUserPromptText = promptText.trim()
     || previous?.routingContext?.lastExplicitUserPromptText
@@ -2606,7 +2768,7 @@ const { pathToFileURL } = require('url');
   };
   provisionalState.fingerprint = buildRouteStateFingerprint(provisionalState);
   ensureDir(statePath);
-  fs.writeFileSync(statePath, JSON.stringify(provisionalState));
+  writeJsonFileAtomic(statePath, JSON.stringify(provisionalState));
 
   let cacheUtils = null;
   if (fs.existsSync(cacheUtilsPath)) {
@@ -2667,8 +2829,8 @@ const { pathToFileURL } = require('url');
     }
 
     ensureDir(statePath);
-    fs.writeFileSync(statePath, JSON.stringify(reusedState));
-    appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
+    writeJsonFileAtomic(statePath, JSON.stringify(reusedState));
+    await appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
       state: reusedState,
     }));
 
@@ -2756,8 +2918,8 @@ const { pathToFileURL } = require('url');
     ...(helpers ? { helpers } : {}),
     routeSummary: compactRouteSummary(routeSummary),
   };
-  fs.writeFileSync(statePath, JSON.stringify(sharedState));
-  appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
+  writeJsonFileAtomic(statePath, JSON.stringify(sharedState));
+  await appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
     routingContext,
     routeSummary,
     state: sharedState,
@@ -2792,7 +2954,14 @@ const { pathToFileURL } = require('url');
 NODE
 
 if [ -f "$THRESHOLD_SCRIPT" ]; then
-  printf '%s' "$INPUT" | CLAUDE_PROJECT_DIR="$PROJECT_ROOT" node "$THRESHOLD_SCRIPT" prompt 2>/dev/null || true
+  # The 'prompt' phase only bookkeeps prompt-bearing events — a tool payload has no
+  # prompt text and that phase exits before doing anything. Every PreToolUse/
+  # PostToolUse call used to pay a second full node spawn for that no-op, doubling the
+  # per-mutation hook latency. Tool payloads always carry tool_name; skip them.
+  case "$INPUT" in
+    *'"tool_name"'*) ;;
+    *) printf '%s' "$INPUT" | CLAUDE_PROJECT_DIR="$PROJECT_ROOT" node "$THRESHOLD_SCRIPT" prompt 2>/dev/null || true ;;
+  esac
 fi
 
 exit 0

package/templates/.claude/hooks/verification-guard.sh

@@ -9,6 +9,7 @@ ROUTE_CACHE_FILE="$PROJECT_ROOT/.claude/ukit/route-cache.json"
 PROGRESS_FILE="$PROJECT_ROOT/.claude/ukit/verification-progress.json"
 
 INPUT="$INPUT" STATE_FILE="$STATE_FILE" ROUTE_CACHE_FILE="$ROUTE_CACHE_FILE" PROGRESS_FILE="$PROGRESS_FILE" node <<'NODE'
+const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 
@@ -41,6 +42,23 @@ function sleepSync(ms) {
   Atomics.wait(new Int32Array(buffer), 0, 0, ms);
 }
 
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+function readLockOwner(lockPath) {
+  const owner = readJson(path.join(lockPath, 'owner'), null);
+  return owner && Number.isInteger(owner.pid) && typeof owner.token === 'string'
+    ? owner
+    : null;
+}
+
 // mkdir-based lock, protocol-compatible with runtime token-utils withFileLock. Sync on
 // purpose (see sleepSync). Fail-open after 5s: this hook must never hang a PreToolUse
 // chain, and a lost progress entry only costs one repeated advisory.
@@ -48,21 +66,37 @@ function withLockSync(lockPath, fn) {
   const staleMs = 10000;
   const maxWaitMs = 5000;
   const startedAt = Date.now();
+  const ownerToken = `${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
   let held = false;
   while (!held) {
     try {
       fs.mkdirSync(path.dirname(lockPath), { recursive: true });
       fs.mkdirSync(lockPath);
+      try {
+        fs.writeFileSync(path.join(lockPath, 'owner'), JSON.stringify({
+          pid: process.pid,
+          token: ownerToken,
+          ts: Date.now(),
+        }));
+      } catch (error) {
+        try {
+          fs.rmSync(lockPath, { recursive: true, force: true });
+        } catch {}
+        throw error;
+      }
       held = true;
     } catch (error) {
       if (!error || error.code !== 'EEXIST') return fn();
       try {
         const stat = fs.statSync(lockPath);
         if (Date.now() - stat.mtimeMs > staleMs) {
-          try {
-            fs.rmSync(lockPath, { recursive: true, force: true });
-            continue;
-          } catch {}
+          const owner = readLockOwner(lockPath);
+          if (!owner || !isPidAlive(owner.pid)) {
+            try {
+              fs.rmSync(lockPath, { recursive: true, force: true });
+              continue;
+            } catch {}
+          }
         }
       } catch {}
       if (Date.now() - startedAt > maxWaitMs) break;
@@ -73,9 +107,12 @@ function withLockSync(lockPath, fn) {
     return fn();
   } finally {
     if (held) {
-      try {
-        fs.rmdirSync(lockPath);
-      } catch {}
+      const owner = readLockOwner(lockPath);
+      if (owner?.token === ownerToken) {
+        try {
+          fs.rmSync(lockPath, { recursive: true, force: true });
+        } catch {}
+      }
     }
   }
 }
@@ -288,14 +325,12 @@ function hasCompletedRecentTargetedLane({
   });
 }
 
-function deny(message) {
-  const advisory = message.replace(/^BLOCKED:/, 'ADVISORY:');
-  if (process.env.UKIT_VERIFICATION_GUARD_ENFORCE === '1') {
-    fs.writeSync(2, `${message}\n`);
-    process.exit(2);
-  }
-
-  fs.writeSync(1, `${advisory}\n`);
+function advise(message) {
+  // This hook is intentionally advisory. The executable hard gates are the completion
+  // ledger, context hard-cap, protected-file, and destructive-command guards; turning
+  // a verification-order recommendation into an exit-2 refusal gave a stale opt-in env
+  // variable a way to freeze a run before it could diagnose or land its current change.
+  fs.writeSync(1, `${message.replace(/^BLOCKED:/, 'ADVISORY:')}\n`);
   process.exit(0);
 }
 
@@ -433,31 +468,31 @@ if (isTargetedVerification) {
 }
 
 if (policyMode === 'confirm-then-broad' && isBroadTestCommand(command) && !explicitBroadRequested && !recentTargetedLaneCompleted) {
-  deny(
+  advise(
     `BLOCKED: Ask the user before broad verification. Routed policy is confirm-then-broad because the index could not localize related tests confidently.${helperCommand}`,
   );
 }
 
 if ((policyMode === 'auto-run-targeted' || policyMode === 'auto-run-targeted-then-fallback') && !isPrimaryCommand && missingPrimary.length > 0) {
-  deny(
+  advise(
     `BLOCKED: Run targeted verification first. Routed policy is ${policyMode} and the preferred first command(s) are: ${missingPrimaryText}.${helperCommand}`,
   );
 }
 
 if (policyMode === 'auto-run-targeted' && !explicitBroadRequested && !isPrimaryCommand) {
-  deny(
+  advise(
     `BLOCKED: Broader verification is not the default for this routed context. Stay with targeted verification unless the user explicitly requests a full suite. Preferred order: ${preferredText}.${helperCommand}`,
   );
 }
 
 if (policyMode === 'auto-run-targeted-then-fallback' && !explicitBroadRequested && isVerificationCommand(command) && !isPrimaryCommand && !isFallbackCommand) {
-  deny(
+  advise(
     `BLOCKED: Follow the routed verification order. This command is outside the recommended fallback lane. Preferred order: ${preferredText}.${helperCommand}`,
   );
 }
 
 if (policyMode === 'docs-light' && !explicitBroadRequested && isBroadTestCommand(command)) {
-  deny(
+  advise(
     `BLOCKED: Docs-focused change detected. Broad test runs are not the default for docs-light verification. Ask first if a full suite is still required.${helperCommand}`,
   );
 }

package/templates/.claude/ukit/index/route-task.mjs

@@ -450,6 +450,7 @@ async function prepareTaskRoute({
     intentMode,
     executionScores,
     executionCandidates,
+    signalText: buildNormalizedRouteSignalText(normalizedPrompt, normalizedCommand),
   });
   const preservedPrompt = normalizedPrompt || String(lastExplicitUserPromptText || '').trim();
   const visionInfo = await resolveVisionLane({
@@ -1749,8 +1750,10 @@ function deriveExecutionMode({
   intentMode = null,
   executionScores = {},
   executionCandidates = null,
+  signalText = '',
 } = {}) {
   const raw = `${promptText ?? ''}\n${commandText ?? ''}`.toLowerCase();
+  const signalRaw = `${raw}\n${String(signalText || '').toLowerCase()}`;
   const scores = executionScores;
   const candidates = executionCandidates ?? buildExecutionModeCandidates({
     promptText,
@@ -1760,18 +1763,48 @@ function deriveExecutionMode({
     executionScores,
   });
   const explicitReviewLead = /\b(review this|audit this|review\b.*\brelease readiness|verify\b.*\brelease readiness)\b/.test(raw);
+  const releaseVerificationContinuation = /\b(?:pending\s+diff[- ]review|self-install|verify\s+(?:consistency|release)|release\s+(?:verification|readiness))\b/.test(raw)
+    && /\b(?:release|tag|publish|push|report)\b/.test(raw);
   const strongImpactLead = scores.sharedRisk
     && (scores.impactSignal || /\b(check all affected|map all affected|across all affected)\b/.test(raw));
   const boundedLocalBuildCandidate = scores.buildSignal && scores.boundedEditSignal && scores.explicitTarget && !scores.sharedRisk;
+  // A bare delivery command ("push this to git", "đẩy bộ này lên git") performs no
+  // repository mutation the ledger could ever receipt. With no edit/review/debug/
+  // build signal present, routing it to an investigation lane fabricates write debt
+  // and the completion gate then demands an edit that cannot exist. Delivery-only
+  // requests carry no completion contract instead.
+  const deliveryWordSignal = /\bgit\s+push\b/.test(signalRaw)
+    || /\bpush\b[^\n]{0,60}\b(?:git|github|gitlab|remote|origin|repo)\b/.test(signalRaw)
+    || /\b(?:git|github|gitlab|remote|origin|repo)\b[^\n]{0,60}\bpush\b/.test(signalRaw)
+    || /\bday\b(?:\s+\S+){0,3}?\s+len\b/.test(signalRaw);
+  const deliveryOnlySignal = deliveryWordSignal
+    && scores.editCertainty === 0
+    && !scores.implementSignal
+    && !scores.reviewSignal
+    && !scores.debugSignal
+    && !scores.failureSignal
+    && !scores.impactSignal
+    && !scores.buildSignal
+    && !scores.directTransformSignal
+    && !scores.smallFixSignal
+    && !scores.sharedRisk
+    && !targetFile;
 
   if (isInformationalPrompt({ promptText, commandText, scores })) {
     return 'informational';
   }
 
-  if ((intentMode === 'review-specific' || explicitReviewLead) && !scores.implementSignal) {
+  if (
+    releaseVerificationContinuation
+    || ((intentMode === 'review-specific' || explicitReviewLead) && !scores.implementSignal)
+  ) {
     return 'review-release';
   }
 
+  if (deliveryOnlySignal) {
+    return 'informational';
+  }
+
   if (strongImpactLead || (scores.blastRadius >= 3 && (scores.ambiguity >= 2 || scores.investigationNeed >= 2))) {
     return 'map-impact';
   }
@@ -1871,7 +1904,7 @@ function buildExecutionModeCandidates({
     ),
     'map-impact': (
       (scores.sharedRisk ? 7 : 0)
-      + (scores.impactSignal ? 5 : 0)
+      + (scores.impactSignal ? 5 : -5)
       + (scores.ambiguity * 2)
       + scores.investigationNeed
     ),
@@ -2784,7 +2817,7 @@ function buildRouteRequestKey({
   previousContextSnapshot = null,
   recentOutputSnapshot = null,
 } = {}) {
-  return buildCompactMachineKey('route-v2', {
+  return buildCompactMachineKey('route-v3', {
     commandNamespace,
     indexGeneratedAtMs,
     projectFingerprint,