@ngockhoale/ukit 2.2.14 → 2.3.0

package/src/core/router/router.js

@@ -1,180 +0,0 @@
-const HIGH_COMPLEXITY_KEYWORDS = [
-  'architecture',
-  'architect',
-  'design',
-  'trade-off',
-  'tradeoff',
-  'security',
-  'compare',
-  'why',
-  'reasoning',
-  'scalable',
-  'system design',
-];
-
-const LOW_COMPLEXITY_KEYWORDS = [
-  'rename',
-  'add field',
-  'change text',
-  'format',
-  'typo',
-  'update label',
-  'refactor name',
-];
-
-const REVIEW_KEYWORDS = ['review', 'code review', 'audit'];
-const DEBUG_KEYWORDS = ['debug', 'bug', 'stack trace', 'error', 'crash', 'retry', 'failed attempt', 'failure'];
-const CODING_HINTS = ['src/', 'package.json', 'function', 'class', 'implement', 'file', '.js', '.ts', '.tsx', '.jsx', '```'];
-
-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) ?? [];
-  return Math.max(explicitCount, new Set(pathMatches).size);
-}
-
-export function detectComplexity(message, context = '') {
-  const combined = normalize(`${message}\n${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) => 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';
-  }
-
-  if (lowSignals > 0 || (fileHints <= 1 && wordCount <= 24 && !hasRetryPattern)) {
-    return 'low';
-  }
-
-  return 'medium';
-}
-
-function detectTaskType(message, context = '', complexity = 'medium') {
-  const combined = normalize(`${message}\n${context}`);
-
-  if (DEBUG_KEYWORDS.some((keyword) => matchesKeyword(combined, keyword)) && complexity === 'high') {
-    return 'debug_hard';
-  }
-
-  if (HIGH_COMPLEXITY_KEYWORDS.some((keyword) => matchesKeyword(combined, keyword))) {
-    return 'reasoning';
-  }
-
-  if (REVIEW_KEYWORDS.some((keyword) => matchesKeyword(combined, keyword))) {
-    return 'review';
-  }
-
-  if (CODING_HINTS.some((keyword) => matchesKeyword(combined, keyword))) {
-    return 'coding';
-  }
-
-  return 'simple_chat';
-}
-
-function recommendTier(type, complexity) {
-  if (type === 'simple_chat' && complexity === 'low') {
-    return 'fast';
-  }
-
-  if (type === 'reasoning') {
-    return 'powerful';
-  }
-
-  if (type === 'debug_hard' && complexity === 'high') {
-    return 'powerful';
-  }
-
-  if (type === 'review') {
-    return complexity === 'high' ? 'powerful' : 'balanced';
-  }
-
-  if (type === 'coding') {
-    return complexity === 'high' ? 'powerful' : 'balanced';
-  }
-
-  return complexity === 'low' ? 'fast' : 'balanced';
-}
-
-function buildReason(type, complexity) {
-  if (type === 'simple_chat') {
-    return 'Short conversational request without strong coding or reasoning signals.';
-  }
-
-  if (type === 'debug_hard') {
-    return 'Debugging request includes repeated failures or stack-trace style signals.';
-  }
-
-  if (type === 'reasoning') {
-    return 'Request asks for architecture, comparison, trade-offs, or deeper analysis.';
-  }
-
-  if (type === 'review') {
-    return complexity === 'high'
-      ? 'Review request touches higher-risk or cross-cutting areas.'
-      : 'Review request is scoped enough for the balanced tier.';
-  }
-
-  if (type === 'coding') {
-    return complexity === 'high'
-      ? 'Implementation spans multiple modules or difficult trade-offs.'
-      : 'Normal implementation work is best handled by the balanced tier.';
-  }
-
-  return 'Fallback routing decision.';
-}
-
-export function classifyTask(userMessage, context = '') {
-  const complexity = detectComplexity(userMessage, context);
-  const type = detectTaskType(userMessage, context, complexity);
-  const recommendedTier = recommendTier(type, complexity);
-
-  return {
-    type,
-    complexity,
-    recommendedTier,
-    reason: buildReason(type, complexity),
-  };
-}
-
-export function selectModel(classification, config) {
-  const tier = classification?.recommendedTier ?? 'balanced';
-  if (config?.[tier]) {
-    return config[tier];
-  }
-
-  if (tier === 'powerful' && config?.advisorModel) {
-    return config.advisorModel;
-  }
-
-  if (tier === 'balanced' && config?.defaultModel) {
-    return config.defaultModel;
-  }
-
-  if (tier === 'fast' && config?.fast) {
-    return config.fast;
-  }
-
-  return config?.defaultModel ?? config?.balanced ?? config?.fast ?? config?.powerful ?? null;
-}

package/src/core/validation/confidence.js

@@ -1,89 +0,0 @@
-const HEDGING_WORDS = [
-  'maybe',
-  'might',
-  'i think',
-  'probably',
-  'possibly',
-  'could be',
-  'perhaps',
-  'có thể',
-  'chắc là',
-  'hình như',
-];
-
-const VERIFICATION_WORDS = [
-  'verified',
-  'tested',
-  'passes',
-  'passed',
-  'checked',
-  'confirmed',
-  'validated',
-  'đã test',
-  'đã kiểm tra',
-];
-
-function normalize(text) {
-  return String(text ?? '').toLowerCase();
-}
-
-function buildResult(score, factors) {
-  const clamped = Math.max(0, Math.min(100, Math.round(score)));
-  const level = clamped >= 80 ? 'high' : clamped >= 50 ? 'medium' : 'low';
-  const action = clamped >= 80 ? 'respond' : clamped >= 50 ? 'warn' : 'clarify';
-
-  return {
-    score: clamped,
-    level,
-    factors,
-    action,
-  };
-}
-
-export function scoreConfidence(output, taskType, context = '') {
-  const normalizedOutput = normalize(output);
-  const normalizedContext = normalize(context);
-  const factors = [];
-  let score = 50;
-
-  if (normalizedContext.trim().length >= 24) {
-    score += 15;
-    factors.push({ name: 'context_availability', impact: 'positive', reason: 'Enough task context is available.' });
-  } else {
-    score -= 20;
-    factors.push({ name: 'context_availability', impact: 'negative', reason: 'Very little context is available.' });
-  }
-
-  if (normalizedOutput.length >= 60 && !HEDGING_WORDS.some((word) => normalizedOutput.includes(word))) {
-    score += 15;
-    factors.push({ name: 'task_clarity', impact: 'positive', reason: 'Output is specific and direct.' });
-  } else if (normalizedOutput.length < 30) {
-    score -= 10;
-    factors.push({ name: 'task_clarity', impact: 'negative', reason: 'Output is too short to inspire confidence.' });
-  }
-
-  const hedges = HEDGING_WORDS.filter((word) => normalizedOutput.includes(word));
-  if (hedges.length > 0) {
-    score -= 30;
-    factors.push({ name: 'model_certainty', impact: 'negative', reason: `Hedging language detected: ${hedges.join(', ')}.` });
-  } else {
-    score += 10;
-    factors.push({ name: 'model_certainty', impact: 'positive', reason: 'Language is direct rather than hedged.' });
-  }
-
-  const verificationHits = VERIFICATION_WORDS.filter((word) => normalizedOutput.includes(word));
-  if (verificationHits.length > 0) {
-    score += 20;
-    factors.push({ name: 'verification', impact: 'positive', reason: `Verification signals found: ${verificationHits.join(', ')}.` });
-  } else if (taskType === 'coding' || taskType === 'debug' || taskType === 'debug_hard') {
-    score -= 10;
-    factors.push({ name: 'verification', impact: 'negative', reason: 'No verification evidence was provided for a technical task.' });
-  }
-
-  if (/\b(previous|existing|again|recall|memory)\b/.test(normalizedContext)) {
-    score += 5;
-    factors.push({ name: 'prior_knowledge', impact: 'positive', reason: 'Context suggests continuity with prior knowledge.' });
-  }
-
-  return buildResult(score, factors);
-}

package/src/core/validation/validator.js

@@ -1,165 +0,0 @@
-const REQUIREMENT_PREFIX = /^\s*(?:[-*•]|\d+[.)])\s+/;
-const STOPWORDS = new Set([
-  'the', 'a', 'an', 'and', 'or', 'to', 'for', 'of', 'with', 'in', 'on', 'is', 'are',
-  'be', 'this', 'that', 'it', 'as', 'by', 'run', 'add', 'use', 'please', 'giúp', 'hãy',
-  'và', 'là', 'cho', 'cần', 'một', 'những',
-]);
-
-function normalize(text) {
-  return String(text ?? '')
-    .toLowerCase()
-    .replace(/```[\w-]*\n?/g, ' ')
-    .replace(/```/g, ' ')
-    .replace(/[^\p{L}\p{N}\s]/gu, ' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function unwrapCodeFence(output) {
-  const match = String(output ?? '').match(/```(?:[\w-]+)?\n([\s\S]*?)```/);
-  return match ? match[1].trim() : String(output ?? '').trim();
-}
-
-function tokenize(text) {
-  return normalize(text)
-    .split(/\s+/)
-    .filter((token) => token && !STOPWORDS.has(token) && token.length > 1);
-}
-
-function parseRequirements(spec) {
-  if (!spec) {
-    return [];
-  }
-
-  if (Array.isArray(spec?.requirements)) {
-    return spec.requirements.filter(Boolean);
-  }
-
-  if (typeof spec === 'string') {
-    const lines = spec.split('\n').map((line) => line.trim()).filter(Boolean);
-    const bulletLines = lines.filter((line) => REQUIREMENT_PREFIX.test(line));
-    if (bulletLines.length > 0) {
-      return bulletLines.map((line) => line.replace(REQUIREMENT_PREFIX, '').trim());
-    }
-
-    return lines.length > 0 ? [lines.join(' ')] : [];
-  }
-
-  return [];
-}
-
-function requirementCovered(requirement, output) {
-  const outputTokens = new Set(tokenize(output));
-  const requirementTokens = tokenize(requirement);
-  if (requirementTokens.length === 0) {
-    return true;
-  }
-
-  const matches = requirementTokens.filter((token) => outputTokens.has(token)).length;
-  const threshold = requirementTokens.length <= 2 ? requirementTokens.length : Math.max(2, Math.ceil(requirementTokens.length * 0.6));
-  return matches >= threshold;
-}
-
-function buildCompletenessCheck(output, spec) {
-  const requirements = parseRequirements(spec);
-  if (requirements.length === 0) {
-    return { name: 'completeness', passed: true };
-  }
-
-  const missing = requirements.filter((requirement) => !requirementCovered(requirement, output));
-  return {
-    name: 'completeness',
-    passed: missing.length === 0,
-    details: missing.length === 0 ? undefined : `Missing requirement coverage: ${missing.join('; ')}`,
-  };
-}
-
-function countListItems(output) {
-  return String(output ?? '')
-    .split('\n')
-    .filter((line) => /^\s*(?:[-*•]|\d+[.)])\s+/.test(line))
-    .length;
-}
-
-function buildConsistencyCheck(output) {
-  const text = String(output ?? '');
-  const numericClaim = text.match(/\b(\d+)\s+(?:steps?|items?|checks?|requirements?|bước|mục)\b/i);
-  if (!numericClaim) {
-    return { name: 'consistency', passed: true };
-  }
-
-  const expectedCount = Number.parseInt(numericClaim[1], 10);
-  const actualCount = countListItems(text);
-  const passed = actualCount === expectedCount;
-
-  return {
-    name: 'consistency',
-    passed,
-    details: passed ? undefined : `Declared ${expectedCount} items but found ${actualCount}.`,
-  };
-}
-
-function detectRequestedFormat(taskType, spec) {
-  if (typeof spec === 'object' && typeof spec?.format === 'string') {
-    return spec.format.toLowerCase();
-  }
-
-  const combined = `${taskType ?? ''}\n${typeof spec === 'string' ? spec : ''}`.toLowerCase();
-  if (combined.includes('json')) return 'json';
-  if (combined.includes('code')) return 'code';
-  if (combined.includes('list')) return 'list';
-  return 'text';
-}
-
-function buildFormatCheck(output, taskType, spec) {
-  const format = detectRequestedFormat(taskType, spec);
-  const raw = String(output ?? '').trim();
-
-  if (format === 'json') {
-    try {
-      JSON.parse(unwrapCodeFence(raw));
-      return { name: 'format', passed: true };
-    } catch (error) {
-      return { name: 'format', passed: false, details: `Invalid JSON output: ${error.message}` };
-    }
-  }
-
-  if (format === 'code') {
-    const passed = /```/.test(raw);
-    return {
-      name: 'format',
-      passed,
-      details: passed ? undefined : 'Expected a code block in the output.',
-    };
-  }
-
-  if (format === 'list') {
-    const passed = countListItems(raw) > 0;
-    return {
-      name: 'format',
-      passed,
-      details: passed ? undefined : 'Expected a list-style response.',
-    };
-  }
-
-  return { name: 'format', passed: true };
-}
-
-export function validateOutput(output, taskType, spec) {
-  const checks = [
-    buildCompletenessCheck(output, spec),
-    buildConsistencyCheck(output),
-    buildFormatCheck(output, taskType, spec),
-  ];
-
-  const failedChecks = checks.filter((check) => !check.passed);
-
-  return {
-    passed: failedChecks.length === 0,
-    checks,
-    shouldRetry: failedChecks.length > 0,
-    retryHint: failedChecks.length === 0
-      ? undefined
-      : `Previous output failed validation: ${failedChecks.map((check) => `${check.name}${check.details ? ` (${check.details})` : ''}`).join('; ')}`,
-  };
-}

package/templates/.claude/hooks/vision-gate.sh

@@ -1,230 +0,0 @@
-#!/bin/bash
-# PreToolUse hook: hard-enforce the TASK-008 vision-analysis gate.
-#
-# Blocks Edit/Write whenever a pending image marker (written by vision-router.sh via
-# extract-image.mjs --mark-pending) has no matching analyzed-<sha>.json receipt from a
-# vision-capable model. Opposite fail direction from vision-router.sh: that hook fails
-# OPEN (never wedge a prompt); this hook fails CLOSED (a broken gate must not silently
-# permit blind edits). "Fails closed" applies only to this hook's own logic errors — if
-# no pending marker exists at all, it exits 0 immediately, before any other logic. That
-# is >99% of invocations and must stay free.
-#
-# Always hard-blocks (exit 2). No advisory/soft mode — matches handoff-model-guard.sh's
-# posture: the user explicitly asked for strict, mechanical, non-bypassable enforcement.
-# A wrong image analysis yields confidently wrong results, which is worse than no
-# analysis at all.
-#
-# Matcher is Edit|Write ONLY. Never Read/Grep/Glob/Bash — ukit-vision-analyst itself
-# needs Read to see the extracted image and Bash to write its receipt; gating those
-# tools would deadlock the only lane that can clear the gate.
-#
-# Never recomputes a sha. extract-image.mjs (TASK-002) is the single owner of the hash;
-# this hook only matches pending-<sha>.json to analyzed-<sha>.json by filename.
-#
-# Session-scoped and 24h-bounded: a stale marker from another session, or an abandoned
-# session's marker older than 24h, must never permanently block writes.
-
-INPUT=$(cat)
-PROJECT_ROOT="${CLAUDE_PROJECT_DIR:-$PWD}"
-
-INPUT="$INPUT" PROJECT_ROOT="$PROJECT_ROOT" node <<'NODE'
-const fs = require('fs');
-const path = require('path');
-const { pathToFileURL } = require('url');
-
-const MARKER_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24h
-
-const payload = (() => {
-  try {
-    const parsed = JSON.parse(process.env.INPUT || '');
-    return parsed && typeof parsed === 'object' ? parsed : {};
-  } catch {
-    return {};
-  }
-})();
-
-const projectRoot = process.env.PROJECT_ROOT;
-const toolName = payload?.tool_name || '';
-
-// Gate only Edit|Write. Every other tool (Read, Grep, Glob, Bash, ...) is free — the
-// vision analyst needs Read/Bash to clear this very gate. This check is independent of
-// tool_input shape: the gate never inspects file_path/content, only tool_name.
-if (toolName !== 'Edit' && toolName !== 'Write') {
-  process.exit(0);
-}
-
-const sessionId = (typeof payload.session_id === 'string' && payload.session_id.trim())
-  ? payload.session_id.trim()
-  : 'default';
-
-const sessionDir = path.join(projectRoot, '.ukit', 'storage', 'cache', 'vision', sessionId);
-
-let markerNames = [];
-try {
-  markerNames = fs.readdirSync(sessionDir).filter((name) => /^pending-.+\.json$/.test(name));
-} catch {
-  markerNames = [];
-}
-
-// No pending marker at all: the overwhelmingly common path. Exit 0 immediately, before
-// any config reads, gateway detection, or receipt checks.
-if (markerNames.length === 0) {
-  process.exit(0);
-}
-
-function readJsonSafe(filePath) {
-  try {
-    const raw = fs.readFileSync(filePath, 'utf8');
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === 'object' ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-// Tri-state on purpose: true | false | null(unknown). Returning false on a detection
-// FAILURE would be read as "unicMode is off", which GRANTS the fallback-model exception
-// below — i.e. deleting or breaking one gitignored file would make the gate accept a
-// plain code-tier receipt. Unknown must deny the exception, not grant it.
-async function detectUnicModeSafe() {
-  try {
-    const gatewayPath = path.join(projectRoot, '.claude', 'ukit', 'index', 'unic-gateway.mjs');
-    if (!fs.existsSync(gatewayPath)) return null;
-    const mod = await import(pathToFileURL(gatewayPath).href);
-    if (typeof mod.detectUnicGateway !== 'function') return null;
-    const result = mod.detectUnicGateway({ rootDir: projectRoot });
-    return !!result?.unicMode;
-  } catch {
-    return null;
-  }
-}
-
-// Anchored, not a substring match: "unic-vision-mini" and "not-unic-vision" are different
-// models and must not inherit the real one's capability by sharing a substring.
-// Only reached when unicMode is true or unknown — off-gateway sessions already exited
-// above — so `unic-vision` is the only model that can legitimately clear the gate here.
-function isVisionCapable(model) {
-  if (typeof model !== 'string' || !model.trim()) return false;
-  return /^unic-vision$/i.test(model.trim());
-}
-
-const VALID_STATUSES = new Set(['OK', 'NO_IMAGE', 'UNREADABLE']);
-
-// A receipt whose self-reported model is not vision-capable (unic-code, unic-smart,
-// sonnet, opus, ...) is treated as ABSENT and still blocks — accepting it would make the
-// whole enforcement design theatre. A JSON.parse throw is caught per-receipt and turned
-// into BLOCK, never an accidental skip-through.
-// The gate keys its directory on the hook payload's session_id, but the analyst resolves
-// its own sessionId by discovering the newest transcript. Those agree in the common case
-// and diverge with concurrent sessions on one repo, which would leave the receipt in a
-// sibling directory and hold the gate shut. The sha is content-addressed, so accepting a
-// receipt from any session dir is safe: it still must exist and be vision-capable.
-function findReceipt(sha) {
-  const own = path.join(sessionDir, `analyzed-${sha}.json`);
-  if (fs.existsSync(own)) return own;
-  const visionRoot = path.join(projectRoot, '.ukit', 'storage', 'cache', 'vision');
-  let entries = [];
-  try {
-    entries = fs.readdirSync(visionRoot, { withFileTypes: true });
-  } catch {
-    return null;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name === sessionId) continue;
-    const candidate = path.join(visionRoot, entry.name, `analyzed-${sha}.json`);
-    if (fs.existsSync(candidate)) return candidate;
-  }
-  return null;
-}
-
-function checkReceipt(receiptPath) {
-  if (!receiptPath || !fs.existsSync(receiptPath)) {
-    return { ok: false, reason: 'no analysis receipt found' };
-  }
-  const receipt = readJsonSafe(receiptPath);
-  if (!receipt) {
-    return { ok: false, reason: 'receipt is not valid JSON' };
-  }
-  if (!isVisionCapable(receipt.model)) {
-    const modelLabel = typeof receipt.model === 'string' && receipt.model.trim() ? receipt.model.trim() : '(missing)';
-    return { ok: false, reason: `receipt model "${modelLabel}" is not vision-capable — treated as absent` };
-  }
-  const status = receipt.status;
-  if (!VALID_STATUSES.has(status)) {
-    return { ok: false, reason: `receipt status "${status}" is not a valid terminal outcome` };
-  }
-  return { ok: true };
-}
-
-(async () => {
-  const now = Date.now();
-  const unicMode = await detectUnicModeSafe();
-
-  // The gate exists because the UNIC gateway BLINDS the model: unic-code/unic-smart
-  // cannot see images there, so an unanalysed image means guessing. Off the gateway
-  // Claude reads images natively and there is nothing left to enforce.
-  //
-  // This early exit is what makes the gate satisfiable at all off-gateway. The previous
-  // design tried to cover this case by accepting a receipt whose model string equalled
-  // modelTiers.vision.fallbackModel — but the analyst's frontmatter pins `unic-vision`,
-  // so off-gateway it runs on whatever model is actually available and self-reports THAT.
-  // A hardcoded fallback ID could never match it, so no valid receipt was reachable and
-  // one pasted screenshot hard-blocked Edit/Write for the rest of the session.
-  //
-  // Only a POSITIVE false stands the gate down. null (detection failed) still enforces:
-  // breaking one gitignored file must not be a bypass.
-  if (unicMode === false) {
-    process.exit(0);
-  }
-
-  const unsatisfied = [];
-  for (const markerName of markerNames) {
-    const sha = markerName.replace(/^pending-/, '').replace(/\.json$/, '');
-    const markerPath = path.join(sessionDir, markerName);
-
-    let markerTs = null;
-    const marker = readJsonSafe(markerPath);
-    if (marker && typeof marker.ts === 'number' && Number.isFinite(marker.ts)) {
-      markerTs = marker.ts;
-    }
-    if (markerTs == null) {
-      try {
-        markerTs = fs.statSync(markerPath).mtimeMs;
-      } catch {
-        markerTs = now;
-      }
-    }
-    // Abandoned-session bound: a marker older than 24h can never brick the repo.
-    if (now - markerTs > MARKER_MAX_AGE_MS) continue;
-
-    const receiptPath = findReceipt(sha);
-    const result = checkReceipt(receiptPath);
-    if (!result.ok) {
-      unsatisfied.push({ sha, reason: result.reason });
-    }
-  }
-
-  if (unsatisfied.length === 0) {
-    process.exit(0);
-    return;
-  }
-
-  const lines = [
-    'BLOCKED (vision gate): image(s) pending analysis — Edit/Write refused.',
-    ...unsatisfied.map((u) => `  - sha ${u.sha}: ${u.reason}`),
-    'unic-code / unic-smart cannot read images on this gateway and must not guess at their',
-    'contents — a wrong image analysis yields confidently wrong results.',
-    'Remedy: delegate to Agent(subagent_type: "ukit-vision-analyst") to analyse the pending',
-    'image(s) first, then retry this edit.',
-  ];
-  process.stderr.write(`${lines.join('\n')}\n`);
-  process.exit(2);
-})().catch((err) => {
-  // A logic error inside this hook's own JS must still fail CLOSED — the opposite fail
-  // direction from vision-router.sh, which fails open unconditionally.
-  process.stderr.write(`BLOCKED (vision gate): internal error, failing closed: ${err?.message ?? err}\n`);
-  process.exit(2);
-});
-NODE
-
-exit $?