@ngockhoale/ukit 1.4.1 → 1.4.2

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|login|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';
+    }
+
+    if ((inferred === 'simple' || inferred === 'trivial') && isSharedImpactFile(targetFile)) {
+      return 'shared-simple';
     }
 
-    return 'simple';
+    return inferred;
   }
 
   function shellEscape(value) {
@@ -1129,6 +1305,21 @@ 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 approachSelector = buildApproachSelectorResult({
+      executionMode,
+      executionScores,
+    });
+    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 +1343,12 @@ const { pathToFileURL } = require('url');
       fallbackCommands,
       preferredOrder,
       policyMode,
+      executionMode,
+      executionScores,
+      approachSelector,
+      executionContract,
+      completionState,
+      continuationState,
       delegateHint: delegationRecommendation?.hint || null,
       nextActionType: nextAction?.type || null,
       nextActionCommand,
@@ -1160,6 +1357,396 @@ 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);
+
+    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 (/\b(failing|broken|error|crash|timeout)\b/.test(raw)) {
+      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,
+    };
+  }
+
+  function deriveExecutionMode({
+    promptText = '',
+    commandText = '',
+    targetFile = null,
+    intentMode = null,
+    executionScores = {},
+  } = {}) {
+    const raw = `${promptText || ''}\n${commandText || ''}`.toLowerCase();
+    const scores = executionScores;
+    const explicitReviewLead = /\b(review this|audit this|review\b.*\brelease readiness|verify\b.*\brelease readiness)\b/.test(raw);
+
+    if (intentMode === 'review-specific' || explicitReviewLead) {
+      return 'review-release';
+    }
+
+    if (scores.blastRadius >= 3 && (scores.ambiguity >= 2 || scores.investigationNeed >= 2)) {
+      return 'map-impact';
+    }
+
+    if (scores.blastRadius >= 3 || isSharedImpactFile(targetFile)) {
+      return 'shared-edit';
+    }
+
+    if (scores.investigationNeed >= 3) {
+      return 'find-cause';
+    }
+
+    if (
+      scores.editCertainty >= 3
+      && scores.ambiguity === 0
+      && scores.blastRadius === 0
+      && scores.verificationBurden <= 1
+    ) {
+      return 'tiny-fix';
+    }
+
+    if (
+      /\b(build|create|add|implement|feature|summary card)\b/.test(raw)
+      && scores.investigationNeed === 0
+      && scores.blastRadius < 3
+    ) {
+      return 'local-build';
+    }
+
+    if (scores.editCertainty >= 2 && scores.investigationNeed === 0 && scores.blastRadius === 0) {
+      return 'local-fix';
+    }
+
+    return 'local-build';
+  }
+
+  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,
+  } = {}) {
+    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,
+    };
+  }
+
+  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,
+    };
+  }
+
+  function advanceContinuationState(continuationState = null, previousContinuationState = null) {
+    if (!continuationState || typeof continuationState !== 'object') {
+      return continuationState;
+    }
+
+    if (!continuationState.required) {
+      return {
+        ...continuationState,
+        repeatCount: 0,
+        stuckRisk: null,
+        rescueMode: 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);
+
+    return {
+      ...continuationState,
+      repeatCount,
+      stuckRisk,
+      rescueMode,
+    };
+  }
+
+  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 +1855,8 @@ const { pathToFileURL } = require('url');
     return {
       lastExplicitUserPromptText: routingContext.lastExplicitUserPromptText || '',
       taskType: routingContext.taskType || null,
+      intentMode: routingContext.intentMode || null,
+      executionMode: routingContext.executionMode || null,
     };
   }
 
@@ -1299,6 +1888,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,
@@ -1373,7 +1968,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 '';
     }
 
@@ -1426,12 +2021,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 +2099,21 @@ const { pathToFileURL } = require('url');
     selectedIds,
     buildRouteSignalText,
   });
+  const executionScores = deriveExecutionScores({
+    promptText,
+    commandText,
+    targetFile: filePath,
+    intentMode,
+    taskType,
+  });
+  const executionMode = deriveExecutionMode({
+    promptText,
+    commandText,
+    targetFile: filePath,
+    intentMode,
+    taskType,
+    executionScores,
+  });
   const lastExplicitUserPromptText = promptText.trim()
     || previous?.routingContext?.lastExplicitUserPromptText
     || '';
@@ -1508,6 +2124,9 @@ const { pathToFileURL } = require('url');
     targetFile: filePath,
     contextIntent,
     taskType,
+    intentMode,
+    executionScores,
+    executionMode,
   };
   const useIndexedContext = shouldUseIndexedContext({
     activeSkills: selected,
@@ -1565,12 +2184,23 @@ 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;
     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);
@@ -1588,7 +2218,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 +2252,17 @@ 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,
+    );
 
   const fingerprint = buildRouteStateFingerprint({
     activeSkills: selected,
@@ -1669,9 +2307,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);
 });