@haposoft/cafekit 0.16.0 → 0.16.2

package/bin/lib/i18n.js

@@ -62,16 +62,6 @@ const MESSAGES = {
     documentSkillsMetadataRecovery: 'Could not read {path}; preserving document skills to avoid destructive cleanup.',
     skillsSkipped:         'Skill dependencies skipped.\n  Run later: npx @haposoft/cafekit --with-skills-deps',
 
-    // rtk token-saver setup
-    rtkConfirm:            'Install the rtk token-saver? (compacts git/grep/ls/build/test output for Claude Code Bash commands)',
-    rtkInstalling:         'Installing rtk via {method}',
-    rtkInstalled:          'rtk installed',
-    rtkInstallFailed:      'Could not install rtk — skipping (non-fatal). Install manually later: https://github.com/rtk-ai/rtk',
-    rtkInitFailed:         'rtk init -g failed: {reason} — hook not registered (non-fatal)',
-    rtkNeedsJq:            'rtk hook needs jq to run. Install jq, then the hook activates automatically.',
-    rtkFailed:             'rtk setup error: {reason} — skipped (non-fatal)',
-    rtkSkipped:            'rtk token-saver skipped.\n  Run later: npx @haposoft/cafekit --with-rtk',
-    rtkSummary:            'rtk token-saver: hook registered for Claude Code Bash commands',
     venvCreating:          'Setting up Python environment',
     venvReady:             'Python environment ready',
     venvFailed:            'Could not create Python environment — check your Python 3 installation.',
@@ -130,6 +120,7 @@ const MESSAGES = {
 
     // Platform/language auto-skip when already installed
     installingFor:        'Installing for: {names}',
+    grokCompatNotice:     'Grok CLI reads this install through its Claude compatibility. Trust the project first: run `grok --trust` or `/hooks-trust`, or its project hooks are skipped.',
     langKept:             'Language: {lang} (saved — skipping prompt)',
     platformKept:         'Platform: {names} (saved — skipping prompt)',
 
@@ -186,16 +177,6 @@ const MESSAGES = {
     documentSkillsMetadataRecovery: '{path} を読み取れないため、破壊的な削除を避けて document skills を保持します。',
     skillsSkipped:         'スキルの依存関係をスキップしました。\n  後で実行: npx @haposoft/cafekit --with-skills-deps',
 
-    // rtk token-saver setup
-    rtkConfirm:            'rtk トークンセーバーをインストールしますか？（Claude Code の Bash コマンドの git/grep/ls/build/test 出力を圧縮します）',
-    rtkInstalling:         '{method} で rtk をインストール中',
-    rtkInstalled:          'rtk をインストールしました',
-    rtkInstallFailed:      'rtk をインストールできませんでした — スキップします（致命的ではありません）。後で手動でインストール: https://github.com/rtk-ai/rtk',
-    rtkInitFailed:         'rtk init -g が失敗しました: {reason} — フックは未登録です（致命的ではありません）',
-    rtkNeedsJq:            'rtk フックの実行には jq が必要です。jq をインストールするとフックが自動的に有効になります。',
-    rtkFailed:             'rtk セットアップエラー: {reason} — スキップしました（致命的ではありません）',
-    rtkSkipped:            'rtk トークンセーバーをスキップしました。\n  後で実行: npx @haposoft/cafekit --with-rtk',
-    rtkSummary:            'rtk トークンセーバー: Claude Code の Bash コマンド用にフックを登録しました',
     venvCreating:          'Python 環境を準備しています',
     venvReady:             'Python 環境の準備ができました',
     venvFailed:            'Python 環境を作成できませんでした — Python 3 のインストールを確認してください。',
@@ -251,6 +232,7 @@ const MESSAGES = {
 
     // Platform/language auto-skip when already installed
     installingFor:        'インストール先: {names}',
+    grokCompatNotice:     'Grok CLI はこのインストールを Claude 互換として読み込みます。先にプロジェクトを信頼してください: `grok --trust` または `/hooks-trust`。信頼しないとプロジェクトフックはスキップされます。',
     langKept:             '言語: {lang} (保存済み — スキップ)',
     platformKept:         'プラットフォーム: {names} (保存済み — スキップ)',
 
@@ -307,16 +289,6 @@ const MESSAGES = {
     documentSkillsMetadataRecovery: 'Không đọc được {path}; giữ nguyên skill tài liệu để tránh dọn nhầm dữ liệu.',
     skillsSkipped:         'Đã bỏ qua dependencies skill.\n  Cài sau bằng lệnh: npx @haposoft/cafekit --with-skills-deps',
 
-    // rtk token-saver setup
-    rtkConfirm:            'Cài rtk token-saver? (rút gọn output git/grep/ls/build/test cho các lệnh Bash của Claude Code)',
-    rtkInstalling:         'Đang cài rtk qua {method}',
-    rtkInstalled:          'Đã cài rtk',
-    rtkInstallFailed:      'Không thể cài rtk — bỏ qua (không nghiêm trọng). Cài thủ công sau: https://github.com/rtk-ai/rtk',
-    rtkInitFailed:         'rtk init -g thất bại: {reason} — hook chưa được đăng ký (không nghiêm trọng)',
-    rtkNeedsJq:            'Hook của rtk cần jq để chạy. Cài jq thì hook sẽ tự kích hoạt.',
-    rtkFailed:             'Lỗi cài rtk: {reason} — đã bỏ qua (không nghiêm trọng)',
-    rtkSkipped:            'Đã bỏ qua rtk token-saver.\n  Cài sau bằng lệnh: npx @haposoft/cafekit --with-rtk',
-    rtkSummary:            'rtk token-saver: đã đăng ký hook cho các lệnh Bash của Claude Code',
     venvCreating:          'Đang thiết lập môi trường Python',
     venvReady:             'Môi trường Python đã sẵn sàng',
     venvFailed:            'Không thể tạo môi trường Python — hãy kiểm tra cài đặt Python 3.',
@@ -372,6 +344,7 @@ const MESSAGES = {
 
     // Platform/language auto-skip when already installed
     installingFor:        'Cài cho: {names}',
+    grokCompatNotice:     'Grok CLI đọc bản cài này qua lớp tương thích Claude. Hãy trust project trước: chạy `grok --trust` hoặc `/hooks-trust`, nếu không project hooks sẽ bị bỏ qua.',
     langKept:             'Ngôn ngữ: {lang} (đã lưu — bỏ qua chọn lại)',
     platformKept:         'Nền tảng: {names} (đã lưu — bỏ qua chọn lại)',
 

package/bin/phases/codex-hooks.js

@@ -16,7 +16,9 @@ const path = require('path');
 const { PLATFORMS } = require('../lib/context');
 
 const CODEX_SRC = path.join(__dirname, '../../src/codex');
-const WINDOWS_HOOK_COMMAND = /^node "\.codex\/hooks\/([a-z0-9-]+\.cjs)"$/;
+const HOOK_COMMAND_TEMPLATE = /^node "\.codex\/hooks\/([a-z0-9-]+\.cjs)"$/;
+// What an installer before 0.16.2 wrote for POSIX. Kept only to recognize and repair it.
+const LEGACY_GIT_COMMAND = /^node "\$\(git rev-parse --show-toplevel\)\/\.codex\/hooks\/([a-z0-9-]+\.cjs)"$/;
 
 /** The hook script a command runs, which is stable across installs and platforms. */
 function hookScript(command) {
@@ -25,21 +27,81 @@ function hookScript(command) {
   return match ? match[1] : null;
 }
 
+/** Single quotes suppress every shell expansion, so only a literal quote needs escaping. */
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+function hookPathFor(script, projectRoot) {
+  return path.join(fs.realpathSync(projectRoot), '.codex', 'hooks', script);
+}
+
 /**
- * Rewrite a managed `commandWindows` into a path-encoded invocation. Absolute Windows
- * paths cannot be quoted safely inside the Codex command string, so the path travels
- * base64url and is decoded by the launcher.
+ * The POSIX launcher carries the installed path literally.
+ *
+ * It used to resolve its own root with `$(git rev-parse --show-toplevel)`, which returns
+ * nothing outside a repository and the *outer* root for a project nested inside one. Both
+ * cases produced a path that does not exist, so Codex started every hook, every hook died,
+ * and the gates were silently absent. The path is known at install time, so it is written
+ * directly. The literal `/hooks/<script>.cjs` segment must survive, because hookScript()
+ * reads it as the identity that lets a reinstall recognize CafeKit's own entries.
  */
-function materializeWindowsCommand(handler, projectRoot) {
-  if (typeof handler.commandWindows !== 'string') return handler;
-  const match = handler.commandWindows.match(WINDOWS_HOOK_COMMAND);
-  if (!match) throw new Error(`Unsupported Codex Windows hook command: ${handler.commandWindows}`);
-  const hookPath = path.join(fs.realpathSync(projectRoot), '.codex', 'hooks', match[1]);
-  const encoded = Buffer.from(hookPath, 'utf8').toString('base64url');
-  return {
-    ...handler,
-    commandWindows: 'node -e "process.argv[1]=Buffer.from(process.argv[1],\'base64url\').toString(\'utf8\');require(\'module\').runMain()" ' + encoded,
-  };
+function posixHookCommand(script, projectRoot) {
+  return `node ${shellQuote(hookPathFor(script, projectRoot))}`;
+}
+
+/**
+ * Absolute Windows paths cannot be quoted safely inside the Codex command string, so that
+ * side travels base64url and is decoded by the launcher.
+ */
+function windowsHookCommand(script, projectRoot) {
+  const encoded = Buffer.from(hookPathFor(script, projectRoot), 'utf8').toString('base64url');
+  return 'node -e "process.argv[1]=Buffer.from(process.argv[1],\'base64url\').toString(\'utf8\');require(\'module\').runMain()" ' + encoded;
+}
+
+/** Rewrite a managed template handler into absolute launchers for both platforms. */
+function materializeHookCommands(handler, projectRoot) {
+  const next = { ...handler };
+  for (const [field, build] of [['command', posixHookCommand], ['commandWindows', windowsHookCommand]]) {
+    if (typeof handler[field] !== 'string') continue;
+    const match = handler[field].match(HOOK_COMMAND_TEMPLATE);
+    if (!match) throw new Error(`Unsupported Codex hook ${field}: ${handler[field]}`);
+    next[field] = build(match[1], projectRoot);
+  }
+  return next;
+}
+
+/**
+ * Repair launchers an older installer wrote. A reinstall treats an already-registered
+ * script as the user's placement and leaves it alone, so without this pass every existing
+ * project would keep its broken git-derived command forever. Only the exact byte pattern
+ * CafeKit itself emitted is rewritten; anything else stays untouched.
+ */
+function repairLegacyCodexLaunchers(config, projectRoot) {
+  if (!config.hooks) return { config, repaired: 0 };
+  let repaired = 0;
+  const hooks = {};
+  for (const [eventName, groups] of Object.entries(config.hooks)) {
+    if (!Array.isArray(groups)) { hooks[eventName] = groups; continue; }
+    hooks[eventName] = groups.map((group) => {
+      if (!Array.isArray(group?.hooks)) return group;
+      return {
+        ...group,
+        hooks: group.hooks.map((handler) => {
+          const legacy = typeof handler?.command === 'string' && handler.command.match(LEGACY_GIT_COMMAND);
+          const template = typeof handler?.commandWindows === 'string'
+            && handler.commandWindows.match(HOOK_COMMAND_TEMPLATE);
+          if (!legacy && !template) return handler;
+          const next = { ...handler };
+          if (legacy) next.command = posixHookCommand(legacy[1], projectRoot);
+          if (template) next.commandWindows = windowsHookCommand(template[1], projectRoot);
+          repaired += 1;
+          return next;
+        }),
+      };
+    });
+  }
+  return { config: repaired > 0 ? { ...config, hooks } : config, repaired };
 }
 
 /** Drop CafeKit hooks the manifest has retired, leaving foreign entries untouched. */
@@ -96,12 +158,18 @@ function mergeCodexHooks(ctx, platformKey, projectRoot = process.cwd()) {
     }
   }
 
-  const { config: base, removed } = pruneObsoleteCodexHooks({ ...existing }, ctx);
+  const { config: pruned, removed } = pruneObsoleteCodexHooks({ ...existing }, ctx);
   if (removed > 0) {
     ctx.ui.detail(`  ↻ ${ctx.dryRun ? '[dry-run] ' : ''}Codex hooks: removed ${removed} obsolete hook(s)`);
     ctx.results.updated++;
   }
 
+  const { config: base, repaired } = repairLegacyCodexLaunchers(pruned, projectRoot);
+  if (repaired > 0) {
+    ctx.ui.detail(`  ↻ ${ctx.dryRun ? '[dry-run] ' : ''}Codex hooks: repaired ${repaired} launcher(s) that resolved their path through Git`);
+    ctx.results.updated++;
+  }
+
   const merged = { ...base };
   if (typeof managed.description === 'string' && typeof merged.description !== 'string') {
     merged.description = managed.description;
@@ -124,7 +192,7 @@ function mergeCodexHooks(ctx, platformKey, projectRoot = process.cwd()) {
           const script = hookScript(handler?.command);
           return script && !registered.has(script);
         })
-        .map((handler) => materializeWindowsCommand(handler, projectRoot));
+        .map((handler) => materializeHookCommands(handler, projectRoot));
       if (wanted.length === 0) continue;
 
       const matcher = managedGroup.matcher || '';
@@ -153,4 +221,9 @@ function mergeCodexHooks(ctx, platformKey, projectRoot = process.cwd()) {
   }
 }
 
-module.exports = { mergeCodexHooks, pruneObsoleteCodexHooks, hookScript };
+module.exports = {
+  mergeCodexHooks,
+  pruneObsoleteCodexHooks,
+  repairLegacyCodexLaunchers,
+  hookScript,
+};

package/bin/phases/copy-payload.js

@@ -189,7 +189,14 @@ function copyPlatformFiles(ctx, platformKey) {
     } else {
       report(ctx, 'missing', `agents: ${platform.agentsDir}`);
     }
+  }
 
+  // ── Scripts ─────────────────────────────────────────────
+  // Gated on its own capability. This block used to sit inside the agents guard,
+  // so a platform with agents: false and scripts: true (omp) never received
+  // .omp/scripts/, and every Stop-time gate that requires ../scripts/*.cjs answered
+  // "Completion gate unavailable" on each session_stop.
+  if (hasPlatformCapability(platformKey, 'scripts')) {
     const scriptsSourceDir = path.join(SRC, 'claude/scripts');
     if (fs.existsSync(scriptsSourceDir)) {
       const scriptsDest = getRuntimeSupportTargetDir(platformKey, 'scripts');

package/bin/phases/omp-runtime.js

@@ -0,0 +1,140 @@
+'use strict';
+
+/**
+ * Phase: Oh My Pi runtime.
+ *
+ * omp discovers `.claude/skills` and `.agents/skills` on its own, so CafeKit copies no
+ * skill payload here. What omp does not have is CafeKit's enforcement chain, so this
+ * phase provisions what carries it:
+ *
+ *   .omp/hooks/           the gate scripts: the Claude set, with omp's overlay on top
+ *   .omp/extensions/      the bridge omp auto-loads, which dispatches those scripts
+ *   .omp/runtime.json     the hooks' configuration, beside the schema that describes it
+ *   .omp/rules/           the rules the hooks inject
+ *
+ * The hooks are portable: they derive their runtime directory from their own location,
+ * so the Claude bytes run unchanged under `.omp/`. Only the files that genuinely differ
+ * for omp live in `src/omp/hooks/` and are written over the Claude set afterwards, so a
+ * change to a shared hook reaches omp without anyone remembering to re-fork it.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { PLATFORMS } = require('../lib/context');
+const { writeManagedFile, copyManagedTree } = require('../lib/managed-writer');
+const { report, treeAction } = require('./report');
+const { copyRulesDirectory } = require('./claude-runtime');
+
+const SRC = path.join(__dirname, '../../src');
+const CLAUDE_SRC = path.join(SRC, 'claude');
+const OMP_SRC = path.join(SRC, 'omp');
+
+/** Files under `src/omp/hooks/` that replace their Claude counterpart, relative to the hooks dir. */
+function overlayFiles(dir = path.join(OMP_SRC, 'hooks'), prefix = '') {
+  if (!fs.existsSync(dir)) return [];
+  const found = [];
+  for (const name of fs.readdirSync(dir)) {
+    const rel = prefix ? `${prefix}/${name}` : name;
+    if (fs.statSync(path.join(dir, name)).isDirectory()) found.push(...overlayFiles(path.join(dir, name), rel));
+    else found.push(rel);
+  }
+  return found.sort();
+}
+
+/**
+ * The Claude hook set is the list the migration manifest ships to `.claude/`, not a
+ * directory walk: the source tree also holds `__tests__/`, which must never install.
+ */
+function claudeHookFiles(ctx) {
+  const files = ctx.manifest?.runtime?.files || [];
+  return files.filter((rel) => rel.startsWith('hooks/')).map((rel) => rel.slice('hooks/'.length));
+}
+
+function writeSourceFile(ctx, platformKey, src, dest, label) {
+  const platform = PLATFORMS[platformKey];
+  const { action } = writeManagedFile({
+    src,
+    dest,
+    platformFolder: platform.folder,
+    ctx,
+    tracker: ctx.trackers[platformKey]
+  });
+  report(ctx, action, label);
+}
+
+function installHooks(ctx, platformKey) {
+  const platform = PLATFORMS[platformKey];
+  const overlay = new Set(overlayFiles());
+  // Claude set first, skipping anything the overlay is about to replace so a file is
+  // written once and the manifest records the bytes that actually land.
+  for (const rel of claudeHookFiles(ctx)) {
+    if (overlay.has(rel)) continue;
+    writeSourceFile(
+      ctx,
+      platformKey,
+      path.join(CLAUDE_SRC, 'hooks', rel),
+      path.join(platform.folder, 'hooks', rel),
+      `omp hooks: ${rel}`
+    );
+  }
+  for (const rel of overlay) {
+    writeSourceFile(
+      ctx,
+      platformKey,
+      path.join(OMP_SRC, 'hooks', rel),
+      path.join(platform.folder, 'hooks', rel),
+      `omp hooks (overlay): ${rel}`
+    );
+  }
+}
+
+function installRuntimeFiles(ctx, platformKey) {
+  const platform = PLATFORMS[platformKey];
+  writeSourceFile(
+    ctx,
+    platformKey,
+    path.join(OMP_SRC, 'runtime.json'),
+    path.join(platform.folder, 'runtime.json'),
+    'omp runtime: runtime.json'
+  );
+  // One canonical runtime schema lives in the Claude source tree; every installed
+  // runtime references it as ./runtime.schema.json beside its runtime.json.
+  writeSourceFile(
+    ctx,
+    platformKey,
+    path.join(CLAUDE_SRC, 'runtime.schema.json'),
+    path.join(platform.folder, 'runtime.schema.json'),
+    'omp runtime schema'
+  );
+}
+
+function installBridge(ctx, platformKey) {
+  const platform = PLATFORMS[platformKey];
+  const bridgeSource = path.join(OMP_SRC, 'extensions');
+  const bridgeDest = path.join(platform.folder, 'extensions');
+  if (fs.existsSync(bridgeSource)) {
+    const bridge = copyManagedTree({
+      src: bridgeSource,
+      dest: bridgeDest,
+      platformFolder: platform.folder,
+      ctx,
+      tracker: ctx.trackers[platformKey]
+    });
+    report(ctx, treeAction(bridge), 'omp bridge extension');
+  } else if (!ctx.dryRun) {
+    // A half-provisioned install is visibly empty rather than silently absent.
+    fs.mkdirSync(bridgeDest, { recursive: true });
+    ctx.ui.detail('  ✓ omp extensions directory created (bridge not present)');
+  }
+}
+
+function installOmpRuntime(ctx, platformKey) {
+  if (platformKey !== 'omp') return;
+  installHooks(ctx, platformKey);
+  installRuntimeFiles(ctx, platformKey);
+  installBridge(ctx, platformKey);
+  copyRulesDirectory(ctx, platformKey);
+  return ctx;
+}
+
+module.exports = { installOmpRuntime, overlayFiles, claudeHookFiles };

package/bin/phases/root-config.js

@@ -110,6 +110,9 @@ function ensureGitignore(ctx) {
     // Local runtime payload — reinstall with npx; keep out of git
     '.claude/',
     '.codex/',
+    // omp auto-executes every file in .omp/extensions/, so a committed copy
+    // would run arbitrary code on clone. Keep it out of git like the rest.
+    '.omp/',
     '.agents/'
   ];
   const prefix = ctx.dryRun ? '[dry-run] ' : '';

package/bin/phases/select-platform.js

@@ -11,7 +11,8 @@ const path = require('path');
 const {
   PLATFORMS,
   detectPlatforms,
-  getPlatformKeys
+  getPlatformKeys,
+  resolvePlatformAliases
 } = require('../lib/context');
 const { SUPPORTED, LANGUAGE_LABELS, OTHER_LABEL } = require('../lib/i18n');
 
@@ -36,7 +37,25 @@ function getInstalledLocale(platformKeys = getPlatformKeys()) {
 }
 
 /** First step: pick the installer/UI language (interactive only). */
+/**
+ * Resolve host aliases on the requested platform list, once, before anything reads it.
+ *
+ * selectLanguage() filters this list through PLATFORMS to decide which installed runtime
+ * to take a saved locale from, so an unresolved alias would empty that list and fall back
+ * to scanning every platform folder — `--platform grok` in a project that also has
+ * `.codex/` would then silently take Codex's language.
+ */
+function applyPlatformAliases(ctx) {
+  const requested = ctx.options.platforms || [];
+  if (requested.length === 0) return ctx;
+  const { platforms, aliased } = resolvePlatformAliases(requested);
+  ctx.options.platforms = platforms;
+  ctx.aliasedHost = aliased;
+  return ctx;
+}
+
 async function selectLanguage(ctx) {
+  applyPlatformAliases(ctx);
   // Restore the saved locale BEFORE the interactivity check: a non-interactive
   // upgrade (--yes) must not forget the configured language. Skipping this left
   // ctx at the 'en' default, and patchRuntimeLocale then clobbered the user's
@@ -161,6 +180,7 @@ async function resolvePlatforms(ctx) {
     ctx.ui.info(ctx.t('installingFor', {
       names: platformNames(requested)
     }));
+    if (ctx.aliasedHost) ctx.ui.info(ctx.t('grokCompatNotice'));
     reportInstallMode(ctx);
     return ctx;
   }
@@ -244,6 +264,7 @@ function getInstalledPlatform() {
 
 module.exports = {
   selectLanguage,
+  applyPlatformAliases,
   promptPlatformSelection,
   resolvePlatforms,
   getInstalledPlatform,

package/bin/phases/summary.js

@@ -59,10 +59,6 @@ function printSummary(ctx) {
     }[key];
     if (messageKey) lines.push(t(messageKey));
   }
-  // rtk token-saver result (set by phases/setup-rtk.js when setup completed).
-  if (ctx.rtkSetupRan) {
-    lines.push(t('rtkSummary'));
-  }
   const keySkills = skillsNeedingKeys(platforms);
   if (keySkills.length > 0) {
     lines.push(t('nsKeys', { skills: keySkills.join(', ') }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haposoft/cafekit",
-  "version": "0.16.0",
+  "version": "0.16.2",
   "description": "Native spec-driven workflows for Claude Code and Codex CLI. Bundles CafeKit skills, runtime hooks, agents, and installer scaffolding.",
   "author": "Haposoft <nghialt@haposoft.com>",
   "license": "MIT",

package/src/claude/hooks/__tests__/semantic-review-authority.test.js

@@ -30,6 +30,8 @@ function installSemanticRuntime(target, runtime) {
   for (const name of ['semantic-review-authority.cjs', 'completion-authority-state.cjs']) {
     fs.copyFileSync(path.join(PACKAGE_ROOT, `src/${runtime}/hooks`, name), path.join(hooks, name));
   }
+  fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/runtime-dir.cjs'), path.join(hooks, 'lib/runtime-dir.cjs'));
+  fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/hook-payload.cjs'), path.join(hooks, 'lib/hook-payload.cjs'));
   fs.copyFileSync(
     path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/runtime-path-safety.cjs'),
     path.join(hooks, 'lib/runtime-path-safety.cjs'),