@ucsandman/legcli 0.8.0 → 0.9.0

package/src/harness/vendor/agnostic-ai/engine/harness/status.cjs

@@ -0,0 +1,171 @@
+/**
+ * engine/harness/status.cjs — what every client actually looks like right now.
+ *
+ * Reads the targets from disk (an apply run in check mode: nothing is written)
+ * and reports per component whether it is in sync. Nothing is asserted from
+ * memory; a claim here always came from a file this process just read.
+ *
+ * `renderHtml(report)` is the human surface: one standalone page, no assets.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const bundleMod = require('./bundle.cjs');
+const { apply, DEFAULT_STORAGE } = require('./apply.cjs');
+
+const NO_BUNDLE = 'no bundle captured yet; run npm run capture';
+
+/**
+ * status({ home, port, storageDir, json, explain, bundleDir, html, quiet })
+ *   -> { syncState, targets, report }
+ * syncState is 'synced' | 'stale' | 'error' | 'no-bundle'.
+ */
+function status(options = {}) {
+  const {
+    home = os.homedir(), port, to, bundleDir, json = false, explain = false,
+    html = false, quiet = false, adapters, registry,
+  } = options;
+  const storageDir = options.storageDir || DEFAULT_STORAGE;
+  const log = options.log || ((line) => { if (!quiet && !json) console.log(line); });
+
+  const bundle = options.bundle || bundleMod.load(bundleDir || bundleMod.DEFAULT_DIR);
+  if (!bundle) {
+    log(NO_BUNDLE);
+    return { syncState: 'no-bundle', targets: {}, report: null, message: NO_BUNDLE };
+  }
+
+  const report = apply({ bundle, home, port, to, check: true, storageDir, adapters, registry, log });
+  const anyError = Object.values(report.targets).some((t) => t.status === 'error');
+  const syncState = anyError ? 'error' : report.stale ? 'stale' : 'synced';
+  report.syncState = syncState;
+
+  if (explain) log(formatDropped(report));
+  if (html) {
+    const file = path.join(storageDir, 'harness-status.html');
+    fs.mkdirSync(storageDir, { recursive: true });
+    fs.writeFileSync(file, renderHtml(report), 'utf8');
+    report.htmlFile = file;
+    log(`status page: ${file}`);
+  }
+  if (json) console.log(JSON.stringify(report, null, 2));
+
+  return { syncState, targets: report.targets, report };
+}
+
+/** Every dropped item from a report, grouped per target, with its reason. */
+function formatDropped(report) {
+  const lines = [];
+  let total = 0;
+  for (const target of Object.values(report.targets)) {
+    const items = [];
+    for (const [component, result] of Object.entries(target.components || {})) {
+      for (const drop of result.dropped || []) items.push(`    ${component}: ${drop.item} — ${drop.reason}`);
+    }
+    if (!items.length) continue;
+    total += items.length;
+    lines.push(`  ${target.name} (${items.length})`);
+    lines.push(...items);
+  }
+  lines.unshift(`Dropped items: ${total} across ${Object.keys(report.targets).length} targets`);
+  if (!total) lines.push('  (nothing was dropped)');
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// HTML status page — standalone, no external assets, light and dark.
+// ---------------------------------------------------------------------------
+const esc = (s) => String(s == null ? '' : s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+
+const STATUS_CLASS = { synced: 'ok', written: 'ok', source: 'src', stale: 'bad', skipped: 'warn', unsupported: 'muted', error: 'bad' };
+const CELL = { synced: '✓', written: '●', stale: '✗', skipped: '!', unsupported: '–', error: 'E', source: '=' };
+
+const PAGE_CSS = `
+:root { color-scheme: light dark; --bg:#ffffff; --surface:#f6f8fa; --border:#d0d7de; --text:#1f2328; --muted:#656d76; --ok:#1a7f37; --bad:#cf222e; --warn:#9a6700; --accent:#0969da; }
+@media (prefers-color-scheme: dark) { :root { --bg:#0d1117; --surface:#161b22; --border:#30363d; --text:#e6edf3; --muted:#8b949e; --ok:#3fb950; --bad:#f85149; --warn:#d29922; --accent:#58a6ff; } }
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; background: var(--bg); color: var(--text); line-height: 1.5; padding: 28px 24px; }
+.wrap { max-width: 1100px; margin: 0 auto; }
+h1 { font-size: 22px; font-weight: 650; }
+h2 { font-size: 15px; font-weight: 650; margin: 28px 0 10px; }
+.lede { color: var(--muted); margin-top: 6px; font-size: 14px; }
+.cards { display: grid; grid-template-columns: repeat(auto-fill, minmax(210px, 1fr)); gap: 12px; margin-top: 20px; }
+.card { background: var(--surface); border: 1px solid var(--border); border-radius: 8px; padding: 12px 14px; }
+.card .n { font-weight: 650; }
+.card .d { font-size: 12px; color: var(--muted); margin-top: 4px; font-family: ui-monospace, Consolas, monospace; word-break: break-all; }
+.pill { float: right; font-size: 11px; font-weight: 650; text-transform: uppercase; letter-spacing: .4px; padding: 1px 8px; border-radius: 10px; border: 1px solid currentColor; }
+table { border-collapse: collapse; width: 100%; font-size: 13px; }
+th, td { border-bottom: 1px solid var(--border); padding: 6px 8px; text-align: left; }
+th { color: var(--muted); font-weight: 550; font-size: 11px; text-transform: uppercase; letter-spacing: .4px; }
+td.c { text-align: center; font-size: 15px; }
+.ok { color: var(--ok); } .bad { color: var(--bad); } .warn { color: var(--warn); } .muted { color: var(--muted); } .src { color: var(--accent); }
+.legend, .foot { color: var(--muted); font-size: 12px; margin-top: 10px; }
+code, pre { font-family: ui-monospace, Consolas, monospace; font-size: 12px; }
+pre { background: var(--surface); border: 1px solid var(--border); border-radius: 8px; padding: 10px 12px; overflow-x: auto; }
+ul { margin-left: 18px; font-size: 13px; }
+li { margin: 2px 0; }
+`;
+
+function renderHtml(report) {
+  const targets = Object.values(report.targets || {});
+  const totals = report.totals || {};
+  const supported = (t) => Object.values(t.components || {}).filter((r) => r.status !== 'unsupported');
+  const syncedOf = (t) => supported(t).filter((r) => r.status === 'synced').length;
+
+  const cards = targets.map((t) => {
+    const cls = STATUS_CLASS[t.status] || 'muted';
+    const detail = t.status === 'source'
+      ? 'source of truth — never written to'
+      : `${syncedOf(t)}/${supported(t).length} components synced · ${t.dropped || 0} dropped`;
+    return `<div class="card"><span class="pill ${cls}">${esc(t.status)}</span><div class="n">${esc(t.name)}</div>` +
+      `<div class="d">${esc(t.home || t.adapter)}</div>` +
+      `<div class="d">${t.installed ? 'installed' : 'not installed'} · ${detail}</div></div>`;
+  }).join('\n');
+
+  const rows = targets.map((t) => {
+    const cells = bundleMod.COMPONENTS.map((c) => {
+      if (t.status === 'source') return `<td class="c src" title="source of truth">${CELL.source}</td>`;
+      const r = (t.components || {})[c] || { status: 'unsupported' };
+      const title = [r.note, r.error, `${(r.files || []).length} files`].filter(Boolean).join(' — ');
+      return `<td class="c ${STATUS_CLASS[r.status] || 'muted'}" title="${esc(r.status)}${title ? ': ' + esc(title) : ''}">${CELL[r.status] || '?'}</td>`;
+    }).join('');
+    return `<tr><td>${esc(t.name)}</td>${cells}<td>${t.dropped || 0}</td></tr>`;
+  }).join('\n');
+
+  const droppedBlocks = targets.map((t) => {
+    const items = [];
+    for (const [component, r] of Object.entries(t.components || {})) {
+      for (const d of r.dropped || []) items.push(`<li><code>${esc(component)}</code> ${esc(d.item)} — ${esc(d.reason)}</li>`);
+    }
+    return items.length ? `<h2>${esc(t.name)} — ${items.length} dropped</h2><ul>${items.join('')}</ul>` : '';
+  }).filter(Boolean).join('\n') || '<p class="foot">Nothing was dropped.</p>';
+
+  const b = report.bundle || {};
+  const counts = Object.entries(b.components || {}).map(([k, v]) => `${k} ${v}`).join(' · ') || 'none';
+
+  return `<!DOCTYPE html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Agnostic harness — port status</title><style>${PAGE_CSS}</style></head>
+<body><div class="wrap">
+<h1>Harness port status</h1>
+<p class="lede">Your <strong>${esc(b.source || 'unknown')}</strong> harness, copied into every other AI coding client on this machine. Each cell says whether that client's rules, hooks, skills, agents, commands, MCP servers and permissions match it.</p>
+<p class="foot">${targets.length} targets · ${totals.wouldWrite || 0} files out of date · ${totals.unchanged || 0} already in sync · ${totals.dropped || 0} dropped · checked ${esc(report.appliedAt)}</p>
+<div class="cards">${cards}</div>
+<h2>Component matrix</h2>
+<table><thead><tr><th>Client</th>${bundleMod.COMPONENTS.map((c) => `<th>${esc(c)}</th>`).join('')}<th>dropped</th></tr></thead><tbody>${rows}</tbody></table>
+<p class="legend">✓ in sync · ● written · ✗ out of date · ! skipped (hand-edited, needs --force) · – client has no such surface · E error · = the source client</p>
+<h2>What was not ported</h2>
+${droppedBlocks}
+<h2>Bundle</h2>
+<p class="foot">source <code>${esc(b.source || '?')}</code> · captured ${esc(b.capturedAt || 'never')} · ${esc(counts)}</p>
+<h2>Regenerate</h2>
+<pre>npm run capture   # re-read the source client
+npm run port      # capture, then write every target
+npm run port:check # report only, write nothing
+npm run explain   # every dropped item and why</pre>
+</div></body></html>
+`;
+}
+
+module.exports = { status, renderHtml, formatDropped, NO_BUNDLE };

package/src/harness/vendor/agnostic-ai/engine/harness/targets/agy.cjs

@@ -0,0 +1,113 @@
+/**
+ * engine/harness/targets/agy.cjs — Antigravity CLI (`agy`).
+ *
+ * Rules land in ~/.gemini/GEMINI.md, which the Gemini CLI target writes too:
+ * the registry gives both the same rulesFile and the same preamble, so whichever
+ * adapter runs first writes the file and the other sees it unchanged.
+ *
+ * Hooks are agy's own dialect. The file format is verified on this machine from
+ * the CLI's own shipped documentation:
+ *   ~/.gemini/antigravity-cli/builtin/skills/agy-customizations/docs/hooks.md
+ * "The `hooks.json` file is a JSON object where each top-level key is a hook
+ * name, mapping to its event configuration." PreToolUse and PostToolUse are
+ * *grouped* (a `matcher` + `hooks` wrapper); PreInvocation, PostInvocation and
+ * Stop are *flat* lists of handler objects. Each handler is
+ * `{ type?: "command", command, timeout?: seconds }`.
+ *
+ * That one top-level key is also the ownership boundary: the harness owns the
+ * key `agnostic-ai` and nothing else in the file, so a hook another plugin or
+ * the operator registered under its own name survives every run untouched.
+ *
+ * Every ported guard runs through engine/hooks/shim.cjs, which speaks agy's
+ * camelCase protojson payloads and its allow/deny/ask/force_ask decisions.
+ * agy merges the results of several hooks for one event and the LAST reason
+ * wins, so the guards for one event are chained inside ONE entry with `++`.
+ */
+
+const common = require('../common.cjs');
+const generic = require('./generic.cjs');
+
+const I = generic._internals;
+
+/** The single top-level key in hooks.json that this harness owns: the configured brand id. */
+const hookName = () => common.config.brand.id;
+
+const EVENT_MAP = {
+  PreToolUse: 'PreToolUse',
+  PostToolUse: 'PostToolUse',
+  UserPromptSubmit: 'PreInvocation',
+  Stop: 'Stop',
+};
+
+// Only these two carry a matcher/hooks wrapper; the rest are flat handler lists.
+const GROUPED = new Set(['PreToolUse', 'PostToolUse']);
+
+// Claude tool token -> agy tool name (the reverse of the adapter's own map).
+const MATCHER_MAP = {
+  Bash: 'run_command', PowerShell: 'run_command',
+  Write: 'write_to_file',
+  Edit: 'replace_file_content', MultiEdit: 'replace_file_content', NotebookEdit: 'replace_file_content',
+  Read: 'view_file', Grep: 'grep_search', Glob: 'list_dir',
+  Agent: 'invoke_subagent', Task: 'invoke_subagent', Workflow: 'invoke_subagent',
+  WebFetch: 'read_url_content', WebSearch: 'search_web',
+};
+
+function hooks(ctx) {
+  const file = I.at(ctx, ctx.target.hooksConfigFile);
+  if (!file) return I.unsupported('no hooks config file in the target registry');
+  const config = I.readUserJson(file);
+  if (config === null) return { status: 'error', files: [{ path: file, action: 'unchanged' }], dropped: [], error: `${common.tildePath(file, ctx.home)} is not valid JSON; nothing was written` };
+
+  const dropped = [];
+  const buckets = new Map(); // `${agyEvent} ${matcher ?? ''}` -> { event, matcher, handlers }
+
+  for (const [event, groups] of Object.entries(ctx.bundle.hooks.events || {})) {
+    const agyEvent = EVENT_MAP[event];
+    if (!agyEvent) { dropped.push({ item: `hook event ${event}`, reason: 'no Antigravity event (it has only PreToolUse, PostToolUse, PreInvocation, PostInvocation, Stop)' }); continue; }
+    for (const group of groups || []) {
+      const { kept, dropped: gone } = I.portedHandlers(ctx, event, group);
+      dropped.push(...gone);
+      if (!kept.length) continue;
+      let matcher;
+      if (GROUPED.has(agyEvent)) {
+        matcher = I.translateMatcher(group.matcher, MATCHER_MAP, { keepUnknown: true });
+        if (matcher === null) { dropped.push({ item: `${event} [${group.matcher}]`, reason: 'no Antigravity tool behind this matcher' }); continue; }
+      }
+      const key = `${agyEvent} ${matcher === undefined ? '' : matcher}`;
+      if (!buckets.has(key)) buckets.set(key, { event: agyEvent, matcher, handlers: [] });
+      buckets.get(key).handlers.push(...kept);
+    }
+  }
+
+  const block = {};
+  for (const { event, matcher, handlers } of buckets.values()) {
+    const handler = { type: 'command', command: I.shimCommand('agy', event, handlers.map((h) => h.command)) };
+    const timeout = I.chainTimeout(handlers);
+    if (timeout !== undefined) handler.timeout = timeout;
+    block[event] = block[event] || [];
+    // Grouped events wrap the handler; flat events take it directly.
+    block[event].push(GROUPED.has(event) ? (matcher === undefined ? { hooks: [handler] } : { matcher, hooks: [handler] }) : handler);
+  }
+  for (const [event, groups] of Object.entries(I.extraGroups(ctx))) {
+    (block[event] = block[event] || []).push(...groups);
+  }
+
+  // A previous installer wrote a flat `{"preToolUse": "<command>"}` shape here.
+  // It is not ours, so it is left byte for byte and only reported.
+  for (const [name, value] of Object.entries(config)) {
+    if (name === hookName()) continue;
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      dropped.push({ item: `hooks.json key "${name}"`, reason: 'not a named-hook object (legacy installer format); left untouched because the harness does not own it' });
+    }
+  }
+
+  I.owned(ctx, 'hooks'); // initialise this target's ownership record
+  if (Object.keys(block).length) config[hookName()] = block;
+  else delete config[hookName()];
+  const res = I.writeUserJson(ctx, file, config);
+  if (!ctx.check && !ctx.dryRun) ctx.state.owned[ctx.target.id].hooks = Object.keys(block).length ? [hookName()] : [];
+  const entries = Object.values(block).reduce((n, list) => n + list.length, 0);
+  return I.result(ctx, [{ path: file, action: res.action }], dropped, `${entries} chained entr(ies) under the "${hookName()}" hook`);
+}
+
+module.exports = Object.assign({}, generic, { id: 'agy', hooks });

package/src/harness/vendor/agnostic-ai/engine/harness/targets/claude.cjs

@@ -0,0 +1,158 @@
+/**
+ * engine/harness/targets/claude.cjs — Claude Code as a TARGET.
+ *
+ * The reverse direction: a harness captured from another client (Codex, say)
+ * rendered back into ~/.claude. Claude Code's dialect is the bundle's own
+ * dialect, so hooks and matcher tokens need no shim and almost no translation.
+ *
+ * Surfaces written here:
+ *   ~/.claude/agnostic-rules.md  the agreement (plus the @import line in CLAUDE.md)
+ *   ~/.claude/SOUL.md            identity
+ *   ~/.claude/settings.json      hooks + permissions (managed keys, user keys kept)
+ *   ~/.claude.json               mcpServers
+ *   ~/.claude/agents/*.md        subagents
+ *   ~/.claude/commands/*.md      slash commands
+ *   ~/.claude/skills/<name>      junctions to the captured skills
+ */
+
+const path = require('path');
+const common = require('../common.cjs');
+const bundleLib = require('../bundle.cjs');
+const generic = require('./generic.cjs');
+
+const I = generic._internals;
+
+// Codex renames the edit tool; every other Claude matcher token round-trips.
+const MATCHER_MAP = { apply_patch: 'Edit|Write', spawn_agent: 'Agent', wait_agent: 'Agent' };
+
+/** `@~/.claude/agnostic-rules.md` — present in any spelling that resolves to the rules file. */
+function importsRules(text, rulesFile, home) {
+  const want = path.resolve(rulesFile).toLowerCase();
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const m = /^@(\S+)\s*$/.exec(line.trim());
+    if (m && path.resolve(common.expandPath(m[1], home)).toLowerCase() === want) return true;
+  }
+  return false;
+}
+
+function rules(ctx) {
+  const base = generic.rules(ctx);
+  if (base.status === 'unsupported' || base.status === 'error') return base;
+
+  const rulesFile = I.at(ctx, ctx.target.rulesFile);
+  // beside the client's configured home (CLAUDE_CONFIG_DIR moves it), not a hardcoded ~/.claude
+  const claudeMd = path.join(I.at(ctx, ctx.target.home) || path.join(ctx.home, '.claude'), 'CLAUDE.md');
+  const importLine = `@${common.tildePath(rulesFile, ctx.home)}`;
+  const existing = common.readText(claudeMd);
+
+  if (existing !== null && importsRules(existing, rulesFile, ctx.home)) {
+    base.files.push({ path: claudeMd, action: 'unchanged' });
+    return I.result(ctx, base.files, base.dropped, base.note);
+  }
+  // Never rewrite what is already there: append the import, or create the
+  // smallest file that loads the agreement.
+  const next = existing === null
+    ? `# CLAUDE.md\n\n${importLine}\n`
+    : `${existing.replace(/\s*$/, '')}\n\n${importLine}\n`;
+  const res = ctx.write(claudeMd, next, { region: true });
+  base.files.push({ path: claudeMd, action: res.action });
+  return I.result(ctx, base.files, base.dropped, `added ${importLine} to CLAUDE.md`);
+}
+
+function hooks(ctx) {
+  const file = I.at(ctx, ctx.target.hooksConfigFile);
+  if (!file) return I.unsupported('no hooks config file in the target registry');
+  const settings = I.readUserJson(file);
+  if (settings === null) return { status: 'error', files: [{ path: file, action: 'unchanged' }], dropped: [], error: `${common.tildePath(file, ctx.home)} is not valid JSON; nothing was written` };
+
+  const dropped = [];
+  const next = {};
+  for (const [event, groups] of Object.entries(ctx.bundle.hooks.events || {})) {
+    for (const group of groups || []) {
+      const { kept, dropped: gone } = I.portedHandlers(ctx, event, group);
+      dropped.push(...gone);
+      if (!kept.length) continue;
+      const matcher = I.translateMatcher(group.matcher, MATCHER_MAP, { keepUnknown: true });
+      if (matcher === null) { dropped.push({ item: `${event} [${group.matcher}]`, reason: 'every tool token in the matcher was dropped' }); continue; }
+      const out = matcher === undefined ? { hooks: kept } : { matcher, hooks: kept };
+      (next[event] = next[event] || []).push(out);
+    }
+  }
+  for (const [event, groups] of Object.entries(I.extraGroups(ctx))) {
+    (next[event] = next[event] || []).push(...groups);
+  }
+
+  settings.hooks = settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks) ? settings.hooks : {};
+  const keys = I.applyOwnedGroups(settings.hooks, I.owned(ctx, 'hooks'), next);
+  if (!Object.keys(settings.hooks).length) delete settings.hooks;
+  const res = I.writeUserJson(ctx, file, settings);
+  if (!ctx.check && !ctx.dryRun) ctx.state.owned[ctx.target.id].hooks = keys;
+  return I.result(ctx, [{ path: file, action: res.action }], dropped, `${keys.length} hook group(s) in settings.json`);
+}
+
+function permissions(ctx) {
+  const file = I.at(ctx, ctx.target.hooksConfigFile);
+  if (!file) return I.unsupported('no settings.json in the target registry');
+  const settings = I.readUserJson(file);
+  if (settings === null) return { status: 'error', files: [{ path: file, action: 'unchanged' }], dropped: [], error: `${common.tildePath(file, ctx.home)} is not valid JSON; nothing was written` };
+
+  settings.permissions = settings.permissions && typeof settings.permissions === 'object' ? settings.permissions : {};
+  const previous = new Set(I.owned(ctx, 'permissions'));
+  const keys = [];
+  for (const bucket of ['allow', 'deny', 'ask']) {
+    const wanted = ctx.bundle.permissions[bucket] || [];
+    const current = Array.isArray(settings.permissions[bucket]) ? settings.permissions[bucket] : [];
+    // Drop what we put there last time, keep everything the user added, re-add ours.
+    const merged = current.filter((e) => !previous.has(`${bucket}:${e}`));
+    for (const entry of wanted) {
+      if (!merged.includes(entry)) merged.push(entry);
+      keys.push(`${bucket}:${entry}`);
+    }
+    if (merged.length) settings.permissions[bucket] = merged;
+    else delete settings.permissions[bucket];
+  }
+  if (!Object.keys(settings.permissions).length) delete settings.permissions;
+  const res = I.writeUserJson(ctx, file, settings);
+  if (!ctx.check && !ctx.dryRun) ctx.state.owned[ctx.target.id].permissions = keys;
+  return I.result(ctx, [{ path: file, action: res.action }], [], `${keys.length} permission entr(ies)`);
+}
+
+// Claude Code enforces read-only through the `tools` list, not through a flag.
+// A source that only knows a sandbox mode (Codex: sandbox_mode = "read-only")
+// therefore has to be given a concrete list, or the ported agent would silently
+// gain write tools it did not have. This is the set this repo's own read-only
+// agents carry.
+const READONLY_TOOLS = 'Read, Grep, Glob';
+
+function agents(ctx) {
+  const dir = I.at(ctx, ctx.target.agentsDir);
+  if (!dir) return I.unsupported('client has no subagent directory');
+  let derived = 0;
+  const { files, dropped } = I.renderMarkdownDir(ctx, 'agents', dir, ctx.bundle.agents, (a) => {
+    const readonly = String(a.meta.readonly) === 'true';
+    if (readonly && !a.meta.tools) derived++;
+    return {
+      name: a.name,
+      description: a.meta.description,
+      model: bundleLib.modelTier(a.meta.model || 'inherit'),
+      ...(a.meta.tools ? { tools: a.meta.tools } : readonly ? { tools: READONLY_TOOLS } : {}),
+      ...(readonly ? { readonly: true } : {}),
+    };
+  });
+  return I.result(ctx, files, dropped, derived ? `${derived} read-only agent(s) given the tools list "${READONLY_TOOLS}"` : undefined);
+}
+
+function commands(ctx) {
+  const dir = I.at(ctx, ctx.target.commandsDir);
+  if (!dir) return I.unsupported('client has no slash-command directory');
+  const { files, dropped } = I.renderMarkdownDir(ctx, 'commands', dir, ctx.bundle.commands, (c) => ({
+    description: c.meta.description,
+    ...(c.meta['argument-hint'] ? { 'argument-hint': c.meta['argument-hint'] } : {}),
+  }));
+  return I.result(ctx, files, dropped);
+}
+
+module.exports = Object.assign({}, generic, {
+  id: 'claude',
+  rules, hooks, permissions, agents, commands,
+});