@ngockhoale/ukit 2.2.11 → 2.2.14

package/CHANGELOG.md

@@ -2,6 +2,93 @@
 
 All notable changes to UKit are documented here.
 
+## 2.2.14 - 2026-09-05
+
+The context hard-cap gate no longer bricks healthy sessions with a phantom token count. The
+tracker behind `compact.hardCapTokens` accumulates every prompt and tool output across a
+session, and it only reset on the PreCompact hook — which fires for a manual `/compact` but not
+for every harness auto-compact path (SDK/VSCode being the known gap). A session whose live
+context had been compacted down to almost nothing could therefore reach a tracked 528k against
+the 500k cap: Read/Grep stayed open but every Edit/Write/Bash was refused, and the user saw the
+assistant freeze with no error. Every real compaction — manual or automatic — now also leaves a
+`compact_boundary` entry in the session transcript, so `compact-threshold.mjs` rebase the
+counter from that record (`syncCompactPressureStateWithTranscript`, stamped
+`lastCompactBoundaryAt` so each boundary resets exactly once). Both the prompt-time hook and
+`context-hardcap-gate.sh` sync before acting, and the reset is persisted so the gate re-arms
+instead of disabling itself.
+
+When the cap is genuinely reached, the model is now ordered to tell the user instead of going
+quiet. The hard-phase prompt warning and the gate's block message both lead with an explicit
+directive — tell the user "gõ /compact ngay" as the first sentence of the reply, since typing
+"continue" alone hits the same block — and the advisory soft phase tells the model to surface
+`/compact` at the next natural pause. `context-window-guard.sh`'s overflow directive likewise
+demands the compact instruction as the first sentence rather than a buried suggestion.
+
+Vietnamese concrete bug reports route to the debug lane again. Signals such as `lỗi`, `sửa`,
+`đăng nhập`, `đang ở đâu` were written inside `\b(...)\b`, but JavaScript `\b` is ASCII-only and
+those words have diacritic edges, so the patterns could never match — "app bị lỗi khi đăng nhập,
+sửa giúp tôi" fell through to informational lanes while the identical English prompt routed
+correctly. All Vietnamese intent patterns in the router and catalog now use explicit
+`(?<![A-Za-z0-9_])` / `(?![A-Za-z0-9_])` edges; regression tests cover the debug-lane prompt,
+the open-ended status question, and hook-level state.
+
+## 2.2.13 - 2026-09-05
+
+Question-shaped prompts no longer get blocked by the completion gate. "Đây là lỗi gì?",
+"model bạn đang dùng là model gì", or "what is this error?" route to the informational lane and
+answer freely; only prompts that actually ask for a change (fix/sửa/build/…) still owe write and
+verification evidence before claiming done. Two layered causes: the Vietnamese question pattern
+only matched adjacent `là gì` (missing "là model gì" / "là lỗi gì"), and the `\blỗi` veto never
+fired at all — JavaScript `\b` word boundaries don't exist around diacritic characters. A
+`strongQuestion` signal (an explicit `?`, a leading interrogative, or the Vietnamese pattern) now
+overrides error-wording vetoes, while "error when I run tests" and "why is build failing?" still
+route to investigation.
+
+The source-code index understands SQL from the canonical source, not just the installed mirror.
+`CREATE TABLE/VIEW/FUNCTION/PROCEDURE/INDEX/TYPE` and `ALTER TABLE` statements are extracted as
+symbols with schema-qualified names captured by their bare object name (`qas.fn_rpt_billing` →
+`fn_rpt_billing`), and `.sql` files are tracked and code-indexed. The schema bump had previously
+landed only in the runtime mirror; `src/index/` now carries the same v8 schema so the mirror-parity
+test holds and the `scripts/index` lane benefits too.
+
+The handoff model-tier guard closes an under-block found while scenario-testing it. Once a real
+`EXECUTOR_MODEL` or `REVIEWER_MODEL` was on disk, an in-place rewrite could silently demote the
+executor to a lite tier or set executor == reviewer; validation now also fires when an
+already-real model line changes value (same-model rewrites and upward escalation stay free). The
+push-time backstop was unaffected — this moves the rejection to write time, where it belongs.
+
+`handoff.maxParallelAgents` template default is now 2, matching the operator setting; the config
+help prose no longer claims a default of 12 one line above a configured 2.
+
+## 2.2.12 - 2026-09-04
+
+`ukit install` and `ukit update` now clean up broken Claude Code hook registrations automatically.
+
+A hook whose stdout contains a `hookSpecificOutput` object without the required `hookEventName`
+field fails Claude Code's schema validation on **every** tool call, surfacing as a repeating
+`PreToolUse:<Tool> hook error — Hook JSON output validation failed`. Such a hook has no effect
+either way, since its output is discarded — it produces nothing but noise.
+
+New `src/core/repairBrokenHooks.js` detects that shape generically (not keyed to any one vendor)
+across user settings, project settings, and `settings.local.json`, expanding
+`$CLAUDE_PROJECT_DIR`/`$HOME`/`~` in hook commands and also catching hooks inlined into
+`settings.json` instead of a script file. Offending registrations are removed after a
+`.ukit-backup` restore point is written next to each settings file. Detection matches only real
+key assignments, so prose mentions of the field in a hook's own comments or docstrings never
+trigger a removal.
+
+Wired into the install pipeline; since `ukit update` re-runs `ukit install`, both commands are
+covered with no new flags or commands to learn — teammates still only need `ukit install`.
+
+Scope is deliberate: UKit removes the *registration* only. An unregistered hook script never
+executes, so that is sufficient, and UKit does not delete the script file or uninstall the tool
+that wrote it. When the owning tool can be identified from the hook source, the install report
+names it and notes that it may re-register on activation, leaving permanent removal as a human
+decision.
+
+Known real-world instance: VSCode extension `tjcg.auto-accept-claude-code` v0.5.0 hardcodes two
+such hook templates and rewrites its hook file on activation.
+
 ## 2.2.11 - 2026-08-29
 
 Same-day follow-up to 2.2.10. The two premises that release shipped as unverified were checked

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "2.2.11",
+  "version": "2.2.14",
   "description": "Install/update an index-first AI workspace for Claude Code, OpenAI Codex, OpenCode, and omp (Oh My Pi).",
   "license": "MIT",
   "type": "module",

package/src/cli/commands/install.js

@@ -1,5 +1,6 @@
 import { buildPathConfig } from '../../core/paths.js';
 import { runInstallPipeline } from '../../core/runInstallPipeline.js';
+import { formatRepairReport } from '../../core/repairBrokenHooks.js';
 import { buildCodeIndex } from '../../index/buildIndex.js';
 import { installIndexRefreshHooks } from '../../index/gitHooks.js';
 import fs from 'node:fs/promises';
@@ -238,6 +239,10 @@ export async function runInstall({ packageRoot, projectRoot, packageVersion, arg
     .join(', ');
   console.log(`[UKit] Providers: ${providerStatus}, all=${result.providerContext.allSupported}`);
 
+  for (const line of formatRepairReport(result.hookRepair ?? { removals: [], files: [] })) {
+    console.log(`[UKit] ${line}`);
+  }
+
   const docsLabels = [
     'docs/PROJECT.md',
     'docs/MEMORY.md',

package/src/core/repairBrokenHooks.js

@@ -0,0 +1,240 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+// Claude Code rejects any hook whose stdout carries a `hookSpecificOutput` object
+// without `hookEventName` inside it, and surfaces it as a per-tool-call
+// "Hook JSON output validation failed" error. A hook in that state never has any
+// effect - its output is discarded - so removing its registration only removes noise.
+//
+// Detection is deliberately generic rather than keyed to one known-bad extension:
+// any tool that ships this shape produces the same failure.
+
+// Only real key assignments count. Prose mentions of the field inside docstrings
+// and comments are common in hook SDKs and must not trigger a removal.
+const HOOK_OUTPUT_KEY = /["']hookSpecificOutput["']\s*\]?\s*[:=]/g;
+
+// How far past the key to look for the sibling field. Generous enough for a
+// formatted object literal, short enough not to reach an unrelated later block.
+const SIBLING_SCAN_WINDOW = 400;
+
+// Paths in a hook command string, e.g. "$CLAUDE_PROJECT_DIR/.claude/hooks/x.sh".
+const SCRIPT_PATH = /["']?((?:\/|~|\$\{?[A-Z_]+\}?\/)[^"'\s]+\.(?:sh|ps1|py|js|mjs|cjs|bash|zsh))["']?/g;
+
+// e.g. "# Auto-Accept Extension: PreToolUse hook" -> "Auto-Accept Extension"
+const OWNER_HINT = /^[#/\s]*([A-Z][\w-]*(?:\s+[\w-]+)*\s+Extension)\b/m;
+
+/**
+ * True when `source` assigns hookSpecificOutput without a nearby hookEventName.
+ */
+export function hasBrokenHookShape(source) {
+  if (typeof source !== 'string') {
+    return false;
+  }
+
+  HOOK_OUTPUT_KEY.lastIndex = 0;
+  let match = HOOK_OUTPUT_KEY.exec(source);
+  while (match) {
+    const window = source.slice(match.index, match.index + SIBLING_SCAN_WINDOW);
+    if (!window.includes('hookEventName')) {
+      HOOK_OUTPUT_KEY.lastIndex = 0;
+      return true;
+    }
+    match = HOOK_OUTPUT_KEY.exec(source);
+  }
+
+  return false;
+}
+
+function expandPath(rawPath, { projectRoot, homeDir }) {
+  return rawPath
+    .replace(/\$\{?CLAUDE_PROJECT_DIR\}?/g, projectRoot)
+    .replace(/\$\{?HOME-?\}?/g, homeDir)
+    .replace(/^~/, homeDir);
+}
+
+function extractScriptPaths(command, { projectRoot, homeDir }) {
+  const paths = [];
+  SCRIPT_PATH.lastIndex = 0;
+  let match = SCRIPT_PATH.exec(command);
+  while (match) {
+    paths.push(expandPath(match[1], { projectRoot, homeDir }));
+    match = SCRIPT_PATH.exec(command);
+  }
+  return paths;
+}
+
+async function readFileIfExists(filePath) {
+  try {
+    return await fs.readFile(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Inspect one registered hook command. Returns null when it is fine, or
+ * { source, ownerHint } describing where the broken shape was found.
+ */
+async function inspectHookCommand(command, { projectRoot, homeDir }) {
+  if (typeof command !== 'string' || !command) {
+    return null;
+  }
+
+  for (const scriptPath of extractScriptPaths(command, { projectRoot, homeDir })) {
+    const contents = await readFileIfExists(scriptPath);
+    if (contents !== null && hasBrokenHookShape(contents)) {
+      return { source: scriptPath, ownerHint: OWNER_HINT.exec(contents)?.[1] ?? null };
+    }
+  }
+
+  // Some tools inline the whole hook body into settings.json instead of a script.
+  if (hasBrokenHookShape(command)) {
+    return { source: '<inline command>', ownerHint: null };
+  }
+
+  return null;
+}
+
+/**
+ * Drop broken hook entries from one parsed settings object.
+ * Mutates `settings` and returns the removals found.
+ */
+async function stripBrokenHooks(settings, { projectRoot, homeDir }) {
+  const removals = [];
+  const events = settings?.hooks;
+  if (!events || typeof events !== 'object' || Array.isArray(events)) {
+    return removals;
+  }
+
+  for (const [event, groups] of Object.entries(events)) {
+    if (!Array.isArray(groups)) {
+      continue;
+    }
+
+    const keptGroups = [];
+    for (const group of groups) {
+      if (!group || typeof group !== 'object') {
+        keptGroups.push(group);
+        continue;
+      }
+
+      const hooks = Array.isArray(group.hooks) ? group.hooks : null;
+      if (!hooks) {
+        keptGroups.push(group);
+        continue;
+      }
+
+      const keptHooks = [];
+      for (const hook of hooks) {
+        const finding = await inspectHookCommand(hook?.command, { projectRoot, homeDir });
+        if (finding) {
+          removals.push({ event, matcher: group.matcher ?? '', ...finding });
+        } else {
+          keptHooks.push(hook);
+        }
+      }
+
+      // A group that was already empty stays as-is; only drop groups we emptied.
+      if (keptHooks.length === 0 && hooks.length > 0) {
+        continue;
+      }
+
+      group.hooks = keptHooks;
+      keptGroups.push(group);
+    }
+
+    if (keptGroups.length > 0) {
+      events[event] = keptGroups;
+    } else {
+      delete events[event];
+    }
+  }
+
+  return removals;
+}
+
+function backupPathFor(settingsPath) {
+  return `${settingsPath}.ukit-backup`;
+}
+
+/**
+ * Remove Claude Code hook registrations that would fail schema validation on every
+ * tool call, from the user-level and project-level settings files.
+ *
+ * Registration removal alone is enough: an unregistered script is never executed.
+ * The script file itself is left on disk untouched - it belongs to whichever tool
+ * wrote it, and deleting another tool's files is not UKit's call.
+ *
+ * @returns {Promise<{removals: Array, files: string[]}>}
+ */
+export async function repairBrokenHooks({ projectRoot, homeDir = os.homedir() } = {}) {
+  const candidates = [
+    path.join(homeDir, '.claude', 'settings.json'),
+    path.join(projectRoot, '.claude', 'settings.json'),
+    path.join(projectRoot, '.claude', 'settings.local.json'),
+  ];
+
+  const removals = [];
+  const files = [];
+
+  for (const settingsPath of candidates) {
+    const raw = await readFileIfExists(settingsPath);
+    if (raw === null) {
+      continue;
+    }
+
+    let settings;
+    try {
+      settings = JSON.parse(raw);
+    } catch {
+      // Malformed settings are not ours to rewrite.
+      continue;
+    }
+
+    const found = await stripBrokenHooks(settings, { projectRoot, homeDir });
+    if (found.length === 0) {
+      continue;
+    }
+
+    // Keep a restore point before touching a file the user did not ask us to edit.
+    await fs.writeFile(backupPathFor(settingsPath), raw, 'utf8');
+    await fs.writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
+
+    files.push(settingsPath);
+    removals.push(...found.map((entry) => ({ ...entry, settingsPath })));
+  }
+
+  return { removals, files };
+}
+
+/**
+ * Human-readable lines for the install/update report. Empty array when nothing was repaired.
+ */
+export function formatRepairReport({ removals, files }) {
+  if (!removals || removals.length === 0) {
+    return [];
+  }
+
+  const lines = [
+    `Removed ${removals.length} broken Claude Code hook registration(s).`,
+    'They emitted hookSpecificOutput without hookEventName, so every tool call failed',
+    'schema validation and the hook never actually ran.',
+  ];
+
+  for (const removal of removals) {
+    const owner = removal.ownerHint ? ` (${removal.ownerHint})` : '';
+    lines.push(`  - ${removal.event}: ${removal.source}${owner}`);
+  }
+
+  const owners = [...new Set(removals.map((entry) => entry.ownerHint).filter(Boolean))];
+  if (owners.length > 0) {
+    lines.push(
+      `Warning: ${owners.join(', ')} rewrites its hook on activation, so this can come back.`,
+      'Uninstall that extension to stop it for good - UKit will not remove it for you.',
+    );
+  }
+
+  lines.push(`Backup: ${files.map((file) => `${file}.ukit-backup`).join(', ')}`);
+  return lines;
+}

package/src/core/runInstallPipeline.js

@@ -12,6 +12,7 @@ import { summarizeDiff, toDiffRows } from './report.js';
 import { writeInstallMetadata } from './metadata.js';
 import { cleanupLegacyPaths, migrateLegacyRuntimeRoot } from './migrateLegacy.js';
 import { ensureGitignore } from './ensureGitignore.js';
+import { repairBrokenHooks } from './repairBrokenHooks.js';
 import { cleanupEmptyParents, readJsonIfExists, removeFileOrLinkOnly, resolveProjectRelativePath } from './fileOps.js';
 
 const AUTO_PRUNE_OBSOLETE_PREFIXES = [
@@ -316,6 +317,13 @@ export async function runInstallPipeline({
     }
 
     await ensureGitignore(pathConfig.projectRoot);
+
+    // A hook that emits hookSpecificOutput without hookEventName fails Claude Code's
+    // schema check on every tool call, so it only ever produces noise. Teammates are
+    // not expected to know that - `ukit install` (and `ukit update`, which re-runs
+    // install) clears it for them. Backups are written next to each settings file.
+    const hookRepair = await repairBrokenHooks({ projectRoot: pathConfig.projectRoot });
+
     await pruneObsoleteManagedPaths({
       installMetaData,
       projectRoot: pathConfig.projectRoot,
@@ -350,6 +358,7 @@ export async function runInstallPipeline({
       summary,
       rows: toDiffRows(diffResults),
       writes,
+      hookRepair,
     };
   }
 
@@ -361,5 +370,6 @@ export async function runInstallPipeline({
     summary: plannedSummary,
     rows: toDiffRows(diffResults),
     writes: [],
+    hookRepair: { removals: [], files: [] },
   };
 }

package/src/index/buildIndex.js

@@ -29,11 +29,11 @@ const EXCLUDED_DIR_NAMES = new Set([
   '.venv',
   'venv',
 ]);
-const CODE_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue']);
+const CODE_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue', '.sql']);
 const STYLE_EXTENSIONS = new Set(['.css', '.scss', '.sass', '.less']);
 // `.sh` is tracked but never parsed, like `.md`/`.json`/`.yaml` — it is matched
 // by path only. Without it every shipped hook script was invisible to the index.
-const TRACKED_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue', '.json', '.yaml', '.yml', '.md', '.sh']);
+const TRACKED_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue', '.sql', '.json', '.yaml', '.yml', '.md', '.sh']);
 const DISCOVERED_EXTENSIONS = new Set([...TRACKED_EXTENSIONS, ...STYLE_EXTENSIONS]);
 export const DEFAULT_INDEX_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const INDEX_PARSE_BATCH_SIZE = 8;
@@ -729,6 +729,19 @@ export function extractSymbols(filePath, content) {
     }
   };
 
+  if (filePath.endsWith('.sql')) {
+    // Capture the object name, skipping an optional schema qualifier (qas.fn_rpt_billing → fn_rpt_billing).
+    const sqlIdent = '(?:(?:["`]?[A-Za-z_][A-Za-z0-9_$]*["`]?)\\s*\\.\\s*)?["`]?([A-Za-z_][A-Za-z0-9_$]*)["`]?';
+    addMatches(new RegExp(`CREATE\\s+(?:OR\\s+REPLACE\\s+)?TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'table');
+    addMatches(new RegExp(`CREATE\\s+(?:OR\\s+REPLACE\\s+)?VIEW\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'view');
+    addMatches(new RegExp(`CREATE\\s+(?:OR\\s+REPLACE\\s+)?FUNCTION\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'function');
+    addMatches(new RegExp(`CREATE\\s+(?:OR\\s+REPLACE\\s+)?PROCEDURE\\s+${sqlIdent}`, 'gi'), 'procedure');
+    addMatches(new RegExp(`CREATE\\s+(?:UNIQUE\\s+)?INDEX\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'index');
+    addMatches(new RegExp(`CREATE\\s+(?:TYPE|DOMAIN|SEQUENCE|MATERIALIZED\\s+VIEW)\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'type');
+    addMatches(new RegExp(`ALTER\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'table');
+    return dedupeBy(symbols, (item) => `${item.filePath}:${item.type}:${item.name}`);
+  }
+
   addMatches(/export\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'function');
   addMatches(/export\s+class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'class');
   addMatches(/(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?\(/g, 'callable');

package/src/index/paths.js

@@ -13,7 +13,7 @@ export const INDEX_ARTIFACTS = {
   analogs: 'analogs.json',
 };
 
-export const INDEX_SCHEMA_VERSION = 7;
+export const INDEX_SCHEMA_VERSION = 8;
 
 export function getIndexDir(rootDir) {
   return path.join(rootDir, '.cache', 'index');

package/src/index/routeCatalog.js

@@ -234,7 +234,7 @@ export const ROUTE_CATALOG = [
     contextMode: 'standalone',
     signals: [
       { type: 'prompt', regex: /\b(what(?:'s| is)? next|next steps?|project status|current status|where are we|continue(?: from)?(?: last session)?|roadmap|status\.md|task queue|tasks\.md|next queued task|pick next task|work from tasks)\b/i, score: 7 },
-      { type: 'prompt', regex: /\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/i, score: 7 },
+      { type: 'prompt', regex: /(?<![A-Za-z0-9_])(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)(?![A-Za-z0-9_])/i, score: 7 },
     ],
   },
   {

package/src/index/taskRouting.js

@@ -960,7 +960,7 @@ function hasHandoffSignal(lower, raw) {
     || /\b(ai handoff|handoff phase|handoff mode|clear handoff|update handoff|start handoff|handoff clear)\b/.test(lower)
     || /\b(brainstorm|idea dump|ideas?).{0,80}\b(handoff|tasks?|taskify|split|breakdown)\b/.test(lower)
     || /\b(handoff|tasks?|taskify|split|breakdown).{0,80}\b(brainstorm|idea dump|ideas?)\b/.test(lower)
-    || /\b(gom|chia|tach|tách|lên|len|xóa|clear|dọn).{0,80}\b(idea|ý tưởng|y tuong|task|công việc|cong viec|handoff)\b/.test(raw)
+    || /(?<![A-Za-z0-9_])(gom|chia|tach|tách|lên|len|xóa|clear|dọn).{0,80}(?<![A-Za-z0-9_])(idea|ý tưởng|y tuong|task|công việc|cong viec|handoff)(?![A-Za-z0-9_])/.test(raw)
     || /\b(bàn giao|ban giao).{0,80}\b(ai|task|công việc|cong viec)\b/.test(raw);
 }
 
@@ -980,7 +980,7 @@ function hasStatusUpdateSignal(lower, 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);
+    || /(?<![A-Za-z0-9_])(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)(?![A-Za-z0-9_])/.test(raw);
 }
 
 function hasTaskQueueNextSignal(lower, raw) {
@@ -994,7 +994,7 @@ function hasConcreteTaskSignal(lower, raw, targetFile, { taskQueueNext = false }
   }
 
   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);
+    || /(?<![A-Za-z0-9_])(sửa|fix|lỗi|bug|debug|implement|cài|thêm|review|kiểm tra|soát|đăng nhập)(?![A-Za-z0-9_])/.test(raw);
 }
 
 function hasDocsSpecificTaskSignal(lower, raw, targetFile, { taskQueueNext = false } = {}) {
@@ -1017,11 +1017,11 @@ function hasDocsSpecificTaskSignal(lower, raw, targetFile, { taskQueueNext = fal
 
     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);
+      || /(?<![A-Za-z0-9_])(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)(?![A-Za-z0-9_])/.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);
+    || /(?<![A-Za-z0-9_])(mẫu|câu chữ|chỉnh|sửa chữ|ngữ pháp|định dạng|cấu trúc|tài liệu)(?![A-Za-z0-9_])/.test(raw);
 }
 
 function hasExplicitStatusUpdateSignal(lower, raw) {

package/templates/.claude/hooks/context-hardcap-gate.sh

@@ -100,7 +100,21 @@ function readRunCursor() {
   const mod = await import(pathToFileURL(thresholdModulePath).href);
   const pressurePath = path.join(projectRoot, '.ukit', 'storage', 'cache', 'compact-pressure.json');
   const rawState = readJsonSafe(pressurePath, null);
-  const state = mod.buildCompactPressureState(rawState, config);
+
+  // A compaction the PreCompact hook missed (SDK/VSCode auto-compact) leaves the tracked
+  // counter counting history that was already summarised away — the exact failure that
+  // bricks a healthy session at this cap. The transcript's own compact_boundary entries
+  // are the reliable record of real compactions, so sync before deciding, and persist the
+  // reset so it re-arms exactly once per boundary instead of disabling the gate.
+  let state = mod.buildCompactPressureState(rawState, config);
+  try {
+    const synced = await mod.syncCompactPressureStateWithTranscript(rawState, config, payload.transcript_path);
+    if (synced.reset) {
+      state = await mod.writeCompactPressureState(projectRoot, synced.state, config);
+    }
+  } catch {
+    state = mod.buildCompactPressureState(rawState, config);
+  }
   const thresholds = mod.buildCompactThresholds(config);
 
   const gracePath = path.join(projectRoot, '.ukit', 'storage', 'cache', 'hardcap-grace.json');
@@ -140,6 +154,7 @@ function readRunCursor() {
           `An unfinished run is in flight (Phase: ${run.phase}${run.cursor ? `, Cursor: ${run.cursor}` : ''}), so this call is allowed instead of stranding it mid-edit.`,
           'Spend the remaining grace on LANDING, not on new work: finish the current edit, commit, update docs/AI_HANDOFF/RUN.md, push.',
           'Do NOT start a new task, open new files, or spawn agents. When grace runs out the gate blocks hard.',
+          'Tell the user in your reply that context is over the cap and they should run /compact as soon as this run lands.',
           'After the user runs /compact, the SessionStart resume hook replays the cursor and the run continues automatically.',
         ].join('\n') + '\n',
       );
@@ -150,12 +165,13 @@ function readRunCursor() {
 
   const lines = [
     `BLOCKED (context hard cap): estimated context ~${state.estimatedTotalTokens} tokens >= hard cap ${thresholds.hardCapTokens}.`,
+    'FIRST ACTION IN YOUR REPLY — tell the user plainly, do not just stop silently: "Context đã đầy — hãy gõ /compact ngay (run /compact now)".',
+    'Typing "continue" alone will hit this same block; only /compact (or a new session) resets the counter. After compacting, resume the interrupted task.',
     'This is an absolute ceiling (compact.hardCapTokens), separate from the soft/hard advisory phases — those were apparently not followed.',
     `Edit/Write/Bash refused (tool_name=${toolName}) until real compaction happens.`,
     run
       ? 'The unfinished-run grace window (compact.hardCapGraceCalls) is already exhausted — progress should be committed and the cursor written by now.'
       : 'No unfinished run in docs/AI_HANDOFF/RUN.md, so there is no grace window to spend.',
-    'Remedy (any one): run /compact, or start a new session (SessionStart resets the counter), or delete .ukit/storage/cache/compact-pressure.json.',
     'Do not work around this by summarizing inline and continuing, and do not reach for a non-gated write tool.',
   ];
   process.stderr.write(`${lines.join('\n')}\n`);

package/templates/.claude/hooks/context-window-guard.sh

@@ -211,7 +211,7 @@ if (withinCooldown) {
   lines_out.push('ACTION THIS TURN, before starting new investigation/subagents/pipeline phases:');
   lines_out.push('1) Persist current progress now (update docs/STATUS.md, e.g. via the update-status skill) so nothing is lost.');
   lines_out.push('2) If the remaining work still has multiple steps or pipeline phases left, split what remains into bounded docs/AI_HANDOFF tasks instead of continuing in this one thread — smaller phases keep each turn under the cap.');
-  lines_out.push('3) Otherwise, tell the user plainly: run /compact now, or wrap up and start a fresh session — work already committed/persisted to disk is not lost.');
+  lines_out.push('3) Otherwise, make the user\'s next action the FIRST sentence of your reply so it cannot be missed: "Context sắp đầy — gõ /compact ngay (run /compact now)", or wrap up and start a fresh session — work already committed/persisted to disk is not lost. Do not keep working silently until tools start being refused.');
   if (sidechainEntries > 0) {
     lines_out.push(`Note: ${sidechainEntries} subagent entries in this stretch — each teammate carries its own context window, and every finished report is injected back here, so running many at once is the fastest way to overflow this session. Avoid spawning more until context drops back under the cap.`);
   }

package/templates/.claude/hooks/handoff-model-guard.sh

@@ -60,6 +60,20 @@ function extractField(text, name) {
   return matches[matches.length - 1][1].trim();
 }
 
+// Phase-section detection and model extraction must run on visible content only:
+// task/plan templates carry `## Executor Report` / `## Reviewer Verdict` inside HTML
+// comments, and matching those made plain task creation fail with reviewer/executor
+// model errors (the Phase 2 misfire).
+function stripHtmlComments(text) {
+  return String(text || '').replace(/<!--[\s\S]*?-->/g, '');
+}
+
+function isPlaceholderValue(value) {
+  const raw = String(value || '').trim();
+  if (!raw || /^[<(]/.test(raw)) return true;
+  return ['-','--','tbd','todo','n/a','na','none','unknown','pending'].includes(raw.toLowerCase());
+}
+
 if (toolName === 'Write' || toolName === 'Edit') {
   const filePath = String(input.file_path || '');
   if (!filePath) process.exit(0);
@@ -84,9 +98,11 @@ if (toolName === 'Write' || toolName === 'Edit') {
       : currentContent.replace(oldStr, newStr);
   }
   const newContent = resultingContent();
+  const newVisible = stripHtmlComments(newContent);
+  const currentVisible = stripHtmlComments(currentContent);
 
-  if (isPlan && /## Planner Report/.test(newContent)) {
-    const plannerModel = extractField(newContent, 'PLANNER_MODEL');
+  if (isPlan && /## Planner Report/.test(newVisible)) {
+    const plannerModel = extractField(newVisible, 'PLANNER_MODEL');
     if (!plannerModel || /^unknown$/i.test(plannerModel)) {
       block('PLANNER_MODEL missing/unknown in PLAN.md. Planning must run via Agent tool subagent_type: "handoff-planner" (opus/unic-smart) and self-report its model.');
     }
@@ -102,42 +118,96 @@ if (toolName === 'Write' || toolName === 'Edit') {
     const taskId = taskMatch[1];
     const planPath = path.join(projectRoot, 'docs/AI_HANDOFF/PLAN.md');
 
-    const isFreshTaskFile = !fileExists && !/## Executor Report|## Reviewer Verdict/.test(newContent);
+    const hasExecutorReport = /## Executor Report/.test(newVisible);
+    const hasReviewerVerdict = /## Reviewer Verdict/.test(newVisible);
+    const isFreshTaskFile = !fileExists;
     if (isFreshTaskFile) {
       const planContent = fs.existsSync(planPath) ? fs.readFileSync(planPath, 'utf8') : '';
-      const plannerModel = extractField(planContent, 'PLANNER_MODEL');
+      const plannerModel = extractField(stripHtmlComments(planContent), 'PLANNER_MODEL');
       if (!plannerModel || tierOf(plannerModel) !== 'smart') {
         block(`Cannot create ${taskId}.md — PLAN.md has no valid smart-tier PLANNER_MODEL yet. Run planning via Agent tool subagent_type: "handoff-planner" (opus/unic-smart) first.`);
       }
     }
 
-    if (/## Executor Report/.test(newContent) && !/## Executor Report/.test(currentContent)) {
-      const executorModel = extractField(newContent, 'EXECUTOR_MODEL');
-      if (!executorModel || /^unknown$/i.test(executorModel)) {
-        block(`${taskId}: EXECUTOR_MODEL missing/unknown. Implementation must run via Agent tool subagent_type: "feature-implementer" (sonnet/unic-code) and self-report its model.`);
+    // A section already on disk only counts as validated when its model is real —
+    // otherwise a placeholder skeleton created at Phase 2 could be silently promoted
+    // to a "real" report without ever passing tier validation.
+    const currentExecutorReal = /## Executor Report/.test(currentVisible)
+      && !isPlaceholderValue(extractField(currentVisible, 'EXECUTOR_MODEL'));
+    if (hasExecutorReport && !currentExecutorReal) {
+      const executorModel = extractField(newVisible, 'EXECUTOR_MODEL');
+      if (isPlaceholderValue(executorModel) || /^unknown$/i.test(executorModel)) {
+        if (!isFreshTaskFile) {
+          block(`${taskId}: EXECUTOR_MODEL missing/placeholder. Implementation must run via Agent tool subagent_type: "feature-implementer" (sonnet/unic-code) and self-report its model.`);
+        }
+        // Else: skeleton sections copied from a task template at creation time — the
+        // real Executor Report is appended in Phase 3 and validated there.
+      } else {
+        if (tierOf(executorModel) === 'vision') {
+          block(`${taskId}: EXECUTOR_MODEL "${executorModel}" ${VISION_LANE_MESSAGE}`);
+        }
+        if (tierOf(executorModel) === 'lite') {
+          block(`${taskId}: EXECUTOR_MODEL "${executorModel}" is lite tier. Implementation must run on at least sonnet/unic-code, never haiku/unic-lite.`);
+        }
       }
-      if (tierOf(executorModel) === 'vision') {
-        block(`${taskId}: EXECUTOR_MODEL "${executorModel}" ${VISION_LANE_MESSAGE}`);
-      }
-      if (tierOf(executorModel) === 'lite') {
-        block(`${taskId}: EXECUTOR_MODEL "${executorModel}" is lite tier. Implementation must run on at least sonnet/unic-code, never haiku/unic-lite.`);
+    } else if (hasExecutorReport && currentExecutorReal) {
+      // An in-place rewrite of an already-real model line must not silently demote the
+      // tier or collide with the reviewer; the push-time check would catch it, but the
+      // violating report should never be accepted onto disk in the first place.
+      const previousExecutorModel = extractField(currentVisible, 'EXECUTOR_MODEL');
+      const executorModel = extractField(newVisible, 'EXECUTOR_MODEL');
+      if (executorModel && previousExecutorModel && executorModel !== previousExecutorModel) {
+        if (tierOf(executorModel) === 'vision') {
+          block(`${taskId}: EXECUTOR_MODEL "${executorModel}" ${VISION_LANE_MESSAGE}`);
+        }
+        if (tierOf(executorModel) === 'lite') {
+          block(`${taskId}: EXECUTOR_MODEL "${executorModel}" is lite tier. Implementation must run on at least sonnet/unic-code, never haiku/unic-lite.`);
+        }
+        const verdictModel = extractField(newVisible, 'REVIEWER_MODEL');
+        if (!isPlaceholderValue(verdictModel) && verdictModel.toLowerCase() === executorModel.toLowerCase()) {
+          block(`${taskId}: EXECUTOR_MODEL ("${executorModel}") matches REVIEWER_MODEL ("${verdictModel}") — reviewer must differ from executor.`);
+        }
       }
     }
 
-    if (/## Reviewer Verdict/.test(newContent) && !/## Reviewer Verdict/.test(currentContent)) {
-      const executorModel = extractField(currentContent, 'EXECUTOR_MODEL') || extractField(newContent, 'EXECUTOR_MODEL');
-      const reviewerModel = extractField(newContent, 'REVIEWER_MODEL');
-      if (!reviewerModel || /^unknown$/i.test(reviewerModel)) {
-        block(`${taskId}: REVIEWER_MODEL missing/unknown. Review must run via Agent tool subagent_type: "code-reviewer" (opus/unic-smart) and self-report its model.`);
-      }
-      if (tierOf(reviewerModel) === 'vision') {
-        block(`${taskId}: REVIEWER_MODEL "${reviewerModel}" ${VISION_LANE_MESSAGE}`);
-      }
-      if (tierOf(reviewerModel) !== 'smart') {
-        block(`${taskId}: REVIEWER_MODEL "${reviewerModel}" is not strong/opus tier. Review must run via Agent tool subagent_type: "code-reviewer" (opus/unic-smart).`);
+    const currentReviewerReal = /## Reviewer Verdict/.test(currentVisible)
+      && !isPlaceholderValue(extractField(currentVisible, 'REVIEWER_MODEL'));
+    if (hasReviewerVerdict && !currentReviewerReal) {
+      const executorModel = extractField(currentVisible, 'EXECUTOR_MODEL') || extractField(newVisible, 'EXECUTOR_MODEL');
+      const reviewerModel = extractField(newVisible, 'REVIEWER_MODEL');
+      if (isPlaceholderValue(reviewerModel) || /^unknown$/i.test(reviewerModel)) {
+        if (!isFreshTaskFile) {
+          block(`${taskId}: REVIEWER_MODEL missing/placeholder. Review must run via Agent tool subagent_type: "code-reviewer" (opus/unic-smart) and self-report its model.`);
+        }
+        // Else: skeleton Reviewer Verdict on a freshly created task file — Phase 4
+        // appends the real verdict and it is validated there.
+      } else {
+        if (tierOf(reviewerModel) === 'vision') {
+          block(`${taskId}: REVIEWER_MODEL "${reviewerModel}" ${VISION_LANE_MESSAGE}`);
+        }
+        if (tierOf(reviewerModel) !== 'smart') {
+          block(`${taskId}: REVIEWER_MODEL "${reviewerModel}" is not strong/opus tier. Review must run via Agent tool subagent_type: "code-reviewer" (opus/unic-smart).`);
+        }
+        if (executorModel && reviewerModel && executorModel.toLowerCase() === reviewerModel.toLowerCase()) {
+          block(`${taskId}: REVIEWER_MODEL ("${reviewerModel}") matches EXECUTOR_MODEL — reviewer must differ from executor. Re-run review through a different subagent/model.`);
+        }
       }
-      if (executorModel && reviewerModel && executorModel.toLowerCase() === reviewerModel.toLowerCase()) {
-        block(`${taskId}: REVIEWER_MODEL ("${reviewerModel}") matches EXECUTOR_MODEL — reviewer must differ from executor. Re-run review through a different subagent/model.`);
+    } else if (hasReviewerVerdict && currentReviewerReal) {
+      // Mirror of the executor in-place rule: a real reviewer verdict must not be
+      // rewritten onto a weaker tier or onto the executor's own model.
+      const previousReviewerModel = extractField(currentVisible, 'REVIEWER_MODEL');
+      const reviewerModel = extractField(newVisible, 'REVIEWER_MODEL');
+      if (reviewerModel && previousReviewerModel && reviewerModel !== previousReviewerModel) {
+        if (tierOf(reviewerModel) === 'vision') {
+          block(`${taskId}: REVIEWER_MODEL "${reviewerModel}" ${VISION_LANE_MESSAGE}`);
+        }
+        if (tierOf(reviewerModel) !== 'smart') {
+          block(`${taskId}: REVIEWER_MODEL "${reviewerModel}" is not strong/opus tier. Review must run via Agent tool subagent_type: "code-reviewer" (opus/unic-smart).`);
+        }
+        const executorModel = extractField(newVisible, 'EXECUTOR_MODEL');
+        if (!isPlaceholderValue(executorModel) && executorModel.toLowerCase() === reviewerModel.toLowerCase()) {
+          block(`${taskId}: REVIEWER_MODEL ("${reviewerModel}") matches EXECUTOR_MODEL — reviewer must differ from executor. Re-run review through a different subagent/model.`);
+        }
       }
     }
   }
@@ -160,7 +230,7 @@ if (toolName === 'Bash') {
   for (const taskId of taskIds) {
     const taskPath = path.join(projectRoot, `docs/AI_HANDOFF/tasks/${taskId}.md`);
     if (!fs.existsSync(taskPath)) continue;
-    const text = fs.readFileSync(taskPath, 'utf8');
+    const text = stripHtmlComments(fs.readFileSync(taskPath, 'utf8'));
     if (!text.includes('## Reviewer Verdict')) continue; // not yet reviewed, not this push's concern
 
     // A documented, human-approved exception (e.g. an opus-tier executor escalation left no
@@ -172,10 +242,10 @@ if (toolName === 'Bash') {
     const executorModel = extractField(text, 'EXECUTOR_MODEL');
     const reviewerModel = extractField(text, 'REVIEWER_MODEL');
 
-    if (!executorModel || /^unknown$/i.test(executorModel)) problems.push(`${taskId}: EXECUTOR_MODEL missing/unknown`);
+    if (isPlaceholderValue(executorModel) || /^unknown$/i.test(executorModel)) problems.push(`${taskId}: EXECUTOR_MODEL missing/placeholder`);
     else if (tierOf(executorModel) === 'lite') problems.push(`${taskId}: EXECUTOR_MODEL "${executorModel}" is lite tier`);
 
-    if (!reviewerModel || /^unknown$/i.test(reviewerModel)) problems.push(`${taskId}: REVIEWER_MODEL missing/unknown`);
+    if (isPlaceholderValue(reviewerModel) || /^unknown$/i.test(reviewerModel)) problems.push(`${taskId}: REVIEWER_MODEL missing/placeholder`);
     else if (tierOf(reviewerModel) !== 'smart') problems.push(`${taskId}: REVIEWER_MODEL "${reviewerModel}" is not opus/unic-smart tier`);
 
     if (executorModel && reviewerModel && executorModel.toLowerCase() === reviewerModel.toLowerCase()) {

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

@@ -331,7 +331,7 @@ const { pathToFileURL } = require('url');
   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);
+      || /(?<![A-Za-z0-9_])(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)(?![A-Za-z0-9_])/.test(raw);
   }
 
   function hasTaskQueueNextSignal(lower, raw) {
@@ -345,7 +345,7 @@ const { pathToFileURL } = require('url');
     }
 
     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);
+      || /(?<![A-Za-z0-9_])(sửa|fix|lỗi|bug|debug|implement|cài|thêm|review|kiểm tra|soát|đăng nhập)(?![A-Za-z0-9_])/.test(raw);
   }
 
   function hasDocsSpecificTaskSignal(lower, raw, targetFile, { taskQueueNext = false } = {}) {
@@ -368,11 +368,11 @@ const { pathToFileURL } = require('url');
 
       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);
+        || /(?<![A-Za-z0-9_])(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)(?![A-Za-z0-9_])/.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);
+      || /(?<![A-Za-z0-9_])(mẫu|câu chữ|chỉnh|sửa chữ|ngữ pháp|định dạng|cấu trúc|tài liệu)(?![A-Za-z0-9_])/.test(raw);
   }
 
   function hasExplicitStatusUpdateSignal(lower, raw) {
@@ -1473,6 +1473,48 @@ const { pathToFileURL } = require('url');
     };
   }
 
+  function isInformationalPrompt({
+    promptText = '',
+    commandText = '',
+    scores = null,
+  } = {}) {
+    if (String(commandText || '').trim()) return false;
+    const raw = String(promptText || '').toLowerCase().trim();
+    if (!raw) return false;
+    const questionSignal = raw.includes('?')
+      || /\b(what|how|when|which|where|who|is|are|does|do|did|can|could|would|should|will)\b/.test(raw)
+      || /(là\s+(?:[^\s]+\s+){0,2}gì|thế nào|như thế nào|bao nhiêu|khi nào|bao giờ|ở đâu|nghĩa là|được không|không\b)/.test(raw);
+    // '?' or a leading/Vietnamese interrogative — required to overrule error wording.
+    const strongQuestion = raw.includes('?')
+      || /^(what|how|when|which|where|who|is|are|does|do|did|can|could|would|should|will)\b/.test(raw)
+      || /(là\s+(?:[^\s]+\s+){0,2}gì|thế nào|như thế nào|bao nhiêu|khi nào|bao giờ|ở đâu)/.test(raw);
+    if (scores) {
+      if (
+        scores.implementSignal
+        || scores.reviewSignal
+        || scores.debugSignal
+        || scores.impactSignal
+        || scores.smallFixSignal
+        || scores.directTransformSignal
+      ) {
+        return false;
+      }
+      if (scores.failureSignal && !strongQuestion) {
+        return false;
+      }
+    }
+    const implementWords = /(?<![A-Za-z0-9_])(implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|sửa|thêm|tạo|xóa|đổi|thay thế|cập nhật|viết|build|chạy|cài)(?![A-Za-z0-9_])/.test(raw);
+    if (implementWords) return false;
+    const investigationWords = /\b(why|debug|triage|root cause|investigate|tại sao)\b/.test(raw);
+    if (investigationWords) return false;
+    // \b never matches around 'lỗi' (diacritics are not \w), so test it as a plain
+    // substring: an error report is informational only when phrased as a question.
+    if (raw.includes('lỗi') && !strongQuestion) return false;
+    const reviewWords = /\b(review|audit|verify)\b/.test(raw);
+    if (reviewWords) return false;
+    return questionSignal;
+  }
+
   function deriveExecutionMode({
     promptText = '',
     commandText = '',
@@ -1495,6 +1537,10 @@ const { pathToFileURL } = require('url');
       && (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 (isInformationalPrompt({ promptText, commandText, scores })) {
+      return 'informational';
+    }
+
     if ((intentMode === 'review-specific' || explicitReviewLead) && !scores.implementSignal) {
       return 'review-release';
     }
@@ -1778,7 +1824,7 @@ const { pathToFileURL } = require('url');
   }
 
   function buildCompletionState({ executionMode = null, verificationRecommendation = null } = {}) {
-    if (!executionMode) {
+    if (!executionMode || executionMode === 'informational') {
       return null;
     }
 
@@ -2331,8 +2377,9 @@ const { pathToFileURL } = require('url');
   const now = Date.now();
   const debounceMs = 10 * 60 * 1000;
   const previousTs = Number(previous?.ts || 0);
+  const informationalNoTargetPrompt = isInformationalPrompt({ promptText, commandText }) && !filePath;
 
-  if (active.length === 0) {
+  if (active.length === 0 || informationalNoTargetPrompt) {
     const lastExplicitUserPromptText = promptText.trim()
       || previous?.routingContext?.lastExplicitUserPromptText
       || '';
@@ -2343,6 +2390,7 @@ const { pathToFileURL } = require('url');
       targetFile: filePath,
       contextIntent: '',
       taskType: '',
+      ...(informationalNoTargetPrompt ? { executionMode: 'informational' } : {}),
     };
     const previousContext = buildPreviousContextSnapshot({
       projectRoot,

package/templates/.claude/ukit/index/lib/index-core.mjs

@@ -24,11 +24,11 @@ const EXCLUDED_DIR_NAMES = new Set([
   '.venv',
   'venv',
 ]);
-const CODE_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue']);
+const CODE_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue', '.sql']);
 const STYLE_EXTENSIONS = new Set(['.css', '.scss', '.sass', '.less']);
-const TRACKED_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue', '.json', '.yaml', '.yml', '.md', '.sh']);
+const TRACKED_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue', '.sql', '.json', '.yaml', '.yml', '.md', '.sh']);
 const DISCOVERED_EXTENSIONS = new Set([...TRACKED_EXTENSIONS, ...STYLE_EXTENSIONS]);
-export const INDEX_SCHEMA_VERSION = 7;
+export const INDEX_SCHEMA_VERSION = 8;
 export const DEFAULT_INDEX_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const INDEX_PARSE_BATCH_SIZE = 8;
 const MAX_IMPORTER_HOPS = 2;
@@ -1810,26 +1810,38 @@ export function extractSymbols(filePath, content) {
     }
   };
 
-  addMatches(/export\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'function');
-  addMatches(/export\s+class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'class');
-  addMatches(/(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?\(/g, 'callable');
-  addMatches(/(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>/g, 'callable');
-  addMatches(/export\s+default\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'default-function');
-  addMatches(/export\s+default\s+class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'default-class');
-  addMatches(/export\s+default\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*(?:;|\n|$)/g, 'default-reference');
-  addMatches(/defineOptions\(\s*\{[\s\S]*?name\s*:\s*['"]([^'"]+)['"]/g, 'component-name');
-  addMatches(/defineComponent\(\s*\{[\s\S]*?name\s*:\s*['"]([^'"]+)['"]/g, 'component-name');
-  addMatches(/export\s+default\s*\{[\s\S]*?name\s*:\s*['"]([^'"]+)['"]/g, 'component-name');
-
-  if (/\bexport\s+default\b/.test(content)) {
-    addSymbol('default', 'default-export');
-  }
-
-  for (const match of content.matchAll(/export\s*\{([^}]+)\}/g)) {
-    for (const part of (match[1] ?? '').split(',').map((x) => x.trim()).filter(Boolean)) {
-      const parsed = part.match(/^([A-Za-z_$][A-Za-z0-9_$]*)(?:\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*))?$/);
-      if (!parsed) continue;
-      addSymbol(parsed[2] ?? parsed[1], 'named-export', match.index);
+  if (filePath.endsWith('.sql')) {
+    // Capture the object name, skipping an optional schema qualifier (qas.fn_rpt_billing → fn_rpt_billing).
+    const sqlIdent = '(?:(?:["`]?[A-Za-z_][A-Za-z0-9_$]*["`]?)\\s*\\.\\s*)?["`]?([A-Za-z_][A-Za-z0-9_$]*)["`]?';
+    addMatches(new RegExp(`CREATE\\s+(?:OR\\s+REPLACE\\s+)?TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'table');
+    addMatches(new RegExp(`CREATE\\s+(?:OR\\s+REPLACE\\s+)?VIEW\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'view');
+    addMatches(new RegExp(`CREATE\\s+(?:OR\\s+REPLACE\\s+)?FUNCTION\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'function');
+    addMatches(new RegExp(`CREATE\\s+(?:OR\\s+REPLACE\\s+)?PROCEDURE\\s+${sqlIdent}`, 'gi'), 'procedure');
+    addMatches(new RegExp(`CREATE\\s+(?:UNIQUE\\s+)?INDEX\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'index');
+    addMatches(new RegExp(`CREATE\\s+(?:TYPE|DOMAIN|SEQUENCE|MATERIALIZED\\s+VIEW)\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'type');
+    addMatches(new RegExp(`ALTER\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'table');
+  } else {
+    addMatches(/export\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'function');
+    addMatches(/export\s+class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'class');
+    addMatches(/(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?\(/g, 'callable');
+    addMatches(/(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>/g, 'callable');
+    addMatches(/export\s+default\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'default-function');
+    addMatches(/export\s+default\s+class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'default-class');
+    addMatches(/export\s+default\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*(?:;|\n|$)/g, 'default-reference');
+    addMatches(/defineOptions\(\s*\{[\s\S]*?name\s*:\s*['"]([^'"]+)['"]/g, 'component-name');
+    addMatches(/defineComponent\(\s*\{[\s\S]*?name\s*:\s*['"]([^'"]+)['"]/g, 'component-name');
+    addMatches(/export\s+default\s*\{[\s\S]*?name\s*:\s*['"]([^'"]+)['"]/g, 'component-name');
+
+    if (/\bexport\s+default\b/.test(content)) {
+      addSymbol('default', 'default-export');
+    }
+
+    for (const match of content.matchAll(/export\s*\{([^}]+)\}/g)) {
+      for (const part of (match[1] ?? '').split(',').map((x) => x.trim()).filter(Boolean)) {
+        const parsed = part.match(/^([A-Za-z_$][A-Za-z0-9_$]*)(?:\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*))?$/);
+        if (!parsed) continue;
+        addSymbol(parsed[2] ?? parsed[1], 'named-export', match.index);
+      }
     }
   }
 

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

@@ -234,7 +234,7 @@ export const ROUTE_CATALOG = [
     contextMode: 'standalone',
     signals: [
       { type: 'prompt', regex: /\b(what(?:'s| is)? next|next steps?|project status|current status|where are we|continue(?: from)?(?: last session)?|roadmap|status\.md|task queue|tasks\.md|next queued task|pick next task|work from tasks)\b/i, score: 7 },
-      { type: 'prompt', regex: /\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/i, score: 7 },
+      { type: 'prompt', regex: /(?<![A-Za-z0-9_])(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)(?![A-Za-z0-9_])/i, score: 7 },
     ],
   },
   {

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

@@ -1044,7 +1044,7 @@ function hasHandoffSignal(lower, raw) {
     || /\b(ai handoff|handoff phase|handoff mode|clear handoff|update handoff|start handoff|handoff clear)\b/.test(lower)
     || /\b(brainstorm|idea dump|ideas?).{0,80}\b(handoff|tasks?|taskify|split|breakdown)\b/.test(lower)
     || /\b(handoff|tasks?|taskify|split|breakdown).{0,80}\b(brainstorm|idea dump|ideas?)\b/.test(lower)
-    || /\b(gom|chia|tach|tách|lên|len|xóa|clear|dọn).{0,80}\b(idea|ý tưởng|y tuong|task|công việc|cong viec|handoff)\b/.test(raw)
+    || /(?<![A-Za-z0-9_])(gom|chia|tach|tách|lên|len|xóa|clear|dọn).{0,80}(?<![A-Za-z0-9_])(idea|ý tưởng|y tuong|task|công việc|cong viec|handoff)(?![A-Za-z0-9_])/.test(raw)
     || /\b(bàn giao|ban giao).{0,80}\b(ai|task|công việc|cong viec)\b/.test(raw);
 }
 
@@ -1056,7 +1056,7 @@ function hasHandoffClearSignal(lower, 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);
+    || /(?<![A-Za-z0-9_])(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)(?![A-Za-z0-9_])/.test(raw);
 }
 
 function hasTaskQueueNextSignal(lower, raw) {
@@ -1070,7 +1070,7 @@ function hasConcreteTaskSignal(lower, raw, targetFile, { taskQueueNext = false }
   }
 
   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);
+    || /(?<![A-Za-z0-9_])(sửa|fix|lỗi|bug|debug|implement|cài|thêm|review|kiểm tra|soát|đăng nhập)(?![A-Za-z0-9_])/.test(raw);
 }
 
 function hasDocsSpecificTaskSignal(lower, raw, targetFile, { taskQueueNext = false } = {}) {
@@ -1093,11 +1093,11 @@ function hasDocsSpecificTaskSignal(lower, raw, targetFile, { taskQueueNext = fal
 
     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);
+      || /(?<![A-Za-z0-9_])(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)(?![A-Za-z0-9_])/.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);
+    || /(?<![A-Za-z0-9_])(mẫu|câu chữ|chỉnh|sửa chữ|ngữ pháp|định dạng|cấu trúc|tài liệu)(?![A-Za-z0-9_])/.test(raw);
 }
 
 function hasExplicitStatusUpdateSignal(lower, raw) {
@@ -1644,6 +1644,48 @@ function deriveExecutionScores({
   };
 }
 
+function isInformationalPrompt({
+  promptText = '',
+  commandText = '',
+  scores = null,
+} = {}) {
+  if (String(commandText || '').trim()) return false;
+  const raw = String(promptText || '').toLowerCase().trim();
+  if (!raw) return false;
+  const questionSignal = raw.includes('?')
+    || /\b(what|how|when|which|where|who|is|are|does|do|did|can|could|would|should|will)\b/.test(raw)
+    || /(là\s+(?:[^\s]+\s+){0,2}gì|thế nào|như thế nào|bao nhiêu|khi nào|bao giờ|ở đâu|nghĩa là|được không|không\b)/.test(raw);
+  // '?' or a leading/Vietnamese interrogative — required to overrule error wording.
+  const strongQuestion = raw.includes('?')
+    || /^(what|how|when|which|where|who|is|are|does|do|did|can|could|would|should|will)\b/.test(raw)
+    || /(là\s+(?:[^\s]+\s+){0,2}gì|thế nào|như thế nào|bao nhiêu|khi nào|bao giờ|ở đâu)/.test(raw);
+  if (scores) {
+    if (
+      scores.implementSignal
+      || scores.reviewSignal
+      || scores.debugSignal
+      || scores.impactSignal
+      || scores.smallFixSignal
+      || scores.directTransformSignal
+    ) {
+      return false;
+    }
+    if (scores.failureSignal && !strongQuestion) {
+      return false;
+    }
+  }
+  const implementWords = /(?<![A-Za-z0-9_])(implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|sửa|thêm|tạo|xóa|đổi|thay thế|cập nhật|viết|build|chạy|cài)(?![A-Za-z0-9_])/.test(raw);
+  if (implementWords) return false;
+  const investigationWords = /\b(why|debug|triage|root cause|investigate|tại sao)\b/.test(raw);
+  if (investigationWords) return false;
+  // \b never matches around 'lỗi' (diacritics are not \w), so test it as a plain
+  // substring: an error report is informational only when phrased as a question.
+  if (raw.includes('lỗi') && !strongQuestion) return false;
+  const reviewWords = /\b(review|audit|verify)\b/.test(raw);
+  if (reviewWords) return false;
+  return questionSignal;
+}
+
 function deriveExecutionMode({
   promptText = '',
   commandText = '',
@@ -1666,6 +1708,10 @@ function deriveExecutionMode({
     && (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 (isInformationalPrompt({ promptText, commandText, scores })) {
+    return 'informational';
+  }
+
   if ((intentMode === 'review-specific' || explicitReviewLead) && !scores.implementSignal) {
     return 'review-release';
   }
@@ -1956,7 +2002,7 @@ function buildApproachSelectorResult({
 }
 
 function buildCompletionState({ executionMode = null, verificationRecommendation = null } = {}) {
-  if (!executionMode) {
+  if (!executionMode || executionMode === 'informational') {
     return null;
   }
 

package/templates/.claude/ukit/runtime/compact-threshold.mjs

@@ -481,9 +481,80 @@ export function resetCompactPressureState(rawState = {}, config = {}) {
     recentOutputs: [],
     cooldownUntil: 0,
     latestPlan: null,
+    // Stamp the moment a compaction was accounted for, so the transcript sync (which may
+    // run slightly later than the boundary was written) does not double-fire.
+    lastCompactBoundaryAt: Date.now(),
   }, config);
 }
 
+const BOUNDARY_TAIL_BYTES = 4 * 1024 * 1024;
+
+// Find the newest compaction recorded in the session transcript, as epoch ms (0 if none).
+// Every real compaction — manual /compact AND harness auto-compact — appends a
+// `compact_boundary` entry to the transcript, while PreCompact hooks do not fire on every
+// compaction path (SDK/VSCode auto-compact being the known gap). That makes the transcript
+// the one record that cannot miss a compaction. Only the tail is read: boundaries are
+// appended chronologically and only the newest matters.
+export async function detectLatestCompactBoundaryAt(transcriptPath, { tailBytes = BOUNDARY_TAIL_BYTES } = {}) {
+  if (typeof transcriptPath !== 'string' || !transcriptPath.trim()) {
+    return 0;
+  }
+  try {
+    const stat = await fs.stat(transcriptPath);
+    if (!stat.isFile() || stat.size === 0) {
+      return 0;
+    }
+    const start = Math.max(0, stat.size - tailBytes);
+    const length = stat.size - start;
+    const buffer = Buffer.allocUnsafe(length);
+    const handle = await fs.open(transcriptPath, 'r');
+    let text;
+    try {
+      const { bytesRead } = await handle.read(buffer, 0, length, start);
+      text = buffer.toString('utf8', 0, bytesRead);
+    } finally {
+      await handle.close();
+    }
+    const lines = text.split('\n');
+    if (start > 0) lines.shift(); // a tail read can split the first line
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      const line = lines[i];
+      if (!line.includes('compact_boundary')) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry?.type === 'system' && entry?.subtype === 'compact_boundary') {
+          const at = Date.parse(entry.timestamp ?? '');
+          if (Number.isFinite(at)) return at;
+        }
+      } catch { /* not a usable boundary line */ }
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+// Rebase the tracked counter whenever the transcript proves a compaction this state has
+// not accounted for yet (lastCompactBoundaryAt stamps what has been seen, so each
+// boundary fires the reset exactly once). Without this, sessionTokens keeps counting
+// history that was already summarised away and the hard-cap gate bricks a healthy
+// session. Callers must persist when reset=true, or the reset would re-fire (and
+// zero the counter) on every call.
+export async function syncCompactPressureStateWithTranscript(rawState = null, config = {}, transcriptPath = '') {
+  const boundaryAt = await detectLatestCompactBoundaryAt(transcriptPath);
+  const accounted = finiteNumber(rawState?.lastCompactBoundaryAt, 0);
+  if (!boundaryAt || boundaryAt <= accounted) {
+    return { state: rawState, reset: false };
+  }
+  return {
+    state: {
+      ...resetCompactPressureState(rawState ?? {}, config),
+      lastCompactBoundaryAt: boundaryAt,
+    },
+    reset: true,
+  };
+}
+
 function buildReleaseThresholds(thresholds = buildCompactThresholds()) {
   const softReleaseThreshold = Math.max(
     Math.min(thresholds.softThreshold, Math.round(thresholds.softThreshold * SOFT_RELEASE_RATIO)),
@@ -648,6 +719,7 @@ export function buildCompactPressureState(rawState = null, config = {}) {
     phase: resolveCompactPhase(estimatedTotalTokens, thresholds, rawState),
     taskMode,
     cooldownUntil: finiteNumber(rawState?.cooldownUntil, 0),
+    lastCompactBoundaryAt: finiteNumber(rawState?.lastCompactBoundaryAt, 0),
     routingContext: rawState?.routingContext && typeof rawState.routingContext === 'object'
       ? rawState.routingContext
       : {},
@@ -1058,6 +1130,22 @@ async function runCli() {
       return;
     }
 
+    // Heal a stale counter BEFORE the phase is computed. Auto-compact paths that never
+    // fire the PreCompact hook leave sessionTokens counting history that was already
+    // summarised away — that phantom total is how a healthy session got hard-cap blocked.
+    // The transcript's compact_boundary entries record every real compaction, manual or
+    // automatic, so they are the correction signal here.
+    try {
+      const synced = await syncCompactPressureStateWithTranscript(
+        await readCompactPressureState(projectRoot, config),
+        config,
+        payload.transcript_path,
+      );
+      if (synced.reset) {
+        await writeCompactPressureState(projectRoot, synced.state, config);
+      }
+    } catch { /* advisory healing only — never block the prompt over it */ }
+
     const nextState = await updateCompactPressureFromPrompt(projectRoot, {
       promptText,
       routingContext: routeState?.routingContext ?? {},
@@ -1065,9 +1153,16 @@ async function runCli() {
       routeSummary: routeState?.routeSummary ?? null,
     }, config);
 
-    if (nextState.phase === 'soft' || nextState.phase === 'hard') {
+    if (nextState.phase === 'hard') {
+      process.stdout.write(
+        `[ukit-skill-router] Context pressure: hard (est ${nextState.estimatedTotalTokens} / soft ${nextState.softThreshold} / hard ${nextState.hardThreshold}). `
+          + 'FIRST THING IN YOUR REPLY, tell the user plainly — do not stay silent: "Context sắp đầy — hãy gõ /compact ngay bây giờ (run /compact now)". '
+          + 'Then hold heavy work: no new investigations, subagents, or large edits until the user has compacted.\n',
+      );
+    } else if (nextState.phase === 'soft') {
       process.stdout.write(
-        `[ukit-skill-router] Context pressure: ${nextState.phase} (est ${nextState.estimatedTotalTokens} / soft ${nextState.softThreshold} / hard ${nextState.hardThreshold}). Suggest running /compact soon, or I will self-summarize before continuing.\n`,
+        `[ukit-skill-router] Context pressure: soft (est ${nextState.estimatedTotalTokens} / soft ${nextState.softThreshold} / hard ${nextState.hardThreshold}). `
+          + 'Finish the current step, then tell the user to run /compact at the next natural pause instead of continuing indefinitely.\n',
       );
     }
   }

package/templates/ukit/storage/config.json

@@ -195,7 +195,7 @@
   "handoff": {
     "enabled": true,
     "crossTool": true,
-    "maxParallelAgents": 12,
+    "maxParallelAgents": 2,
     "autonomy": {
       "askWindow": "plan-only",
       "planReviewRounds": 2,
@@ -511,7 +511,7 @@
     "handoff": {
       "enabled": "Bật Quality Gate cho handoff: plan có Test Plan, executor test-first, reviewer model khác. Tắt = quay về flow cũ (dễ lọt lỗi vặt).",
       "crossTool": "true nghĩa là handoff truyền qua file (PLAN/INDEX/tasks) chứ không qua in-process subagent — cho phép plan ở Claude Code, execute ở Kilo Code, review ở Claude Code khác model.",
-      "maxParallelAgents": "Số agent chạy song song TỐI ĐA trong một wave (mặc định 12, tăng từ 3 để giảm thời gian chờ khi có nhiều task độc lập; 12 là số chọn theo dải an toàn ~10-15 dưới đây, không phải số đo được). Một wave có nhiều task hơn số này sẽ được chia thành nhiều batch chạy lần lượt — áp dụng cho cả Phase 3 Implement và Phase 4 Review. Lý do giới hạn vẫn còn: mỗi agent nền có context window riêng, và report của agent khi xong sẽ được inject ngược vào session chính — chạy quá nhiều cùng lúc (vd 20+) vẫn có thể làm session chính vượt context window và bỏ lại worktree rác. Hạ xuống 3-5 nếu task nặng (verification output dài) hoặc thấy compact bị trigger liên tục; tránh vượt quá ~10-15.",
+      "maxParallelAgents": "Số agent chạy song song TỐI ĐA trong một wave (mặc định 2 để giữ session chính nhẹ và hạn chế rủi ro compact/worktree rác; nếu máy khỏe và task độc lập nhiều thì có thể nâng dần 3-5, tối đa ~10-15). Một wave có nhiều task hơn số này sẽ được chia thành nhiều batch chạy lần lượt — áp dụng cho cả Phase 3 Implement và Phase 4 Review. Lý do giới hạn vẫn còn: mỗi agent nền có context window riêng, và report của agent khi xong sẽ được inject ngược vào session chính — chạy quá nhiều cùng lúc (vd 20+) vẫn có thể làm session chính vượt context window và bỏ lại worktree rác. Hạ xuống 1-2 nếu task nặng (verification output dài) hoặc thấy compact bị trigger liên tục.",
       "plan": {
         "requireTestPlan": "Bắt buộc PLAN.md §4 phải có Test Plan trước khi task chuyển ready.",
         "minTestsHappyPath": "Tối thiểu test cho happy path.",