@ngockhoale/ukit 1.4.0 → 1.4.2

package/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to UKit are documented here.
 
 ## Unreleased
 
+## 1.4.2 - 2026-05-10
+
+### Added
+
+- Added a quality-first internal orchestration ladder with seven execution layers: `tiny-fix`, `local-fix`, `local-build`, `find-cause`, `shared-edit`, `map-impact`, and `review-release`.
+- Added structured route continuity state so installed helpers and hooks can carry `completionState`, `continuationState`, and stuck-lane rescue signals across turns instead of forgetting unfinished execution debt.
+- Added orchestration/runtime config defaults and Codex adapter metadata for the internal advisor/orchestrator contract while keeping the teammate workflow centered on `ukit install`.
+
+### Fixed
+
+- Kept context routing and context-mode hints internal so UKit no longer surfaces `pull-indexed-context`, `resolve-context`, or `mode=LITE/FULL` in the main route prose for ordinary work.
+- Preserved the structured route state (`nextActionType`, `helperHint`, `contextMode`) for internal orchestration, while removing the user/model-facing leakage that was nudging sessions into micro-step stop-and-wait behavior.
+- Hardened implementation routing and installed agent guidance so explicit implement/apply/fix requests keep moving through bounded read → edit → verify flow instead of stopping after read-only inspection.
+- Escalated repeated unfinished returns with `repeatCount`, `stuckRisk`, and `rescueMode` so UKit can rescue a stuck lane instead of quietly looping the same partial milestone.
+- Fixed the installed `route-task` continuation handoff so previous route summaries are carried through correctly during rescue escalation.
+
+### Tests
+
+- Added/updated route, hook, reinject, install-pipeline, and package-artifact coverage for internal helper hiding, continuation rescue escalation, and the expanded orchestration contract.
+
+## 1.4.1 - 2026-05-09
+
+- Completed cleanup and 1.4.1 template alignment.
+
 ## 1.4.0 - 2026-05-09
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Install/update an index-first AI workspace for Claude Code, Antigravity, OpenAI Codex, and OpenCode.",
   "license": "MIT",
   "type": "module",

package/src/bug/triageBug.js

@@ -1,6 +1,7 @@
 import { queryCodeIndex } from '../index/queryIndex.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { detectPackageManager } from '../core/packageManager.js';
 import { inferRelatedTestsFromArtifacts, loadRelatedTestArtifacts } from '../index/relatedTests.js';
 
 const DEEP_KEYWORDS = ['race', 'flaky', 'intermittent', 'timeout', 'deadlock'];
@@ -88,36 +89,3 @@ async function buildTestCommand(rootDir, testFile) {
   // npm default
   return `npm test -- ${testFile}`;
 }
-
-async function detectPackageManager(rootDir) {
-  const packageJsonPath = path.join(rootDir, 'package.json');
-  try {
-    const raw = await fs.readFile(packageJsonPath, 'utf8');
-    const pkg = JSON.parse(raw);
-    const declared = String(pkg?.packageManager ?? '').toLowerCase();
-    if (declared.startsWith('pnpm')) return 'pnpm';
-    if (declared.startsWith('yarn')) return 'yarn';
-    if (declared.startsWith('bun')) return 'bun';
-    if (declared.startsWith('npm')) return 'npm';
-  } catch {
-    // fall through to lockfile detection
-  }
-
-  const checks = [
-    ['pnpm-lock.yaml', 'pnpm'],
-    ['yarn.lock', 'yarn'],
-    ['bun.lockb', 'bun'],
-    ['package-lock.json', 'npm'],
-  ];
-
-  for (const [lockfile, pm] of checks) {
-    try {
-      await fs.access(path.join(rootDir, lockfile));
-      return pm;
-    } catch {
-      // continue
-    }
-  }
-
-  return 'npm';
-}

package/src/cli/commands/install.js

@@ -106,6 +106,9 @@ export async function pruneDeselectedAdapters({
   createInterface = readline.createInterface,
 }) {
   const retainedManagedPaths = [];
+  const retainPaths = (paths) => {
+    retainedManagedPaths.push(...paths);
+  };
   const installMetaPath = path.join(projectRoot, '.claude', 'ukit', '.ukit', 'install.json');
   const deselectedKeys = getDeselectedAdapterKeys(optionalToolKeys);
   if (deselectedKeys.length === 0) {
@@ -139,11 +142,7 @@ export async function pruneDeselectedAdapters({
   const { input: inputStream, output: outputStream } = io;
   if (!inputStream?.isTTY || !outputStream?.isTTY) {
     const adapterNames = existingDeselectedAdapters.map(({ adapter }) => adapter.label).join(', ');
-    await removeTrackedPathsFromMetadata({
-      installMetaPath,
-      projectRoot,
-      removeRelativePaths: existingDeselectedAdapters.flatMap(({ existingManagedPaths }) => existingManagedPaths),
-    });
+    retainPaths(existingDeselectedAdapters.flatMap(({ existingManagedPaths }) => existingManagedPaths));
     console.log(
       `[UKit] Deselected adapters with existing files detected (${adapterNames}). Skipping removal in non-interactive mode.`,
     );
@@ -160,11 +159,7 @@ export async function pruneDeselectedAdapters({
       );
 
       if (!shouldRemove) {
-        await removeTrackedPathsFromMetadata({
-          installMetaPath,
-          projectRoot,
-          removeRelativePaths: existingManagedPaths,
-        });
+        retainPaths(existingManagedPaths);
         continue;
       }
 

package/src/context/detectProjectContext.js

@@ -1,27 +1,6 @@
 import path from 'node:path';
-import { pathExists, readJsonIfExists } from '../core/fileOps.js';
-
-async function inferPackageManager(projectRoot, packageJson) {
-  // packageManager field takes priority over lockfiles — it is an explicit
-  // declaration of intent, while lockfiles may be stale (e.g. old yarn.lock
-  // leftover after switching to npm).
-  const declared = packageJson?.packageManager;
-  if (typeof declared === 'string') {
-    if (declared.startsWith('yarn@')) return 'yarn';
-    if (declared.startsWith('pnpm@')) return 'pnpm';
-    if (declared.startsWith('npm@')) return 'npm';
-  }
-
-  if (await pathExists(path.join(projectRoot, 'yarn.lock'))) {
-    return 'yarn';
-  }
-
-  if (await pathExists(path.join(projectRoot, 'pnpm-lock.yaml'))) {
-    return 'pnpm';
-  }
-
-  return 'npm';
-}
+import { readJsonIfExists } from '../core/fileOps.js';
+import { detectPackageManager } from '../core/packageManager.js';
 
 function inferProjectName(projectRoot, packageJson) {
   if (typeof packageJson?.name === 'string' && packageJson.name.trim() !== '') {
@@ -41,7 +20,7 @@ export async function detectProjectContext(projectRoot) {
       name: inferProjectName(projectRoot, packageJson),
     },
     runtime: {
-      packageManager: await inferPackageManager(projectRoot, packageJson),
+      packageManager: await detectPackageManager(projectRoot, packageJson),
       os: process.platform,
       nodeVersion: process.version,
     },

package/src/core/compact/index.js

@@ -1,6 +1,6 @@
 import { readJsonIfExists, writeJson } from '../fileOps.js';
 import { buildRuntimePaths } from '../runtimePaths.js';
-import { compressLine, compressMarkdownLines, estimateTokenCount } from '../token/index.js';
+import { compressLine, compressMarkdownLines, estimateTokenCount, normalizeLineForDedupe, uniqueLines } from '../token/index.js';
 
 export const DEFAULT_COMPACT_HISTORY_MAX_ENTRIES = 50;
 const DEFAULT_MAX_COMPACT_ANCHORS = 3;
@@ -132,27 +132,6 @@ function normalizeAnchorPattern(pattern) {
   return null;
 }
 
-function normalizeLineForDedupe(line) {
-  return String(line ?? '').trim().replace(/\s+/g, ' ').toLowerCase();
-}
-
-function uniqueLines(lines) {
-  const seen = new Set();
-  const unique = [];
-
-  for (const line of lines) {
-    const trimmed = String(line ?? '').trim();
-    const normalized = normalizeLineForDedupe(trimmed);
-    if (!normalized || seen.has(normalized)) {
-      continue;
-    }
-    seen.add(normalized);
-    unique.push(trimmed);
-  }
-
-  return unique;
-}
-
 function resolveAnchorLines(rawLines, { header = null, anchorLines = [], anchorPatterns = [], maxAnchors = DEFAULT_MAX_COMPACT_ANCHORS } = {}) {
   const predicates = anchorPatterns
     .map((pattern) => normalizeAnchorPattern(pattern))
@@ -182,6 +161,7 @@ function buildCompactedContextLines(
     forceFirstCount = 0,
   } = {},
 ) {
+  const hardTokenCap = Math.max(maxTokens, Math.ceil(maxTokens * 2));
   const sourceLines = Array.isArray(lines) ? lines : [];
   const selected = [];
   const seen = new Set();
@@ -201,19 +181,24 @@ function buildCompactedContextLines(
 
     const tokens = estimateTokenCount(compressed);
     const forceLine = nonEmptyCount < forceFirstCount;
-    const wouldOverflow = selected.length > 0 && (usedTokens + tokens) > maxTokens;
     const wouldExceedLines = nonEmptyCount >= maxLines;
 
-    if (!forceLine && (wouldOverflow || wouldExceedLines)) {
+    if (wouldExceedLines || (!forceLine && selected.length > 0 && (usedTokens + tokens) > maxTokens)) {
       break;
     }
-    if (forceLine && wouldExceedLines) {
+
+    const selectedLine = forceLine && (usedTokens + tokens) > hardTokenCap
+      ? truncateToTokenBudget(compressed, hardTokenCap - usedTokens)
+      : compressed;
+    const selectedTokens = estimateTokenCount(selectedLine);
+
+    if (!selectedLine) {
       break;
     }
 
-    selected.push(compressed);
+    selected.push(selectedLine);
     seen.add(dedupeKey);
-    usedTokens += tokens;
+    usedTokens += selectedTokens;
     nonEmptyCount += 1;
   }
 
@@ -236,6 +221,13 @@ function findMissingAnchors(text, anchorLines) {
   });
 }
 
+function truncateToTokenBudget(line, maxTokens) {
+  if (maxTokens <= 0) return '';
+  const maxChars = Math.max(1, (maxTokens * 4) - 4);
+  const value = String(line ?? '');
+  return value.length <= maxChars ? value : `${value.slice(0, Math.max(1, maxChars - 1)).trimEnd()}…`;
+}
+
 export async function readCompactHistory(projectRoot, options = {}) {
   const runtimePaths = buildRuntimePaths(projectRoot);
   const raw = await readJsonIfExists(runtimePaths.compactHistoryPath);

package/src/core/ensureGitignore.js

@@ -59,7 +59,7 @@ export async function ensureGitignore(projectRoot) {
     .split('\n')
     .map((l) => l.trim())
     .filter((trimmed) => trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('!'));
-  const missing = UKIT_ENTRIES.filter((e) => !activeLines.some((l) => l.includes(e)));
+  const missing = UKIT_ENTRIES.filter((e) => !activeLines.some((l) => l === e));
   if (missing.length === 0) {
     return false;
   }

package/src/core/fileOps.js

@@ -14,8 +14,11 @@ export async function readJsonIfExists(filePath) {
   try {
     const raw = await fs.readFile(filePath, 'utf8');
     return JSON.parse(raw);
-  } catch {
-    return null;
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return null;
+    }
+    throw error;
   }
 }
 
@@ -23,6 +26,42 @@ export function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+async function isDirEmpty(dirPath) {
+  try {
+    const entries = await fs.readdir(dirPath);
+    return entries.length === 0;
+  } catch {
+    return false;
+  }
+}
+
+export async function cleanupEmptyParents(targetPath, projectRoot) {
+  let currentDir = path.dirname(targetPath);
+  const stopDir = path.resolve(projectRoot);
+
+  while (currentDir !== stopDir) {
+    const relative = path.relative(stopDir, currentDir);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+      break;
+    }
+
+    let stat;
+    try {
+      stat = await fs.lstat(currentDir);
+    } catch {
+      currentDir = path.dirname(currentDir);
+      continue;
+    }
+
+    if (!stat.isDirectory() || !(await isDirEmpty(currentDir))) {
+      break;
+    }
+
+    await fs.rmdir(currentDir);
+    currentDir = path.dirname(currentDir);
+  }
+}
+
 export function resolveProjectRelativePath(projectRoot, relPath) {
   if (typeof relPath !== 'string') {
     return null;

package/src/core/memory/hygiene.js

@@ -141,8 +141,24 @@ function archiveSessions(projectMemory, config) {
   return archived;
 }
 
-export function runHygiene(projectMemory, config = {}) {
+function normalizeConfig(config = {}) {
   const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  return {
+    ...mergedConfig,
+    archiveAfterDays: Number.isFinite(mergedConfig.archiveAfterDays) && mergedConfig.archiveAfterDays > 0
+      ? mergedConfig.archiveAfterDays
+      : DEFAULT_CONFIG.archiveAfterDays,
+    maxSessionsKept: Number.isInteger(mergedConfig.maxSessionsKept) && mergedConfig.maxSessionsKept > 0
+      ? mergedConfig.maxSessionsKept
+      : DEFAULT_CONFIG.maxSessionsKept,
+    redactPatterns: Array.isArray(mergedConfig.redactPatterns)
+      ? mergedConfig.redactPatterns
+      : DEFAULT_CONFIG.redactPatterns,
+  };
+}
+
+export function runHygiene(projectMemory, config = {}) {
+  const mergedConfig = normalizeConfig(config);
   const nextMemory = redactValue(clone(projectMemory), mergedConfig.redactPatterns);
 
   nextMemory.conventions = uniqueStrings(nextMemory.conventions);

package/src/core/memory/store.js

@@ -85,28 +85,6 @@ function createSearchableText(type, content) {
   ].filter(Boolean).join('\n');
 }
 
-function computeRelevance(searchableText, query) {
-  if (!query) {
-    return 1;
-  }
-
-  const haystack = searchableText.toLowerCase();
-  const needle = query.toLowerCase();
-  if (!haystack.includes(needle)) {
-    return 0;
-  }
-
-  const parts = needle.split(/\s+/).filter(Boolean);
-  let score = 1;
-  for (const part of parts) {
-    if (haystack.includes(part)) {
-      score += 1;
-    }
-  }
-
-  return score;
-}
-
 export async function exportMemory(projectRoot) {
   const runtimePaths = buildRuntimePaths(projectRoot);
   const user = (await readJsonIfExists(runtimePaths.userMemoryPath)) ?? defaultUserMemory();
@@ -150,18 +128,6 @@ export async function listMemoryItems(projectRoot) {
   ];
 }
 
-export async function searchMemoryItems(projectRoot, query, { limit = 10 } = {}) {
-  const items = await listMemoryItems(projectRoot);
-  return items
-    .map((item) => ({
-      ...item,
-      relevanceScore: computeRelevance(`${item.summary}\n${item.searchableText}`, query),
-    }))
-    .filter((item) => item.relevanceScore > 0)
-    .sort((left, right) => right.relevanceScore - left.relevanceScore)
-    .slice(0, limit);
-}
-
 export async function forgetMemoryItem(projectRoot, memoryId) {
   const runtimePaths = buildRuntimePaths(projectRoot);
   if (memoryId === 'user:user' || memoryId === 'user') {
@@ -169,11 +135,18 @@ export async function forgetMemoryItem(projectRoot, memoryId) {
     return { removed: true, type: 'user', path: runtimePaths.userMemoryPath };
   }
 
-  const [type, rawId] = String(memoryId).split(':');
-  if (!type || !rawId) {
+  const id = String(memoryId);
+  const separatorIndex = id.indexOf(':');
+  if (separatorIndex <= 0 || separatorIndex === id.length - 1) {
     return { removed: false, type: null, path: null };
   }
 
+  const type = id.slice(0, separatorIndex);
+  const rawId = id.slice(separatorIndex + 1);
+  if (rawId.includes('/') || rawId.includes('\\') || rawId === '..') {
+    return { removed: false, type, path: null };
+  }
+
   const baseDir = type === 'project'
     ? runtimePaths.projectsDir
     : type === 'session'
@@ -184,6 +157,11 @@ export async function forgetMemoryItem(projectRoot, memoryId) {
   }
 
   const targetPath = path.join(baseDir, `${rawId}.json`);
+  const relativeTarget = path.relative(path.resolve(baseDir), path.resolve(targetPath));
+  if (!relativeTarget || relativeTarget.startsWith('..') || path.isAbsolute(relativeTarget)) {
+    return { removed: false, type, path: null };
+  }
+
   try {
     await fs.unlink(targetPath);
     return { removed: true, type, path: targetPath };

package/src/core/metadata.js

@@ -111,17 +111,17 @@ export async function removeTrackedPathsFromMetadata({
     return;
   }
 
-  const normalizedTargets = new Set(
-    removeRelativePaths.map((relPath) => relPath && relPath.replace(/\\/g, '/')),
-  );
+  const targetPaths = [...new Set(removeRelativePaths
+    .map((relPath) => (typeof relPath === 'string' ? relPath.trim().replace(/\\/g, '/') : ''))
+    .filter(Boolean))];
 
   const filteredFiles = metadata.files.filter((entry) => {
     const p = typeof entry === 'string' ? entry : entry?.p;
     if (!p) {
       return true;
     }
-    const normalized = p.replace(/\\/g, '/');
-    return ![...normalizedTargets].some((targetPath) => isSameOrDescendantPath(normalized, targetPath));
+    const normalized = p.trim().replace(/\\/g, '/');
+    return !targetPaths.some((targetPath) => isSameOrDescendantPath(normalized, targetPath));
   });
 
   if (filteredFiles.length === metadata.files.length) {

package/src/core/output/index.js

@@ -8,7 +8,9 @@ import {
   compressLine,
   compressMarkdownLines,
   estimateTokenCount,
+  normalizeLineForDedupe,
   readPromptCacheEntry,
+  uniqueLines,
   writePromptCacheEntry,
 } from '../token/index.js';
 
@@ -191,10 +193,6 @@ function splitLines(value) {
     .map((line) => line.replace(/\s+$/g, ''));
 }
 
-function normalizeLineForDedupe(line) {
-  return String(line ?? '').trim().replace(/\s+/g, ' ').toLowerCase();
-}
-
 function matchesAnyPattern(line, patterns = []) {
   return patterns.some((pattern) => pattern.test(line));
 }
@@ -284,7 +282,8 @@ function buildRecoveryFileName({
     profile: String(profile ?? 'generic').trim(),
     exitCode: Number.isFinite(Number(exitCode)) ? Number(exitCode) : null,
   }).split(':').at(-1)?.replace(/[^a-z0-9_-]/gi, '-').slice(0, 16) || 'recovery';
-  return `${slug}-${fingerprint}.log`;
+  const uniqueSuffix = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  return `${slug}-${uniqueSuffix}-${fingerprint}.log`;
 }
 
 function buildRawOutputText({ command = '', stdout = '', stderr = '', exitCode = null } = {}) {
@@ -425,6 +424,7 @@ function isTailSummaryLine(line, profile = null) {
 }
 
 function buildCompactedSummaryLines(lines, { maxTokens = 180, maxLines = 10, forceFirstCount = 1 } = {}) {
+  const hardTokenCap = Math.max(maxTokens, Math.ceil(maxTokens * 2));
   const sourceLines = Array.isArray(lines) ? lines : [];
   const selected = [];
   const seen = new Set();
@@ -440,19 +440,24 @@ function buildCompactedSummaryLines(lines, { maxTokens = 180, maxLines = 10, for
 
     const tokens = estimateTokenCount(compressed);
     const forceLine = nonEmptyCount < forceFirstCount;
-    const wouldOverflow = selected.length > 0 && (usedTokens + tokens) > maxTokens;
     const wouldExceedLines = nonEmptyCount >= maxLines;
 
-    if (!forceLine && (wouldOverflow || wouldExceedLines)) {
+    if (wouldExceedLines || (!forceLine && selected.length > 0 && (usedTokens + tokens) > maxTokens)) {
       break;
     }
-    if (forceLine && wouldExceedLines) {
+
+    const selectedLine = forceLine && (usedTokens + tokens) > hardTokenCap
+      ? truncateToTokenBudget(compressed, hardTokenCap - usedTokens)
+      : compressed;
+    const selectedTokens = estimateTokenCount(selectedLine);
+
+    if (!selectedLine) {
       break;
     }
 
-    selected.push(compressed);
+    selected.push(selectedLine);
     seen.add(dedupeKey);
-    usedTokens += tokens;
+    usedTokens += selectedTokens;
     nonEmptyCount += 1;
   }
 
@@ -471,16 +476,11 @@ function findMissingAnchors(summary, anchorLines) {
   });
 }
 
-function uniqueLines(lines) {
-  const seen = new Set();
-  const unique = [];
-  for (const line of lines) {
-    const normalized = normalizeLineForDedupe(line);
-    if (!normalized || seen.has(normalized)) continue;
-    seen.add(normalized);
-    unique.push(String(line ?? '').trim());
-  }
-  return unique;
+function truncateToTokenBudget(line, maxTokens) {
+  if (maxTokens <= 0) return '';
+  const maxChars = Math.max(1, (maxTokens * 4) - 4);
+  const value = String(line ?? '');
+  return value.length <= maxChars ? value : `${value.slice(0, Math.max(1, maxChars - 1)).trimEnd()}…`;
 }
 
 function looksLikeSearchPath(filePath) {

package/src/core/packageManager.js

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { pathExists } from './fileOps.js';
+
+export const PACKAGE_MANAGER_LOCKFILES = [
+  ['pnpm-lock.yaml', 'pnpm'],
+  ['yarn.lock', 'yarn'],
+  ['bun.lockb', 'bun'],
+  ['bun.lock', 'bun'],
+  ['package-lock.json', 'npm'],
+];
+
+export function getDeclaredPackageManager(pkg = null) {
+  const declared = String(pkg?.packageManager ?? '').toLowerCase();
+  if (declared.startsWith('pnpm')) return 'pnpm';
+  if (declared.startsWith('yarn')) return 'yarn';
+  if (declared.startsWith('bun')) return 'bun';
+  if (declared.startsWith('npm')) return 'npm';
+  return null;
+}
+
+export async function detectPackageManager(projectRoot, packageJson = null) {
+  const declaredPackageManager = getDeclaredPackageManager(packageJson);
+  if (declaredPackageManager) return declaredPackageManager;
+
+  for (const [lockfile, packageManager] of PACKAGE_MANAGER_LOCKFILES) {
+    if (await pathExists(path.join(projectRoot, lockfile))) {
+      return packageManager;
+    }
+  }
+
+  return 'npm';
+}
+
+export function detectPackageManagerFromFingerprint({ fingerprintEntries = [], pkg = null } = {}) {
+  const declaredPackageManager = getDeclaredPackageManager(pkg);
+  if (declaredPackageManager) return declaredPackageManager;
+
+  const existingFiles = new Set(
+    fingerprintEntries
+      .filter((entry) => entry && entry.mtimeMs !== null)
+      .map((entry) => entry.filePath),
+  );
+
+  for (const [lockfile, packageManager] of PACKAGE_MANAGER_LOCKFILES) {
+    if (existingFiles.has(lockfile)) {
+      return packageManager;
+    }
+  }
+
+  return 'npm';
+}

package/src/core/router/router.js

@@ -30,6 +30,22 @@ function normalize(text) {
   return String(text ?? '').toLowerCase();
 }
 
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function matchesKeyword(text, keyword) {
+  if (keyword.startsWith('.')) {
+    return new RegExp(`(?:^|[\\s/\\\\])[^\\s/\\\\]+${escapeRegExp(keyword)}(?:$|[\\s)\\],.;:])`).test(text);
+  }
+
+  if (keyword.includes(' ')) {
+    return new RegExp(`\\b${keyword.split(/\\s+/).map(escapeRegExp).join('\\\\s+')}\\b`).test(text);
+  }
+
+  return new RegExp(`\\b${escapeRegExp(keyword)}\\b`).test(text);
+}
+
 function countFileHints(text) {
   const explicitCount = Number.parseInt(normalize(text).match(/\b(\d+)\s+files?\b/)?.[1] ?? '0', 10);
   const pathMatches = normalize(text).match(/\b[\w./-]+\.(?:js|ts|tsx|jsx|json|md|yaml|yml)\b/g) ?? [];
@@ -41,8 +57,8 @@ export function detectComplexity(message, context = '') {
   const wordCount = combined.split(/\s+/).filter(Boolean).length;
   const fileHints = countFileHints(combined);
   const hasRetryPattern = /\b(retry|failed|failure|attempt)\b/.test(combined);
-  const highSignals = HIGH_COMPLEXITY_KEYWORDS.filter((keyword) => combined.includes(keyword)).length;
-  const lowSignals = LOW_COMPLEXITY_KEYWORDS.filter((keyword) => combined.includes(keyword)).length;
+  const highSignals = HIGH_COMPLEXITY_KEYWORDS.filter((keyword) => matchesKeyword(combined, keyword)).length;
+  const lowSignals = LOW_COMPLEXITY_KEYWORDS.filter((keyword) => matchesKeyword(combined, keyword)).length;
 
   if (highSignals > 0 || fileHints > 5 || (hasRetryPattern && /\b(debug|error|crash|stack trace)\b/.test(combined))) {
     return 'high';
@@ -58,19 +74,19 @@ export function detectComplexity(message, context = '') {
 function detectTaskType(message, context = '', complexity = 'medium') {
   const combined = normalize(`${message}\n${context}`);
 
-  if (DEBUG_KEYWORDS.some((keyword) => combined.includes(keyword)) && complexity === 'high') {
+  if (DEBUG_KEYWORDS.some((keyword) => matchesKeyword(combined, keyword)) && complexity === 'high') {
     return 'debug_hard';
   }
 
-  if (HIGH_COMPLEXITY_KEYWORDS.some((keyword) => combined.includes(keyword))) {
+  if (HIGH_COMPLEXITY_KEYWORDS.some((keyword) => matchesKeyword(combined, keyword))) {
     return 'reasoning';
   }
 
-  if (REVIEW_KEYWORDS.some((keyword) => combined.includes(keyword))) {
+  if (REVIEW_KEYWORDS.some((keyword) => matchesKeyword(combined, keyword))) {
     return 'review';
   }
 
-  if (CODING_HINTS.some((keyword) => combined.includes(keyword))) {
+  if (CODING_HINTS.some((keyword) => matchesKeyword(combined, keyword))) {
     return 'coding';
   }