@haposoft/cafekit 0.8.15 → 0.8.16

package/README.md

@@ -2,7 +2,7 @@
 
 > Claude Code-first spec-driven workflow and runtime bundle for AI coding assistants.
 
-[![Version](https://img.shields.io/badge/version-0.8.11-blue.svg)](https://github.com/haposoft/cafekit)
+[![Version](https://img.shields.io/badge/version-0.8.16-blue.svg)](https://github.com/haposoft/cafekit)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Claude%20Code](https://img.shields.io/badge/Claude%20Code-Primary-orange.svg)](https://claude.ai/code)
 
@@ -87,6 +87,12 @@ CafeKit ships many skills, but the main release surface is:
 
 Common companion skills bundled in this package include `inspect`, `impact-analysis`, `research`, `ai-multimodal`, `frontend-development`, `backend-development`, and `react-best-practices`.
 
+CafeKit uses rule-based skill routing guidance instead of an automatic prompt-scoring hook. See `.claude/rules/skill-workflow-routing.md`, `.claude/rules/skill-domain-routing.md`, or run:
+
+```bash
+node .claude/scripts/generate-skill-catalog.cjs --skills
+```
+
 ## Quick Start
 
 For unclear ideas, brainstorm first:

package/bin/install.js

@@ -780,6 +780,79 @@ function copyClaudeRuntimeFiles(platformKey, results, options = {}) {
   });
 }
 
+function removeObsoleteClaudeRuntimeFiles(platformKey, results) {
+  if (platformKey !== 'claude') return;
+
+  const obsoleteFiles = CLAUDE_MIGRATION_MANIFEST?.obsolete?.runtimeFiles || [];
+  const targetBase = path.join(PLATFORMS.claude.folder);
+
+  obsoleteFiles.forEach(relPath => {
+    const targetPath = path.join(targetBase, relPath);
+
+    if (!fs.existsSync(targetPath)) {
+      return;
+    }
+
+    fs.rmSync(targetPath, { force: true });
+    console.log(`  ↻ Removed obsolete runtime: ${relPath}`);
+    results.updated++;
+  });
+}
+
+function pruneObsoleteSettingsHooks(settings, results) {
+  const obsoleteSubstrings = CLAUDE_MIGRATION_MANIFEST?.obsolete?.settingsHookCommandSubstrings || [];
+
+  if (!settings.hooks || obsoleteSubstrings.length === 0) {
+    return settings;
+  }
+
+  let removedCount = 0;
+  const prunedHooks = {};
+
+  Object.entries(settings.hooks).forEach(([eventName, matcherEntries]) => {
+    if (!Array.isArray(matcherEntries)) {
+      prunedHooks[eventName] = matcherEntries;
+      return;
+    }
+
+    const prunedEntries = [];
+
+    matcherEntries.forEach(entry => {
+      if (!Array.isArray(entry?.hooks)) {
+        prunedEntries.push(entry);
+        return;
+      }
+
+      const remainingHooks = entry.hooks.filter(hook => {
+        const command = hook?.command || '';
+        const isObsolete = obsoleteSubstrings.some(substring => command.includes(substring));
+
+        if (isObsolete) {
+          removedCount++;
+        }
+
+        return !isObsolete;
+      });
+
+      if (remainingHooks.length > 0) {
+        prunedEntries.push({ ...entry, hooks: remainingHooks });
+      }
+    });
+
+    if (prunedEntries.length > 0) {
+      prunedHooks[eventName] = prunedEntries;
+    }
+  });
+
+  if (removedCount > 0) {
+    console.log(`  ↻ Settings: removed ${removedCount} obsolete hook(s)`);
+    results.updated++;
+    return { ...settings, hooks: prunedHooks };
+  }
+
+  return settings;
+}
+
 // Merge Claude settings.json
 function mergeClaudeSettings(platformKey, results, options = {}) {
   if (platformKey !== 'claude') return;
@@ -802,7 +875,7 @@ function mergeClaudeSettings(platformKey, results, options = {}) {
     existingSettings = JSON.parse(fs.readFileSync(targetPath, 'utf8'));
   }
 
-  const mergedSettings = { ...existingSettings };
+  const mergedSettings = pruneObsoleteSettingsHooks({ ...existingSettings }, results);
 
   // Merge statusLine
   if (managedSettings.statusLine) {
@@ -1106,6 +1179,7 @@ async function main() {
       if (platformKey === 'claude') {
         copyRoutingFile(platformKey, results, installerOptions);
         copyClaudeRuntimeFiles(platformKey, results, installerOptions);
+        removeObsoleteClaudeRuntimeFiles(platformKey, results);
         mergeClaudeSettings(platformKey, results, installerOptions);
         copyClaudeMdFile(platformKey, results, installerOptions);
         copyRulesDirectory(platformKey, results, installerOptions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haposoft/cafekit",
-  "version": "0.8.15",
+  "version": "0.8.16",
   "description": "Claude Code-first spec-driven workflow for AI coding assistants. Bundles CafeKit hapo: skills, runtime hooks, agents, and installer scaffolding.",
   "author": "Haposoft <nghialt@haposoft.com>",
   "license": "MIT",

package/src/claude/CLAUDE.md

@@ -88,6 +88,8 @@ Consult these when the task touches the relevant area:
 
 - Primary workflow: `./.claude/rules/workflow.md`
 - Development rules: `./.claude/rules/ai-dev-rules.md`
+- Skill workflow routing: `./.claude/rules/skill-workflow-routing.md`
+- Skill domain routing: `./.claude/rules/skill-domain-routing.md`
 - Subagent coordination: `./.claude/rules/orchestrator.md`
 - Docs maintenance: `./.claude/rules/manage-docs.md`
 - State sync: `./.claude/rules/state-sync.md`
@@ -97,6 +99,8 @@ Consult these when the task touches the relevant area:
 ## Skill And Script Use
 
 - Evaluate the available skills catalog before work and activate the relevant skill(s).
+- Use `./.claude/rules/skill-workflow-routing.md` and `./.claude/rules/skill-domain-routing.md` to choose skills. CafeKit does not auto-route prompts through a scoring hook.
+- When needed, run `node .claude/scripts/generate-skill-catalog.cjs --skills` to inspect the installed skill catalog.
 - If there is a reasonable chance a skill applies, prefer the skill workflow over ad hoc execution.
 - If modifying skills, edit the current project/runtime files, not `~/.claude/skills` directly.
 - Run Python skill scripts with the skill venv:

package/src/claude/hooks/lib/config.cjs

@@ -64,7 +64,6 @@ const DEFAULT_CONFIG = {
     'session-init': true,
     'subagent-init': true,
     'dev-rules-reminder': true,
-    'skill-router': true,
     'usage': true,
     'context-tracking': true,
     'scout-block': true,

package/src/claude/hooks/lib/context.cjs

@@ -358,7 +358,7 @@ function buildRulesSection({ devRulesPath, catalogScript, skillsVenv, plansPath,
   lines.push(`- **IMPORTANT:** DO NOT create markdown files outside of "${plansRef}" or "${docsRef}" UNLESS the user explicitly requests it.`);
 
   if (catalogScript) {
-    lines.push(`- Activate skills: Run \`python ${catalogScript} --skills\` to generate a skills catalog and analyze it, then activate the relevant skills that are needed for the task during the process.`);
+    lines.push(`- Activate skills: Use \`.claude/rules/skill-workflow-routing.md\` and \`.claude/rules/skill-domain-routing.md\`; run \`node ${catalogScript} --skills\` when you need a generated skills catalog.`);
   }
 
   if (skillsVenv) {
@@ -525,7 +525,7 @@ function buildReminderContext({ sessionId, config, staticEnv, configDirName = '.
 
   // Resolve paths
   const devRulesPath = resolveRulesPath('ai-dev-rules.md', configDirName);
-  const catalogScript = resolveScriptPath('generate_catalogs.py', configDirName);
+  const catalogScript = resolveScriptPath('generate-skill-catalog.cjs', configDirName);
   const skillsVenv = resolveSkillsVenv(configDirName);
 
   // Build plan context

package/src/claude/hooks/rules.cjs

@@ -91,6 +91,13 @@ try {
   lines.push('- Ensure token efficiency while maintaining high quality.');
   lines.push('');
 
+  // Skill routing: advisory rule docs, no automatic prompt router.
+  lines.push('## Skill Routing');
+  lines.push('- Choose skills from intent using `.claude/rules/skill-workflow-routing.md` and `.claude/rules/skill-domain-routing.md`.');
+  lines.push('- If needed, run `node .claude/scripts/generate-skill-catalog.cjs --skills` to inspect installed skills.');
+  lines.push('- Explicit user commands and direct-answer requests override routing suggestions.');
+  lines.push('');
+
   // Modularization
   lines.push('## [IMPORTANT] Consider Modularization:');
   lines.push('- If a file exceeds 200 lines, consider splitting it');

package/src/claude/migration-manifest.json

@@ -58,6 +58,7 @@
     "required": [
       "validate-docs.cjs",
       "validate-docs-reconstruct.cjs",
+      "generate-skill-catalog.cjs",
       "browser-tool.cjs",
       "validate-spec-output.cjs"
     ]
@@ -68,6 +69,15 @@
   "hooks": {
     "assumed": []
   },
+  "obsolete": {
+    "runtimeFiles": [
+      "hooks/skill-router.cjs",
+      "hooks/lib/skill-router-routes.cjs"
+    ],
+    "settingsHookCommandSubstrings": [
+      "hooks/skill-router.cjs"
+    ]
+  },
   "runtime": {
     "files": [
       "gitignore",
@@ -80,7 +90,6 @@
       "hooks/privacy-block.cjs",
       "hooks/inspect-block.cjs",
       "hooks/rules.cjs",
-      "hooks/skill-router.cjs",
       "hooks/spec-state.cjs",
       "hooks/state.cjs",
       "hooks/lib/color.cjs",
@@ -89,8 +98,7 @@
       "hooks/lib/git.cjs",
       "hooks/lib/config.cjs",
       "hooks/lib/context.cjs",
-      "hooks/lib/detect.cjs",
-      "hooks/lib/skill-router-routes.cjs"
+      "hooks/lib/detect.cjs"
     ]
   },
   "settings": {

package/src/claude/rules/skill-domain-routing.md

@@ -0,0 +1,87 @@
+# Skill Domain Routing
+
+Use this decision tree to choose domain skills from the installed CafeKit skill set. This is advisory routing, not an automatic hook.
+
+## Frontend And UI
+
+```text
+User wants to...
+├── choose style, color, layout, UX, design system       -> /hapo:frontend-design
+├── build React/TypeScript UI components                 -> /hapo:frontend-development
+├── optimize React/Next.js performance or rerenders      -> /hapo:react-best-practices
+├── apply deep UI/UX intelligence, visual polish         -> /hapo:ui-ux-pro-max
+└── test UI in browser                                   -> /hapo:web-testing or /hapo:agent-browser
+```
+
+Use `/hapo:react-best-practices` for performance/re-render patterns. Use `/hapo:frontend-development` for normal implementation.
+
+## Backend, Data, And Infrastructure
+
+```text
+User wants to...
+├── API, service, auth, database-backed feature          -> /hapo:backend-development
+├── deployment, Docker, Kubernetes, Cloudflare, CI/CD     -> /hapo:devops
+├── mobile apps, iOS, Android, React Native, Flutter     -> /hapo:mobile-development
+└── impact of changing existing behavior                 -> /hapo:impact-analysis
+```
+
+## Codebase Understanding
+
+```text
+User wants to...
+├── find files, locate code, scan project structure       -> /hapo:inspect
+├── diagnose an error or failing check                    -> /hapo:debug
+├── understand possible side effects                      -> /hapo:impact-analysis
+└── compare external approaches or best practices         -> /hapo:research
+```
+
+Local source truth comes from `/hapo:inspect`; external/current knowledge comes from `/hapo:research`.
+
+## Documentation
+
+```text
+User wants to...
+├── create missing project docs                           -> /hapo:docs --init
+├── update docs after source changes                      -> /hapo:docs --update
+├── summarize codebase quickly                            -> /hapo:docs --summarize
+├── reconstruct as-is docs from legacy source code        -> /hapo:docs --reconstruct <scope>
+└── create a future feature spec                          -> /hapo:specs
+```
+
+Keep as-is reconstruction separate from future requirements. Reconstructed docs document current behavior; specs define requested changes.
+
+## Testing And Browser
+
+```text
+User wants to...
+├── run test suites, coverage, scoped verification        -> /hapo:test
+├── E2E/unit/integration/load/security/a11y strategy      -> /hapo:web-testing
+├── drive a browser with snapshots or Browserbase         -> /hapo:agent-browser
+└── Chrome DevTools/Puppeteer evidence                    -> /hapo:chrome-devtools
+```
+
+## Documents And Media
+
+```text
+User wants to...
+├── PowerPoint/slides                                     -> /hapo:pptx
+├── Word documents                                        -> /hapo:docx
+├── PDFs                                                  -> /hapo:pdf
+├── spreadsheets/CSV/XLSX                                 -> /hapo:xlsx
+└── image/audio/video/document multimodal analysis        -> /hapo:ai-multimodal
+```
+
+## Git And Release
+
+```text
+User wants to...
+├── commit, branch, tag, push, release prep               -> /hapo:git
+└── review before release                                 -> /hapo:code-review
+```
+
+## Usage Notes
+
+- Read the selected skill's `SKILL.md` before acting.
+- Do not activate a skill only because one keyword appears. Use the whole user intent.
+- If a task spans multiple domains, name the primary skill and mention the secondary skill in the plan.
+- If no domain skill fits, use the core CafeKit workflow in `skill-workflow-routing.md`.

package/src/claude/rules/skill-workflow-routing.md

@@ -0,0 +1,84 @@
+# Skill Workflow Routing
+
+Use this rule instead of automatic prompt routing. Read the user's intent, choose the primary CafeKit workflow, then load the relevant `.claude/skills/<skill>/SKILL.md`.
+
+Do not inject or force a skill when the user explicitly asks for a direct answer, a specific command, or a different workflow.
+
+## Core Specification Workflow
+
+```text
+/hapo:brainstorm -> /hapo:specs -> /hapo:develop -> /hapo:test -> /hapo:code-review -> /hapo:git
+```
+
+| User intent | Suggested start |
+|---|---|
+| unclear idea, possible approaches, scope tradeoffs | `/hapo:brainstorm` |
+| create requirements, design, task breakdown, validate spec | `/hapo:specs` |
+| implement an approved spec or a specific task file | `/hapo:develop` |
+| run tests, QA, runtime verification | `/hapo:test` |
+| review code quality, security, regressions, maintainability | `/hapo:code-review` |
+| commit, tag, push, branch, release prep | `/hapo:git` |
+
+## Bug And Incident Workflow
+
+```text
+/hapo:debug -> /hapo:hotfix -> /hapo:test -> /hapo:code-review
+```
+
+| User intent | Suggested start |
+|---|---|
+| diagnose why something fails, find root cause, inspect CI/logs | `/hapo:debug` |
+| fix a known bug after diagnosis, urgent regression, production issue | `/hapo:hotfix` |
+| verify the fix and affected behavior | `/hapo:test` |
+| check side effects before closeout | `/hapo:code-review` |
+
+`/hapo:debug` is diagnostic-only. Do not edit product code there. Use `/hapo:hotfix` when the user asks to fix.
+
+## Existing System Documentation Workflow
+
+```text
+/hapo:inspect -> /hapo:docs --reconstruct -> human review -> /hapo:specs -> /hapo:develop
+```
+
+| User intent | Suggested start |
+|---|---|
+| understand source structure or locate implementation areas | `/hapo:inspect` |
+| rebuild as-is docs/requirements from a legacy codebase | `/hapo:docs --reconstruct <scope>` |
+| update normal project docs | `/hapo:docs --update` |
+| initialize missing docs | `/hapo:docs --init` |
+| summarize a codebase without full docs work | `/hapo:docs --summarize` |
+
+Do not turn reconstructed docs directly into implementation. Human review must approve the as-is docs before `/hapo:specs` defines future changes.
+
+## Research And Analysis Workflow
+
+```text
+/hapo:inspect -> /hapo:impact-analysis -> /hapo:research
+```
+
+| User intent | Suggested start |
+|---|---|
+| file discovery, codebase structure, source scouting | `/hapo:inspect` |
+| affected files, blast radius, dependency impact, side effects | `/hapo:impact-analysis` |
+| external best practices, tool comparison, technical investigation | `/hapo:research` |
+
+Use `/hapo:research` for external knowledge. Use `/hapo:inspect` for local source truth.
+
+## Output Artifact Workflow
+
+| User intent | Suggested skill |
+|---|---|
+| diagrams, architecture maps, Mermaid/SVG/PNG graph output | `/hapo:generate-graph` |
+| PowerPoint or slide deck creation/editing | `/hapo:pptx` |
+| Word documents | `/hapo:docx` |
+| PDF processing | `/hapo:pdf` |
+| spreadsheets | `/hapo:xlsx` |
+| screenshots, images, audio, video, OCR, multimodal understanding | `/hapo:ai-multimodal` |
+
+## Selection Rules
+
+- Pick one primary workflow first.
+- Add a secondary skill only when it materially changes execution.
+- Prefer explicit user commands over this table.
+- If two workflows conflict, ask one concise clarification.
+- If the user asks to "fix" and root cause is unknown, start with `/hapo:debug` unless the issue is trivial and local.

package/src/claude/scripts/generate-skill-catalog.cjs

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * CafeKit skill catalog scanner.
+ *
+ * This mirrors the Research/.claude approach: expose the installed skill set as
+ * a readable catalog so the model can choose skills from rules, not from an
+ * automatic prompt-scoring hook.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function usage() {
+  console.log(`Usage:
+  node .claude/scripts/generate-skill-catalog.cjs [--skills] [--json] [--root <skills-dir>]
+
+Examples:
+  node .claude/scripts/generate-skill-catalog.cjs --skills
+  node .claude/scripts/generate-skill-catalog.cjs --json --root .claude/skills`);
+}
+
+function parseArgs(argv) {
+  const args = { json: false, help: false, root: null };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') args.help = true;
+    else if (arg === '--json') args.json = true;
+    else if (arg === '--skills') continue;
+    else if (arg === '--root') {
+      args.root = argv[i + 1] || null;
+      i += 1;
+    } else {
+      args.root = args.root || arg;
+    }
+  }
+  return args;
+}
+
+function defaultSkillsRoot() {
+  const installed = path.resolve(process.cwd(), '.claude', 'skills');
+  if (fs.existsSync(installed)) return installed;
+  return path.resolve(__dirname, '..', 'skills');
+}
+
+function readText(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function extractFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+  if (!match) return {};
+  const frontmatter = {};
+  const lines = match[1].split(/\r?\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1];
+    let value = kv[2].trim();
+    if (value === '>' || value === '>-' || value === '|' || value === '|-') {
+      const block = [];
+      i += 1;
+      while (i < lines.length && /^\s+/.test(lines[i])) {
+        block.push(lines[i].trim());
+        i += 1;
+      }
+      i -= 1;
+      value = block.join(' ');
+    }
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    frontmatter[key] = value;
+  }
+  return frontmatter;
+}
+
+function firstParagraph(content) {
+  const body = content.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, '');
+  const paragraph = [];
+  for (const rawLine of body.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) {
+      if (paragraph.length > 0) break;
+      continue;
+    }
+    paragraph.push(line);
+    if (paragraph.join(' ').length > 160) break;
+  }
+  return paragraph.join(' ').slice(0, 360);
+}
+
+function categorize(name, description) {
+  const text = `${name} ${description}`.toLowerCase();
+  if (/spec|brainstorm|develop|sync/.test(text)) return 'workflow';
+  if (/debug|hotfix|inspect|impact|review|test|agent-browser|chrome/.test(text)) return 'quality';
+  if (/frontend|react|ui|ux|mobile/.test(text)) return 'frontend-mobile';
+  if (/pdf|docx|pptx|xlsx|multimodal/.test(text)) return 'artifacts-tools';
+  if (/backend|devops|api|database|deploy/.test(text)) return 'backend-infra';
+  if (/docs|research|graph/.test(text)) return 'knowledge';
+  if (/git/.test(text)) return 'git';
+  return 'other';
+}
+
+function scanSkills(root) {
+  if (!fs.existsSync(root)) {
+    throw new Error(`skills root not found: ${root}`);
+  }
+  const entries = fs.readdirSync(root, { withFileTypes: true });
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+    const skillPath = path.join(root, entry.name, 'SKILL.md');
+    if (!fs.existsSync(skillPath)) continue;
+    const content = readText(skillPath);
+    const frontmatter = extractFrontmatter(content);
+    const name = frontmatter.name || entry.name;
+    const description = frontmatter.description || firstParagraph(content);
+    skills.push({
+      name,
+      directory: entry.name,
+      description,
+      category: categorize(name, description),
+      has_references: fs.existsSync(path.join(root, entry.name, 'references')),
+      has_scripts: fs.existsSync(path.join(root, entry.name, 'scripts')),
+    });
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function renderMarkdown(skills, root) {
+  const lines = [
+    '# CafeKit Skills Catalog',
+    '',
+    `Skills root: \`${root}\``,
+    `Total skills: ${skills.length}`,
+    '',
+  ];
+  const categories = [...new Set(skills.map((skill) => skill.category))].sort();
+  for (const category of categories) {
+    lines.push(`## ${category}`, '');
+    for (const skill of skills.filter((item) => item.category === category)) {
+      const badges = [
+        skill.has_references ? 'refs' : null,
+        skill.has_scripts ? 'scripts' : null,
+      ].filter(Boolean);
+      lines.push(
+        `- \`${skill.name}\` (${skill.directory})${badges.length ? ` [${badges.join(', ')}]` : ''}: ${skill.description}`
+      );
+    }
+    lines.push('');
+  }
+  return lines.join('\n').trim() + '\n';
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    usage();
+    return;
+  }
+
+  const root = path.resolve(process.cwd(), args.root || defaultSkillsRoot());
+  const skills = scanSkills(root);
+  if (args.json) {
+    console.log(JSON.stringify({ root, total: skills.length, skills }, null, 2));
+    return;
+  }
+  console.log(renderMarkdown(skills, root));
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`[skill-catalog] ${error.message}`);
+  process.exit(1);
+}

package/src/claude/settings/settings.json

@@ -42,10 +42,6 @@
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/rules.cjs\""
           },
-          {
-            "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/skill-router.cjs\""
-          },
           {
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/spec-state.cjs\""

package/src/claude/hooks/lib/skill-router-routes.cjs

@@ -1,196 +0,0 @@
-const MIN_SCORE = 4;
-const WEIGHTS = { strong: 6, medium: 3, weak: 1, negative: -5 };
-
-const ROUTES = [
-  route('hapo:hotfix', 'urgent fix or production regression', 100, {
-    strong: ['hotfix', 'fix bug', 'fix lỗi', 'fix loi', 'sửa lỗi', 'sua loi', 'production bug', 'prod bug', 'regression', 'lỗi production', 'loi production', 'sửa gấp', 'sua gap', 'バグ修正', '不具合修正', '本番障害', '本番バグ', '緊急修正', '至急修正', 'リグレッション'],
-    medium: ['khẩn cấp', 'khan cap', 'production', 'critical bug', 'rollback', '修正して', '直して', '緊急', '本番', '重大バグ', 'ロールバック', '障害対応'],
-    weak: ['fix', 'fixing', 'sửa', 'sua', 'urgent', 'emergency', 'release is broken', '修正', '直す', '至急', 'リリースが壊れた'],
-    negative: ['slide', 'pptx', 'spec', 'brainstorm'],
-  }),
-  route('hapo:debug', 'bug investigation or failure diagnosis', 90, {
-    strong: ['debug', 'root cause', 'diagnose', 'stack trace', 'không chạy', 'khong chay', 'デバッグ', '原因調査', '根本原因', 'スタックトレース', '動かない'],
-    medium: ['bug', 'error', 'exception', 'failing', 'failed', 'failure', 'broken', 'lỗi', 'loi', 'tại sao', 'tai sao', 'vì sao', 'vi sao', 'nguyên nhân', 'nguyen nhan', 'ci fail', 'build fail', 'バグ', 'エラー', '例外', '失敗', '壊れている', 'なぜ', '原因', 'ci失敗', 'ビルド失敗'],
-    weak: ['sai', 'fail', 'issue', 'problem', '問題', '不具合'],
-    negative: ['commit', 'push', 'slide', 'pptx'],
-  }),
-  route('hapo:specs', 'specification, requirements, design, tasks, or spec validation', 80, {
-    strong: ['spec', 'specs', 'requirements', 'acceptance criteria', 'task breakdown', 'đặc tả', 'dac ta', '仕様', '仕様書', '要件', '受け入れ条件', 'タスク分解', '仕様を作って', '仕様を作成'],
-    medium: ['requirement', 'ears', 'design doc', 'scope', '--validate', 'yêu cầu', 'yeu cau', 'phạm vi', 'pham vi', 'validate spec', 'kiểm tra spec', 'kiem tra spec', '要求', '設計書', 'スコープ', '検証', '仕様を確認'],
-    weak: ['tính năng mới', 'tinh nang moi', 'feature idea', 'user story', 'criteria', 'task list', '新機能', 'ユーザーストーリー', '基準', 'タスクリスト'],
-    negative: ['commit', 'push', 'bug', 'error', 'production', 'pptx', 'pdf', 'reconstruct requirements', 'as-is requirements', 'legacy system documentation', 'documentation from source code', 'docs from source code', 'ソースコードから'],
-  }),
-  route('hapo:develop', 'implementation from an approved spec or task list', 75, {
-    strong: ['develop', 'implement', 'implementation', 'theo spec', 'theo specs', 'approved spec', 'làm theo spec', 'lam theo spec', '実装', '開発', '仕様に沿って', '仕様どおり', '承認済み仕様'],
-    medium: ['build this', 'code this', 'start task', 'run task', 'thực hiện task', 'thuc hien task', 'phát triển', 'phat trien', 'bắt đầu implement', 'bat dau implement', 'vào code', 'vao code', '作って', 'コードを書いて', 'タスクを開始', 'タスクを実行', '開発して', '実装して'],
-    weak: ['triển khai', 'trien khai', 'đưa vào code', 'dua vao code', 'code feature', 'コード化', '機能を作る'],
-    negative: ['bug', 'debug', 'review', 'test only', 'commit'],
-  }),
-  route('hapo:test', 'test, verification, QA, or runtime validation', 70, {
-    strong: ['unit test', 'integration test', 'e2e', 'playwright', 'coverage', 'test all', 'run all tests', 'test toàn bộ', 'test toan bo', 'kiểm thử', 'kiem thu', 'kiểm tra toàn bộ', 'kiem tra toan bo', '単体テスト', '結合テスト', '全体テスト', 'カバレッジ', 'テストして'],
-    medium: ['test', 'tests', 'testing', 'qa', 'verify', 'verification', 'kiểm tra chạy', 'kiem tra chay', 'xác minh', 'xac minh', 'テスト', '検証', '確認', '動作確認', '全体確認'],
-    weak: ['assert', 'runtime proof', 'manual qa', 'end to end', 'smoke test', 'アサート', 'スモークテスト'],
-    negative: ['spec', 'requirements', 'commit', 'push'],
-  }),
-  route('hapo:code-review', 'code review, audit, security, or quality assessment', 68, {
-    strong: ['code review', 'security review', 'performance review', 'đánh giá code', 'danh gia code', 'コードレビュー', 'セキュリティレビュー', '性能レビュー'],
-    medium: ['review', 'audit', 'quality', 'đánh giá', 'danh gia', 'kiểm tra chất lượng', 'kiem tra chat luong', 'レビュー', '監査', '品質', '品質確認'],
-    weak: ['risk', 'maintainability', 'readability', 'vulnerability', 'lỗ hổng', 'lo hong', 'リスク', '保守性', '可読性', '脆弱性'],
-    negative: ['slide', 'pptx', 'commit and push'],
-  }),
-  route('hapo:git', 'git, commit, push, branch, tag, or pull request workflow', 65, {
-    strong: ['commit', 'push', 'pull request', 'git', 'đẩy lên', 'day len', 'コミット', 'プッシュ', 'プルリク', 'リリースして'],
-    medium: ['pr ', 'branch', 'tag', 'release', 'publish', 'merge', 'rebase', 'ブランチ', 'タグ', 'リリース', '公開', 'マージ', 'リベース'],
-    weak: ['origin', 'remote', 'checkout', 'stash', 'version bump', 'リモート', 'チェックアウト', 'スタッシュ', 'バージョン更新'],
-    negative: ['deploy', 'test', 'review only'],
-  }),
-  route('hapo:inspect', 'codebase discovery, file search, structure scan, or locating implementation areas', 64, {
-    strong: ['inspect', 'codebase scan', 'scan codebase', 'scan source', 'file discovery', 'find files', 'locate files', 'xem source', 'xem codebase', 'kiểm tra source', 'kiem tra source', 'kiểm tra source code', 'kiem tra source code', 'quét source', 'quet source', 'quét codebase', 'quet codebase', 'kiểm tra cấu trúc', 'kiem tra cau truc', 'コード構造', 'ソース確認', 'コードベース確認', 'ファイル探索', '構造を確認'],
-    medium: ['search files', 'find where', 'where is', 'project structure', 'code structure', 'repo structure', 'source code', 'tìm file', 'tim file', 'tìm trong source', 'tim trong source', 'cấu trúc project', 'cau truc project', 'ở đâu', 'o dau', 'nằm đâu', 'nam dau', '関連ファイル', 'どこにある', 'プロジェクト構造', 'リポジトリ構造', '探して'],
-    weak: ['scan', 'inspect code', 'explore code', 'xem qua', 'xem giúp', '調べて', '確認して'],
-    negative: ['bug', 'error', 'lỗi', 'loi', 'fail', 'failure', 'production', 'hotfix', 'fix', 'sửa', 'sua', 'debug', 'develop', 'implement', 'test', 'commit', 'push', 'slide', 'pptx'],
-  }),
-  route('hapo:impact-analysis', 'impact analysis before changing existing behavior', 64, {
-    strong: ['impact analysis', 'blast radius', 'ảnh hưởng', 'anh huong', 'tác động', 'tac dong', '影響分析', '影響範囲', '影響', '副作用'],
-    medium: ['impact', 'liên quan những đâu', 'lien quan nhung dau', 'affected files', 'dependency impact', '関連箇所', '影響ファイル', '依存関係'],
-    weak: ['before changing', 'risk area', 'downstream', 'upstream', 'side effect', '変更前', 'リスク範囲', '下流', '上流'],
-    negative: ['slide', 'pptx'],
-  }),
-  route('hapo:frontend-design', 'UI/UX design, visual style, layout, or color system', 62, {
-    strong: ['ui design', 'visual style', 'color system', 'thiết kế giao diện', 'thiet ke giao dien', 'màu sắc', 'mau sac', 'uiデザイン', '画面デザイン', 'ビジュアルスタイル', '配色'],
-    medium: ['ux', 'layout', 'style', 'theme', 'responsive design', 'giao diện', 'giao dien', 'wireframe', 'レイアウト', 'スタイル', 'テーマ', 'レスポンシブデザイン', '画面', 'ワイヤーフレーム', '色'],
-    weak: ['palette', 'typography', 'spacing', 'polish ui', 'mockup', 'prototype', 'パレット', 'タイポグラフィ', '余白', 'モックアップ', 'プロトタイプ'],
-    negative: ['backend', 'api', 'database'],
-  }),
-  route('hapo:react-best-practices', 'React and Next.js performance patterns, rerender optimization, and Vercel best practices', 60, {
-    strong: ['react best practices', 'next.js best practices', 'vercel react best practices', 'react performance', 'next.js performance', 'optimize react', 'optimize next.js', 'rerender nhiều', 'rerender nhieu', 'nhiều rerender', 'nhieu rerender', 'tối ưu react', 'toi uu react', 'tối ưu next.js', 'toi uu next.js', 'reactベストプラクティス', 'next.jsベストプラクティス', 'react最適化', 'next.js最適化', 'react性能'],
-    medium: ['bundle optimization', 'bundle size', 'rerender optimization', 're-render optimization', 'data fetching', 'server component', 'client component', 'suspense', 'hydration', 'waterfall', 'usememo', 'usecallback', 'react cache', 'optimize', 'optimization', 'tối ưu', 'toi uu', 'tối ưu rerender', 'toi uu rerender', 'tối ưu bundle', 'toi uu bundle', 'バンドル最適化', '再レンダー最適化', '最適化', 'データ取得', 'サーバーコンポーネント', 'クライアントコンポーネント', 'ハイドレーション'],
-    weak: ['react', 'next.js', 'memo', 'rerender', 're-render', 'render performance', 'component performance', 'waterfalls', 'lazy state', 'dynamic import', 'react pattern', 'next.js pattern', 'レンダー性能', 'コンポーネント性能', '動的インポート'],
-    negative: ['backend', 'api', 'database', 'slide', 'pptx', 'commit', 'push'],
-  }),
-  route('hapo:frontend-development', 'frontend implementation work', 58, {
-    strong: ['react', 'next.js', 'vite', 'frontend', 'tailwind', 'web app', 'フロントエンド', 'webアプリ'],
-    medium: ['component', 'css', 'html', 'browser ui', 'client side', 'giao diện react', 'コンポーネント', 'ブラウザui', 'クライアント側', 'react画面'],
-    weak: ['state management', 'hook', 'form', 'table', 'dashboard ui', '状態管理', 'フック', 'フォーム', 'テーブル', 'ダッシュボードui'],
-    negative: ['best practices', 'performance', 'optimize', 'optimization', 'rerender', 're-render', 'tối ưu', 'toi uu', '再レンダー', '最適化', '性能', 'backend only', 'database only', 'slide', 'pptx'],
-  }),
-  route('hapo:backend-development', 'backend, API, database, or service implementation', 58, {
-    strong: ['backend', 'api', 'database', 'endpoint', 'server', 'service', 'バックエンド', 'データベース', 'エンドポイント', 'サーバー', 'サービス'],
-    medium: ['db', 'sql', 'postgres', 'mysql', 'migration', 'schema', 'worker', 'queue', 'マイグレーション', 'スキーマ', 'ワーカー', 'キュー'],
-    weak: ['controller', 'route handler', 'repository', 'model', 'auth service', 'コントローラ', 'ルートハンドラ', 'リポジトリ', 'モデル', '認証サービス'],
-    negative: ['frontend only', 'slide', 'pptx'],
-  }),
-  route('hapo:mobile-development', 'mobile app implementation', 56, {
-    strong: ['mobile', 'ios', 'android', 'react native', 'flutter', 'モバイル'],
-    medium: ['app store', 'play store', 'native app', 'mobile screen', 'アプリストア', 'playストア', 'ネイティブアプリ', 'モバイル画面'],
-    weak: ['gesture', 'push notification', 'offline sync', 'ジェスチャー', 'プッシュ通知', 'オフライン同期'],
-    negative: ['web only', 'desktop only'],
-  }),
-  route('hapo:devops', 'deployment, infrastructure, CI/CD, or operations work', 54, {
-    strong: ['deploy', 'deployment', 'docker', 'kubernetes', 'ci/cd', 'github actions', 'デプロイ', 'デプロイメント'],
-    medium: ['vercel', 'infra', 'infrastructure', 'devops', 'pipeline', 'environment variable', 'インフラ', 'パイプライン', '環境変数'],
-    weak: ['build server', 'container', 'helm', 'terraform', 'monitoring', 'ビルドサーバー', 'コンテナ', '監視'],
-    negative: ['slide', 'pptx', 'spec only'],
-  }),
-  route('hapo:generate-graph', 'diagram, graph, architecture map, or flow visualization', 52, {
-    strong: ['diagram', 'graph', 'mermaid', 'flowchart', 'architecture diagram', 'sơ đồ', 'so do', '図', '図解', 'ダイアグラム', 'グラフ', 'フローチャート', '構成図'],
-    medium: ['biểu đồ', 'bieu do', 'visualize', 'sequence diagram', 'data flow', '可視化', 'シーケンス図', 'データフロー'],
-    weak: ['mind map', 'dependency map', 'system map', 'マインドマップ', '依存関係図', 'システム図'],
-    negative: ['pptx', 'slide deck'],
-  }),
-  route('hapo:docs', 'project documentation, codebase docs, or source-backed as-is reconstruction', 51, {
-    strong: ['hapo:docs', 'project docs', 'system docs', 'codebase docs', 'codebase documentation', 'documentation from source code', 'docs from source code', 'generate docs from codebase', 'dựng tài liệu từ source code', 'dung tai lieu tu source code', 'tài liệu hệ thống', 'tai lieu he thong', 'tài liệu hiện trạng', 'tai lieu hien trang', 'tạo tài liệu project', 'tao tai lieu project', 'legacy documentation', 'legacy system documentation', 'as-is documentation', 'as-is requirements', 'requirement reconstruction', 'reconstruct requirements', 'reconstruct requirements from legacy system', 'ソースコードから仕様書', 'ソースコードから仕様書を作成', 'ソースコードからドキュメント', '既存システムのドキュメント', '現行仕様書', 'as-isドキュメント'],
-    medium: ['create docs', 'update docs', 'refresh docs', 'summarize codebase', 'system documentation', 'source to docs', 'reverse documentation', 'current-state docs', 'existing system docs', 'legacy docs', 'legacy system', 'dựng docs', 'dung docs', 'tạo docs', 'tao docs', 'cập nhật docs', 'cap nhat docs', 'tóm tắt codebase', 'tom tat codebase', 'dựng lại tài liệu', 'dung lai tai lieu', '仕様書を作成', 'ドキュメント作成', 'ドキュメント更新', 'コードベース要約', '既存システム', 'レガシーシステム'],
-    weak: ['docs', 'documentation', 'document project', 'document codebase', 'as-is', 'reconstruct', 'hiện trạng', 'hien trang', 'tài liệu', 'tai lieu', 'ドキュメント', '資料化', '仕様化', '現状'],
-    negative: ['official docs', 'latest docs', 'library docs', 'framework docs', 'api docs lookup', 'context7', 'best practice', 'research', 'pptx', 'slide'],
-  }),
-  route('hapo:brainstorm', 'early ideation or unclear solution direction', 50, {
-    strong: ['brainstorm', 'ý tưởng', 'y tuong', 'phương án', 'phuong an', 'gợi ý', 'goi y', 'ブレスト', 'アイデア', '案', '提案して', '相談'],
-    medium: ['idea', 'ideas', 'approach', 'options', 'tradeoff', 'chủ đề', 'chu de', 'cần làm gì', 'can lam gi', 'アプローチ', '選択肢', 'トレードオフ', 'テーマ', '何をすれば'],
-    weak: ['proposal', 'strategy', 'plan options', 'explore', 'direction', 'seminar topic', '提案', '戦略', '方向性', '検討'],
-    negative: ['commit', 'push', 'bug', 'error'],
-  }),
-  route('hapo:research', 'technical research or best-practice lookup', 48, {
-    strong: ['research', 'best practice', 'tìm hiểu', 'tim hieu', 'nghiên cứu', 'nghien cuu', '調査', 'リサーチ', 'ベストプラクティス'],
-    medium: ['documentation', 'docs', 'compare tools', 'latest docs', 'official docs', 'ドキュメント', '比較', '最新ドキュメント', '公式ドキュメント'],
-    weak: ['investigate options', 'market scan', 'reference', 'source material', '選択肢を調べる', '参考資料', '資料'],
-    negative: ['commit', 'push'],
-  }),
-  route('hapo:pptx', 'presentation or PowerPoint work', 46, {
-    strong: ['pptx', 'powerpoint', 'slide deck', 'presentation deck', 'スライド資料', 'プレゼン資料'],
-    medium: ['slide', 'slides', 'deck', 'presentation', 'seminar slides', 'スライド', 'プレゼン', 'セミナー資料'],
-    weak: ['speaker notes', 'appendix', 'mục lục slide', 'muc luc slide', '発表ノート', '付録', '目次'],
-    negative: ['source code', 'api', 'database'],
-  }),
-  route('hapo:agent-browser', 'browser automation with snapshot refs, web interaction, recording, or Browserbase cloud browser workflows', 45, {
-    strong: ['agent-browser', 'browser automation', 'web automation', 'browserbase', 'cloud browser', 'snapshot refs', 'browser snapshot', 'automate browser', 'tự động trình duyệt', 'tu dong trinh duyet', 'tự động thao tác trình duyệt', 'tu dong thao tac trinh duyet', 'ブラウザ自動化', 'クラウドブラウザ', 'ブラウザ操作', 'ブラウザスナップショット'],
-    medium: ['open url', 'navigate site', 'click in browser', 'fill form in browser', 'record browser', 'browser session', 'multi tab', 'browser test session', 'mở website', 'mo website', 'truy cập website', 'truy cap website', 'click trên web', 'click tren web', 'điền form web', 'dien form web', 'サイトを開く', 'ブラウザで開く', 'ブラウザで', 'フォーム入力', 'フォーム入力を自動化', '自動化して', 'クリック操作', '録画'],
-    weak: ['click button', 'fill form', 'open site', 'web session', 'browser ref', 'viewport', 'cookies', 'localstorage', 'ボタンをクリック', 'ビューポート', 'クッキー'],
-    negative: ['attached screenshot', 'ảnh đính kèm', 'anh dinh kem', '画像添付', 'source code', 'codebase', 'commit', 'push', 'pptx', 'pdf'],
-  }),
-  route('hapo:pdf', 'PDF reading, extraction, or generation', 44, {
-    strong: ['pdf'], medium: ['export pdf', 'read pdf', 'extract pdf', 'pdf出力', 'pdfを読む', 'pdf抽出'], weak: ['page render', 'ページレンダー'], negative: [],
-  }),
-  route('hapo:docx', 'Word document work', 42, {
-    strong: ['docx', 'word document', 'word file', 'word文書', 'wordファイル'], medium: ['word'], weak: ['tracked changes', 'document file', '変更履歴', '文書ファイル'], negative: [],
-  }),
-  route('hapo:xlsx', 'spreadsheet or Excel work', 42, {
-    strong: ['xlsx', 'excel', 'spreadsheet', 'スプレッドシート'], medium: ['csv', 'sheet', 'workbook', 'シート', 'ワークブック'], weak: ['formula', 'pivot table', '数式', 'ピボットテーブル'], negative: [],
-  }),
-  route('hapo:ai-multimodal', 'image, video, audio, or multimodal artifact analysis', 40, {
-    strong: ['screenshot', 'video', 'audio', 'multimodal', 'ảnh', 'anh', 'hình', 'hinh', 'スクリーンショット', '動画', '音声', '画像', '写真'],
-    medium: ['image', 'screen capture', 'recording', 'file attached', 'イメージ', '画面キャプチャ', '録画', '添付ファイル'],
-    weak: ['visual', 'describe image', 'ocr', 'ビジュアル', '画像説明'],
-    negative: ['pptx', 'pdf export'],
-  }),
-];
-
-function route(skill, reason, priority, signals) {
-  return { skill, reason, priority, signals };
-}
-
-function normalize(value) {
-  return String(value || '')
-    .normalize('NFKC')
-    .normalize('NFD')
-    .replace(/[\u0300-\u036f]/g, '')
-    .normalize('NFC')
-    .toLowerCase();
-}
-
-function scoreRoute(prompt, routeItem) {
-  const normalized = normalize(prompt);
-  const matched = [];
-  let score = 0;
-  for (const [bucket, weight] of Object.entries(WEIGHTS)) {
-    for (const term of routeItem.signals[bucket] || []) {
-      if (!normalized.includes(normalize(term))) continue;
-      score += weight;
-      matched.push({ bucket, term, weight });
-    }
-  }
-  return { ...routeItem, score, matched, confidence: confidence(score) };
-}
-
-function confidence(score) {
-  if (score >= 12) return 'high';
-  if (score >= 7) return 'medium';
-  if (score >= MIN_SCORE) return 'low';
-  return 'none';
-}
-
-function findRoute(prompt) {
-  const candidates = ROUTES
-    .map((routeItem, index) => ({ ...scoreRoute(prompt, routeItem), index }))
-    .filter((routeItem) => routeItem.score >= MIN_SCORE)
-    .sort((a, b) => b.score - a.score || b.priority - a.priority || a.index - b.index);
-  return candidates[0] || null;
-}
-
-module.exports = {
-  MIN_SCORE,
-  ROUTES,
-  findRoute,
-  normalize,
-  scoreRoute,
-};

package/src/claude/hooks/skill-router.cjs

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-/**
- * Copyright (c) 2026 Haposoft. MIT License.
- *
- * UserPromptSubmit Hook - skill-router.cjs
- *
- * Adds a deterministic CafeKit skill suggestion for natural-language prompts.
- * It never overrides explicit slash commands; it only injects a short routing hint.
- *
- * Exit: 0 always (fail-open)
- */
-
-const fs = require('fs');
-const path = require('path');
-
-function logCrash(error) {
-  try {
-    const dir = path.join(__dirname, '.logs');
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.appendFileSync(
-      path.join(dir, 'hook-log.jsonl'),
-      JSON.stringify({
-        ts: new Date().toISOString(),
-        hook: 'skill-router',
-        status: 'crash',
-        error: error.message,
-      }) + '\n'
-    );
-  } catch (_) {}
-}
-
-try {
-  const { isHookEnabled } = require('./lib/config.cjs');
-  const { findRoute } = require('./lib/skill-router-routes.cjs');
-
-  function isExplicitCommand(prompt) {
-    const trimmed = prompt.trim();
-    return trimmed.startsWith('/') || /^hapo:[a-z-]+/i.test(trimmed);
-  }
-
-  const stdin = fs.readFileSync(0, 'utf8').trim();
-  if (!stdin) process.exit(0);
-
-  const payload = JSON.parse(stdin);
-  const cwd = payload.cwd || process.cwd();
-  const prompt = payload.prompt || '';
-  if (!isHookEnabled('skill-router', { cwd })) process.exit(0);
-  if (!prompt || isExplicitCommand(prompt)) process.exit(0);
-
-  const route = findRoute(prompt);
-  if (!route) process.exit(0);
-
-  const skillDir = route.skill.replace(/^hapo:/, '');
-  const lines = [
-    '## CafeKit Skill Router',
-    `- Suggested skill: \`${route.skill}\``,
-    `- Why: ${route.reason}.`,
-    `- Confidence: ${route.confidence} (score ${route.score}).`,
-    `- Action: before acting, read \`.claude/skills/${skillDir}/SKILL.md\` and follow that workflow.`,
-    '- If the user explicitly names another workflow or asks for direct answering only, follow the user request.',
-  ];
-
-  console.log(lines.join('\n'));
-  process.exit(0);
-} catch (error) {
-  try { logCrash(error); } catch (_) {}
-  process.exit(0);
-}