@ngockhoale/ukit 1.4.1 → 1.4.3

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

@@ -176,6 +176,26 @@ const { pathToFileURL } = require('url');
     };
   }
 
+  function shouldKeepRouteEntryForIntent(entry, intentMode) {
+    if (entry.id === 'next-step' && ['scoped-advice', 'docs-specific'].includes(intentMode)) {
+      return false;
+    }
+
+    if (entry.id === 'update-status' && intentMode === 'docs-specific') {
+      return false;
+    }
+
+    if (entry.id === 'docs-quality' && ['open-ended-status', 'status-update'].includes(intentMode)) {
+      return false;
+    }
+
+    if (entry.id === 'code-review' && intentMode === 'implement-specific') {
+      return false;
+    }
+
+    return true;
+  }
+
   function deriveSkillPriorityBoost(skillId, routeSignals = {}) {
     const combinedPromptSignals = [
       routeSignals.promptRawText || '',
@@ -183,6 +203,10 @@ const { pathToFileURL } = require('url');
       routeSignals.commandRawText || '',
       routeSignals.commandNormalizedText || '',
     ].join('\n');
+    const rawPromptSignals = [
+      routeSignals.promptRawText || '',
+      routeSignals.commandRawText || '',
+    ].join('\n');
 
     if (
       skillId === 'testing-quality'
@@ -191,6 +215,14 @@ const { pathToFileURL } = require('url');
       return 1;
     }
 
+    if (
+      skillId === 'code-review'
+      && /\b(implement|build|create|add|ship|deliver|refactor|integrate|integration|scaffold|feature|update|change|modify|inject|apply)\b/.test(rawPromptSignals)
+      && !/\b(review|audit|diff|pr feedback|code review|kiem tra|soat)\b/.test(rawPromptSignals)
+    ) {
+      return -4;
+    }
+
     return 0;
   }
 
@@ -215,6 +247,131 @@ const { pathToFileURL } = require('url');
     };
   }
 
+  function deriveIntentMode({ promptText = '', commandText = '', targetFile = null } = {}) {
+    const lower = buildRouteSignalText(promptText, commandText);
+    const raw = `${promptText || ''}\n${commandText || ''}`.toLowerCase();
+    const taskQueueNext = hasTaskQueueNextSignal(lower, raw);
+    const docsSpecific = hasDocsSpecificTaskSignal(lower, raw, targetFile, { taskQueueNext });
+    const statusUpdate = hasStatusUpdateSignal(lower, raw);
+    const openEndedStatus = hasOpenEndedStatusSignal(lower, raw) || taskQueueNext;
+    const concreteTask = hasConcreteTaskSignal(lower, raw, targetFile, { taskQueueNext });
+
+    if (docsSpecific) {
+      return 'docs-specific';
+    }
+
+    if (statusUpdate) {
+      return 'status-update';
+    }
+
+    if (concreteTask && openEndedStatus) {
+      return 'scoped-advice';
+    }
+
+    if (openEndedStatus) {
+      return 'open-ended-status';
+    }
+
+    if (concreteTask) {
+      if (/\b(bug|debug|error|crash|broken|failing|stack trace|triage|fix|timeout)\b/.test(lower)) {
+        return 'debug-specific';
+      }
+      if (/\b(review|audit|diff|pr feedback|code review|kiem tra|soat)\b/.test(raw)) {
+        return 'review-specific';
+      }
+      if (/\b(implement|build|create|add|ship|deliver|refactor|integrate|integration|scaffold|feature|update|change|modify|inject|apply)\b/.test(raw)) {
+        return 'implement-specific';
+      }
+    }
+
+    return null;
+  }
+
+  function hasStatusUpdateSignal(lower, raw) {
+    return /\b(update|refresh|write|sync|record|capture|summarize|summarise).{0,64}\b(status\.md|project status|current state|next candidates|session state)\b/.test(lower)
+      || /\b(status\.md|project status).{0,64}\b(update|refresh|write|sync|record|capture|summarize|summarise)\b/.test(lower)
+      || /\b(wrap up|handoff|end this session|ending this session|session summary|before final)\b/.test(lower)
+      || /\b(cap nhat|ghi lai|tong ket|chot session|ban giao).{0,64}\b(status|trang thai|viec tiep theo)\b/.test(lower)
+      || /\b(cập nhật|ghi lại|tổng kết|chốt session|bàn giao).{0,64}\b(status|trạng thái|việc tiếp theo)\b/.test(raw);
+  }
+
+  function hasOpenEndedStatusSignal(lower, raw) {
+    return /\b(what next|what is next|what's next|next step|next steps|project status|current status|where are we|continue|continue from last session|roadmap|status\.md|task queue|tasks\.md|next queued task|pick next task|work from tasks)\b/.test(lower)
+      || /\b(lam gi tiep|buoc tiep theo|tiep theo lam gi|lam tiep|dang o dau|trang thai project|tinh trang project|task tiep theo|viec tiep theo trong tasks)\b/.test(lower)
+      || /\b(làm gì tiếp|bước tiếp theo|tiếp theo làm gì|làm tiếp|đang ở đâu|trạng thái project|tình trạng project|task tiếp theo|việc tiếp theo trong tasks)\b/.test(raw);
+  }
+
+  function hasTaskQueueNextSignal(lower, raw) {
+    return /\b(task queue|tasks\.md|next queued task|pick next task|work from tasks|next task from tasks|ready for ai)\b/.test(lower)
+      || /\b(task tiếp theo|việc tiếp theo trong tasks|làm task trong tasks|lấy task tiếp theo)\b/.test(raw);
+  }
+
+  function hasConcreteTaskSignal(lower, raw, targetFile, { taskQueueNext = false } = {}) {
+    if (targetFile && !isStatusFileTarget(targetFile) && !(taskQueueNext && isTasksFileTarget(targetFile))) {
+      return true;
+    }
+
+    return /\b(bug|debug|error|crash|broken|failing|stack trace|triage|fix|implement|build|create|add|ship|deliver|refactor|integrate|integration|scaffold|feature|update|change|modify|inject|apply|review|audit|diff|pr feedback|code review|auth|login|api|endpoint|test|spec)\b/.test(lower)
+      || /\b(sửa|fix|lỗi|bug|debug|implement|cài|thêm|review|kiểm tra|soát|đăng nhập)\b/.test(raw);
+  }
+
+  function hasDocsSpecificTaskSignal(lower, raw, targetFile, { taskQueueNext = false } = {}) {
+    if (!targetFile || !isDocsTarget(targetFile)) {
+      return /\b(clean tasks|cleanup tasks|prune tasks|dedupe tasks|clear completed tasks|dọn tasks|dọn task)\b/.test(lower)
+        || /\b(dọn tasks|dọn task|dọn danh sách task|xóa task đã xong)\b/.test(raw);
+    }
+
+    if (taskQueueNext && isTasksFileTarget(targetFile) && !/\b(clean|cleanup|prune|dedupe|edit|template|wording|format|structure)\b/.test(lower)) {
+      return false;
+    }
+
+    const targetName = path.posix.basename(String(targetFile || '').replaceAll('\\', '/')).toLowerCase();
+    const explicitStatusUpdate = hasExplicitStatusUpdateSignal(lower, raw);
+
+    if (!isStatusFileTarget(targetFile)) {
+      if (explicitStatusUpdate && !mentionsTargetDoc(lower, targetName)) {
+        return false;
+      }
+
+      return mentionsTargetDoc(lower, targetName)
+        || /\b(edit|write|improve|document|docs?|readme|changelog|worklog|memory|code map|template|wording|copy|grammar|format|structure|heading|section|handoff notes?)\b/.test(lower)
+        || /\b(câu chữ|chỉnh|sửa chữ|ngữ pháp|định dạng|cấu trúc|tài liệu|ghi chú bàn giao)\b/.test(raw);
+    }
+
+    return /\b(template|wording|edit|copy|grammar|format|structure|heading|section|docs?)\b/.test(lower)
+      || /\b(mẫu|câu chữ|chỉnh|sửa chữ|ngữ pháp|định dạng|cấu trúc|tài liệu)\b/.test(raw);
+  }
+
+  function hasExplicitStatusUpdateSignal(lower, raw) {
+    return /\b(update|refresh|write|sync|record|capture|summarize|summarise).{0,64}\b(status\.md|project status|current state|next candidates|session state)\b/.test(lower)
+      || /\b(status\.md|project status).{0,64}\b(update|refresh|write|sync|record|capture|summarize|summarise)\b/.test(lower)
+      || /\b(cap nhat|ghi lai|tong ket|chot session|ban giao).{0,64}\b(status|trang thai|viec tiep theo)\b/.test(lower)
+      || /\b(cập nhật|ghi lại|tổng kết|chốt session|bàn giao).{0,64}\b(status|trạng thái|việc tiếp theo)\b/.test(raw);
+  }
+
+  function mentionsTargetDoc(lower, targetName) {
+    if (!targetName) {
+      return false;
+    }
+
+    const escaped = targetName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const withoutExt = escaped.replace(/\\\.md$/i, '');
+    return new RegExp(`\\b(?:${escaped}|${withoutExt})\\b`, 'i').test(lower);
+  }
+
+  function isStatusFileTarget(targetFile) {
+    return /(?:^|\/)docs\/STATUS\.md$|(?:^|\/)STATUS\.md$/i.test(String(targetFile || ''));
+  }
+
+  function isTasksFileTarget(targetFile) {
+    return /(?:^|\/)docs\/TASKS\.md$|(?:^|\/)TASKS\.md$/i.test(String(targetFile || ''));
+  }
+
+  function isDocsTarget(targetFile) {
+    const normalized = String(targetFile || '').replaceAll('\\', '/');
+    return /(?:^|\/)docs\/.+\.md$|(?:^|\/)(?:README|CHANGELOG|AGENTS|CLAUDE|STATUS)\.md$/i.test(normalized);
+  }
+
   function shouldUseIndexedContext({ activeSkills = [], targetFile = null } = {}) {
     if (activeSkills.length === 0) {
       return Boolean(targetFile);
@@ -312,6 +469,7 @@ const { pathToFileURL } = require('url');
       targetFile: routingContext.targetFile || '',
       contextIntent: routingContext.contextIntent || '',
       taskType: routingContext.taskType || '',
+      executionMode: routingContext.executionMode || '',
       previousContextFingerprint: previousContextFingerprint || null,
     });
   }
@@ -325,6 +483,17 @@ const { pathToFileURL } = require('url');
     return buildCompactMachineKey('routefp-v3', {
       skills: activeSkills.map((item) => item.id),
       taskType: routingContext?.taskType || null,
+      executionMode: routeSummary?.executionMode || null,
+      approachRiskLevel: routeSummary?.approachSelector?.riskLevel || null,
+      approachContextPolicy: routeSummary?.approachSelector?.contextPolicy || null,
+      approachVerificationPolicy: routeSummary?.approachSelector?.verificationPolicy || null,
+      approachCompletionRule: routeSummary?.approachSelector?.completionRule || null,
+      continuationRequired: routeSummary?.continuationState?.required || null,
+      continuationReasons: unique(routeSummary?.continuationState?.reasons ?? []),
+      continuationMilestone: routeSummary?.continuationState?.nextMilestone || null,
+      continuationRepeatCount: routeSummary?.continuationState?.repeatCount || null,
+      continuationStuckRisk: routeSummary?.continuationState?.stuckRisk || null,
+      continuationRescueMode: routeSummary?.continuationState?.rescueMode || null,
       previousContextLine: previousContext?.line || null,
       previousContextIds: unique(previousContext?.selectedIds ?? []),
       policyMode: routeSummary?.policyMode || null,
@@ -332,6 +501,8 @@ const { pathToFileURL } = require('url');
       nextActionType: routeSummary?.nextActionType || null,
       nextActionCommand: routeSummary?.nextActionCommand || null,
       helperHint: routeSummary?.helperHint || null,
+      completionRule: routeSummary?.executionContract?.completionRule || null,
+      completionMissingEvidence: unique(routeSummary?.completionState?.missingEvidence ?? []),
       primaryCommands: [...new Set((routeSummary?.primaryCommands || []).filter(Boolean))],
       fallbackCommands: [...new Set((routeSummary?.fallbackCommands || []).filter(Boolean))],
       preferredOrder: [...new Set((routeSummary?.preferredOrder || []).filter(Boolean))],
@@ -397,11 +568,16 @@ const { pathToFileURL } = require('url');
       return 'non-trivial';
     }
 
+    let inferred = 'simple';
     if (/\b(typo|label|text|rename|color|spacing|toggle|comment)\b/.test(lower)) {
-      return 'trivial';
+      inferred = 'trivial';
     }
 
-    return 'simple';
+    if ((inferred === 'simple' || inferred === 'trivial') && isSharedImpactFile(targetFile)) {
+      return 'shared-simple';
+    }
+
+    return inferred;
   }
 
   function shellEscape(value) {
@@ -1129,6 +1305,23 @@ const { pathToFileURL } = require('url');
     const compactHelperLane = nextAction?.type === 'pull-indexed-context'
       && typeof contextRecommendation?.command === 'string'
       && contextRecommendation.command.trim();
+    const executionMode = routingContext.executionMode || null;
+    const executionScores = routingContext.executionScores || null;
+    const executionCandidates = routingContext.executionCandidates || null;
+    const approachSelector = buildApproachSelectorResult({
+      executionMode,
+      executionScores,
+      executionCandidates,
+    });
+    const executionContract = buildExecutionContract(executionMode);
+    const completionState = buildCompletionState({
+      executionMode,
+      verificationRecommendation,
+    });
+    const continuationState = buildContinuationState({
+      nextActionType: nextAction?.type || null,
+      completionState,
+    });
     const helperHint = compactHelperHint(
       compactHelperLane
         ? contextRecommendation?.command
@@ -1152,6 +1345,13 @@ const { pathToFileURL } = require('url');
       fallbackCommands,
       preferredOrder,
       policyMode,
+      executionMode,
+      executionScores,
+      executionCandidates,
+      approachSelector,
+      executionContract,
+      completionState,
+      continuationState,
       delegateHint: delegationRecommendation?.hint || null,
       nextActionType: nextAction?.type || null,
       nextActionCommand,
@@ -1160,6 +1360,580 @@ const { pathToFileURL } = require('url');
     };
   }
 
+  function deriveExecutionScores({
+    promptText = '',
+    commandText = '',
+    targetFile = null,
+    intentMode = null,
+    taskType = null,
+  } = {}) {
+    const raw = `${promptText || ''}\n${commandText || ''}`.toLowerCase();
+    const sharedRisk = isSharedImpactFile(targetFile);
+    const directTransformSignal = /\b(change|replace|set|rename|convert|swap)\b/.test(raw) || /\bchange\s+.+\s+to\s+.+\b/.test(raw);
+    const smallFixSignal = /\b(adjust|tweak|patch|fix|modify|update|apply)\b/.test(raw);
+    const buildSignal = /\b(build|create|add|implement|feature)\b/.test(raw);
+    const debugSignal = intentMode === 'debug-specific' || /\b(root cause|debug|triage|flaky|investigate|why)\b/.test(raw);
+    const reviewSignal = intentMode === 'review-specific' || /\b(review|audit|verify|release readiness)\b/.test(raw);
+    const failureSignal = /\b(failing|failed|broken|error|crash|timeout|undefined|exception|eacces|trace)\b/.test(raw);
+    const impactSignal = /\b(map impact|impact|blast radius|all affected|across (?:runtime|templates|helpers|adapters|mirrors)|affected adapters|affected mirrors|inspect impact)\b/.test(raw);
+    const boundedEditSignal = /\b(one[- ]line|small|tiny|single|local|guard|log line|loading message|label)\b/.test(raw);
+    const implementSignal = /\b(implement|apply|update|modify|add|create|ship|deliver|fix)\b/.test(raw)
+      || /\bchange\s+.+\s+to\s+.+\b/.test(raw);
+    const explicitTarget = Boolean(targetFile);
+
+    let editCertainty = 0;
+    if (directTransformSignal) {
+      editCertainty = 3;
+    } else if (smallFixSignal) {
+      editCertainty = 2;
+    } else if (buildSignal) {
+      editCertainty = 1;
+    }
+
+    let investigationNeed = 0;
+    if (debugSignal) {
+      investigationNeed = 3;
+    } else if (failureSignal) {
+      investigationNeed = 2;
+    }
+
+    let blastRadius = 0;
+    if (sharedRisk) {
+      blastRadius = 3;
+    } else if (taskType === 'non-trivial' || taskType === 'shared-simple') {
+      blastRadius = 2;
+    } else if (!targetFile) {
+      blastRadius = 1;
+    }
+
+    let verificationBurden = 1;
+    if (reviewSignal || sharedRisk) {
+      verificationBurden = 3;
+    } else if (debugSignal || taskType === 'non-trivial') {
+      verificationBurden = 2;
+    }
+
+    let ambiguity = 0;
+    if (!targetFile) {
+      ambiguity = 2;
+    } else if (buildSignal && !directTransformSignal && !smallFixSignal) {
+      ambiguity = 1;
+    }
+
+    return {
+      editCertainty,
+      investigationNeed,
+      blastRadius,
+      verificationBurden,
+      ambiguity,
+      sharedRisk,
+      directTransformSignal,
+      smallFixSignal,
+      buildSignal,
+      debugSignal,
+      reviewSignal,
+      failureSignal,
+      impactSignal,
+      boundedEditSignal,
+      implementSignal,
+      explicitTarget,
+    };
+  }
+
+  function deriveExecutionMode({
+    promptText = '',
+    commandText = '',
+    targetFile = null,
+    intentMode = null,
+    executionScores = {},
+    executionCandidates = null,
+  } = {}) {
+    const raw = `${promptText || ''}\n${commandText || ''}`.toLowerCase();
+    const scores = executionScores;
+    const candidates = executionCandidates ?? buildExecutionModeCandidates({
+      promptText,
+      commandText,
+      targetFile,
+      intentMode,
+      executionScores,
+    });
+    const explicitReviewLead = /\b(review this|audit this|review\b.*\brelease readiness|verify\b.*\brelease readiness)\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;
+
+    if ((intentMode === 'review-specific' || explicitReviewLead) && !scores.implementSignal) {
+      return 'review-release';
+    }
+
+    if (strongImpactLead || (scores.blastRadius >= 3 && (scores.ambiguity >= 2 || scores.investigationNeed >= 2))) {
+      return 'map-impact';
+    }
+
+    if (scores.sharedRisk && scores.failureSignal && scores.investigationNeed >= 2 && !scores.impactSignal) {
+      return 'shared-edit';
+    }
+
+    if (scores.blastRadius >= 3 || scores.sharedRisk) {
+      return 'shared-edit';
+    }
+
+    if (scores.investigationNeed >= 3 || (scores.failureSignal && scores.investigationNeed >= 2)) {
+      return 'find-cause';
+    }
+
+    if (scores.directTransformSignal && !scores.explicitTarget && scores.investigationNeed === 0 && !scores.sharedRisk) {
+      return 'local-build';
+    }
+
+    if (
+      scores.editCertainty >= 3
+      && scores.ambiguity <= 1
+      && scores.blastRadius === 0
+      && scores.verificationBurden <= 1
+    ) {
+      return 'tiny-fix';
+    }
+
+    if (boundedLocalBuildCandidate && scores.investigationNeed === 0) {
+      return 'local-fix';
+    }
+
+    if (
+      /\b(build|create|add|implement|feature|summary card)\b/.test(raw)
+      && scores.investigationNeed === 0
+      && scores.blastRadius < 3
+      && !scores.boundedEditSignal
+    ) {
+      return 'local-build';
+    }
+
+    if (scores.editCertainty >= 2 && scores.investigationNeed === 0 && scores.blastRadius === 0) {
+      return 'local-fix';
+    }
+
+    return applySafeUpwardBias(candidates, 'local-build');
+  }
+
+  function buildExecutionModeCandidates({
+    promptText = '',
+    commandText = '',
+    targetFile = null,
+    intentMode = null,
+    executionScores = {},
+  } = {}) {
+    const scores = executionScores;
+    const raw = `${promptText || ''}\n${commandText || ''}`.toLowerCase();
+    const explicitReviewLead = (intentMode === 'review-specific' || /\b(review this|audit this|review\b.*\brelease readiness|verify\b.*\brelease readiness)\b/.test(raw))
+      && !scores.implementSignal;
+
+    const modeScores = {
+      'tiny-fix': (
+        (scores.editCertainty * 4)
+        + (scores.directTransformSignal ? 4 : 0)
+        + (scores.explicitTarget ? 1 : 0)
+        - (scores.failureSignal ? 4 : 0)
+        - (scores.blastRadius * 4)
+        - (scores.ambiguity * 2)
+      ),
+      'local-fix': (
+        (scores.editCertainty * 3)
+        + (scores.boundedEditSignal ? 3 : 0)
+        + (scores.explicitTarget ? 1 : 0)
+        - (scores.failureSignal ? 2 : 0)
+        - (scores.blastRadius * 4)
+      ),
+      'local-build': (
+        (scores.buildSignal ? 6 : 0)
+        + (scores.editCertainty * 1)
+        + (scores.explicitTarget ? 1 : 0)
+        - (scores.boundedEditSignal ? 3 : 0)
+        - (scores.failureSignal ? 3 : 0)
+        - (scores.blastRadius * 4)
+      ),
+      'find-cause': (
+        (scores.investigationNeed * 4)
+        + (scores.failureSignal ? 3 : 0)
+        + (scores.debugSignal ? 2 : 0)
+        - (scores.blastRadius >= 3 ? 1 : 0)
+      ),
+      'shared-edit': (
+        (scores.sharedRisk ? 8 : 0)
+        + (scores.editCertainty * 1)
+        + (scores.buildSignal ? 1 : 0)
+        - (scores.impactSignal ? 2 : 0)
+      ),
+      'map-impact': (
+        (scores.sharedRisk ? 7 : 0)
+        + (scores.impactSignal ? 5 : 0)
+        + (scores.ambiguity * 2)
+        + scores.investigationNeed
+      ),
+      'review-release': (
+        (explicitReviewLead ? 10 : 0)
+        + (scores.reviewSignal ? 3 : 0)
+        - (scores.implementSignal ? 5 : 0)
+      ),
+    };
+
+    return Object.entries(modeScores)
+      .map(([mode, score]) => ({ mode, score }))
+      .sort((a, b) => b.score - a.score || executionModeRank(a.mode) - executionModeRank(b.mode));
+  }
+
+  function applySafeUpwardBias(candidates = [], fallbackMode = 'local-build') {
+    const [topCandidate, competingCandidate] = candidates;
+    if (!topCandidate) {
+      return fallbackMode;
+    }
+
+    if (!competingCandidate) {
+      return topCandidate.mode;
+    }
+
+    const scoreGap = Number(topCandidate.score ?? 0) - Number(competingCandidate.score ?? 0);
+    const rankGap = executionModeRank(competingCandidate.mode) - executionModeRank(topCandidate.mode);
+    if (scoreGap <= 1 && rankGap === 1) {
+      return competingCandidate.mode;
+    }
+
+    return topCandidate.mode;
+  }
+
+  function executionModeRank(mode = '') {
+    const orderedModes = [
+      'tiny-fix',
+      'local-fix',
+      'local-build',
+      'find-cause',
+      'shared-edit',
+      'map-impact',
+      'review-release',
+    ];
+
+    const index = orderedModes.indexOf(mode);
+    return index >= 0 ? index : orderedModes.length;
+  }
+
+  function buildExecutionContract(executionMode = null) {
+    if (!executionMode) {
+      return null;
+    }
+
+    const contracts = {
+      'tiny-fix': {
+        maxReadPasses: 0,
+        maxContextPulls: 0,
+        verificationPolicy: 'minimal-or-targeted',
+        completionRule: 'never-claim-done-without-write',
+        delegationPolicy: 'disallow',
+        completionEvidence: ['write-evidence'],
+      },
+      'local-fix': {
+        maxReadPasses: 1,
+        maxContextPulls: 1,
+        verificationPolicy: 'targeted-if-covered',
+        completionRule: 'require-write',
+        delegationPolicy: 'disallow',
+        completionEvidence: ['write-evidence'],
+      },
+      'local-build': {
+        maxReadPasses: 2,
+        maxContextPulls: 1,
+        verificationPolicy: 'targeted-if-covered',
+        completionRule: 'require-write',
+        delegationPolicy: 'disallow-by-default',
+        completionEvidence: ['write-evidence'],
+      },
+      'find-cause': {
+        maxReadPassesBeforeReassess: 3,
+        verificationPolicy: 'root-cause-then-targeted',
+        completionRule: 'never-claim-fixed-without-write-and-verification',
+        delegationPolicy: 'allow-specialized-debug-lane',
+        completionEvidence: ['write-evidence', 'verification-evidence'],
+      },
+      'shared-edit': {
+        maxReadPasses: 2,
+        maxContextPulls: 2,
+        verificationPolicy: 'targeted-then-widen-on-risk',
+        completionRule: 'require-write-and-verification',
+        delegationPolicy: 'allow-qualified-sidecar',
+        completionEvidence: ['write-evidence', 'verification-evidence'],
+        mirrorConsistencyRequired: true,
+      },
+      'map-impact': {
+        maxReadPasses: 3,
+        maxContextPulls: 3,
+        verificationPolicy: 'impact-first-then-targeted-then-widen-on-risk',
+        completionRule: 'require-impact-evidence-before-edit-claim',
+        delegationPolicy: 'allow-impact-sidecar',
+        completionEvidence: ['impact-evidence', 'write-evidence', 'verification-evidence'],
+        mirrorConsistencyRequired: true,
+      },
+      'review-release': {
+        verificationPolicy: 'evidence-first',
+        completionRule: 'report-findings-not-implementation',
+        delegationPolicy: 'allow-review-sidecar',
+        completionEvidence: ['verification-evidence'],
+      },
+    };
+
+    return contracts[executionMode] ? { ...contracts[executionMode] } : null;
+  }
+
+  function buildApproachSelectorResult({
+    executionMode = null,
+    executionScores = null,
+    executionCandidates = null,
+  } = {}) {
+    if (!executionMode) {
+      return null;
+    }
+
+    const executionContract = buildExecutionContract(executionMode);
+    const policyByMode = {
+      'tiny-fix': {
+        riskLevel: 'minimal',
+        contextPolicy: 'confirm-target-only',
+      },
+      'local-fix': {
+        riskLevel: 'local',
+        contextPolicy: 'bounded-local',
+      },
+      'local-build': {
+        riskLevel: 'local',
+        contextPolicy: 'bounded-with-related-files',
+      },
+      'find-cause': {
+        riskLevel: 'investigation',
+        contextPolicy: 'trace-then-bounded-context',
+      },
+      'shared-edit': {
+        riskLevel: 'shared',
+        contextPolicy: 'bounded-with-related-tests',
+      },
+      'map-impact': {
+        riskLevel: 'wide',
+        contextPolicy: 'impact-map-first',
+      },
+      'review-release': {
+        riskLevel: 'release',
+        contextPolicy: 'evidence-review-only',
+      },
+    };
+    const selectedPolicy = policyByMode[executionMode] ?? {
+      riskLevel: 'local',
+      contextPolicy: 'bounded-local',
+    };
+
+    return {
+      executionMode,
+      executionScores: executionScores ? { ...executionScores } : null,
+      riskLevel: selectedPolicy.riskLevel,
+      contextPolicy: selectedPolicy.contextPolicy,
+      verificationPolicy: executionContract?.verificationPolicy ?? null,
+      completionRule: executionContract?.completionRule ?? null,
+      competingMode: executionCandidates?.[1]?.mode ?? null,
+      competingScoreGap: executionCandidates?.length >= 2
+        ? Number(executionCandidates[0]?.score ?? 0) - Number(executionCandidates[1]?.score ?? 0)
+        : null,
+      candidateModes: (executionCandidates ?? []).slice(0, 3).map((entry) => ({
+        mode: entry.mode,
+        score: entry.score,
+      })),
+    };
+  }
+
+  function buildCompletionState({ executionMode = null, verificationRecommendation = null } = {}) {
+    if (!executionMode) {
+      return null;
+    }
+
+    const contract = buildExecutionContract(executionMode);
+    const missingEvidence = [...(contract?.completionEvidence ?? [])];
+    const requiresVerification = missingEvidence.includes('verification-evidence');
+    if (
+      requiresVerification
+      && verificationRecommendation
+      && !(verificationRecommendation.commands?.length || verificationRecommendation.fallbackCommands?.length)
+    ) {
+      missingEvidence.push('verification-plan');
+    }
+
+    let reason = 'completion evidence is still required';
+    if (['tiny-fix', 'local-fix', 'local-build', 'shared-edit'].includes(executionMode)) {
+      reason = 'implement request has not produced an edit yet';
+    } else if (executionMode === 'review-release') {
+      reason = 'review/release evidence is still required before final claim';
+    } else if (executionMode === 'map-impact') {
+      reason = 'impact evidence is still required before safe completion claim';
+    }
+
+    return {
+      claimAllowed: false,
+      missingEvidence,
+      reason,
+    };
+  }
+
+  function buildContinuationState({
+    nextActionType = null,
+    completionState = null,
+  } = {}) {
+    const reasons = [];
+    const missingEvidence = unique(completionState?.missingEvidence ?? []);
+
+    if (nextActionType === 'pull-indexed-context') {
+      reasons.push('pending-bounded-context');
+    }
+
+    if (nextActionType === 'read-skill-instructions') {
+      reasons.push('pending-skill-read');
+    }
+
+    if (missingEvidence.includes('write-evidence')) {
+      reasons.push('missing-write-evidence');
+    }
+
+    if (missingEvidence.includes('verification-evidence') || missingEvidence.includes('verification-plan')) {
+      reasons.push('missing-verification-evidence');
+    }
+
+    if (missingEvidence.includes('impact-evidence')) {
+      reasons.push('missing-impact-evidence');
+    }
+
+    const nextMilestone = reasons.includes('pending-bounded-context')
+      ? 'complete-bounded-context-then-continue'
+      : (
+        reasons.includes('missing-write-evidence')
+          ? 'produce-write-evidence'
+          : (
+            reasons.includes('missing-verification-evidence')
+              ? 'produce-verification-evidence'
+              : (
+                reasons.includes('missing-impact-evidence')
+                  ? 'produce-impact-evidence'
+                  : null
+              )
+          )
+      );
+
+    return {
+      required: reasons.length > 0,
+      reasons,
+      doneLanguageBlocked: reasons.length > 0,
+      stopAllowedOnlyFor: reasons.length > 0 ? ['real-blocker'] : [],
+      nextMilestone,
+      repeatCount: reasons.length > 0 ? 1 : 0,
+      stuckRisk: null,
+      rescueMode: null,
+      wideningBlocked: false,
+      milestonePriority: reasons.length > 0 ? 'normal' : null,
+    };
+  }
+
+  function advanceContinuationState(continuationState = null, previousContinuationState = null) {
+    if (!continuationState || typeof continuationState !== 'object') {
+      return continuationState;
+    }
+
+    if (!continuationState.required) {
+      return {
+        ...continuationState,
+        repeatCount: 0,
+        stuckRisk: null,
+        rescueMode: null,
+        wideningBlocked: false,
+        milestonePriority: null,
+      };
+    }
+
+    const currentReasons = unique(continuationState.reasons ?? []);
+    const previousReasons = unique(previousContinuationState?.reasons ?? []);
+    const sameMilestone = Boolean(
+      previousContinuationState?.required
+      && continuationState.nextMilestone
+      && previousContinuationState.nextMilestone === continuationState.nextMilestone
+      && JSON.stringify(previousReasons) === JSON.stringify(currentReasons)
+    );
+    const repeatCount = sameMilestone
+      ? Math.max(1, Number(previousContinuationState?.repeatCount ?? 1) + 1)
+      : 1;
+    const rescueMode = repeatCount >= 2
+      ? (
+        currentReasons.includes('pending-bounded-context')
+          ? 'finish-current-milestone-before-more-reading'
+          : (
+            currentReasons.includes('missing-write-evidence')
+              ? 'finish-write-before-more-analysis'
+              : 'finish-required-milestone-before-widening'
+          )
+      )
+      : null;
+    const stuckRisk = repeatCount >= 3
+      ? 'high'
+      : (repeatCount === 2 ? 'elevated' : null);
+    const wideningBlocked = repeatCount >= 2 && Boolean(rescueMode);
+    const nextMilestone = repeatCount >= 2 && currentReasons.includes('missing-write-evidence')
+      ? 'finish-write-before-more-analysis'
+      : (
+        repeatCount >= 2 && currentReasons.includes('pending-bounded-context')
+          ? 'finish-current-milestone-before-more-reading'
+          : continuationState.nextMilestone
+      );
+
+    return {
+      ...continuationState,
+      nextMilestone,
+      repeatCount,
+      stuckRisk,
+      rescueMode,
+      wideningBlocked,
+      milestonePriority: wideningBlocked ? 'execute-current-milestone' : 'normal',
+    };
+  }
+
+  function applyRescueBiasToRouteSummary(routeSummary = null) {
+    if (!routeSummary || typeof routeSummary !== 'object') {
+      return routeSummary;
+    }
+
+    const continuationState = routeSummary.continuationState;
+    if (
+      continuationState?.repeatCount >= 2
+      && continuationState?.wideningBlocked
+      && (continuationState.reasons ?? []).includes('missing-write-evidence')
+    ) {
+      routeSummary.nextActionType = 'execute-current-milestone';
+      routeSummary.nextActionCommand = null;
+      routeSummary.helperHint = null;
+    }
+
+    return routeSummary;
+  }
+
+  const SHARED_IMPACT_PATTERNS = [
+    /^\.claude\/hooks\//,
+    /^\.claude\/ukit\//,
+    /^\.codex\//,
+    /^src\/index\//,
+    /^src\/core\/(runInstallPipeline|applyPlan|buildPlan|diffPlan|metadata|migrateLegacy|uninstall|runtimeConfig|runtimePaths)\.js$/,
+    /^src\/core\/(output|token|compact)\//,
+    /^templates\/\.claude\/hooks\//,
+    /^templates\/\.claude\/ukit\//,
+    /^manifests\/platform\.full\.yaml$/,
+    /^templates\//,
+  ];
+
+  function isSharedImpactFile(filePath) {
+    const normalized = String(filePath ?? '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
+    if (!normalized) {
+      return false;
+    }
+    return SHARED_IMPACT_PATTERNS.some((pattern) => pattern.test(normalized));
+  }
+
   function summarizeCompactList(values, limit = 2) {
     const normalized = [...new Set((values || []).filter(Boolean))];
     return {
@@ -1268,6 +2042,8 @@ const { pathToFileURL } = require('url');
     return {
       lastExplicitUserPromptText: routingContext.lastExplicitUserPromptText || '',
       taskType: routingContext.taskType || null,
+      intentMode: routingContext.intentMode || null,
+      executionMode: routingContext.executionMode || null,
     };
   }
 
@@ -1299,6 +2075,12 @@ const { pathToFileURL } = require('url');
       fallbackCommands: [...new Set((routeSummary.fallbackCommands || []).filter(Boolean))].slice(0, 3),
       preferredOrder: [...new Set((routeSummary.preferredOrder || []).filter(Boolean))].slice(0, 5),
       policyMode: routeSummary.policyMode || null,
+      executionMode: routeSummary.executionMode || null,
+      executionScores: routeSummary.executionScores || null,
+      approachSelector: routeSummary.approachSelector || null,
+      executionContract: routeSummary.executionContract || null,
+      completionState: routeSummary.completionState || null,
+      continuationState: routeSummary.continuationState || null,
       delegateHint: routeSummary.delegateHint || null,
       nextActionType: routeSummary.nextActionType || null,
       nextActionCommand: routeSummary.nextActionCommand || null,
@@ -1306,6 +2088,79 @@ const { pathToFileURL } = require('url');
     };
   }
 
+  function buildRouteAuditEntry({
+    routingContext = {},
+    routeSummary = {},
+    state = null,
+  } = {}) {
+    const candidateModes = Array.isArray(routeSummary?.approachSelector?.candidateModes)
+      ? routeSummary.approachSelector.candidateModes
+      : [];
+
+    return {
+      ts: Date.now(),
+      source: state?.source || 'skill-router',
+      requestKey: state?.requestKey || null,
+      adapter: routingContext.adapter || 'claude',
+      promptFingerprint: stableMachineDigest({
+        prompt: routingContext.lastExplicitUserPromptText || '',
+        adapter: routingContext.adapter || 'claude',
+      }),
+      targetFile: routingContext.targetFile || null,
+      taskType: routingContext.taskType || null,
+      executionMode: routeSummary.executionMode || null,
+      competingMode: routeSummary?.approachSelector?.competingMode || null,
+      competingScoreGap: routeSummary?.approachSelector?.competingScoreGap || null,
+      candidateModes: candidateModes.slice(0, 3),
+      nextActionType: routeSummary.nextActionType || null,
+      nextMilestone: routeSummary?.continuationState?.nextMilestone || null,
+      repeatCount: routeSummary?.continuationState?.repeatCount || null,
+      rescueMode: routeSummary?.continuationState?.rescueMode || null,
+      wideningBlocked: routeSummary?.continuationState?.wideningBlocked || null,
+    };
+  }
+
+  function appendRouteAuditEntry(filePath, entry) {
+    if (!entry || typeof entry !== 'object') {
+      return;
+    }
+
+    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;
+    });
+
+    ensureDir(filePath);
+    fs.writeFileSync(filePath, JSON.stringify({
+      entries: [entry, ...filtered].slice(0, 40),
+    }));
+  }
+
   function shouldIncludePreviousContext({ routingContext = {}, useIndexedContext = true } = {}) {
     const taskType = String(routingContext?.taskType || '').trim();
     const hasExplicitTarget = Boolean(String(routingContext?.targetFile || '').trim());
@@ -1373,7 +2228,7 @@ const { pathToFileURL } = require('url');
     }
 
     const nextActionType = String(routeSummary.nextActionType ?? '').trim();
-    if (!nextActionType || nextActionType === 'read-skill-instructions') {
+    if (!nextActionType || nextActionType === 'read-skill-instructions' || nextActionType === 'pull-indexed-context') {
       return '';
     }
 
@@ -1404,6 +2259,7 @@ const { pathToFileURL } = require('url');
   const projectRoot = process.env.PROJECT_ROOT || process.cwd();
   const statePath = process.env.STATE_FILE || path.join(projectRoot, '.claude', 'ukit', 'skill-router-state.json');
   const routeCachePath = path.join(projectRoot, '.claude', 'ukit', 'route-cache.json');
+  const routeAuditPath = path.join(projectRoot, '.ukit', 'storage', 'cache', 'route-audit.json');
   const cacheUtilsPath = path.join(projectRoot, '.claude', 'ukit', 'index', 'cache-utils.mjs');
   const previous = readJson(statePath, {});
   const runtimeConfig = loadRuntimeConfig(projectRoot);
@@ -1426,12 +2282,18 @@ const { pathToFileURL } = require('url');
     commandNormalizedText: buildRouteSignalText(commandText),
     fileText: String(filePath || '').toLowerCase(),
   };
+  const intentMode = deriveIntentMode({
+    promptText,
+    commandText,
+    targetFile: filePath,
+  });
 
   const catalog = await loadRouteCatalog(projectRoot);
 
   const active = catalog
     .map((entry) => scoreSkillRouteEntry(entry, routeSignals))
-    .filter((entry) => entry.score > 0 && existsSkill(projectRoot, entry.path));
+    .filter((entry) => entry.score > 0 && existsSkill(projectRoot, entry.path))
+    .filter((entry) => shouldKeepRouteEntryForIntent(entry, intentMode));
 
   const now = Date.now();
   const debounceMs = 10 * 60 * 1000;
@@ -1498,6 +2360,28 @@ const { pathToFileURL } = require('url');
     selectedIds,
     buildRouteSignalText,
   });
+  const executionScores = deriveExecutionScores({
+    promptText,
+    commandText,
+    targetFile: filePath,
+    intentMode,
+    taskType,
+  });
+  const executionCandidates = buildExecutionModeCandidates({
+    promptText,
+    commandText,
+    targetFile: filePath,
+    intentMode,
+    executionScores,
+  });
+  const executionMode = deriveExecutionMode({
+    promptText,
+    commandText,
+    targetFile: filePath,
+    intentMode,
+    executionScores,
+    executionCandidates,
+  });
   const lastExplicitUserPromptText = promptText.trim()
     || previous?.routingContext?.lastExplicitUserPromptText
     || '';
@@ -1508,6 +2392,10 @@ const { pathToFileURL } = require('url');
     targetFile: filePath,
     contextIntent,
     taskType,
+    intentMode,
+    executionScores,
+    executionCandidates,
+    executionMode,
   };
   const useIndexedContext = shouldUseIndexedContext({
     activeSkills: selected,
@@ -1565,12 +2453,26 @@ const { pathToFileURL } = require('url');
     && cachedRouteState?.routeSummary
     && Array.isArray(cachedRouteState?.activeSkills)
   ) {
+    const rescuedRouteSummary = cachedRouteState.routeSummary
+      ? {
+          ...cachedRouteState.routeSummary,
+          continuationState: advanceContinuationState(
+            cachedRouteState.routeSummary.continuationState || null,
+            cachedRouteState.routeSummary.continuationState || null,
+          ),
+        }
+      : null;
+    if (rescuedRouteSummary) {
+      applyRescueBiasToRouteSummary(rescuedRouteSummary);
+    }
     const reusedState = {
       ...cachedRouteState,
       source: 'skill-router',
       ts: now,
       requestKey,
+      routeSummary: rescuedRouteSummary,
     };
+    reusedState.fingerprint = buildRouteStateFingerprint(reusedState);
 
     if (previous?.fingerprint === reusedState.fingerprint && now - previousTs < debounceMs) {
       process.exit(0);
@@ -1578,6 +2480,9 @@ const { pathToFileURL } = require('url');
 
     ensureDir(statePath);
     fs.writeFileSync(statePath, JSON.stringify(reusedState));
+    appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
+      state: reusedState,
+    }));
 
     process.stdout.write(`[ukit-skill-router] Read skills: ${getActiveSkillPaths(reusedState.activeSkills || []).join(', ')}\n`);
     process.stdout.write(`[ukit-skill-router] Route: ${formatDisplayRouteSummary(reusedState.routeSummary, reusedState.routingContext)}\n`);
@@ -1588,7 +2493,11 @@ const { pathToFileURL } = require('url');
     if (reusedState.routeSummary?.delegateHint) {
       process.stdout.write(`[ukit-skill-router] Delegate: ${reusedState.routeSummary.delegateHint}\n`);
     }
-    if (reusedState.routeSummary?.helperHint && !reusedState.routeSummary?.nextActionCommand) {
+    if (
+      reusedState.routeSummary?.helperHint
+      && !reusedState.routeSummary?.nextActionCommand
+      && reusedState.routeSummary?.nextActionType !== 'pull-indexed-context'
+    ) {
       process.stdout.write(`[ukit-skill-router] Helper: ${reusedState.routeSummary.helperHint}\n`);
     }
     process.exit(0);
@@ -1618,13 +2527,18 @@ const { pathToFileURL } = require('url');
     contextRecommendation,
     verificationRecommendation,
   });
-  const routeSummary = buildRouteSummary({
-    activeSkills: selected,
-    routingContext,
-    contextRecommendation,
-    verificationRecommendation,
-    nextAction,
-  });
+    const routeSummary = buildRouteSummary({
+      activeSkills: selected,
+      routingContext,
+      contextRecommendation,
+      verificationRecommendation,
+      nextAction,
+    });
+    routeSummary.continuationState = advanceContinuationState(
+      routeSummary.continuationState,
+      previous?.routeSummary?.continuationState || null,
+    );
+    applyRescueBiasToRouteSummary(routeSummary);
 
   const fingerprint = buildRouteStateFingerprint({
     activeSkills: selected,
@@ -1654,6 +2568,11 @@ const { pathToFileURL } = require('url');
     routeSummary: compactRouteSummary(routeSummary),
   };
   fs.writeFileSync(statePath, JSON.stringify(sharedState));
+  appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
+    routingContext,
+    routeSummary,
+    state: sharedState,
+  }));
   if (typeof cacheUtils?.writeRecentCacheEntry === 'function') {
     await cacheUtils.writeRecentCacheEntry(routeCachePath, compactRouteCacheState(sharedState), {
       maxEntries: cacheUtils.DEFAULT_RECENT_CACHE_MAX_ENTRIES,
@@ -1669,9 +2588,13 @@ const { pathToFileURL } = require('url');
   if (routeSummary.delegateHint) {
     process.stdout.write(`[ukit-skill-router] Delegate: ${routeSummary.delegateHint}\n`);
   }
-  if (routeSummary.helperHint && !routeSummary.nextActionCommand) {
-    process.stdout.write(`[ukit-skill-router] Helper: ${routeSummary.helperHint}\n`);
-  }
+    if (
+      routeSummary.helperHint
+      && !routeSummary.nextActionCommand
+      && routeSummary.nextActionType !== 'pull-indexed-context'
+    ) {
+      process.stdout.write(`[ukit-skill-router] Helper: ${routeSummary.helperHint}\n`);
+    }
 })().catch(() => {
   process.exit(0);
 });