@bugb-technologies/bravos 0.0.0-stage → 1.0.0

package/dist/migrate.js

@@ -0,0 +1,275 @@
+// @comment -- "Moves an install made under the old name (joseph: .joseph/, joseph-* skills, .omp and .opencode joseph.js) to the bravos layout before init or sync writes the new one. Generated files are removed only when their content still matches the old lock, so an edited skill or hook is kept and named; reports, SAST runs, the watch log, workspace snapshots and review answers are moved, never deleted. Idempotent: a root with no trace of the old name is left untouched and reports null."
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { sha256 } from './lock.js';
+export const OLD_NAME = 'joseph';
+export const OLD_DIR = `.${OLD_NAME}`;
+/** Hook commands the old name registered; the new registrations list them as superseded. */
+export const OLD_HOOK_COMMANDS = {
+    sessionStart: `node ${OLD_DIR}/hooks/session-start.mjs`,
+    prePr: `node ${OLD_DIR}/hooks/pre-pr.mjs`,
+    autopilot: `node ${OLD_DIR}/hooks/autopilot.mjs`,
+};
+export const oldGlobalHookCommand = (home, harness) => `node "${home}/${OLD_DIR}/hooks/session-start.mjs" --harness ${harness} --global`;
+/** Data the old install kept beside its hooks: moved to the same place under .bravos/. */
+const DATA_DIRS = ['reports', 'sast', 'watch', 'workspace', 'review'];
+/** The Python bravos CLI's skills lock (`bravos skills install`): sha256 hex per file, per skill. */
+const PY_SKILLS_LOCK = '.bravos-skills.lock';
+// @comment -- "Replaces the Python bravos CLI's skills that share a name with this package's (bravos-annotate, bravos-codegraph, bravos-sast) when its own lock vouches for every file, so the install that follows writes ours in their place; its other skills, and any it has edited, are left where they are and named."
+function retirePythonSkills(root, ownSkills, dryRun, report) {
+    for (const skillsRoot of ['.claude/skills', '.agents/skills']) {
+        let lock;
+        try {
+            lock = JSON.parse(readFileSync(join(root, skillsRoot, PY_SKILLS_LOCK), 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        for (const [name, entry] of Object.entries(lock.skills ?? {})) {
+            if (!ownSkills.includes(name))
+                continue;
+            const dir = join(root, skillsRoot, name);
+            let st;
+            try {
+                st = lstatSync(dir);
+            }
+            catch {
+                continue;
+            }
+            const rel = `${skillsRoot}/${name}`;
+            if (st.isSymbolicLink()) {
+                report.removed.push(`${rel} (link, python bravos)`);
+                if (!dryRun)
+                    rmSync(dir, { force: true });
+                continue;
+            }
+            const files = entry.files ?? {};
+            const vouched = readdirSync(dir).every((f) => {
+                try {
+                    return files[f] === createHash('sha256').update(readFileSync(join(dir, f))).digest('hex');
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (vouched) {
+                report.removed.push(`${rel}/ (python bravos skill of the same name)`);
+                if (!dryRun)
+                    rmSync(dir, { recursive: true, force: true });
+            }
+            else
+                report.kept.push(`${rel}/ (python bravos skill of the same name, edited; ours is skipped until you move it)`);
+        }
+    }
+}
+function oldLockFiles(root) {
+    try {
+        const p = JSON.parse(readFileSync(join(root, OLD_DIR, 'skills.lock'), 'utf8'));
+        const files = p?.files;
+        if (typeof files !== 'object' || files === null)
+            return {};
+        const out = {};
+        for (const [k, v] of Object.entries(files))
+            if (typeof v === 'string')
+                out[k] = v;
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+function pruneEmpty(root, rel) {
+    let dir = dirname(rel);
+    while (dir && dir !== '.' && dir !== '/') {
+        const abs = join(root, dir);
+        try {
+            if (!lstatSync(abs).isDirectory() || readdirSync(abs).length > 0)
+                return;
+            rmdirSync(abs);
+        }
+        catch {
+            return;
+        }
+        dir = dirname(dir);
+    }
+}
+function pythonSkillCollision(root, ownSkills) {
+    return ['.claude/skills', '.agents/skills'].some((r) => {
+        try {
+            const lock = JSON.parse(readFileSync(join(root, r, PY_SKILLS_LOCK), 'utf8'));
+            return Object.keys(lock?.skills ?? {}).some((n) => ownSkills.includes(n) && existsSync(join(root, r, n)));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function hasOldTraces(root) {
+    if (existsSync(join(root, OLD_DIR)))
+        return true;
+    for (const skillsRoot of ['.claude/skills', '.agents/skills']) {
+        try {
+            if (readdirSync(join(root, skillsRoot)).some((n) => n === OLD_NAME || n.startsWith(`${OLD_NAME}-`)))
+                return true;
+        }
+        catch {
+            /* no such root */
+        }
+    }
+    if (['.omp/extensions', '.opencode/plugins'].some((d) => existsSync(join(root, d, `${OLD_NAME}.js`))))
+        return true;
+    return OLD_NAME in agyDoc(root);
+}
+function agyDoc(root) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(root, '.agents', 'hooks.json'), 'utf8'));
+        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+// @comment -- "The migration itself. `home` marks a user-level install (~/.joseph/hooks and ~/.claude/skills/joseph-*), where the data folders do not exist and the lock is the one under the old home dir."
+export function migrateFromOldName(root, opts = {}) {
+    const ownSkills = opts.ownSkills ?? [];
+    const collision = pythonSkillCollision(root, ownSkills);
+    if (!hasOldTraces(root) && !collision)
+        return null;
+    const dryRun = !!opts.dryRun;
+    const report = { moved: [], removed: [], kept: [], notes: [] };
+    if (collision)
+        retirePythonSkills(root, ownSkills, dryRun, report);
+    if (!hasOldTraces(root)) {
+        if (report.removed.length + report.kept.length > 0)
+            report.notes.unshift(`python bravos skills of the same name: ${report.removed.length} replaced, ${report.kept.length} kept`);
+        return report;
+    }
+    const lock = oldLockFiles(root);
+    // 1. Generated files the old lock knows: skills, hook scripts, omp/opencode plugins and commands.
+    for (const [rel, hash] of Object.entries(lock)) {
+        const abs = join(root, rel);
+        let st;
+        try {
+            st = lstatSync(abs);
+        }
+        catch {
+            continue;
+        }
+        if (st.isSymbolicLink())
+            continue;
+        if (!st.isFile())
+            continue;
+        if (sha256(readFileSync(abs)) === hash) {
+            report.removed.push(rel);
+            if (!dryRun) {
+                rmSync(abs, { force: true });
+                pruneEmpty(root, rel);
+            }
+        }
+        else
+            report.kept.push(rel);
+    }
+    // 2. Old-name skill folders left after that: a link is removed; a real folder is one the lock did not
+    //    vouch for (edited, or from an install whose lock is gone) and is only ever named, never deleted.
+    for (const skillsRoot of ['.claude/skills', '.agents/skills']) {
+        let names = [];
+        try {
+            names = readdirSync(join(root, skillsRoot)).filter((n) => n === OLD_NAME || n.startsWith(`${OLD_NAME}-`));
+        }
+        catch {
+            continue;
+        }
+        for (const n of names) {
+            const dir = join(root, skillsRoot, n);
+            const rel = `${skillsRoot}/${n}`;
+            let st;
+            try {
+                st = lstatSync(dir);
+            }
+            catch {
+                continue;
+            }
+            if (st.isSymbolicLink()) {
+                report.removed.push(`${rel} (link)`);
+                if (!dryRun)
+                    rmSync(dir, { force: true });
+                continue;
+            }
+            if (dryRun && readdirSync(dir).every((f) => report.removed.includes(`${rel}/${f}`)))
+                continue;
+            if (!report.kept.some((k) => k.startsWith(`${rel}/`)))
+                report.kept.push(`${rel}/ (not vouched for by the old lock; delete or rename it by hand)`);
+        }
+    }
+    // 3. Data moves: whatever the old install kept beside its hooks.
+    const oldDir = join(root, OLD_DIR);
+    if (existsSync(oldDir)) {
+        for (const d of DATA_DIRS) {
+            const from = join(oldDir, d);
+            if (!existsSync(from))
+                continue;
+            const to = join(root, '.bravos', d);
+            if (existsSync(to)) {
+                report.kept.push(`${OLD_DIR}/${d}/ (.bravos/${d} already exists; merge by hand)`);
+                continue;
+            }
+            report.moved.push(`${OLD_DIR}/${d} → .bravos/${d}`);
+            if (!dryRun) {
+                mkdirSync(join(root, '.bravos'), { recursive: true });
+                renameSync(from, to);
+            }
+        }
+        // 4. The hook scripts and the lock are the install's own; anything else left is named, not deleted.
+        for (const own of ['hooks', 'skills.lock']) {
+            const abs = join(oldDir, own);
+            if (!existsSync(abs))
+                continue;
+            if (!report.removed.includes(`${OLD_DIR}/${own}`))
+                report.removed.push(`${OLD_DIR}/${own}`);
+            if (!dryRun)
+                rmSync(abs, { recursive: true, force: true });
+        }
+        if (!dryRun) {
+            try {
+                if (readdirSync(oldDir).length === 0)
+                    rmdirSync(oldDir);
+            }
+            catch {
+                /* keep it */
+            }
+        }
+        try {
+            const left = dryRun ? readdirSync(oldDir).filter((n) => n !== 'hooks' && n !== 'skills.lock' && !DATA_DIRS.includes(n)) : readdirSync(oldDir);
+            if (left.length)
+                report.notes.push(`${OLD_DIR}/ still holds ${left.join(', ')}; move or delete it by hand`);
+        }
+        catch {
+            /* removed */
+        }
+    }
+    // 5. Antigravity's hooks file keys its groups by name; the old name's group goes whatever harnesses are chosen now.
+    const agy = agyDoc(root);
+    if (OLD_NAME in agy) {
+        report.removed.push(`.agents/hooks.json ${OLD_NAME} group`);
+        if (!dryRun) {
+            const { [OLD_NAME]: _old, ...rest } = agy;
+            writeFileSync(join(root, '.agents', 'hooks.json'), JSON.stringify(rest, null, 2) + '\n');
+        }
+    }
+    if (report.removed.length + report.moved.length + report.kept.length > 0) {
+        report.notes.unshift(`migrated from the old name (${OLD_NAME}): ${report.removed.length} generated files removed, ${report.moved.length} folders moved, ${report.kept.length} kept`);
+    }
+    return report;
+}
+// @comment -- "Summary lines for an install moved from the old name: what was removed, moved and kept, so an edited skill or an unmerged data folder is named rather than silently left behind."
+export function reportMigration(m, lines) {
+    if (!m)
+        return;
+    for (const n of m.notes)
+        lines.push(n);
+    for (const x of m.moved)
+        lines.push(`  moved ${x}`);
+    for (const x of m.kept)
+        lines.push(`  kept ${x}`);
+}

package/dist/omp.js

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { delimiter, dirname, join } from 'node:path';
+import { readLock, sha256, writeLock } from './lock.js';
+import { templatesDir } from './paths.js';
+// @comment -- "Where bravos's omp extension lives; omp auto-loads project extensions from .omp/extensions/ in the working directory."
+export const OMP_EXTENSION_PATH = '.omp/extensions/bravos.js';
+const MANAGED = '// bravos (managed by bravos init/sync';
+// @comment -- "True when omp is in use for this repo: a .omp/ folder exists, omp is on PATH, or ~/.omp/agent exists."
+export function ompPresent(root, env) {
+    if (existsSync(join(root, '.omp')))
+        return true;
+    if ((env.PATH ?? '').split(delimiter).some((d) => d !== '' && existsSync(join(d, 'omp'))))
+        return true;
+    return !!env.HOME && existsSync(join(env.HOME, '.omp', 'agent'));
+}
+// @comment -- "Writes the omp extension that runs bravos's session start in omp, only when omp is in use; an existing file is replaced only if bravos wrote it (lock hash or managed header) unless --force, and the lock records what was written."
+export function writeOmpExtension(root, env, opts = {}) {
+    if (!opts.always && !ompPresent(root, env))
+        return { status: 'absent' };
+    const path = OMP_EXTENSION_PATH;
+    const abs = join(root, path);
+    const content = readFileSync(opts.source ?? join(templatesDir(), 'omp', 'bravos.js'));
+    const hash = sha256(content);
+    const lock = readLock(root);
+    let status = 'written';
+    if (existsSync(abs)) {
+        const disk = readFileSync(abs);
+        const diskHash = sha256(disk);
+        if (diskHash === hash)
+            return { status: 'unchanged', path };
+        const locked = lock.files[path];
+        if (locked !== undefined && diskHash !== locked && !opts.force) {
+            return { status: 'skipped', path, reason: 'edited since last install (use --force to overwrite)' };
+        }
+        if (locked === undefined && !disk.toString('utf8').startsWith(MANAGED) && !opts.force) {
+            return { status: 'skipped', path, reason: 'authored file, not managed by bravos (use --force to overwrite)' };
+        }
+        status = 'updated';
+    }
+    if (!opts.dryRun) {
+        mkdirSync(dirname(abs), { recursive: true });
+        writeFileSync(abs, content);
+        writeLock(root, { ...lock, files: { ...lock.files, [path]: hash } });
+    }
+    return { status, path };
+}

package/dist/opencode.js

@@ -0,0 +1,118 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { delimiter, dirname, join } from 'node:path';
+import { readLock, sha256, writeLock } from './lock.js';
+import { staleGraphEntry } from './mcp.js';
+import { skillsDir as bundledSkillsDir, templatesDir } from './paths.js';
+import { BravosError } from './types.js';
+// @comment -- "Where bravos's opencode files live: the plugin (session start), one command per skill (opencode lists skills only through its skill tool, not as /commands), and the project opencode.json for MCP."
+export const OPENCODE_PLUGIN_PATH = '.opencode/plugins/bravos.js';
+export const OPENCODE_COMMANDS_DIR = '.opencode/commands';
+export const OPENCODE_CONFIG = 'opencode.json';
+const MANAGED = 'bravos (managed by bravos init/sync';
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+// @comment -- "True when opencode is in use: a .opencode/ folder or opencode.json in the repo, opencode on PATH or in ~/.opencode/bin, or a ~/.config/opencode folder (a user of opencode, even mid-reinstall)."
+export function opencodePresent(root, env) {
+    if (existsSync(join(root, '.opencode')) || existsSync(join(root, OPENCODE_CONFIG)))
+        return true;
+    if ((env.PATH ?? '').split(delimiter).some((d) => d !== '' && existsSync(join(d, 'opencode'))))
+        return true;
+    const home = env.HOME;
+    return !!home && (existsSync(join(home, '.opencode', 'bin', 'opencode')) || existsSync(join(home, '.config', 'opencode')));
+}
+/** First sentence of a skill's frontmatter description, for the command's one-line summary. */
+function skillSummary(skillMd) {
+    const m = skillMd.match(/^description:\s*"?(.*?)"?\s*$/m);
+    const d = (m?.[1] ?? '').replace(/\\"/g, '"');
+    const first = d.split(/(?<=\.)\s/)[0] ?? d;
+    return first.length > 160 ? first.slice(0, 159) + '…' : first;
+}
+// @comment -- "The body of one opencode command: it asks the agent to load the bravos skill of the same name through opencode's skill tool, with the files as a fallback, and passes the user's arguments through."
+export const commandBody = (name, description) => `---
+description: ${JSON.stringify(description)}
+---
+<!-- ${MANAGED}) -->
+Load the \`${name}\` skill with the skill tool (\`skill({ name: "${name}" })\`) and follow it step by step. If the skill tool is not available, read \`.claude/skills/${name}/SKILL.md\` (or \`.agents/skills/${name}/SKILL.md\`) and follow that.
+
+$ARGUMENTS
+`;
+// @comment -- "Plans and writes the opencode integration when opencode is in use: the plugin, one command per bundled skill, and guardlink (plus cxg and codegraph when installed) under mcp in opencode.json. A file bravos did not write, or edited since, is skipped unless --force; existing MCP entries are never overwritten; a malformed opencode.json is refused before anything is written."
+export function writeOpencode(root, env, servers, opts = {}) {
+    if (!opts.always && !opencodePresent(root, env))
+        return { status: 'absent' };
+    // opencode.json first: refuse a malformed file before writing anything else.
+    const cfgAbs = join(root, OPENCODE_CONFIG);
+    let cfg = {};
+    if (existsSync(cfgAbs)) {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(cfgAbs, 'utf8'));
+        }
+        catch {
+            throw new BravosError(`${OPENCODE_CONFIG} is not valid JSON (comments are not supported here); fix it or remove it, nothing was written`);
+        }
+        if (!isObject(parsed))
+            throw new BravosError(`${OPENCODE_CONFIG} is not a JSON object; fix it or remove it, nothing was written`);
+        cfg = parsed;
+    }
+    if (cfg.mcp !== undefined && !isObject(cfg.mcp))
+        throw new BravosError(`${OPENCODE_CONFIG} has an mcp value that is not an object; fix it or remove it, nothing was written`);
+    const mcp = { ...(cfg.mcp ?? {}) };
+    const mcpAdded = Object.keys(servers).filter((n) => !Object.hasOwn(mcp, n));
+    // bravos's own codegraph entry into a replaced bravos install is refreshed; every other entry is kept.
+    const mcpStale = Object.keys(servers).filter((n) => {
+        const e = mcp[n];
+        if (!Object.hasOwn(mcp, n) || !Array.isArray(e?.command))
+            return false;
+        return staleGraphEntry(n, { command: e.command[0], args: e.command.slice(1), env: e.environment }, servers[n]);
+    });
+    for (const n of [...mcpAdded, ...mcpStale]) {
+        mcp[n] = { type: 'local', command: [servers[n].command, ...servers[n].args], enabled: true, ...(servers[n].env ? { environment: servers[n].env } : {}) };
+    }
+    const files = [];
+    files.push({ path: OPENCODE_PLUGIN_PATH, content: readFileSync(opts.plugin ?? join(templatesDir(), 'opencode', 'bravos.js')) });
+    const sdir = opts.skillsDir ?? bundledSkillsDir();
+    for (const name of readdirSync(sdir).filter((n) => existsSync(join(sdir, n, 'SKILL.md'))).sort()) {
+        const desc = skillSummary(readFileSync(join(sdir, name, 'SKILL.md'), 'utf8'));
+        files.push({ path: `${OPENCODE_COMMANDS_DIR}/${name}.md`, content: Buffer.from(commandBody(name, desc)) });
+    }
+    const lock = readLock(root);
+    const written = [];
+    const unchanged = [];
+    const skipped = [];
+    for (const f of files) {
+        const abs = join(root, f.path);
+        const hash = sha256(f.content);
+        if (existsSync(abs)) {
+            const disk = readFileSync(abs);
+            const diskHash = sha256(disk);
+            if (diskHash === hash) {
+                unchanged.push(f.path);
+                continue;
+            }
+            const locked = lock.files[f.path];
+            if (!opts.force && locked !== undefined && diskHash !== locked) {
+                skipped.push({ path: f.path, reason: 'edited since last install (use --force to overwrite)' });
+                continue;
+            }
+            if (!opts.force && locked === undefined && !disk.toString('utf8').includes(MANAGED)) {
+                skipped.push({ path: f.path, reason: 'authored file, not managed by bravos (use --force to overwrite)' });
+                continue;
+            }
+        }
+        written.push(f.path);
+        if (!opts.dryRun) {
+            mkdirSync(dirname(abs), { recursive: true });
+            writeFileSync(abs, f.content);
+            lock.files[f.path] = hash;
+        }
+    }
+    if (!opts.dryRun) {
+        writeLock(root, lock);
+        if (mcpAdded.length > 0 || mcpStale.length > 0) {
+            if (!cfg.$schema)
+                cfg = { $schema: 'https://opencode.ai/config.json', ...cfg };
+            writeFileSync(cfgAbs, JSON.stringify({ ...cfg, mcp }, null, 2) + '\n');
+        }
+    }
+    return { status: 'done', written, unchanged, skipped, mcpAdded, ...(mcpStale.length ? { mcpUpdated: mcpStale } : {}) };
+}

package/dist/paths.js

@@ -0,0 +1,33 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Walk up from this file to the first directory holding package.json (works from src/ and dist/). */
+// @comment -- "Finds the installed bravos package root by walking up to package.json, from src/ or dist/."
+export function packageRoot() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        if (existsSync(join(dir, 'package.json')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            throw new Error('package.json not found above ' + dir);
+        dir = parent;
+    }
+}
+// @comment -- "Path of the bundled skills/ directory in the bravos package."
+export function skillsDir() {
+    return join(packageRoot(), 'skills');
+}
+// @comment -- "Path of the bundled hooks/ directory in the bravos package."
+export function hooksDir() {
+    return join(packageRoot(), 'hooks');
+}
+// @comment -- "bravos's own version, read from its package.json."
+export function version() {
+    const pkg = JSON.parse(readFileSync(join(packageRoot(), 'package.json'), 'utf8'));
+    return pkg.version;
+}
+// @comment -- "Path of the bundled templates/ directory (CI workflows) in the bravos package."
+export function templatesDir() {
+    return join(packageRoot(), 'templates');
+}

package/dist/plugin.js

@@ -0,0 +1,101 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { sessionStart } from './hooks.js';
+import { SERVERS } from './mcp.js';
+import { hooksDir, version } from './paths.js';
+import { listBundledSkills, renderPluginSkillFile, renderSkillFile } from './skills.js';
+// @comment -- "The committed plugin trees (Claude Code's in plugin/, Codex's in plugin-codex/) and the two marketplace files that point at them, all repo-relative."
+export const PLUGIN_DIR = 'plugin';
+export const CODEX_PLUGIN_DIR = 'plugin-codex';
+export const CLAUDE_MARKETPLACE = '.claude-plugin/marketplace.json';
+export const CODEX_MARKETPLACE = '.agents/plugins/marketplace.json';
+const DESCRIPTION = 'Makes Claude Code and Codex power users of guardlink (threat-model-as-code) and cert-x-gen (pentest-as-code): annotate, ship, templatize, prove and recheck, in-session.';
+const AUTHOR = { name: 'BugB Technologies', url: 'https://www.bugb.io' };
+const KEYWORDS = ['security', 'threat-modeling', 'guardlink', 'pentest', 'cxg', 'skills'];
+const json = (v) => Buffer.from(JSON.stringify(v, null, 2) + '\n');
+function walk(dir) {
+    const out = [];
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const abs = join(dir, e.name);
+        if (e.isDirectory())
+            out.push(...walk(abs));
+        else if (e.isFile())
+            out.push(abs);
+    }
+    return out;
+}
+// @comment -- "Every file of both plugin builds, computed and not written. plugin/ (Claude Code): skills rendered with ${CLAUDE_SKILL_DIR} and ${CLAUDE_PLUGIN_ROOT}, the hook scripts, a Claude hooks.json, .mcp.json and .claude-plugin/plugin.json. plugin-codex/ (Codex, Agent Plugins layout): skills rendered with repo-relative .agents/skills paths, the hook scripts, hooks/hooks.json in the shape .codex/hooks.json takes with the command under ${PLUGIN_ROOT}, mcp.json and a root plugin.json. Both register SessionStart only (the pre-PR gate stays opt-in through bravos init) and the guardlink MCP server only. Plus both marketplaces."
+export function pluginFiles(opts = {}) {
+    const v = version();
+    const files = [];
+    const add = (path, content) => files.push({ path, content });
+    const skills = listBundledSkills(opts.skillsDir);
+    const hooks = opts.hooksDir ?? hooksDir();
+    const hookFiles = walk(hooks).sort();
+    for (const skill of skills) {
+        for (const f of skill.files) {
+            const md = f.rel.endsWith('.md');
+            add(`${PLUGIN_DIR}/skills/${skill.name}/${f.rel}`, md ? Buffer.from(renderPluginSkillFile(f.content.toString('utf8'), f.rel)) : f.content);
+            add(`${CODEX_PLUGIN_DIR}/skills/${skill.name}/${f.rel}`, md ? Buffer.from(renderSkillFile(f.content.toString('utf8'), 'agents', skill.name, f.rel)) : f.content);
+        }
+    }
+    for (const dir of [PLUGIN_DIR, CODEX_PLUGIN_DIR]) {
+        for (const abs of hookFiles)
+            add(`${dir}/hooks/${relative(hooks, abs).split('\\').join('/')}`, readFileSync(abs));
+    }
+    add(`${PLUGIN_DIR}/hooks/hooks.json`, json({
+        hooks: {
+            SessionStart: [{
+                    matcher: 'startup|resume|clear|compact',
+                    hooks: [{ type: 'command', command: 'node "${CLAUDE_PLUGIN_ROOT}/hooks/session-start.mjs" --harness claude', timeout: 30 }],
+                }],
+        },
+    }));
+    // Codex substitutes ${PLUGIN_ROOT} in plugin hooks; the group is otherwise the one bravos init writes.
+    const start = sessionStart('agents');
+    const codexStart = { ...start.group, hooks: start.group.hooks.map((h) => ({ ...h, command: 'node "${PLUGIN_ROOT}/hooks/session-start.mjs" --harness codex' })) };
+    add(`${CODEX_PLUGIN_DIR}/hooks/hooks.json`, json({ hooks: { [start.event]: [codexStart] } }));
+    // guardlink only: cxg and codegraph-mcp are optional, and a server that fails to start on every
+    // machine without its binary is noise. bravos init adds them per repo when they are installed.
+    const servers = { guardlink: SERVERS.guardlink };
+    add(`${PLUGIN_DIR}/.mcp.json`, json({ mcpServers: servers }));
+    add(`${CODEX_PLUGIN_DIR}/mcp.json`, json({
+        mcpServers: Object.fromEntries(Object.entries(servers).map(([k, s]) => [k, { type: 'stdio', command: s.command, args: [...s.args] }])),
+    }));
+    const manifest = { name: 'bravos', version: v, description: DESCRIPTION, author: AUTHOR, license: 'SEE LICENSE IN LICENSE', keywords: KEYWORDS };
+    add(`${PLUGIN_DIR}/.claude-plugin/plugin.json`, json(manifest));
+    add(`${CODEX_PLUGIN_DIR}/plugin.json`, json(manifest));
+    add(CLAUDE_MARKETPLACE, json({
+        name: 'bravos',
+        owner: AUTHOR,
+        description: 'The bravos skills pack for guardlink and cert-x-gen.',
+        plugins: [{ name: 'bravos', source: `./${PLUGIN_DIR}`, description: DESCRIPTION, version: v }],
+    }));
+    add(CODEX_MARKETPLACE, json({
+        name: 'bravos',
+        interface: { displayName: 'bravos' },
+        plugins: [{
+                name: 'bravos',
+                source: { source: 'local', path: `./${CODEX_PLUGIN_DIR}` },
+                policy: { installation: 'AVAILABLE', authentication: 'ON_INSTALL' },
+                category: 'Security',
+            }],
+    }));
+    // Code-point order, not localeCompare, so the build is identical on every machine and locale.
+    return files.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+}
+// @comment -- "Writes both plugin builds under root: replaces plugin/ and plugin-codex/ wholesale (so a removed skill leaves the build) and writes the two marketplace files; returns the paths written."
+export function writePlugin(root, opts = {}) {
+    const files = pluginFiles(opts);
+    for (const d of [PLUGIN_DIR, CODEX_PLUGIN_DIR]) {
+        const dir = join(root, d);
+        if (existsSync(dir))
+            rmSync(dir, { recursive: true, force: true });
+    }
+    for (const f of files) {
+        const abs = join(root, f.path);
+        mkdirSync(dirname(abs), { recursive: true });
+        writeFileSync(abs, f.content);
+    }
+    return files.map((f) => f.path);
+}