@haposoft/cafekit 0.11.0 → 0.11.3

package/bin/lib/context.js

@@ -247,6 +247,9 @@ function buildContext(argv, runId) {
   const interactive = isInteractive() && !options.yes;
   // Language: --lang wins; otherwise English (an interactive prompt may change it).
   const lang = options.lang ? resolveLang(options.lang) : 'en';
+  // ctx.locale = the string that gets written to CLAUDE.md / runtime.json as the AI's response language.
+  // For known codes it mirrors lang; for "other", it's set later by setLang.
+  const locale = options.lang || 'en';
   return {
     argv,
     runId,
@@ -254,11 +257,13 @@ function buildContext(argv, runId) {
     dryRun: options.dryRun,
     interactive,
     ui: createUI(interactive),
-    lang,
+    lang,        // UI language (one of SUPPORTED)
+    locale,      // AI response language label (may be freeform, e.g. "Korean")
     t: createTranslator(lang),
-    /** Update the active language + translator (used by the language prompt). */
-    setLang(code) {
+    /** Update UI lang + AI locale. rawLabel is the freeform label when user picks "Other". */
+    setLang(code, rawLabel) {
       this.lang = resolveLang(code);
+      this.locale = rawLabel || LANGUAGE_LABELS[this.lang] || this.lang;
       this.t = createTranslator(this.lang);
     },
     manifest: loadClaudeMigrationManifest(),  // migration manifest (skills/agents/runtime lists)

package/bin/lib/i18n.js

@@ -11,6 +11,7 @@
 const SUPPORTED = ['en', 'ja', 'vi'];
 
 const LANGUAGE_LABELS = { en: 'English', ja: '日本語', vi: 'Tiếng Việt' };
+const OTHER_LABEL = { en: 'Other...', ja: 'その他...', vi: 'Ngôn ngữ khác...' };
 
 const MESSAGES = {
   // ─── English ───────────────────────────────────────────────────────────────
@@ -264,4 +265,4 @@ function createTranslator(lang) {
   };
 }
 
-module.exports = { SUPPORTED, LANGUAGE_LABELS, MESSAGES, resolveLang, createTranslator };
+module.exports = { SUPPORTED, LANGUAGE_LABELS, OTHER_LABEL, MESSAGES, resolveLang, createTranslator };

package/bin/phases/post-install.js

@@ -30,8 +30,9 @@ function patchSettingsLanguage(ctx) {
     return;
   }
 
-  const label = LANGUAGE_LABELS[ctx.lang] || ctx.lang;
-  if (settings.language === label) return; // already up to date
+  // Use locale (freeform label) so "Korean" shows correctly, not just "en".
+  const label = ctx.locale || LANGUAGE_LABELS[ctx.lang] || ctx.lang;
+  if (settings.language === label) return;
   settings.language = label;
   fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
 }
@@ -46,13 +47,16 @@ function patchSettingsLanguage(ctx) {
  */
 function patchLanguageSection(ctx) {
   if (!ctx.platforms.includes('claude')) return;
-  if (ctx.lang === 'en') return; // English is the default — no override needed.
+  // Skip when locale is English (default — no override needed in CLAUDE.md).
+  const locale = ctx.locale || ctx.lang;
+  if (!locale || locale === 'en' || locale === 'English') return;
 
   const claudeMdFile = path.join(process.cwd(), 'CLAUDE.md');
   if (!fs.existsSync(claudeMdFile)) return;
 
   const LANG_LABEL = { vi: 'Vietnamese', ja: 'Japanese', en: 'English' };
-  const label = LANG_LABEL[ctx.lang] || ctx.lang;
+  // Use locale directly when set (e.g. "Korean"), or map from lang code.
+  const label = locale in LANG_LABEL ? LANG_LABEL[locale] : locale;
 
   const newSection = `## Language Consistency <!-- cafekit:lang -->
 
@@ -86,8 +90,10 @@ function patchRuntimeLocale(ctx) {
       continue;
     }
     data.locale = data.locale || {};
-    if (data.locale.responseLanguage === ctx.lang) continue;
-    data.locale.responseLanguage = ctx.lang;
+    // Use locale (freeform label) so custom languages propagate to the AI hook.
+    const locale = ctx.locale || ctx.lang;
+    if (data.locale.responseLanguage === locale) continue;
+    data.locale.responseLanguage = locale;
     fs.writeFileSync(rtPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
     if (ctx.trackers[key]) ctx.trackers[key].record(rtPath);
   }

package/bin/phases/select-platform.js

@@ -12,21 +12,38 @@ const {
   getPlatformKeys,
   warnLegacyClaudeFolder
 } = require('../lib/context');
-const { SUPPORTED, LANGUAGE_LABELS } = require('../lib/i18n');
+const { SUPPORTED, LANGUAGE_LABELS, OTHER_LABEL } = require('../lib/i18n');
+
+const OTHER = '__other__';
 
 /** First step: pick the installer/UI language (interactive only). */
 async function selectLanguage(ctx) {
-  // Honor an explicit --lang or non-interactive default (English) without prompting.
   if (!ctx.interactive || ctx.options.lang) return ctx;
 
+  const options = [
+    ...SUPPORTED.map((code) => ({ value: code, label: LANGUAGE_LABELS[code] })),
+    { value: OTHER, label: OTHER_LABEL.en + ' / その他 / Ngôn ngữ khác' }
+  ];
+
   const r = await ctx.ui.select(
-    {
-      message: 'Select language · 言語を選択 · Chọn ngôn ngữ',
-      options: SUPPORTED.map((code) => ({ value: code, label: LANGUAGE_LABELS[code] }))
-    },
+    { message: 'Select language · 言語を選択 · Chọn ngôn ngữ', options },
     ctx.lang
   );
-  if (!ctx.ui.isCancel(r)) ctx.setLang(r);
+  if (ctx.ui.isCancel(r)) return ctx;
+
+  if (r === OTHER) {
+    // User types their language name — UI stays English, AI responds in that language.
+    const typed = await ctx.ui.text(
+      { message: 'Enter your language (e.g. Korean, French, Spanish…)', placeholder: 'Language name in English' },
+      ''
+    );
+    if (!ctx.ui.isCancel(typed) && typed && typed.trim()) {
+      ctx.setLang('en', typed.trim()); // UI = English, locale = user's label
+    }
+  } else {
+    ctx.setLang(r, LANGUAGE_LABELS[r]);
+  }
+
   return ctx;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haposoft/cafekit",
-  "version": "0.11.0",
+  "version": "0.11.3",
   "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

@@ -15,7 +15,7 @@ These rules reduce common agent coding failures: hidden assumptions, overbuilt s
 - Do not assume silently. State assumptions when they affect the work.
 - If multiple interpretations are plausible, surface them before implementation.
 - If the simpler option is likely better, say so and push back.
-- If the user asks a question about the project, use `/hapo:question` to answer from source evidence before planning.
+- If the user asks a question about the project, use `/question` to answer from source evidence before planning.
 - Before feature planning or coding, read `./README.md` for project context.
 
 ### 2. Simplicity First
@@ -46,7 +46,7 @@ These rules reduce common agent coding failures: hidden assumptions, overbuilt s
 Use this loop for non-trivial work:
 
 1. **Understand** — read README, relevant docs, active spec/task, and existing code.
-2. **Plan** — choose the smallest coherent path; use `/hapo:question` for evidence-backed project questions and `/hapo:specs` for feature specs when ready.
+2. **Plan** — choose the smallest coherent path; use `/question` for evidence-backed project questions and `/specs` for feature specs when ready.
 3. **Execute** — implement only the active task/scope; no placeholder completion.
 4. **Verify** — run exact task commands first, then repo-level lint/test/build as needed.
 5. **Sync** — mark task state only after proof exists.
@@ -98,11 +98,9 @@ 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.
+- **IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.
+- **IMPORTANT:** DO NOT modify skills in `~/.claude/skills` directly. **MUST** modify skills in this current working directory, unless asked to do so.
+- Use `./.claude/rules/skill-workflow-routing.md` and `./.claude/rules/skill-domain-routing.md` as advisory routing when choosing a skill.
 - Run Python skill scripts with the skill venv:
   - macOS/Linux: `.claude/skills/.venv/bin/python3 scripts/<script>.py`
   - Windows: `.claude\skills\.venv\Scripts\python.exe scripts\<script>.py`

package/src/claude/agents/brainstormer.md

@@ -33,7 +33,7 @@ description: >-
 
 # Brainstormer — Solution Architect
 
-You are a **Pragmatic Solution Architect** called by `hapo:brainstorm` when a design choice needs deeper architectural pressure-testing. You do not replace the `hapo:brainstorm` workflow. You supply sharp analysis, alternatives, risks, and recommendation material that the controller can fold back into the main brainstorm.
+You are a **Pragmatic Solution Architect** called by `brainstorm` when a design choice needs deeper architectural pressure-testing. You do not replace the `brainstorm` workflow. You supply sharp analysis, alternatives, risks, and recommendation material that the controller can fold back into the main brainstorm.
 
 Your goal is to help turn a raw idea into a viable, spec-ready design without touching code.
 
@@ -46,7 +46,7 @@ Before concluding any brainstorm session, verify each measurement metric:
 - [ ] **Domino Effect Analysis**: Are downstream impacts (e.g., database bloat, CI/CD delays) explicitly warned about?
 - [ ] **Occam's Razor Selection**: Have I forcefully recommended the simplest, lowest-friction solution?
 - [ ] **Documentation Locked**: Is the agreed architecture written down in a formalized summary block?
-- [ ] **Workflow Fit**: Did my output preserve the `hapo:brainstorm -> hapo:specs` handoff instead of drifting into implementation?
+- [ ] **Workflow Fit**: Did my output preserve the `brainstorm -> hapo:specs` handoff instead of drifting into implementation?
 
 ## Core Principles
 1. **Engineering Trinity:** YAGNI, KISS, and DRY.
@@ -60,7 +60,7 @@ Do not operate in a vacuum. You are equipped to utilize `SendMessage` to summon
 - **Need Best Practices/Examples?** Summon the `researcher` agent to scrape the web and extract contemporary tech patterns.
 - **Need Global Codebase Context?** Inquire with the `docs-keeper` agent to retrieve the latest `./docs/codebase-summary.md` before you design inter-connected systems.
 - **Need to synthesize massive outputs or split heavy tasks?** Defer the aggregation step to the `project-manager` agent.
-- **Final Design Handoff:** Return a concise summary to the `hapo:brainstorm` controller. The controller handles `/hapo:specs`.
+- **Final Design Handoff:** Return a concise summary to the `brainstorm` controller. The controller handles `/specs`.
 
 ## Collaborative Process
 
@@ -72,7 +72,7 @@ Do not operate in a vacuum. You are equipped to utilize `SendMessage` to summon
 6. **Return Summary**: End with a compact design advisory block the controller can paste into the brainstorm report.
 
 <HARD-GATE>
-Do NOT invoke any implementation skill, write code, scaffold a project, modify files, or call `/hapo:develop`. You brainstorm and advise only.
+Do NOT invoke any implementation skill, write code, scaffold a project, modify files, or call `/develop`. You brainstorm and advise only.
 </HARD-GATE>
 
 ## Output Shape
@@ -83,4 +83,4 @@ Return:
 - **Options compared**
 - **Recommended option**
 - **Risks and mitigations**
-- **Suggested handoff notes for `/hapo:specs`**
+- **Suggested handoff notes for `/specs`**

package/src/claude/agents/code-auditor.md

@@ -128,7 +128,7 @@ Classify each issue:
 
 ## Pass/Fail Thresholds (Used in Quality Gate)
 
-When called from `hapo:develop` Step 4 (Quality Gate Auto-Fix):
+When called from `develop` Step 4 (Quality Gate Auto-Fix):
 
 | Condition | Result |
 |-----------|--------|
@@ -153,4 +153,4 @@ When called from `hapo:develop` Step 4 (Quality Gate Auto-Fix):
 - Focus on issues with production impact — skip trivial style nitpicks.
 - Respect project conventions if `docs/code-standards.md` exists.
 - DO NOT modify any files. Read and report only.
-- Integrate with `hapo:code-review` skill for full protocol.
+- Integrate with `code-review` skill for full protocol.

package/src/claude/agents/debugger.md

@@ -44,11 +44,11 @@ When investigating issues, you will:
    - Retrieve CI/CD pipeline logs from GitHub Actions by using `gh` command
    - Examine application logs and error traces
    - Capture system metrics and performance data
-   - Use `hapo:inspect ext` or native CLI (e.g. `curl`) to fetch and read the latest docs of the packages/plugins
+   - Use `inspect ext` or native CLI (e.g. `curl`) to fetch and read the latest docs of the packages/plugins
    - **When you need to understand the project structure:** 
      - Read `docs/codebase-summary.md` if it exists & up-to-date (less than 2 days old)
      - Otherwise, only use the `repomix` command to generate comprehensive codebase summary of the current project at `./repomix-output.xml` and create/update a codebase summary file at `./codebase-summary.md`
-     - **IMPORTANT**: ONLY process this following step `codebase-summary.md` doesn't contain what you need: use `/hapo:inspect ext` for scoped Gemini discovery or `/hapo:inspect` for scoped internal discovery to inspect only the relevant codebase scopes and find the files needed to complete the task
+     - **IMPORTANT**: ONLY process this following step `codebase-summary.md` doesn't contain what you need: use `/inspect ext` for scoped Gemini discovery or `/inspect` for scoped internal discovery to inspect only the relevant codebase scopes and find the files needed to complete the task
    - When you are given a Github repository URL, use `repomix --remote <github-repo-url>` bash command to generate a fresh codebase summary:
       ```bash
       # usage: repomix --remote <github-repo-url>
@@ -90,8 +90,8 @@ You will utilize:
 - **Performance Tools**: Profilers, APM tools, system monitoring utilities
 - **Testing Frameworks**: Run unit tests, integration tests, and diagnostic scripts
 - **CI/CD Tools**: GitHub Actions log analysis, pipeline debugging, `gh` command
-- **Package/Plugin Docs**: Use `hapo:inspect ext` or bash tools to read the latest docs of the packages/plugins
-- **Browser Tools**: `hapo:agent-browser`, `hapo:chrome-devtools`, or project-native browser tests for UI evidence
+- **Package/Plugin Docs**: Use `inspect ext` or bash tools to read the latest docs of the packages/plugins
+- **Browser Tools**: `agent-browser`, `chrome-devtools`, or project-native browser tests for UI evidence
 - **Codebase Analysis**: 
   - If `./docs/codebase-summary.md` exists & up-to-date (less than 2 days old), read it to understand the codebase.
   - If `./docs/codebase-summary.md` doesn't exist or outdated >2 days, use `repomix` command to generate/update a comprehensive codebase summary when you need to understand the project structure

package/src/claude/agents/deployer.md

@@ -13,7 +13,7 @@ You are a deployment engineer who treats every release as a controlled explosion
 
 Before ANY deployment, verify:
 
-- [ ] Engage the `hapo:devops` skill to audit infrastructure configurations, CI/CD pipelines, and runtime constraints.
+- [ ] Engage the `devops` skill to audit infrastructure configurations, CI/CD pipelines, and runtime constraints.
 - [ ] All tests pass (`test-runner` has given a PASS verdict).
 - [ ] Code review score ≥ 9.5 (`code-auditor` verdict: PASS).
 - [ ] No unresolved blockers in `spec.json`.
@@ -97,6 +97,6 @@ docker compose down && docker compose -f docker-compose.prev.yml up -d
 
 ## Integration
 
-- Triggered after `hapo:sync phase <feature> deploy` advances a feature.
+- Triggered after `sync phase <feature> deploy` advances a feature.
 - Reads deployment config from project root (`vercel.json`, `railway.json`, `docker-compose.yml`).
 - Reports deployment status back to orchestrator for `spec.json` state update.

package/src/claude/agents/docs-keeper.md

@@ -11,12 +11,12 @@ You are the authoritative **Documentation Guardian** for this repository.
 Stale docs and phantom specs are worse than no docs — they waste developer hours. 
 Your core operational rule: **Read the code FIRST, verify it WORKS, THEN write the words.**
 
-You juggle two parallel universes defined by the `hapo:specs` ecosystem: The agile feature specification lifecycle (`specs/`) and the global project documentation (`docs/`).
+You juggle two parallel universes defined by the `specs` ecosystem: The agile feature specification lifecycle (`specs/`) and the global project documentation (`docs/`).
 
 ## Core Responsibilities
 
 ### 1. Specs Lifecycle Guardian (`specs/`)
-You enforce integrity across the `hapo:specs` architecture:
+You enforce integrity across the `specs` architecture:
 - Monitor and maintain feature specs explicitly stored in `specs/<feature-name>/`.
 - Validate that `spec.json` states match the reality of `requirements.md` and `design.md`.
 - Track cross-spec dependencies. Connect the dots between overlapping tasks to prevent collisions across multiple active spec tickets.
@@ -47,7 +47,7 @@ Generate the project's technical DNA map:
 - This file acts as the single source of truth for all other agents to quickly grasp the project landscape.
 
 ### 4b. Task Closeout Mode
-When called from `hapo:develop` after a verified task is complete:
+When called from `develop` after a verified task is complete:
 - Treat the job as a **lightweight task-closeout sync**
 - Update only the existing docs affected by that task
 - Start by classifying `Docs impact: none | minor | major`
@@ -68,7 +68,7 @@ If any doc file exceeds **800 LOC**, enforce modularity:
 - Always use relative paths for internal linking: `[text](./path.md)`.
 
 ## Integration Points & Hooks
-- Integrate seamlessly when called by `hapo:specs` or other team components to validate specifications.
+- Integrate seamlessly when called by `specs` or other team components to validate specifications.
 - **No Hallucinated Tools**: Only execute valid Node/Bash scripts that you have verified exist in the project tree.
 
 ## Report Format

package/src/claude/agents/git-ops.md

@@ -5,7 +5,7 @@ model: haiku
 tools: Glob, Grep, Read, Bash, TaskCreate, TaskGet, TaskUpdate, TaskList, SendMessage
 ---
 
-You are the Git Operations Specialist (Chief of the Git Station). You must execute operations with EXTREME SPEED, typically finishing within 2-4 tool calls. Do not perform lengthy explorations. Simply activate the `hapo:git` skill and finalize the operation.
+You are the Git Operations Specialist (Chief of the Git Station). You must execute operations with EXTREME SPEED, typically finishing within 2-4 tool calls. Do not perform lengthy explorations. Simply activate the `git` skill and finalize the operation.
 
 **CRITICAL REQUIREMENT**: Strictly optimize for token efficiency and operational speed, yet maintain high-quality conventional git histories.
 
@@ -14,7 +14,7 @@ You are the Git Operations Specialist (Chief of the Git Station). You must execu
 When instantiated as a team member, you must:
 1. Upon start: call `TaskList` and claim an available task using `TaskUpdate`.
 2. Read the task description via `TaskGet` before executing commands.
-3. Utilize Native Bash Commands (as guided by `hapo:git`) to commit, push, or create independent Worktrees — NEVER trigger garbage commits and NEVER arbitrarily use `force push` unless explicitly and securely designated.
+3. Utilize Native Bash Commands (as guided by `git`) to commit, push, or create independent Worktrees — NEVER trigger garbage commits and NEVER arbitrarily use `force push` unless explicitly and securely designated.
 4. Completion protocol: Execute `TaskUpdate(status: "completed")` and send a summary message via `SendMessage` detailing the Git/Worktree outcome to the Team Leader.
 5. In case of a `shutdown_request`: accept it using `SendMessage(type: "shutdown_response")` unless mid-critical-operation or mid-task.
 6. To chat with parallel peers, invoke `SendMessage(type: "message")` to stream inter-agent communications.

package/src/claude/agents/god-developer.md

@@ -36,8 +36,8 @@ Any logic gaps must be clarified BEFORE typing, not discovered after bugs ship.
 
 When activated, you will receive one of two input types:
 - **Task file list** (`tasks/task-R0-01-*.md`, `task-R1-01-*.md`...) with `spec.json`.
-- **Direct description** from the main agent or `hapo:develop` skill. 
-  *(Always apply domain-specific best practices from `hapo:frontend-development`, `hapo:backend-development`, `hapo:mobile-development`, or `hapo:react-best-practices` when that guidance is provided or readable in the installed skills).*
+- **Direct description** from the main agent or `develop` skill. 
+  *(Always apply domain-specific best practices from `frontend-development`, `backend-development`, `mobile-development`, or `react-best-practices` when that guidance is provided or readable in the installed skills).*
 
 First action: Read ALL task files/spec thoroughly. Mentally map out:
 - Which files need to be created?

package/src/claude/agents/inspector.md

@@ -33,7 +33,7 @@ Before packaging your report, verify:
 ## Responsibilities
 - Provide a file list with brief context descriptions — fast and concise.
 - Target the right directories, skip noise.
-- For `hapo:develop`, scout PER ACTIVE TASK. Use the task packet, `scope_lock`, requirement IDs, and design contracts to identify only the code paths relevant to that task.
+- For `develop`, scout PER ACTIVE TASK. Use the task packet, `scope_lock`, requirement IDs, and design contracts to identify only the code paths relevant to that task.
 - Find integration seams: app/page entrypoints, router registration, CLI command dispatch, worker registration, extension manifests, API consumers, provider mounting, service invocation, state/reducer/action wiring.
 - Flag reachability risks clearly: orphan component/export, unmounted UI, unregistered route, uncalled service/loader, disconnected provider/state, unused reducer/action, generated artifact never referenced.
 - Identify blast-radius touchpoints: current importers/callers of modified exports, public contracts that depend on them, tests likely affected.

package/src/claude/agents/project-manager.md

@@ -31,7 +31,7 @@ Before you declare any phase complete or issue a final status report, you must i
 
 ## Collaborative Interlocking (Swarm Protocol)
 
-- You govern the final phase of `/hapo:specs`. If a spec is prematurely abandoned by `brainstormer`, you drag it back to alignment.
+- You govern the final phase of `/specs`. If a spec is prematurely abandoned by `brainstormer`, you drag it back to alignment.
 - When triggered as an active teammate within multi-agent swarms:
   1. **Init:** Execute `TaskList` immediately, then claim idle aggregation blocks via `TaskUpdate`.
   2. **Context Intake:** Pull strict operational boundaries using `TaskGet`.

package/src/claude/agents/spec-maker.md

@@ -17,7 +17,7 @@ You DO NOT write implementation code. You produce Specifications that downstream
 
 ## Artifact Contract (MANDATORY)
 
-Generate only the CafeKit spec artifacts defined by `hapo:specs`:
+Generate only the CafeKit spec artifacts defined by `specs`:
 
 ```
 specs/<feature>/
@@ -59,8 +59,8 @@ Init → Requirements → Design → Tasks
 ### Auto-Approval Behavior
 - When running the full pipeline end-to-end, follow the auto-approval rules defined in `SKILL.md`.
 - When running a single phase, stop and report status after completion.
-- Normal `/hapo:specs <feature-description>` requests are full pipeline requests.
-- If a pause is required after user review, tell the user to continue with `/hapo:specs resume <feature>` or `/hapo:specs <feature>`.
+- Normal `/specs <feature-description>` requests are full pipeline requests.
+- If a pause is required after user review, tell the user to continue with `/specs resume <feature>` or `/specs <feature>`.
 
 ## Scope Lock Protocol (MANDATORY)
 
@@ -147,11 +147,11 @@ Each task file MUST be compact but implementation-ready:
 
 ## Research Phase
 
-### Follow the `hapo:specs` Evidence Gate
+### Follow the `specs` Evidence Gate
 
 Use `.claude/skills/specs/SKILL.md` as the source of truth for evidence depth. Do not force external research for trivial/internal specs.
 
-When running as the main controller, delegate to the `researcher` agent BEFORE writing detailed requirements only when `hapo:specs` requires external/current research: third-party APIs, libraries, platform policies, AI providers/models/tooling, security/auth/payment/privacy/delete-data rules, performance/accessibility/SEO/security standards, or explicit "best/latest/recommended/optimal" user intent.
+When running as the main controller, delegate to the `researcher` agent BEFORE writing detailed requirements only when `specs` requires external/current research: third-party APIs, libraries, platform policies, AI providers/models/tooling, security/auth/payment/privacy/delete-data rules, performance/accessibility/SEO/security standards, or explicit "best/latest/recommended/optimal" user intent.
 
 When running as this `spec-maker` subagent, do not spawn another subagent. Use bounded `WebSearch`/`WebFetch` directly when available, or return `NEEDS_RESEARCH` with the exact research question for the controller to delegate.
 
@@ -190,7 +190,7 @@ Before marking the spec ready:
 - **Complex** (multi-module, security, migration) → Full spec with mandatory research phase
 
 ### 2. Evidence Phase
-Capture codebase scout findings and external research when required by `hapo:specs`. Record skip rationale in `specs/<feature>/research.md` for trivial/internal cases.
+Capture codebase scout findings and external research when required by `specs`. Record skip rationale in `specs/<feature>/research.md` for trivial/internal cases.
 
 ### 3. Specification Generation (follows SKILL.md Steps 4-7)
 Produce the following artifacts under `specs/<feature>/`:
@@ -211,12 +211,12 @@ specs/<feature>/
 - Update `spec.json` with `"status": "in_progress"` and `"current_phase": "develop"`
 - Ensure `task_files` + `task_registry` are synchronized and `ready_for_implementation` reflects the finalization audit outcome
 - Report the spec directory path to the orchestrator
-- The only valid implementation handoff is `/hapo:develop <feature>` (or `/hapo:develop <feature> <task-file>` for a single task). Never suggest `/work`, `/code`, or an unnamed "orchestrator dispatch" command.
+- The only valid implementation handoff is `/develop <feature>` (or `/develop <feature> <task-file>` for a single task). Never suggest `/work`, `/code`, or an unnamed "orchestrator dispatch" command.
 - DO NOT begin implementation yourself
 
 ## Integration Points
 
-- Output format follows `hapo:specs` protocol (see `skills/specs/SKILL.md`)
+- Output format follows `specs` protocol (see `skills/specs/SKILL.md`)
 - Task files follow `skills/specs/templates/task.md` template
 - `spec.json` follows the `skills/specs/templates/spec-state.json` schema; the generated file must still be named `spec.json`
 - Research output follows `skills/specs/templates/research.md` template

package/src/claude/agents/test-runner.md

@@ -64,7 +64,7 @@ Run the entire test suite without diff filtering. Use when: first run, major ref
 
 1. **Detect Project Type:** Scan for `package.json`, `pytest.ini`, `Cargo.toml`, `pubspec.yaml` to identify the test runner.
 2. **Pre-flight Check:** Run typecheck/lint/build health checks (`npx tsc --noEmit` or equivalent) to catch syntax and package-boundary failures before wasting time on tests.
-3. **Execute Tests:** Run the appropriate test command for the detected project. Deploy `hapo:web-testing` and `hapo:chrome-devtools` skills for rigorous UI/E2E browser test automation when testing frontends.
+3. **Execute Tests:** Run the appropriate test command for the detected project. Deploy `web-testing` and `chrome-devtools` skills for rigorous UI/E2E browser test automation when testing frontends.
 4. **No-op Detection:** Parse runner output for executed test count. If the command exits 0 but runs 0 tests, report `NO_TESTS` instead of `PASS`.
 5. **Build Verification:** Run the relevant build command when available (or the exact command requested by the task evidence section).
 6. **Task Evidence Audit:** Execute or inspect every verification item provided by the task. If a check cannot run, mark it `UNVERIFIED` with the exact blocker.

package/src/claude/agents/ui-ux-designer.md

@@ -39,7 +39,7 @@ You are an award-caliber UI/UX designer. You merge aesthetic excellence with eng
 - Select fonts strategically (prioritize Vietnamese character support).
 - Apply professional composition and color theory principles.
 - Implement design tokens for consistency.
-- Activate the `hapo:frontend-design` skill to ensure your stylistic choices seamlessly translate into semantic engineering architecture.
+- Activate the `frontend-design` skill to ensure your stylistic choices seamlessly translate into semantic engineering architecture.
 - Consider accessibility at every decision point.
 
 ### Phase 3: Build
@@ -80,7 +80,7 @@ You are an award-caliber UI/UX designer. You merge aesthetic excellence with eng
 
 ## Integration
 
-- Reads design specs from `hapo:specs` task files.
+- Reads design specs from `specs` task files.
 - Reports design deliverables to orchestrator.
 - Requests controller-level research delegation when competitive analysis exceeds local search scope.
 - Updates `docs/design-guidelines.md` as the living design system.

package/src/claude/gitignore

@@ -17,3 +17,4 @@ hooks/.logs/
 agent-memory/
 settings.bak.json
 .mcp.json
+.cafekit-update-cache.json

package/src/claude/hooks/session.cjs

@@ -18,8 +18,6 @@ try {
   const { execSync } = require('child_process');
 
   // ── Utilities ─────────────────────────────────────────────────────────────
-
-  /** Run a shell command safely, return stdout or fallback */
   function run(cmd, fallback = '') {
     try {
       return execSync(cmd, {
@@ -88,8 +86,97 @@ try {
     return '';
   }
 
+  // ── CafeKit Update Check ──────────────────────────────────────────────────
+
+  /**
+   * Fetch the latest published version of @haposoft/cafekit from the npm registry.
+   * Returns a string (e.g. "0.11.2") or null on any failure. Timeout: 3 s.
+   */
+  function fetchLatestVersion() {
+    try {
+      const https = require('https');
+      return new Promise((resolve) => {
+        const req = https.get(
+          'https://registry.npmjs.org/@haposoft/cafekit/latest',
+          { timeout: 3000, headers: { Accept: 'application/json' } },
+          (res) => {
+            let body = '';
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+              try { resolve(JSON.parse(body).version || null); }
+              catch { resolve(null); }
+            });
+          }
+        );
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => { req.destroy(); resolve(null); });
+      });
+    } catch { return Promise.resolve(null); }
+  }
+
+  /** Simple semver compare: returns true when b > a. */
+  function isNewer(a, b) {
+    const n = (v) => String(v).split('.').map((x) => parseInt(x, 10) || 0);
+    const [aN, bN] = [n(a), n(b)];
+    for (let i = 0; i < 3; i++) {
+      if (bN[i] > aN[i]) return true;
+      if (bN[i] < aN[i]) return false;
+    }
+    return false;
+  }
+
+  /**
+   * Read the installed CafeKit version from .claude/cafekit.json.
+   * Returns null if not found.
+   */
+  function getInstalledVersion(cwd) {
+    try {
+      const p = path.join(cwd, '.claude', 'cafekit.json');
+      if (!fs.existsSync(p)) return null;
+      const meta = JSON.parse(fs.readFileSync(p, 'utf8'));
+      return typeof meta.version === 'string' ? meta.version : null;
+    } catch { return null; }
+  }
+
+  /**
+   * Check for a newer CafeKit version and return an update notice string,
+   * or an empty string if already up to date or check fails.
+   * Result is cached in .claude/.cafekit-update-cache.json for 12 hours.
+   */
+  async function checkCafeKitUpdate(cwd) {
+    const installed = getInstalledVersion(cwd);
+    if (!installed) return '';
+
+    const CACHE_TTL = 12 * 60 * 60 * 1000; // 12 hours
+    const cachePath = path.join(cwd, '.claude', '.cafekit-update-cache.json');
+
+    // Return cached result if still fresh.
+    try {
+      if (fs.existsSync(cachePath)) {
+        const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+        if (Date.now() - (cache.ts || 0) < CACHE_TTL) {
+          return cache.notice || '';
+        }
+      }
+    } catch { /* stale or corrupt — refetch */ }
+
+    // Fetch from npm registry.
+    const latest = await fetchLatestVersion();
+    const notice = (latest && isNewer(installed, latest))
+      ? `\n⚡ CafeKit update available: ${installed} → ${latest}\n   Run: npx @haposoft/cafekit\n`
+      : '';
+
+    // Persist cache (fail-open if write fails).
+    try {
+      fs.writeFileSync(cachePath, JSON.stringify({ ts: Date.now(), notice }), 'utf8');
+    } catch { /* fail-open */ }
+
+    return notice;
+  }
+
   // ── Main ──────────────────────────────────────────────────────────────────
 
+  (async () => {
   const stdin   = fs.readFileSync(0, 'utf8').trim();
   const payload = stdin ? JSON.parse(stdin) : {};
   const source  = payload.source || 'unknown';
@@ -97,6 +184,9 @@ try {
   const cwd     = process.cwd();
   const runtime = readRuntime(cwd);
 
+  // Check CafeKit update in parallel with project detection (async, fail-open).
+  const updateCheckPromise = checkCafeKitUpdate(cwd);
+
   // Project detection
   const projectType = runtime.project?.type !== 'auto'
     ? (runtime.project?.type || detectProjectType())
@@ -137,14 +227,15 @@ try {
     writeEnv(envFile, 'LOCALE',          process.env.LANG || '');
   }
 
-  // Session summary
+  // Session summary + update notice
+  const updateNotice = await updateCheckPromise;
   const parts = [];
   if (projectType)    parts.push(`Type: ${projectType}`);
   if (packageManager) parts.push(`PM: ${packageManager}`);
   if (framework)      parts.push(`Framework: ${framework}`);
   if (gitBranch)      parts.push(`Branch: ${gitBranch}`);
 
-  console.log(`Session ${source}. ${parts.length ? parts.join(' | ') : 'No project info detected.'}`);
+  console.log(`Session ${source}. ${parts.length ? parts.join(' | ') : 'No project info detected.'}${updateNotice}`);
 
   // Compact warning — context compaction can lose pending approval state
   if (source === 'compact') {
@@ -155,6 +246,7 @@ try {
   }
 
   process.exit(0);
+  })(); // end async IIFE
 
 } catch (e) {
   try {

package/src/claude/references/debugger/frontend-verification.md

@@ -32,8 +32,8 @@ Use this when the issue affects rendering, layout, interaction, hydration, brows
 
 ## Preferred Tools
 
-- `hapo:agent-browser` for visual reproduction, screenshots, and exploratory browser checks
-- `hapo:chrome-devtools` for console, network, CDP, screenshots, ARIA snapshots, and WebSocket debugging
+- `agent-browser` for visual reproduction, screenshots, and exploratory browser checks
+- `chrome-devtools` for console, network, CDP, screenshots, ARIA snapshots, and WebSocket debugging
 - Project-native E2E tooling when it already exists
 
 ## Report Snippet

package/src/claude/rules/manage-docs.md

@@ -57,7 +57,7 @@ Use [Keep a Changelog](https://keepachangelog.com/) convention:
 ## Specification & Execution Tracker (Hapo Protocol)
 
 ### Where Specs Live
-Hapo does not use chaotic plan folders. Requirements and architecture are centralized into a machine-readable Specification structure via `hapo:specs`.
+Hapo does not use chaotic plan folders. Requirements and architecture are centralized into a machine-readable Specification structure via `specs`.
 
 All specifications exist strictly in `./specs/<feature-slug>/`.
 

package/src/claude/rules/state-sync.md

@@ -2,7 +2,7 @@
 
 ## Single Source of Truth
 
-In any Spec-driven workflow (`hapo:specs`), the state of the project is physically persisted in **two layers**:
+In any Spec-driven workflow (`specs`), the state of the project is physically persisted in **two layers**:
 1. **Machine Layer (`spec.json`)**: Tracks phase, status, overall completion, and per-task machine state via `task_registry`.
 2. **Human Layer (`tasks/task-*.md`)**: Checkboxes indicating granular execution progress.