@ucsandman/legcli 0.8.0 → 0.10.0

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

@@ -0,0 +1,330 @@
+/**
+ * engine/harness/sources/claude.cjs — capture the Claude Code harness into the
+ * client-neutral bundle.
+ *
+ * Claude Code is the canonical dialect (hook events, tool names, matcher syntax),
+ * so capture is a read + normalise, not a translation. Capture is COMPLETE: every
+ * hook, skill and server the client has lands in the bundle. What a given target
+ * refuses to carry is that target's decision, made in targets/<id>.cjs from
+ * core/port.json, so `explain` can name the client that dropped it.
+ *
+ * Nothing here is machine-specific: every path comes from `home` or from the
+ * expanded `claude` entry of core/templates/targets.json.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const common = require('../common.cjs');
+const bundleLib = require('../bundle.cjs');
+
+const ID = 'claude';
+const EDIT_TOOLS = /^(?:Edit|Write|MultiEdit|NotebookEdit)$/;
+/** How many levels of `@import` are inlined: the rules file's own, plus one more. */
+const IMPORT_DEPTH = 2;
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+/** True when `child` is `parent` or lives under it (case- and separator-insensitive). */
+function inside(child, parent) {
+  if (!child || !parent) return false;
+  const c = common.plainPath(child);
+  const p = common.plainPath(parent);
+  return c === p || c.startsWith(p.endsWith('/') ? p : `${p}/`);
+}
+
+/**
+ * The registry path when there is one, else the conventional one under `home`.
+ * loadRegistry() expands every entry against the home it is given, and a host
+ * may point a client at a config dir outside that home (CLAUDE_CONFIG_DIR):
+ * that path is the one to read, never a silent fallback to ~/.claude.
+ */
+const pick = (registryPath, fallback) => (registryPath ? registryPath : fallback);
+
+function surfaces(home, target = {}) {
+  const claudeDir = pick(target.home, path.join(home, '.claude'));
+  return {
+    claudeDir,
+    rulesFile: path.join(claudeDir, 'CLAUDE.md'),
+    identityFile: pick(target.traitsFile, path.join(claudeDir, 'SOUL.md')),
+    settingsFile: pick(target.hooksConfigFile, path.join(claudeDir, 'settings.json')),
+    agentsDir: pick(target.agentsDir, path.join(claudeDir, 'agents')),
+    commandsDir: pick(target.commandsDir, path.join(claudeDir, 'commands')),
+    skillsDir: pick(target.skillsDir, path.join(claudeDir, 'skills')),
+    mcpFile: pick(target.mcpConfigFile, path.join(home, '.claude.json')),
+    projectMcpFile: path.join(claudeDir, '.mcp.json'),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Rules: CLAUDE.md with every @import inlined
+// ---------------------------------------------------------------------------
+
+/** `@~/x`, `@C:/x`, `@./x`, `@x` -> an absolute path, resolved against the importing file's directory. */
+function resolveImport(spec, home, baseDir) {
+  if (spec === '~') return home;
+  if (spec.startsWith('~/') || spec.startsWith('~\\')) return path.join(home, spec.slice(2));
+  if (path.isAbsolute(spec)) return path.resolve(spec);
+  return path.resolve(baseDir, spec);
+}
+
+/**
+ * Drop the header a generated file opens with: the `# Title` line and, when the
+ * next non-blank line announces it, the `GENERATED ...` provenance line. The
+ * bundle carries one agreement, not a stack of per-file title pages.
+ */
+function stripGeneratedHeader(text) {
+  const lines = String(text).split(/\r?\n/);
+  if (!/^#\s+\S/.test(lines[0] || '')) return String(text);
+  let i = 1;
+  while (i < lines.length && lines[i].trim() === '') i++;
+  if (i < lines.length && lines[i].includes('GENERATED')) {
+    i++;
+    while (i < lines.length && lines[i].trim() === '') i++;
+  }
+  return lines.slice(i).join('\n');
+}
+
+/**
+ * Inline `@<path>` import lines. An import is followed only when the resolved
+ * file lives inside `home` or inside the repo: an agreement is allowed to be
+ * assembled from the user's own harness and from this repo, and from nothing
+ * else, because the result is copied verbatim into every other client.
+ */
+function inlineImports(text, { home, baseDir, level, warnings, where }) {
+  const out = [];
+  for (const line of String(text).split(/\r?\n/)) {
+    const m = line.match(/^@(\S+)[ \t]*$/);
+    if (!m) { out.push(line); continue; }
+    const spec = m[1];
+    const resolved = resolveImport(spec, home, baseDir);
+    if (level <= 0) {
+      warnings.push(`${where}: import ${spec} is nested deeper than ${IMPORT_DEPTH} levels; the line was dropped`);
+      continue;
+    }
+    if (!inside(resolved, home) && !common.importRoots().some((root) => inside(resolved, root))) {
+      warnings.push(`${where}: import ${spec} resolves outside the home directory and outside the allowed import roots; the line was dropped`);
+      continue;
+    }
+    const raw = common.readText(resolved);
+    if (raw == null) {
+      warnings.push(`${where}: import ${spec} does not exist (${common.tildePath(resolved, home)}); the line was dropped`);
+      continue;
+    }
+    const body = inlineImports(stripGeneratedHeader(raw), {
+      home,
+      baseDir: path.dirname(resolved),
+      level: level - 1,
+      warnings,
+      where: common.tildePath(resolved, home),
+    });
+    out.push(body.trim());
+  }
+  return out.join('\n');
+}
+
+function captureRules(paths, home, warnings) {
+  const raw = common.readText(paths.rulesFile);
+  if (raw == null) throw new Error(`Claude Code rules file not found: ${paths.rulesFile}`);
+  let body = inlineImports(raw, {
+    home,
+    baseDir: path.dirname(paths.rulesFile),
+    level: IMPORT_DEPTH,
+    warnings,
+    where: common.tildePath(paths.rulesFile, home),
+  });
+  body = body.replace(/^#\s*CLAUDE\.md[^\n]*\r?\n+/m, '');
+  return body.replace(/\n{3,}/g, '\n\n').trim();
+}
+
+// ---------------------------------------------------------------------------
+// Hooks: settings.json -> the canonical dialect, copied as-is
+// ---------------------------------------------------------------------------
+function captureHooks(settings, warnings) {
+  const events = {};
+  const src = (settings && settings.hooks) || {};
+  if (Array.isArray(src) || typeof src !== 'object') {
+    warnings.push('settings.json: hooks is not an object; no hooks captured');
+    return events;
+  }
+  for (const [event, groups] of Object.entries(src)) {
+    if (!Array.isArray(groups)) {
+      warnings.push(`settings.json: hooks.${event} is not an array; skipped`);
+      continue;
+    }
+    const kept = [];
+    for (const group of groups) {
+      const handlers = [];
+      for (const h of (group && group.hooks) || []) {
+        if (!h || h.type !== 'command' || typeof h.command !== 'string' || !h.command.trim()) continue;
+        const out = { type: 'command', command: h.command };
+        if (h.timeout != null) out.timeout = h.timeout;
+        if (h.statusMessage) out.statusMessage = h.statusMessage;
+        if (h.async) out.async = true;
+        handlers.push(out);
+      }
+      if (!handlers.length) continue;
+      const out = {};
+      if (group.matcher != null && group.matcher !== '') out.matcher = group.matcher;
+      out.hooks = handlers;
+      kept.push(out);
+    }
+    if (kept.length) events[event] = kept;
+  }
+  return events;
+}
+
+// ---------------------------------------------------------------------------
+// MCP: ~/.claude.json (+ ~/.claude/.mcp.json) -> the neutral server shape
+// ---------------------------------------------------------------------------
+const TRANSPORTS = ['stdio', 'http', 'sse'];
+
+function captureServers(source, into, warnings, origin) {
+  for (const [server, raw] of Object.entries(source || {})) {
+    if (!raw || typeof raw !== 'object') continue;
+    if (Object.prototype.hasOwnProperty.call(into, server)) {
+      warnings.push(`MCP server ${server}: also defined in ${origin}; the first definition wins`);
+      continue;
+    }
+    const declared = String(raw.type || '').toLowerCase();
+    const transport = TRANSPORTS.includes(declared) ? declared : (raw.url ? 'http' : 'stdio');
+    if (raw.type && !TRANSPORTS.includes(declared)) {
+      warnings.push(`MCP server ${server}: unknown type "${raw.type}"; captured as ${transport}`);
+    }
+    // A value that looks like a credential never enters the bundle: the bundle is
+    // copied into every client's config, so one token here becomes N tokens on disk.
+    const scrub = (obj, kind) => {
+      if (!obj || typeof obj !== 'object') return undefined;
+      const out = {};
+      for (const [k, v] of Object.entries(obj)) {
+        if (common.looksSecret(k, v)) {
+          out[k] = `\${${k}}`;
+          warnings.push(`MCP server ${server}: ${kind} ${k} looks like a secret; it stays out of the bundle, export ${k} in the environment of each client`);
+        } else {
+          out[k] = v;
+        }
+      }
+      return Object.keys(out).length ? out : undefined;
+    };
+    const entry = { transport };
+    if (transport === 'stdio') {
+      if (raw.command) entry.command = raw.command;
+      if (Array.isArray(raw.args) && raw.args.length) entry.args = raw.args.slice();
+      if (raw.cwd) entry.cwd = raw.cwd;
+    } else if (raw.url) {
+      entry.url = raw.url;
+    }
+    const env = scrub(raw.env, 'env');
+    if (env) entry.env = env;
+    const headers = scrub(raw.headers, 'header');
+    if (headers) entry.headers = headers;
+    into[server] = entry;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Agents, commands, skills, permissions
+// ---------------------------------------------------------------------------
+function markdownFiles(dir, skip = []) {
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return []; }
+  return entries
+    .filter((e) => !e.isDirectory() && e.name.endsWith('.md') && !skip.includes(e.name))
+    .map((e) => e.name)
+    .sort();
+}
+
+function captureAgents(dir, warnings) {
+  const agents = [];
+  for (const file of markdownFiles(dir)) {
+    const { meta, body } = common.parseFrontmatter(common.readText(path.join(dir, file)) || '');
+    const name = meta.name || file.replace(/\.md$/, '');
+    const tools = typeof meta.tools === 'string' ? meta.tools.trim() : '';
+    const toolList = tools ? tools.split(',').map((t) => t.trim()).filter(Boolean) : [];
+    // A missing `tools` field means "every tool", which includes the edit tools.
+    const readonly = toolList.length > 0 && !toolList.some((t) => EDIT_TOOLS.test(t));
+    if (!meta.description) warnings.push(`agent ${name}: no description in the frontmatter; the agent name is used instead`);
+    const out = {
+      name,
+      description: meta.description || name,
+      model: bundleLib.modelTier(meta.model || 'inherit'),
+    };
+    if (tools) out.tools = tools;
+    if (readonly) out.readonly = true; // omitted when false: `readonly: false` reloads as the string "false"
+    agents.push({ name, meta: out, body: String(body).trim() });
+  }
+  return agents;
+}
+
+function captureCommands(dir) {
+  const commands = [];
+  for (const file of markdownFiles(dir, ['README.md'])) {
+    const { meta, body } = common.parseFrontmatter(common.readText(path.join(dir, file)) || '');
+    const out = {};
+    if (meta.description) out.description = meta.description;
+    if (meta['argument-hint']) out['argument-hint'] = meta['argument-hint'];
+    commands.push({ name: file.replace(/\.md$/, ''), meta: out, body: String(body).trim() });
+  }
+  return commands;
+}
+
+function captureSkills(dir, warnings) {
+  const out = [];
+  for (const skill of common.listSkills(dir)) {
+    // Targets link the REAL directory: a chain of links through one client's
+    // skills dir dies the moment that client is uninstalled.
+    let real = skill.path;
+    try { real = fs.realpathSync(skill.path).replace(/^\\\\\?\\/, ''); } catch (err) {
+      warnings.push(`skill ${skill.name}: could not resolve its real directory (${err.message}); using ${skill.path}`);
+    }
+    out.push({ name: skill.name, path: real });
+  }
+  return out;
+}
+
+const stringList = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : []);
+
+// ---------------------------------------------------------------------------
+function capture({ home, target = {}, port } = {}) {
+  void port; // capture is complete; exclusions are a per-target apply decision
+  if (!home) throw new Error('capture({ home }) needs a home directory');
+  const warnings = [];
+  const paths = surfaces(home, target);
+  const b = bundleLib.createBundle(ID, home);
+
+  b.rules = captureRules(paths, home, warnings);
+
+  const identity = common.readText(paths.identityFile);
+  if (identity != null) b.identity = identity.trim();
+
+  const settings = common.readJSON(paths.settingsFile);
+  if (settings === undefined) warnings.push(`${common.tildePath(paths.settingsFile, home)} is not valid JSON; no hooks or permissions captured`);
+  b.hooks.events = captureHooks(settings, warnings);
+
+  const rootMcp = common.readJSON(paths.mcpFile);
+  if (rootMcp === undefined) warnings.push(`${common.tildePath(paths.mcpFile, home)} is not valid JSON; no MCP servers captured from it`);
+  captureServers(rootMcp && rootMcp.mcpServers, b.mcp.servers, warnings, common.tildePath(paths.mcpFile, home));
+  const projectMcp = common.readJSON(paths.projectMcpFile);
+  if (projectMcp === undefined) warnings.push(`${common.tildePath(paths.projectMcpFile, home)} is not valid JSON; skipped`);
+  captureServers(projectMcp && projectMcp.mcpServers, b.mcp.servers, warnings, common.tildePath(paths.projectMcpFile, home));
+
+  b.agents = captureAgents(paths.agentsDir, warnings);
+  b.commands = captureCommands(paths.commandsDir);
+  b.skills.sourceDir = paths.skillsDir;
+  b.skills.skills = captureSkills(paths.skillsDir, warnings);
+
+  const permissions = (settings && settings.permissions) || {};
+  b.permissions = {
+    allow: stringList(permissions.allow),
+    deny: stringList(permissions.deny),
+    ask: stringList(permissions.ask),
+  };
+
+  // Report, never throw: capture must show what it found even when one surface is
+  // malformed, or the operator cannot see which surface to fix.
+  for (const problem of bundleLib.validate(b)) warnings.push(`bundle: ${problem}`);
+  return { bundle: b, warnings };
+}
+
+module.exports = { id: ID, capture };

package/src/harness/vendor/agnostic-ai/engine/harness/sources/codex.cjs

@@ -0,0 +1,314 @@
+/**
+ * engine/harness/sources/codex.cjs — capture the Codex CLI harness into the bundle.
+ *
+ * Reads the live ~/.codex config, never a memory of it:
+ *
+ *   AGENTS.md      the agreement (a generated file is stripped back to its body)
+ *   config.toml    hooks.<Event> groups and mcp_servers.<name>
+ *   agents/*.toml  subagents (model slug -> the tier that owns it in core/port.json)
+ *   prompts/*.md   slash commands
+ *   skills/        real skill dirs and links, resolved to their real paths
+ *   rules/*.rules  prefix_rule approvals -> Claude permission patterns
+ *
+ * Codex's hook dialect is a near clone of Claude Code's, which is the bundle's
+ * dialect, so hooks come across almost verbatim; only the tool matcher tokens
+ * differ (`apply_patch` is Codex's edit tool).
+ *
+ * Never throws on a missing optional surface. Throws only when AGENTS.md is
+ * missing, because without the agreement there is no harness to port.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const common = require('../common.cjs');
+const bundleLib = require('../bundle.cjs');
+const toml = require('../toml.cjs');
+
+// Codex matcher token -> the Claude tool names the bundle speaks. null = drop.
+const MATCHER_BACK = {
+  apply_patch: 'Edit|Write',
+  spawn_agent: null,
+  wait_agent: null,
+};
+
+const HANDLER_FIELDS = ['timeout', 'statusMessage', 'async'];
+
+const isPlainObject = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+
+// ---------------------------------------------------------------------------
+// Rules and identity
+// ---------------------------------------------------------------------------
+
+/**
+ * A generated AGENTS.md is `<preamble> --- # The agreement <body> --- # Identity
+ * (from SOUL.md) <soul> <!-- generated ... -->`. Give back the two halves with
+ * the generated scaffolding removed; a hand-written AGENTS.md comes back whole.
+ */
+function splitAgentsMd(text) {
+  const head = String(text).split(/\r?\n/).slice(0, 10).join('\n');
+  // Any generator's claim counts (this repo's, a host product's, the legacy sync): the scaffolding has one shape.
+  if (!/GENERATED by |harness-sync/i.test(head)) return { rules: String(text).trim(), identity: '' };
+
+  let body = String(text);
+  const agreement = body.search(/^# The agreement[ \t]*$/m);
+  if (agreement !== -1) body = body.slice(agreement).replace(/^# The agreement[ \t]*\r?\n/, '');
+
+  let identity = '';
+  const identityAt = body.search(/^# Identity\b/m);
+  if (identityAt !== -1) {
+    identity = body.slice(identityAt).replace(/^# Identity[^\n]*\r?\n/, '');
+    body = body.slice(0, identityAt);
+  }
+  const stamp = /<!--[^>]*generated by[^>]*-->/i;
+  identity = identity.replace(stamp, '');
+  body = body.replace(stamp, '');
+  // The generator separates the sections with a `---` rule; drop the trailing one.
+  const trim = (s) => s.replace(/^\s*(?:---[ \t]*\r?\n)?/, '').replace(/\s*(?:\r?\n---[ \t]*)?\s*$/, '').trim();
+  return { rules: trim(body), identity: trim(identity) };
+}
+
+// ---------------------------------------------------------------------------
+// Hooks
+// ---------------------------------------------------------------------------
+
+function matcherBack(matcher) {
+  if (matcher == null || matcher === '' || matcher === '*') return undefined;
+  const out = [];
+  for (const token of String(matcher).split('|')) {
+    const mapped = Object.prototype.hasOwnProperty.call(MATCHER_BACK, token) ? MATCHER_BACK[token] : token;
+    if (!mapped) continue;
+    for (const t of String(mapped).split('|')) if (!out.includes(t)) out.push(t);
+  }
+  return out.length ? out.join('|') : null;
+}
+
+function captureHooks(config, warnings) {
+  const events = {};
+  for (const [event, groups] of Object.entries((config && config.hooks) || {})) {
+    // `hooks.state` holds Codex's trust table, not hook definitions.
+    if (!Array.isArray(groups)) continue;
+    for (const group of groups) {
+      if (!isPlainObject(group) || !Array.isArray(group.hooks)) continue;
+      const matcher = matcherBack(group.matcher);
+      if (matcher === null) { warnings.push(`hooks.${event} [${group.matcher}]: every Codex tool token is Codex-only; group skipped`); continue; }
+      const handlers = [];
+      for (const h of group.hooks) {
+        if (!isPlainObject(h) || h.type !== 'command' || typeof h.command !== 'string' || !h.command) continue;
+        const out = { type: 'command', command: h.command };
+        for (const f of HANDLER_FIELDS) if (h[f] !== undefined && h[f] !== null) out[f] = h[f];
+        handlers.push(out);
+      }
+      if (!handlers.length) continue;
+      const entry = matcher === undefined ? { hooks: handlers } : { matcher, hooks: handlers };
+      (events[event] = events[event] || []).push(entry);
+    }
+  }
+  return events;
+}
+
+// ---------------------------------------------------------------------------
+// MCP servers
+// ---------------------------------------------------------------------------
+
+function captureMcp(config, warnings) {
+  const servers = {};
+  for (const [name, raw] of Object.entries((config && config.mcp_servers) || {})) {
+    if (!isPlainObject(raw)) continue;
+    if (!/^[A-Za-z0-9_.-]+$/.test(name)) { warnings.push(`mcp server "${name}" is not a safe identifier; skipped`); continue; }
+
+    const scrub = (bag, kind) => {
+      const out = {};
+      for (const [k, v] of Object.entries(bag || {})) {
+        if (common.looksSecret(k, v)) {
+          out[k] = `\${${k}}`;
+          warnings.push(`mcp.${name}.${kind}.${k} looked like a live credential; captured as \${${k}} — export it yourself`);
+        } else {
+          out[k] = typeof v === 'string' ? v : String(v);
+        }
+      }
+      return out;
+    };
+
+    if (raw.url) {
+      const headers = scrub(raw.http_headers, 'headers');
+      // `env_http_headers` maps a header name to the env var holding its value.
+      for (const [header, envVar] of Object.entries(raw.env_http_headers || {})) headers[header] = `\${${envVar}}`;
+      const server = { transport: 'http', url: String(raw.url) };
+      if (Object.keys(headers).length) server.headers = headers;
+      servers[name] = server;
+      continue;
+    }
+    if (!raw.command) { warnings.push(`mcp.${name} has neither a command nor a url; skipped`); continue; }
+
+    const env = scrub(raw.env, 'env');
+    // `env_vars` names variables Codex forwards from the ambient environment.
+    for (const v of raw.env_vars || []) env[String(v)] = `\${${v}}`;
+    const server = { transport: 'stdio', command: String(raw.command) };
+    if (Array.isArray(raw.args) && raw.args.length) server.args = raw.args.map(String);
+    if (Object.keys(env).length) server.env = env;
+    if (raw.cwd) server.cwd = String(raw.cwd);
+    servers[name] = server;
+  }
+  return servers;
+}
+
+// ---------------------------------------------------------------------------
+// Agents
+// ---------------------------------------------------------------------------
+
+/** The tier whose ladder entry in core/port.json owns this Codex model slug. */
+function tierForModel(port, slug) {
+  const ladder = ((port.agents && port.agents.modelLadder) || {}).codex || {};
+  for (const [tier, entry] of Object.entries(ladder)) {
+    if (Array.isArray(entry) && String(entry[0]) === String(slug)) return tier;
+  }
+  return slug;
+}
+
+function captureAgents(dir, port, warnings) {
+  const agents = [];
+  let files;
+  try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.toml')).sort(); } catch (_) { return agents; }
+  for (const file of files) {
+    const text = common.readText(path.join(dir, file));
+    if (text == null) continue;
+    const { data, warnings: tomlWarnings } = toml.parse(text);
+    for (const w of tomlWarnings) warnings.push(`agents/${file}: ${w}`);
+    const name = String(data.name || file.replace(/\.toml$/, ''));
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) { warnings.push(`agent "${name}" (${file}) is not kebab-case; skipped`); continue; }
+
+    // The generator prefixes the instructions with a "Generated from ... by ..."
+    // paragraph describing the Codex port. That is scaffolding, not the role.
+    let body = String(data.developer_instructions || '').replace(/^\s+/, '');
+    if (/^Generated from /.test(body)) body = body.replace(/^Generated from [\s\S]*?(?:\r?\n[ \t]*\r?\n|$)/, '');
+
+    agents.push({
+      name,
+      meta: {
+        name,
+        description: String(data.description || name),
+        model: tierForModel(port, data.model || 'inherit'),
+        readonly: data.sandbox_mode === 'read-only' ? 'true' : undefined,
+      },
+      body: body.trim(),
+    });
+  }
+  return agents;
+}
+
+// ---------------------------------------------------------------------------
+// Commands, skills, permissions
+// ---------------------------------------------------------------------------
+
+function captureCommands(dir) {
+  const commands = [];
+  let files;
+  try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.md') && f !== 'README.md').sort(); } catch (_) { return commands; }
+  for (const file of files) {
+    const text = common.readText(path.join(dir, file));
+    if (text == null) continue;
+    const { meta, body } = common.parseFrontmatter(text);
+    const name = file.replace(/\.md$/, '');
+    if (!/^[A-Za-z0-9_-]+$/.test(name)) continue;
+    commands.push({
+      name,
+      meta: { description: meta.description || name, 'argument-hint': meta['argument-hint'] },
+      body: body.trim(),
+    });
+  }
+  return commands;
+}
+
+function captureSkills(dir, warnings) {
+  const skills = [];
+  for (const skill of common.listSkills(dir)) {
+    if (!/^[A-Za-z0-9_.-]+$/.test(skill.name)) { warnings.push(`skill "${skill.name}" is not a safe directory name; skipped`); continue; }
+    let real = skill.path;
+    try { real = fs.realpathSync(skill.path); } catch (_) { /* keep the entry path */ }
+    skills.push({ name: skill.name, path: real });
+  }
+  return skills;
+}
+
+const RULE_DECISION = { allow: 'allow', forbidden: 'deny', prompt: 'ask' };
+const ABSOLUTE = /^(?:[A-Za-z]:[\\/]|\/)/;
+
+/**
+ * `prefix_rule(pattern=["git", "status"], decision="allow")` -> `Bash(git status *)`.
+ *
+ * Codex also records every one-off shell approval here, as an absolute path to
+ * the interpreter plus the whole command line. Those are per-invocation grants
+ * for one machine, not policy, and there are hundreds of them, so a pattern
+ * whose first token is an absolute path is counted and skipped.
+ */
+function capturePermissions(dir, warnings) {
+  const permissions = { allow: [], deny: [], ask: [] };
+  let files;
+  try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.rules')).sort(); } catch (_) { return permissions; }
+  let skippedAbsolute = 0;
+  for (const file of files) {
+    const text = common.readText(path.join(dir, file));
+    if (text == null) continue;
+    for (const line of text.split(/\r?\n/)) {
+      const m = /^prefix_rule\(pattern=(\[[\s\S]*\]),\s*decision="([a-z_]+)"\)\s*$/.exec(line.trim());
+      if (!m) continue;
+      const bucket = RULE_DECISION[m[2]];
+      if (!bucket) continue;
+      let pattern;
+      try { pattern = JSON.parse(m[1]); } catch (_) { continue; }
+      if (!Array.isArray(pattern) || !pattern.length || typeof pattern[0] !== 'string') continue;
+      if (ABSOLUTE.test(pattern[0])) { skippedAbsolute++; continue; }
+      const entry = `Bash(${pattern.join(' ')} *)`;
+      if (!permissions[bucket].includes(entry)) permissions[bucket].push(entry);
+    }
+  }
+  if (skippedAbsolute) {
+    warnings.push(`permissions: skipped ${skippedAbsolute} prefix_rule entr(ies) whose pattern starts with an absolute executable path (Codex records per-invocation shell approvals there; they are not portable policy)`);
+  }
+  return permissions;
+}
+
+// ---------------------------------------------------------------------------
+
+function capture({ home, target, port } = {}) {
+  const policy = port || {};
+  const codexHome = common.expandPath((target && target.home) || '~/.codex', home);
+  const at = (field, fallback) => common.expandPath((target && target[field]) || fallback, home);
+
+  const rulesFile = at('rulesFile', path.join(codexHome, 'AGENTS.md'));
+  const rulesText = common.readText(rulesFile);
+  if (rulesText == null) throw new Error(`Codex rules file not found: ${rulesFile}`);
+
+  const warnings = [];
+  const bundle = bundleLib.createBundle('codex', codexHome);
+
+  const split = splitAgentsMd(rulesText);
+  bundle.rules = split.rules;
+  bundle.identity = split.identity;
+
+  const configFile = at('hooksConfigFile', path.join(codexHome, 'config.toml'));
+  const configText = common.readText(configFile);
+  let config = {};
+  if (configText == null) warnings.push(`${common.tildePath(configFile, home)} not found; no hooks and no MCP servers captured`);
+  else {
+    const parsed = toml.parse(configText);
+    config = parsed.data;
+    for (const w of parsed.warnings) warnings.push(`config.toml: ${w}`);
+  }
+
+  bundle.hooks = { dialect: 'claude', events: captureHooks(config, warnings) };
+  bundle.mcp = { servers: captureMcp(config, warnings) };
+  bundle.agents = captureAgents(at('agentsDir', path.join(codexHome, 'agents')), policy, warnings);
+  bundle.commands = captureCommands(at('commandsDir', path.join(codexHome, 'prompts')));
+
+  const skillsDir = at('skillsDir', path.join(codexHome, 'skills'));
+  bundle.skills = { sourceDir: skillsDir, skills: captureSkills(skillsDir, warnings) };
+
+  const permissionsFile = (target && target.permissionsFile) ? common.expandPath(target.permissionsFile, home) : path.join(codexHome, 'rules', 'x.rules');
+  bundle.permissions = capturePermissions(path.dirname(permissionsFile), warnings);
+
+  bundle.manifest.components = bundleLib.counts(bundle);
+  return { bundle, warnings };
+}
+
+module.exports = { id: 'codex', capture, splitAgentsMd, matcherBack, tierForModel };