@haposoft/cafekit 0.16.0 → 0.16.1

package/bin/__tests__/omp-runtime.test.js

@@ -0,0 +1,150 @@
+'use strict';
+
+// omp discovers .claude/skills and .agents/skills on its own, so CafeKit ships it no
+// skill payload. What omp lacks is the enforcement chain, so an omp install has to
+// provision the hooks and the extension directory that carries it. These tests pin the
+// install path only; gate behaviour belongs to the tasks that author the fork and bridge.
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { test } = require('node:test');
+
+const PACKAGE_ROOT = path.join(__dirname, '../..');
+const INSTALLER = path.join(PACKAGE_ROOT, 'bin/install.js');
+const { PLATFORMS } = require(path.join(PACKAGE_ROOT, 'bin/lib/context'));
+
+function inTempProject(run) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-omp-runtime-'));
+  try {
+    const init = spawnSync('git', ['-C', root, 'init', '-q'], { encoding: 'utf8' });
+    assert.equal(init.status, 0, init.stderr);
+    return run(root);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+function install(root, platform, extra = []) {
+  return spawnSync(process.execPath, [INSTALLER, '--platform', platform, '--yes', ...extra],
+    { cwd: root, encoding: 'utf8', env: { ...process.env, PATH: '/usr/bin:/bin' } });
+}
+
+test('omp is a registered platform that ships no skill payload of its own', () => {
+  const omp = PLATFORMS.omp;
+  assert.ok(omp, 'omp must exist in the platform registry');
+  assert.equal(omp.folder, '.omp');
+  assert.equal(omp.capabilities.skills, false, 'omp reads .claude/skills itself; copying would duplicate');
+  assert.equal(omp.capabilities.agents, false);
+});
+
+test('an omp install creates hooks, an extensions directory, and platform metadata', () => {
+  inTempProject((root) => {
+    const result = install(root, 'omp');
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+
+    const hooks = fs.readdirSync(path.join(root, '.omp', 'hooks')).filter((f) => f.endsWith('.cjs'));
+    assert.ok(hooks.length > 0, 'the gate scripts must be installed');
+    for (const required of ['spec-gate.cjs', 'privacy-block.cjs', 'rules.cjs']) {
+      assert.ok(hooks.includes(required), `missing ${required}`);
+    }
+
+    assert.equal(fs.existsSync(path.join(root, '.omp', 'extensions')), true,
+      'omp auto-loads this directory; a half-provisioned install must be visibly empty, not absent');
+
+    const metadata = JSON.parse(fs.readFileSync(path.join(root, '.omp', 'cafekit.json'), 'utf8'));
+    assert.equal(metadata.platform, 'omp');
+    assert.ok(metadata.version, 'the install must record a version');
+  });
+});
+
+test('a non-omp install creates no .omp directory', () => {
+  inTempProject((root) => {
+    const result = install(root, 'claude');
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+    assert.equal(fs.existsSync(path.join(root, '.omp')), false);
+  });
+});
+
+test('an omp install ignores its own auto-executed extension directory', () => {
+  inTempProject((root) => {
+    assert.equal(install(root, 'omp').status, 0);
+    const ignore = fs.readFileSync(path.join(root, '.gitignore'), 'utf8');
+    // A committed .omp/extensions/ would run arbitrary code on clone, before any gate
+    // can act, so the ignore rule is part of the install rather than user hygiene.
+    assert.match(ignore, /^\.omp\/$/m, '.omp/ must be ignored like .claude/ and .codex/');
+  });
+});
+
+test('reinstalling omp is idempotent and preserves a user-added extension', () => {
+  inTempProject((root) => {
+    assert.equal(install(root, 'omp').status, 0);
+    const mine = path.join(root, '.omp', 'extensions', 'my-own.mjs');
+    fs.writeFileSync(mine, 'export default function () {}\n');
+
+    assert.equal(install(root, 'omp').status, 0);
+    assert.equal(fs.existsSync(mine), true, 'a reinstall erased an extension the user added');
+  });
+});
+
+test('an omp install ships the scripts the Stop gate needs', () => {
+  inTempProject((root) => {
+    fs.mkdirSync(path.join(root, 'specs'), { recursive: true });
+    const result = install(root, 'omp');
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+
+    // Every Stop-time gate requires ../scripts/*.cjs. Without these files the
+    // installed gate answers "Completion gate unavailable" and the bridge turns that
+    // into a block on every session_stop — the defect this case exists to pin.
+    for (const script of ['workflow-policy.cjs', 'spec-receipt.cjs', 'spec-resolver.cjs', 'provenance.cjs']) {
+      assert.equal(fs.existsSync(path.join(root, '.omp', 'scripts', script)), true, `missing .omp/scripts/${script}`);
+    }
+
+    const gate = spawnSync(process.execPath, [path.join(root, '.omp', 'hooks', 'spec-gate.cjs')], {
+      cwd: root,
+      input: JSON.stringify({ session_id: 'gate-probe', cwd: root, hook_event_name: 'Stop', stop_hook_active: false }),
+      encoding: 'utf8',
+    });
+    assert.equal(gate.status, 0, gate.stderr);
+    assert.doesNotMatch(gate.stdout, /Completion gate unavailable/, 'the installed Stop gate must load its scripts');
+  });
+});
+
+test('an omp-only install injects rules', () => {
+  inTempProject((root) => {
+    const result = install(root, 'omp');
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+    assert.equal(fs.existsSync(path.join(root, '.claude')), false, 'this case is about a project with no .claude at all');
+
+    // The hooks read their configuration from the folder they live in, so omp needs its
+    // own runtime.json: no statusline (omp has none), usage off (that hook reads Claude
+    // Code's credential file), coding level 1 like Codex.
+    const runtime = JSON.parse(fs.readFileSync(path.join(root, '.omp', 'runtime.json'), 'utf8'));
+    assert.equal(runtime.codingLevel, 1);
+    assert.equal(runtime.usage.enabled, false);
+    assert.deepEqual(Object.keys(runtime).filter((k) => k.startsWith('statusline')), []);
+    assert.equal(runtime.$schema, './runtime.schema.json');
+    assert.equal(fs.existsSync(path.join(root, '.omp', 'runtime.schema.json')), true, 'the schema installs beside the file that references it');
+
+    // The Claude set arrives whole, the overlay on top, and nothing from the test tree.
+    const hooks = fs.readdirSync(path.join(root, '.omp', 'hooks'));
+    assert.equal(hooks.includes('__tests__'), false, 'the source tree holds tests that must never install');
+    for (const required of ['rules.cjs', 'spec-gate.cjs', 'session.cjs', 'lib/runtime-dir.cjs', 'lib/hook-payload.cjs']) {
+      assert.equal(fs.existsSync(path.join(root, '.omp', 'hooks', required)), true, `missing .omp/hooks/${required}`);
+    }
+    const privacy = fs.readFileSync(path.join(root, '.omp', 'hooks', 'privacy-block.cjs'), 'utf8');
+    assert.ok(privacy.includes("permissionDecision: 'deny'") && !privacy.includes("permissionDecision: 'ask'"),
+      'the installed privacy hook must be the omp overlay, not the Claude file');
+
+    const rules = spawnSync(process.execPath, [path.join(root, '.omp', 'hooks', 'rules.cjs')], {
+      cwd: root,
+      input: JSON.stringify({ session_id: `omp-rules-${Date.now()}`, cwd: root, prompt: 'hello' }),
+      encoding: 'utf8',
+      env: { ...process.env, CLAUDE_PROJECT_DIR: '', PROJECT_ROOT: '' },
+    });
+    assert.equal(rules.status, 0, rules.stderr);
+    assert.match(rules.stdout, /## Rules/, 'without .omp/runtime.json the hook exits silently and omp never sees the rules');
+  });
+});

package/bin/__tests__/runtime-dir.test.js

@@ -0,0 +1,158 @@
+'use strict';
+
+// The gate hooks derive their runtime directory from their own location instead of a
+// literal `.claude`. Each case copies the helper into a directory shaped like a real
+// layout and requires it from there, so the derivation is exercised against the path the
+// module actually sees — not a mocked one.
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { test } = require('node:test');
+
+const PACKAGE_ROOT = path.join(__dirname, '../..');
+const HELPER = path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/runtime-dir.cjs');
+const { spawnSync } = require('node:child_process');
+
+/** Place the helper at <root>/<layout>/hooks/lib/ and return what it derives. */
+function deriveAt(root, layout) {
+  const lib = path.join(root, layout, 'hooks', 'lib');
+  fs.mkdirSync(lib, { recursive: true });
+  const target = path.join(lib, 'runtime-dir.cjs');
+  fs.copyFileSync(HELPER, target);
+  // Each copy is a distinct module path, so require caches never collide.
+  return require(target);
+}
+
+function withTemp(run) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-runtime-dir-'));
+  try { return run(root); } finally { fs.rmSync(root, { recursive: true, force: true }); }
+}
+
+test('installed layouts derive their own folder', () => {
+  withTemp((root) => {
+    for (const folder of ['.claude', '.codex', '.omp']) {
+      const m = deriveAt(root, path.join('project-' + folder.slice(1), folder));
+      assert.equal(m.runtimeDirName(), folder);
+      assert.equal(m.runtimeDir('/p'), path.join('/p', folder));
+      assert.equal(m.runtimePath('/p', 'runtime.json'), path.join('/p', folder, 'runtime.json'));
+    }
+  });
+});
+
+test('the source tree maps platform to dotted name', () => {
+  withTemp((root) => {
+    for (const platform of ['claude', 'omp', 'codex']) {
+      const m = deriveAt(root, path.join('packages', 'spec', 'src', platform));
+      assert.equal(m.runtimeDirName(), `.${platform}`, `source tree for ${platform}`);
+    }
+  });
+});
+
+test('a dotted folder wins over the source marker', () => {
+  withTemp((root) => {
+    // An install whose absolute path happens to contain /packages/spec/src/ must still
+    // report its real folder, not a doubled-dot name derived from the marker.
+    const m = deriveAt(root, path.join('packages', 'spec', 'src', 'fixture', '.codex'));
+    assert.equal(m.runtimeDirName(), '.codex');
+  });
+});
+
+test('an unknown layout falls back to .claude', () => {
+  withTemp((root) => {
+    const m = deriveAt(root, path.join('somewhere', 'else'));
+    assert.equal(m.runtimeDirName(), '.claude', 'the pre-helper behaviour is the fallback');
+  });
+});
+
+test('the helper in the real source tree derives .claude', () => {
+  const m = require(HELPER);
+  assert.equal(m.runtimeDirName(), '.claude');
+});
+
+/** Copy the whole hook tree and the scripts it requires under <root>/<folder>/. */
+function installTreeAs(root, folder) {
+  const rt = path.join(root, folder);
+  fs.cpSync(path.join(PACKAGE_ROOT, 'src/claude/hooks'), path.join(rt, 'hooks'), {
+    recursive: true, filter: (src) => !src.includes(`${path.sep}__tests__`),
+  });
+  fs.cpSync(path.join(PACKAGE_ROOT, 'src/claude/scripts'), path.join(rt, 'scripts'), { recursive: true });
+  return rt;
+}
+
+/** Provenance derives Base/Head with git, so the fixture must be a repository (one empty commit). */
+function gitInit(root) {
+  for (const args of [['init', '-q'], ['config', 'user.email', 'cafekit@example.invalid'], ['config', 'user.name', 'CafeKit Test'], ['commit', '--allow-empty', '-qm', 'fixture']]) {
+    const result = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' });
+    assert.equal(result.status, 0, `git ${args[0]} failed: ${result.stderr}`);
+  }
+}
+
+function runHook(rt, name, payload) {
+  const r = spawnSync(process.execPath, [path.join(rt, 'hooks', name)], {
+    cwd: path.dirname(rt), input: JSON.stringify(payload), encoding: 'utf8',
+    env: { ...process.env, CLAUDE_PROJECT_DIR: '', PROJECT_ROOT: '' },
+  });
+  return { code: r.status, out: (r.stdout || '') + (r.stderr || '') };
+}
+
+test('a hook tree copied under .omp reads .omp/runtime.json', () => {
+  withTemp((root) => {
+    const rt = installTreeAs(root, '.omp');
+    gitInit(root);
+    fs.mkdirSync(path.join(root, 'specs'), { recursive: true });
+    fs.writeFileSync(path.join(root, '.env'), 'TOKEN=redacted\n');
+    assert.equal(fs.existsSync(path.join(root, '.claude')), false, 'the fixture must hold no .claude path at all');
+
+    // rules.cjs: docs path from the sentinel config
+    fs.writeFileSync(path.join(rt, 'runtime.json'), JSON.stringify({ paths: { docs: 'SENTINEL-DOCS', plans: 'plans' } }));
+    const rules = runHook(rt, 'rules.cjs', { session_id: `s-${Date.now()}`, cwd: root });
+    assert.match(rules.out, /SENTINEL-DOCS/, 'rules.cjs must read .omp/runtime.json');
+
+    // inspect-block.cjs: disabled through the sentinel allows a broad search
+    fs.writeFileSync(path.join(rt, 'runtime.json'), JSON.stringify({ inspect: { enabled: false } }));
+    const inspect = runHook(rt, 'inspect-block.cjs', { tool_name: 'Bash', tool_input: { command: 'grep -rn TODO .' }, cwd: root });
+    assert.equal(inspect.code, 0, 'inspect.enabled:false in .omp/runtime.json must allow');
+
+    // privacy-block.cjs: kill switch through the sentinel allows a .env read
+    fs.writeFileSync(path.join(rt, 'runtime.json'), JSON.stringify({ privacyBlock: false }));
+    const privacy = runHook(rt, 'privacy-block.cjs', { tool_name: 'Read', tool_input: { file_path: path.join(root, '.env') }, cwd: root });
+    assert.doesNotMatch(privacy.out, /permissionDecision/, 'privacyBlock:false in .omp/runtime.json must allow');
+
+    // spec-gate.cjs exits silently unless a packet resolves, and only then reads the
+    // completion_gate flag. Resolving a done task derives provenance through git, so the
+    // fixture is a repository (gitInit above) and holds one done task to look at.
+    const feature = path.join(root, 'specs', 'demo'); fs.mkdirSync(feature, { recursive: true });
+    fs.writeFileSync(path.join(feature, 'plan.md'), '# Demo plan\n');
+    fs.writeFileSync(path.join(feature, 'task-01-demo.md'), [
+      '# Task 01: demo', '', 'Status: done', '', '## Dependencies', '', '- none', '',
+      '## Verification Plan', '', '- Command: node --test', '',
+    ].join('\n'));
+    // the completion_gate flag is read from the sentinel and answered as a block
+    fs.writeFileSync(path.join(rt, 'runtime.json'), JSON.stringify({ spec: { completion_gate: false } }));
+    const gate = runHook(rt, 'spec-gate.cjs', { session_id: 's', cwd: root, hook_event_name: 'Stop', stop_hook_active: false });
+    assert.match(gate.out, /worker-writable flag/, 'spec-gate.cjs must read .omp/runtime.json');
+  });
+});
+
+test('advice names the directory the hook lives in', () => {
+  withTemp((root) => {
+    for (const [folder, skills] of [['.omp', '.agents/skills'], ['.claude', '.claude/skills']]) {
+      const project = path.join(root, `p${folder}`); fs.mkdirSync(project, { recursive: true });
+      const rt = installTreeAs(project, folder);
+      fs.mkdirSync(path.join(project, 'specs', 'demo'), { recursive: true });
+      fs.writeFileSync(path.join(rt, 'runtime.json'), '{}');
+      // task-scaffold-guard: a raw Write into a nested task path is refused with scaffold advice
+      const guard = runHook(rt, 'task-scaffold-guard.cjs', { tool_name: 'Write', tool_input: { file_path: path.join(project, 'specs', 'demo', 'tasks', 'task-R0-01-x.md'), content: '# x' }, cwd: project });
+      assert.match(guard.out, new RegExp(`node ${folder.replace('.', '\\.')}/scripts/spec-scaffold\\.cjs`), `scaffold advice must name ${folder}`);
+      // inspect-block: header hint names the runtime file (static check on the installed copy)
+      const src = fs.readFileSync(path.join(rt, 'hooks', 'inspect-block.cjs'), 'utf8');
+      assert.match(src, /<runtime>\/runtime\.json/, 'the disable hint no longer hardcodes a platform');
+      // agent.cjs: skills advice follows the platform registry, not the runtime dir
+      const agentSrc = fs.readFileSync(path.join(rt, 'hooks', 'agent.cjs'), 'utf8');
+      assert.match(agentSrc, /'\.agents\/skills'/, 'non-Claude platforms read .agents/skills');
+      void skills;
+    }
+  });
+});

package/bin/__tests__/runtime-schema.test.js

@@ -12,7 +12,7 @@ const { test } = require('node:test');
 const PACKAGE_ROOT = path.join(__dirname, '../..');
 const SCHEMA_PATH = path.join(PACKAGE_ROOT, 'src/claude/runtime.schema.json');
 const SCHEMA = JSON.parse(fs.readFileSync(SCHEMA_PATH, 'utf8'));
-const RUNTIMES = ['src/claude/runtime.json', 'src/codex/runtime.json'];
+const RUNTIMES = ['src/claude/runtime.json', 'src/codex/runtime.json', 'src/omp/runtime.json'];
 const MANIFEST = require(path.join(PACKAGE_ROOT, 'src/claude/migration-manifest.json'));
 
 function readRuntime(relative) {
@@ -54,14 +54,14 @@ test('the schema is a valid, self-describing JSON Schema document', () => {
   assert.equal(SCHEMA.additionalProperties, false, 'an unknown top-level key must be reported, not accepted silently');
 });
 
-test('every key in both shipped runtime.json files is described by the schema', () => {
+test('every key in each shipped runtime.json is described by the schema', () => {
   for (const relative of RUNTIMES) {
     const missing = undescribedKeys(readRuntime(relative), SCHEMA);
     assert.deepEqual(missing, [], `${relative} ships keys the schema does not describe: ${missing.join(', ')}`);
   }
 });
 
-test('both runtimes point at the schema that installs beside them', () => {
+test('every runtime points at the schema that installs beside it', () => {
   for (const relative of RUNTIMES) {
     assert.equal(readRuntime(relative).$schema, './runtime.schema.json', `${relative} must reference the schema`);
   }
@@ -71,6 +71,8 @@ test('both runtimes point at the schema that installs beside them', () => {
   );
   const codexPhase = fs.readFileSync(path.join(PACKAGE_ROOT, 'bin/phases/codex-runtime.js'), 'utf8');
   assert.match(codexPhase, /runtime\.schema\.json/, 'the schema must also be installed for Codex');
+  const ompPhase = fs.readFileSync(path.join(PACKAGE_ROOT, 'bin/phases/omp-runtime.js'), 'utf8');
+  assert.match(ompPhase, /runtime\.schema\.json/, 'the schema must also be installed for omp');
 });
 
 test('every documented property carries a description a reader can act on', () => {

package/bin/__tests__/specs-v2-execution-closeout.test.js

@@ -263,7 +263,8 @@ function installGate(root, kind) {
     'scripts/workflow-policy.cjs', 'scripts/provenance.cjs', 'scripts/spec-resolver.cjs',
     'scripts/spec-receipt.cjs', 'scripts/validate-spec-output.cjs', 'scripts/spec-ground.cjs',
     'scripts/spec-semantic-model.cjs', 'scripts/spec-final-state.cjs',
-    'hooks/lib/runtime-path-safety.cjs', 'hooks/lib/hook-state-dir.cjs',
+    'hooks/lib/runtime-path-safety.cjs', 'hooks/lib/hook-state-dir.cjs', 'hooks/lib/runtime-dir.cjs',
+    'hooks/lib/hook-payload.cjs',
   ]);
   if (kind === 'claude') {
     for (const name of [
@@ -466,3 +467,29 @@ test('scaffold creates planning artifacts but no task or feature receipts', () =
     assert.equal(files.some((file) => file.includes('receipt')), false);
   });
 });
+
+test('legacy receipt still requires provenance under a clean committed tree', () => {
+  // The workflow task path may validate a committed, unchanged receipt on
+  // structure alone; the legacy task and feature receipt paths must not.
+  withTempResources((resources) => {
+    const root = gitRoot(resources);
+    const { featureDir } = prepare(root);
+    const stale = { base: 'f'.repeat(40), head: 'e'.repeat(40) };
+    fs.writeFileSync(
+      path.join(featureDir, 'receipts', path.basename(TASK)),
+      receiptBody(stale, `Task: ${path.basename(TASK)}\nTask path: ${TASK}`),
+    );
+    fs.writeFileSync(path.join(featureDir, 'feature-receipt.md'), receiptBody(stale, `Feature: ${FEATURE}`));
+    for (const args of [['add', '-A'], ['commit', '-qm', 'committed legacy receipts']]) {
+      const result = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' });
+      assert.equal(result.status, 0, result.stderr);
+    }
+    const clean = spawnSync('git', ['-C', root, 'status', '--porcelain'], { encoding: 'utf8' });
+    assert.equal(clean.stdout.trim(), '', 'fixture tree must be clean before the check');
+    const ctx = runtime(root);
+    const taskFailures = RECEIPT.checkTaskReceipt(featureDir, TASK, { completed_at: '2026-08-13T00:00:00.000Z' }, ctx, POLICY).failures;
+    assert.ok(taskFailures.includes('provenance'), `legacy task receipts keep provenance binding when committed and clean; got ${JSON.stringify(taskFailures)}`);
+    const featureFailures = RECEIPT.checkFeatureReceipt(featureDir, ctx, POLICY).failures;
+    assert.ok(featureFailures.includes('provenance'), `feature receipts keep provenance binding when committed and clean; got ${JSON.stringify(featureFailures)}`);
+  });
+});

package/bin/install.js

@@ -37,12 +37,12 @@ const {
 const { reconcileSkillInventory } = require('./phases/skill-inventory');
 const { mergeClaudeSettings } = require('./phases/claude-settings');
 const { installCodexRuntime } = require('./phases/codex-runtime');
+const { installOmpRuntime } = require('./phases/omp-runtime');
 const { writePlatformVersionMetadata } = require('./phases/write-metadata');
 const { checkVersions } = require('./lib/version-check');
 const { ensureGitignore } = require('./phases/root-config');
 const { runPostInstall } = require('./phases/post-install');
 const { setupSkillDeps } = require('./phases/skills-setup');
-const { setupRtk } = require('./phases/setup-rtk');
 const { printSummary } = require('./phases/summary');
 
 /** Install a single platform: payload + runtime + metadata, under one spinner. */
@@ -78,6 +78,10 @@ function installPlatform(ctx, platformKey) {
     installCodexRuntime(ctx, platformKey);
   }
 
+  if (platformKey === 'omp') {
+    installOmpRuntime(ctx, platformKey);
+  }
+
   writePlatformVersionMetadata(ctx, platformKey);
 
   const wrote = (ctx.results.copied - before.copied) + (ctx.results.updated - before.updated);
@@ -105,7 +109,6 @@ Options:
   -u, --upgrade, -f, --force   Alias of --force-overwrite
   --with-skills-deps   Install skill dependencies (Python venv + pip, npm,
                        Chromium/Playwright). Otherwise prompted interactively.
-  --with-rtk           Install the rtk token-saver (binary + Claude Code hook).
                        Otherwise prompted interactively.
   --with-document-skills     Install docs/DOCX/PDF/PPTX/XLSX/multimodal skills
   --without-document-skills  Skip or remove CafeKit-owned document skills
@@ -190,9 +193,6 @@ async function main() {
     ensureGitignore(ctx);
     await runPostInstall(ctx);
     await setupSkillDeps(ctx);
-    if (ctx.platforms.includes('claude')) {
-      await setupRtk(ctx);
-    }
 
     // Phase handlers may report recoverable-looking errors through counters
     // instead of throwing. Treat them as transactional failure so the snapshot

package/bin/lib/context.js

@@ -119,6 +119,35 @@ const PLATFORMS = {
       rules: true,
       commands: false
     }
+  },
+  omp: {
+    id: 'omp',
+    name: 'Oh My Pi',
+    description: 'Oh My Pi coding agent',
+    folder: '.omp',
+    detectFiles: ['.omp'],
+    commandsDir: null,
+    // omp discovers .claude/skills and .agents/skills itself, so CafeKit copies
+    // no skill payload for it. See specs/omp-runtime-support/plan.md.
+    skillsDir: '.agents/skills',
+    agentsDir: null,
+    skillsRef: '.agents/skills',
+    commandPrefix: '$',
+    sourceDir: 'claude',
+    sourceSubdir: null,
+    backupTargets: ['.omp', 'AGENTS.md'],
+    ownership: {
+      recordRoot: '.',
+      allowedRoots: ['.omp']
+    },
+    capabilities: {
+      skills: false,
+      agents: false,
+      references: true,
+      scripts: true,
+      rules: true,
+      commands: false
+    }
   }
   // Add new platforms here:
   // cursor: {
@@ -132,6 +161,25 @@ const PLATFORMS = {
   // }
 };
 
+/**
+ * Hosts that run another platform's install rather than one of their own.
+ *
+ * Grok CLI discovers `.claude/skills`, `.claude/rules`, `CLAUDE*.md` and the hooks in
+ * `.claude/settings.json` through its own Claude-compatibility layer, and the gate hooks
+ * normalize its envelope, so `--platform grok` provisions the Claude runtime. There is no
+ * `.grok/` payload and deliberately no detection marker: a repository that merely holds
+ * `.grok/` has not asked for a CafeKit install.
+ */
+const PLATFORM_ALIASES = Object.freeze({
+  grok: 'claude'
+});
+
+/** Resolve host aliases and drop duplicates, preserving the requested order. */
+function resolvePlatformAliases(keys = []) {
+  const resolved = keys.map((key) => PLATFORM_ALIASES[key] || key);
+  return { platforms: [...new Set(resolved)], aliased: keys.some((key) => Boolean(PLATFORM_ALIASES[key])) };
+}
+
 // ═══════════════════════════════════════════════════════════
 // DETECTION + PLATFORM HELPERS
 // ═══════════════════════════════════════════════════════════
@@ -207,7 +255,6 @@ function parseInstallerArgs(argv) {
     dryRun: false,
     yes: false,
     withSkillsDeps: false,
-    withRtk: false,
     withDocumentSkills: false,
     withoutDocumentSkills: false,
     platforms: []
@@ -224,8 +271,6 @@ function parseInstallerArgs(argv) {
       args.yes = true;
     } else if (arg === '--with-skills-deps') {
       args.withSkillsDeps = true;
-    } else if (arg === '--with-rtk') {
-      args.withRtk = true;
     } else if (arg === '--with-document-skills') {
       args.withDocumentSkills = true;
     } else if (arg === '--without-document-skills') {
@@ -321,6 +366,8 @@ module.exports = {
   INSTALL_COMMAND,
   DEPENDENCY_TEMPLATES,
   PLATFORMS,
+  PLATFORM_ALIASES,
+  resolvePlatformAliases,
   validateManifestV2,
   loadClaudeMigrationManifest,
   detectPlatforms,

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/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');