@flowrail/init 0.0.17 → 0.1.0

package/dist/destinations.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * Where the Codex installer may write, checked before it writes anything,
+ * and undone if a write fails anyway (ADR-050 D9: all-or-nothing, and never
+ * a byte under `.claude/` — that is the Claude Code install's territory).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvesIntoClaude = resolvesIntoClaude;
+exports.preflightDestinations = preflightDestinations;
+exports.snapshotDestinations = snapshotDestinations;
+exports.restoreDestinations = restoreDestinations;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const env_1 = require("./env");
+function within(child, parent) {
+    const rel = path_1.default.relative(parent, child);
+    return rel === '' || (!rel.startsWith('..') && !path_1.default.isAbsolute(rel));
+}
+function canRead(p) {
+    try {
+        fs_1.default.accessSync(p, fs_1.default.constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function canWrite(p) {
+    try {
+        fs_1.default.accessSync(p, fs_1.default.constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Where the Claude Code install's directory really is: `.claude` may
+ *  itself be a symlink (to a shared directory). */
+function claudeDir(root, realRoot) {
+    const claude = path_1.default.join(root, '.claude');
+    try {
+        return fs_1.default.realpathSync.native(claude);
+    }
+    catch {
+        /* absent, or a link whose target does not exist yet */
+    }
+    // A dangling `.claude` link still names where the Claude Code install
+    // would live: follow it (bounded), resolving whatever part exists.
+    let p = claude;
+    for (let hop = 0; hop < 40; hop++) {
+        let next;
+        try {
+            next = path_1.default.resolve(path_1.default.dirname(p), fs_1.default.readlinkSync(p));
+        }
+        catch {
+            break;
+        }
+        p = next;
+        try {
+            if (!fs_1.default.lstatSync(p).isSymbolicLink())
+                break;
+        }
+        catch {
+            break;
+        }
+    }
+    if (p === claude)
+        return path_1.default.join(realRoot, '.claude');
+    const rest = [];
+    for (let dir = p;; dir = path_1.default.dirname(dir)) {
+        try {
+            return path_1.default.join(fs_1.default.realpathSync.native(dir), ...rest.reverse());
+        }
+        catch {
+            if (dir === path_1.default.dirname(dir))
+                return p;
+            rest.push(path_1.default.basename(dir));
+        }
+    }
+}
+/** Does ``rel``'s deepest existing path resolve into the Claude Code
+ *  install's directory (e.g. `.agents/skills` symlinked to `.claude/skills`)? */
+function resolvesIntoClaude(root, rel) {
+    const realRoot = fs_1.default.realpathSync.native(root);
+    const claude = claudeDir(root, realRoot);
+    for (let p = path_1.default.join(root, rel); within(p, root); p = path_1.default.dirname(p)) {
+        try {
+            return within(fs_1.default.realpathSync.native(p), claude);
+        }
+        catch {
+            if (p === root)
+                return false;
+        }
+    }
+    return false;
+}
+/** Every reason ``rel`` cannot be written safely (empty when it can). */
+function problemsFor(root, realRoot, rel) {
+    const problems = [];
+    const claude = claudeDir(root, realRoot);
+    const checkReal = (p, shown) => {
+        let real;
+        try {
+            real = fs_1.default.realpathSync.native(p);
+        }
+        catch {
+            problems.push(`${shown} is a broken symlink`);
+            return false;
+        }
+        if (!within(real, realRoot)) {
+            problems.push(`${shown} resolves outside the repository`);
+            return false;
+        }
+        if (within(real, claude)) {
+            problems.push(`${shown} resolves into .claude/, which belongs to the Claude Code install`);
+            return false;
+        }
+        return true;
+    };
+    const parts = path_1.default.dirname(rel) === '.' ? [] : path_1.default.dirname(rel).split(path_1.default.sep);
+    let cur = root;
+    let existingDir = root;
+    for (const part of parts) {
+        cur = path_1.default.join(cur, part);
+        const shown = path_1.default.relative(root, cur);
+        let st;
+        try {
+            st = fs_1.default.lstatSync(cur);
+        }
+        catch {
+            break;
+        }
+        if (st.isSymbolicLink() && !checkReal(cur, shown))
+            return problems;
+        if (!fs_1.default.statSync(cur).isDirectory()) {
+            problems.push(`${shown} is a file, but ${rel} has to be created inside it`);
+            return problems;
+        }
+        existingDir = cur;
+    }
+    // Wherever the path really lands — through ANY link, including `.claude`
+    // itself pointing at an ordinary directory such as `.codex` — it must not
+    // be the Claude Code install's directory.
+    let landing;
+    try {
+        landing = path_1.default.join(fs_1.default.realpathSync.native(existingDir), path_1.default.relative(existingDir, path_1.default.join(root, rel)));
+    }
+    catch {
+        landing = path_1.default.join(root, rel);
+    }
+    if (within(landing, claude)) {
+        problems.push(`${rel} resolves into .claude/, which belongs to the Claude Code install`);
+        return problems;
+    }
+    const abs = path_1.default.join(root, rel);
+    let st = null;
+    try {
+        st = fs_1.default.lstatSync(abs);
+    }
+    catch {
+        st = null;
+    }
+    if (st === null) {
+        if (!canWrite(existingDir))
+            problems.push(`${path_1.default.relative(root, existingDir) || '.'} is not writable`);
+        return problems;
+    }
+    if (st.isSymbolicLink() && !checkReal(abs, rel))
+        return problems;
+    const target = fs_1.default.statSync(abs);
+    if (target.isDirectory())
+        problems.push(`${rel} is a directory`);
+    else if (!canRead(abs)) {
+        // It must be snapshotted (and merged) before it is written.
+        problems.push(`${rel} is not readable`);
+    }
+    else if (target.nlink > 1) {
+        // Writing in place would change every other name for this file — one of
+        // which may be under .claude/.
+        problems.push(`${rel} is hard-linked to another file`);
+    }
+    else if (!canWrite(abs))
+        problems.push(`${rel} is not writable`);
+    return problems;
+}
+/** Refuse (before any write) when any destination cannot be written safely. */
+function preflightDestinations(root, rels) {
+    const realRoot = fs_1.default.realpathSync.native(root);
+    const problems = rels.flatMap((rel) => problemsFor(root, realRoot, rel));
+    if (problems.length > 0) {
+        throw new env_1.InitError(`cannot install without writing somewhere unsafe — nothing was changed:\n` +
+            [...new Set(problems)].map((p) => `  - ${p}`).join('\n'));
+    }
+}
+/** Record every destination's current bytes (null = absent). */
+function snapshotDestinations(root, rels) {
+    const missing = new Set();
+    const files = rels.map((rel) => {
+        const abs = path_1.default.join(root, rel);
+        for (let dir = path_1.default.dirname(abs); within(dir, root) && dir !== root; dir = path_1.default.dirname(dir)) {
+            if (!fs_1.default.existsSync(dir))
+                missing.add(dir);
+        }
+        try {
+            return { abs, content: fs_1.default.readFileSync(abs) };
+        }
+        catch (err) {
+            // Only a file that does not exist is "absent" (rollback deletes it);
+            // anything else must never be mistaken for absent.
+            if (err.code === 'ENOENT')
+                return { abs, content: null };
+            throw new env_1.InitError(`cannot snapshot ${rel} before writing (${err.message}); nothing was changed.`);
+        }
+    });
+    // Deepest first, so a child directory goes before its parent.
+    return { files, missingDirs: [...missing].sort((a, b) => b.length - a.length) };
+}
+/** Put every destination back as it was (best effort). */
+function restoreDestinations(snapshot) {
+    for (const { abs, content } of snapshot.files) {
+        try {
+            if (content === null)
+                fs_1.default.rmSync(abs, { force: true });
+            else
+                fs_1.default.writeFileSync(abs, content);
+        }
+        catch {
+            /* best effort: keep restoring the rest */
+        }
+    }
+    for (const dir of snapshot.missingDirs) {
+        try {
+            fs_1.default.rmdirSync(dir);
+        }
+        catch {
+            /* not empty or already gone */
+        }
+    }
+}

package/dist/doctor-script.js

@@ -1184,7 +1184,7 @@ function checkUndeclaredRuntimeImports() {
 if (!checkUndeclaredRuntimeImports()) ok = false;
 
 // ---------------------------------------------------------------------------
-// ADR-019 Decision 6 — version-skew checks.
+// ADR-021 §6 — version-skew checks.
 //
 // Both checks DEGRADE GRACEFULLY: an inability to PROBE (offline npx,
 // unreachable server, missing API key) warns and skips — the doctor must
@@ -1427,7 +1427,7 @@ async function mcpPost(baseUrl, apiKey, requestBody, timeoutMs) {
 /**
  * (b) When the server advertises flowrail_review_app (tools/list) but
  * .claude/settings.json has no FlowRail Stop wiring, whole-app reviews
- * never trigger — settings written by a pre-ADR-019 init against a newer
+ * never trigger — settings written by a pre-ADR-021 init against a newer
  * server. Needs the base URL (from the hook command's FLOWRAIL_MCP_URL
  * prefix) and FLOWRAIL_API_KEY; missing either skips silently.
  */
@@ -1488,6 +1488,16 @@ const VERIFY_LATENCY_PROBE_CAP_MS = 60000;
 const VERIFY_RETRY_BACKOFF_MS = 1500;
 const PROBE_MARKER_FILE = 'status-probe.json';
 const DIAGNOSTIC_DETAIL_MAX_CHARS = 300;
+// Keep aligned with @flowrail/hook's verify-latency operational verdicts.
+const OPERATIONAL_VERDICT_IDS = new Set([
+  'cost_cap_exceeded',
+  'verify_no_verdict',
+  'judge_no_verdict',
+  'managed_model_pricing_unavailable',
+  'managed_admission_unavailable',
+  'managed_route_unavailable',
+  'truncated_judge',
+]);
 
 function failModeSettingsLayers(settings) {
   return doctorSettingsLayers(settings);
@@ -1644,6 +1654,14 @@ function failModePostureMessage(verifyMode, depMode, rawEnv) {
           ? 'FLOWRAIL_FAIL_MODE=' + legacyRaw +
             ' is not a recognised value — treated as unset'
           : 'default — FLOWRAIL_FAIL_MODE unset';
+  if (verifyMode === undefined) {
+    return (
+      'FlowRail: write gate fail mode is SCOPED (' + origin + ') — ' +
+      'incomplete design-bound writes pause for retry; ' +
+      'unbound writes still allow on errors/timeouts' + depGateNote + '. ' +
+      'Set FLOWRAIL_VERIFY_FAIL_MODE=closed to pause unbound writes too.'
+    );
+  }
   return (
     'FlowRail: write gate fail mode is OPEN (' + origin + ') — verifier ' +
     'errors/timeouts allow code writes silently' + depGateNote + '. ' +
@@ -1919,7 +1937,9 @@ async function checkVerifyLatency(settings, hookVerifyBudgetMs) {
       ? 'with the closed verifier posture the write gate will block every code write (issue #300)'
       : posture === 'advisory'
         ? 'the write gate will allow every code write with advisory context (issue #300)'
-        : 'the write gate is failing open on every code write (issue #300)';
+        : posture === undefined
+          ? 'design-bound writes pause for retry; unbound writes fail open (issue #300)'
+          : 'the write gate is failing open on every code write (issue #300)';
 
   if (out.transportError) {
     if (
@@ -2001,12 +2021,10 @@ async function checkVerifyLatency(settings, hookVerifyBudgetMs) {
     );
     return false;
   }
-  // Synthetic verdicts (quota exhausted / credential unavailable / cost
-  // cap) are produced WITHOUT invoking the judge, so they arrive fast —
-  // reporting their round trip as verifier latency would be a false
-  // green. Sentinel ids: leading underscore (_quota_exceeded,
-  // _credential_unavailable) or cost_cap_exceeded; real guardrail ids
-  // are kebab-case.
+  // Operational verdicts refuse dispatch or report an unusable response.
+  // Neither establishes the latency of a usable security verdict. Preserve
+  // the reserved underscore IDs and match other operational IDs exactly so
+  // ordinary guardrail failures still count as measured verifier results.
   const structuredVerdicts = structured ? structured.per_guardrail_verdicts : undefined;
   const verdicts = Array.isArray(structuredVerdicts)
     ? structuredVerdicts
@@ -2015,7 +2033,7 @@ async function checkVerifyLatency(settings, hookVerifyBudgetMs) {
       : [];
   for (const v of verdicts) {
     const gid = v && typeof v.guardrail_id === 'string' ? v.guardrail_id : '';
-    if (gid.charAt(0) === '_' || gid === 'cost_cap_exceeded') {
+    if (gid.charAt(0) === '_' || OPERATIONAL_VERDICT_IDS.has(gid)) {
       console.warn(
         'FlowRail: verify-latency probe inconclusive — the server answered ' +
           'with a synthetic verdict (' +

package/dist/hook-install.js

@@ -42,7 +42,7 @@ const INSTALL_NPM_ARGS = ['install', '--save-dev', exports.HOOK_PACKAGE];
  *      runtime deps, or a wrong binary masquerading at the bin path.
  *
  *      The EXIT CODE is deliberately accepted as either 0 or 2, because
- *      hook >=0.0.18 (ADR-019 / PR #309) splits it by event provenance:
+ *      hook >=0.0.18 (ADR-021 §6 / PR #309) splits it by event provenance:
  *      a provable PreToolUse invocation exits 2, everything else exits 0
  *      so a stale hook can never fail CLOSED on version skew. This
  *      self-test spawns the bin bare — no PreToolUse stdin — so it takes

package/dist/init.js

@@ -27,12 +27,15 @@
  *    and the install is already complete on their side.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INIT_AGENTS = void 0;
+exports.parseAgentArgs = parseAgentArgs;
 exports.runInit = runInit;
 const app_instance_1 = require("./app-instance");
 const claude_settings_1 = require("./claude-settings");
 const connectivity_1 = require("./connectivity");
 const ci_workflow_1 = require("./ci-workflow");
 const doctor_script_1 = require("./doctor-script");
+const codex_init_1 = require("./codex-init");
 const env_1 = require("./env");
 const flowrail_yaml_1 = require("./flowrail-yaml");
 const gitignore_1 = require("./gitignore");
@@ -45,6 +48,42 @@ const repo_scan_trigger_1 = require("./repo-scan-trigger");
 const skills_1 = require("./skills");
 const verify_write_1 = require("./verify-write");
 const PROJECT_ID_PATTERN = /^prj_[0-9a-f]{32}$/;
+/** Agents `--agent` accepts (ADR-050 D9). Without the flag: Claude Code. */
+exports.INIT_AGENTS = ['claude-code', 'codex'];
+/**
+ * Parse `--agent <id>` / `--agent=<id>`. At most once; an unknown value
+ * aborts before anything is read or written. (Older inits silently ignore
+ * unknown flags — instructions must always say `@flowrail/init@latest`.)
+ */
+function parseAgentArgs(argv) {
+    let agent;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        let value;
+        if (arg === '--agent') {
+            value = argv[i + 1];
+            if (value === undefined || value.startsWith('--')) {
+                throw new env_1.InitError(`--agent requires a value: ${exports.INIT_AGENTS.join(' | ')}.`);
+            }
+            i++;
+        }
+        else if (arg.startsWith('--agent=')) {
+            value = arg.slice('--agent='.length);
+        }
+        else {
+            continue;
+        }
+        if (agent !== undefined)
+            throw new env_1.InitError('--agent may be supplied only once (install one agent per run).');
+        agent = value;
+    }
+    if (agent === undefined)
+        return 'claude-code';
+    if (!exports.INIT_AGENTS.includes(agent)) {
+        throw new env_1.InitError(`unknown --agent ${JSON.stringify(agent)}; supported: ${exports.INIT_AGENTS.join(', ')}.`);
+    }
+    return agent;
+}
 function parseCiGateArgs(argv) {
     const enabled = argv.includes('--ci-gate');
     if (!enabled)
@@ -93,6 +132,26 @@ async function runInit(options = {}) {
     // Validate all CI-gate inputs before reading or writing project state. A
     // placeholder or token-shaped value must never leave a partial install.
     const ciGate = parseCiGateArgs(argv);
+    const agent = parseAgentArgs(argv);
+    if (agent === 'codex') {
+        const mcpBase = env['FLOWRAIL_MCP_URL'] ?? mcp_config_1.MCP_BASE_URL_DEFAULT;
+        await (0, codex_init_1.runCodexInit)({
+            projectRoot,
+            argv,
+            env,
+            log,
+            mcpBaseUrl: mcpBase,
+            connectivityUrl: options.connectivityUrl ?? (0, mcp_config_1.mcpUrlFromBase)(mcpBase),
+            ciGate,
+            skillsSourceDir: options.skillsSourceDir,
+            connectivityFetcher: options.connectivityFetcher,
+            hookInstaller: options.hookInstaller,
+            hookSelfTest: options.hookSelfTest,
+            repoScanner: options.repoScanner,
+            appRegistrar: options.appRegistrar,
+        });
+        return;
+    }
     const { apiKey } = (0, env_1.readApiKeyFromEnv)(env);
     // ``FLOWRAIL_MCP_URL`` is the BASE URL — same shape @flowrail/hook
     // reads at runtime. Default to the prod base; staging / local-dev
@@ -131,7 +190,7 @@ async function runInit(options = {}) {
     log('✓ ensured .mcp.json is in .gitignore (with regeneration comment)');
     (0, doctor_script_1.writeDoctorScript)(projectRoot);
     log('✓ wrote scripts/check-flowrail.mjs (doctor script)');
-    const npmPatched = (0, npm_hooks_1.patchNpmScripts)(projectRoot);
+    const npmPatched = (0, npm_hooks_1.patchNpmScripts)(projectRoot, undefined, (hook) => log(`! left the ${hook} npm script unchanged (its ending would not combine safely); add \`&& node scripts/check-flowrail.mjs\` to it yourself`));
     if (npmPatched) {
         log('✓ wired FlowRail doctor into predev/prebuild npm scripts');
     }
@@ -161,7 +220,7 @@ async function runInit(options = {}) {
         fetcher: options.connectivityFetcher,
     });
     log('✓ connectivity check passed');
-    // ADR-019 M0': mint-if-absent app-instance identity + registration.
+    // ADR-021 M0': mint-if-absent app-instance identity + registration.
     // Runs after connectivity (the register call needs the server) and is
     // fail-soft — ensureAppInstance itself degrades to a local-only mint
     // on any registration failure, and this belt-and-suspenders catch

package/dist/json-spans.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * A JSON parser that records where every value sits in the source text, so
+ * an installer can edit one value without re-serializing the rest.
+ *
+ * Re-serializing a user's file changes bytes that carry meaning to other
+ * tools: Codex hashes each hook handler's normalized definition for trust,
+ * and ``1.0`` round-tripping to ``1`` changes that hash — revoking the user's
+ * approval of their own hook (ADR-050 D9: "idempotent, trust-preserving").
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSpanError = void 0;
+exports.parseJsonSpans = parseJsonSpans;
+exports.columnOf = columnOf;
+exports.jsonAt = jsonAt;
+exports.applyEdits = applyEdits;
+class JsonSpanError extends Error {
+}
+exports.JsonSpanError = JsonSpanError;
+function parseJsonSpans(text) {
+    let i = 0;
+    const ws = () => {
+        while (i < text.length && ' \t\n\r'.includes(text[i]))
+            i++;
+    };
+    const str = () => {
+        const start = i;
+        i++;
+        while (i < text.length && text[i] !== '"')
+            i += text[i] === '\\' ? 2 : 1;
+        if (i >= text.length)
+            throw new JsonSpanError('unterminated string');
+        i++;
+        return JSON.parse(text.slice(start, i));
+    };
+    const value = () => {
+        ws();
+        const start = i;
+        const c = text[i];
+        if (c === '{') {
+            i++;
+            const entries = [];
+            ws();
+            if (text[i] === '}') {
+                i++;
+                return { t: 'object', start, end: i, entries };
+            }
+            for (;;) {
+                ws();
+                if (text[i] !== '"')
+                    throw new JsonSpanError('expected key');
+                const keyStart = i;
+                const key = str();
+                ws();
+                if (text[i++] !== ':')
+                    throw new JsonSpanError('expected :');
+                entries.push({ key, keyStart, value: value() });
+                ws();
+                if (text[i] === ',') {
+                    i++;
+                    continue;
+                }
+                if (text[i] === '}') {
+                    i++;
+                    return { t: 'object', start, end: i, entries };
+                }
+                throw new JsonSpanError('expected , or }');
+            }
+        }
+        if (c === '[') {
+            i++;
+            const items = [];
+            ws();
+            if (text[i] === ']') {
+                i++;
+                return { t: 'array', start, end: i, items };
+            }
+            for (;;) {
+                items.push(value());
+                ws();
+                if (text[i] === ',') {
+                    i++;
+                    continue;
+                }
+                if (text[i] === ']') {
+                    i++;
+                    return { t: 'array', start, end: i, items };
+                }
+                throw new JsonSpanError('expected , or ]');
+            }
+        }
+        if (c === '"') {
+            const v = str();
+            return { t: 'scalar', start, end: i, value: v };
+        }
+        const m = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(text.slice(i));
+        if (!m)
+            throw new JsonSpanError('unexpected token');
+        i += m[0].length;
+        return { t: 'scalar', start, end: i, value: JSON.parse(m[0]) };
+    };
+    const root = value();
+    ws();
+    if (i !== text.length)
+        throw new JsonSpanError('trailing data');
+    return root;
+}
+/** The column (0-based) of offset ``at`` on its line. */
+function columnOf(text, at) {
+    const lineStart = text.lastIndexOf('\n', at - 1) + 1;
+    return at - lineStart;
+}
+/** Pretty JSON for ``value`` placed at ``column``: continuation lines are
+ *  indented to line up under it. */
+function jsonAt(value, column) {
+    return JSON.stringify(value, null, 2).split('\n').join(`\n${' '.repeat(column)}`);
+}
+/** Apply non-overlapping edits (any order). */
+function applyEdits(text, edits) {
+    let out = text;
+    for (const e of [...edits].sort((a, b) => b.start - a.start))
+        out = out.slice(0, e.start) + e.text + out.slice(e.end);
+    return out;
+}

package/dist/npm-hooks.js

@@ -7,7 +7,6 @@ exports.patchNpmScripts = patchNpmScripts;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const doctor_script_1 = require("./doctor-script");
-const DOCTOR_COMMAND = `node ${doctor_script_1.DOCTOR_SCRIPT_FILENAME}`;
 const HOOKS_TO_PATCH = ['predev', 'prebuild'];
 /**
  * Appends the FlowRail doctor command to `predev` and `prebuild` npm
@@ -16,10 +15,16 @@ const HOOKS_TO_PATCH = ['predev', 'prebuild'];
  * exist a new entry is created. No-ops when there is no `package.json`,
  * when `package.json` is malformed, or when the command is already present.
  *
+ * An existing script is only extended when the result is still valid
+ * shell: a trailing `;` is dropped first, and a script ending in `&` or `|`,
+ * or holding a `#` comment (which would swallow the appended command), is
+ * left unchanged and reported through ``onSkip``.
+ *
  * Returns true when at least one script was modified and the file was
  * rewritten, false otherwise.
  */
-function patchNpmScripts(projectRoot) {
+function patchNpmScripts(projectRoot, script = doctor_script_1.DOCTOR_SCRIPT_FILENAME, onSkip = () => { }) {
+    const command = `node ${script}`;
     const pkgPath = path_1.default.join(projectRoot, 'package.json');
     if (!fs_1.default.existsSync(pkgPath))
         return false;
@@ -37,11 +42,16 @@ function patchNpmScripts(projectRoot) {
     for (const hook of HOOKS_TO_PATCH) {
         const existing = scripts[hook];
         if (existing === undefined) {
-            scripts[hook] = DOCTOR_COMMAND;
+            scripts[hook] = command;
             changed = true;
         }
-        else if (!existing.includes(doctor_script_1.DOCTOR_SCRIPT_FILENAME)) {
-            scripts[hook] = `${existing} && ${DOCTOR_COMMAND}`;
+        else if (!existing.includes(script)) {
+            const base = existing.replace(/[\s;]+$/, '');
+            if (/[&|]$/.test(base) || /(^|\s)#/.test(base)) {
+                onSkip(hook);
+                continue;
+            }
+            scripts[hook] = `${base} && ${command}`;
             changed = true;
         }
     }

package/dist/skills.js

@@ -23,7 +23,7 @@ const path_1 = __importDefault(require("path"));
 const manifest = require('@flowrail/skills/manifest.json');
 exports.FLOWRAIL_SKILLS = manifest.skills;
 function copySkills(opts) {
-    const targetRoot = path_1.default.join(opts.projectRoot, '.claude', 'skills');
+    const targetRoot = path_1.default.join(opts.projectRoot, opts.targetDir ?? path_1.default.join('.claude', 'skills'));
     fs_1.default.mkdirSync(targetRoot, { recursive: true });
     for (const skill of exports.FLOWRAIL_SKILLS) {
         const src = path_1.default.join(opts.skillsSourceDir, skill, 'SKILL.md');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flowrail/init",
-  "version": "0.0.17",
-  "description": "One-shot FlowRail installer for Claude Code. Wires PreToolUse hooks, MCP server config, and skill markdown into your repo, then probes the FlowRail server with your API key.",
+  "version": "0.1.0",
+  "description": "One-shot FlowRail installer for Claude Code (default) and OpenAI Codex (--agent codex). Wires hooks, MCP server config, and skills into your repo, then probes the FlowRail server with your API key.",
   "license": "UNLICENSED",
   "private": false,
   "publishConfig": {
@@ -22,10 +22,11 @@
   "scripts": {
     "build": "tsc",
     "test": "jest",
-    "prepublishOnly": "npm run build && npm test"
+    "prepublishOnly": "npm run build && npm test && node scripts/check-pinned-hook-published.mjs"
   },
   "dependencies": {
-    "@flowrail/skills": "0.0.7"
+    "@flowrail/skills": "0.0.9",
+    "smol-toml": "1.9.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",