plumbbob 0.8.13 → 0.8.17

package/node_modules/checkride/dist/init.js

@@ -12,14 +12,17 @@
  * it afterward.
  */
 import { existsSync, readFileSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ADAPTERS, SLOTS } from './adapters.js';
+import { planSnippets, selectDocFiles } from './snippets.js';
 import { CLAUDE_SETTINGS_FILE, writeStopHook } from './agent-setup/index.js';
-import { BASELINE_FILE, isFingerprintable, runBaseline } from './baseline/index.js';
+import { BASELINE_FILE, isFingerprintable } from './baseline/index.js';
+import { runBaseline } from './baseline-command.js';
 import { configSchemaUrl, resolveChecks } from './config.js';
 import { runChecks } from './orchestrator.js';
+import { detectPackageManager } from './pm/index.js';
 const NULL_OUT = { write: () => true };
 /** Run the adopted checks once; a failing (non-skipped) check marks its slot. */
 async function defaultProbe(slots, cwd) {
@@ -297,11 +300,10 @@ async function writeSharedStatic(w) {
         ['shared/gitignore', '.gitignore'],
         ['shared/npmrc', '.npmrc'],
     ];
-    for (const [from, to] of map)
-        await put(w, to, readTemplate(from));
-    for (const rule of ['no-class.yml', 'no-default-export.yml', 'no-deep-sibling-import.yml', 'require-js-extension.yml']) {
-        await put(w, join('rules', rule), readTemplate(join('shared', 'rules', rule)));
-    }
+    // Independent writes to distinct paths — run them concurrently.
+    await Promise.all(map.map(([from, to]) => put(w, to, readTemplate(from))));
+    const rules = ['no-class.yml', 'no-default-export.yml', 'no-deep-sibling-import.yml', 'require-js-extension.yml'];
+    await Promise.all(rules.map((rule) => put(w, join('rules', rule), readTemplate(join('shared', 'rules', rule)))));
 }
 async function writePackage(w, dir, pkgName, value) {
     await put(w, join(dir, 'package.json'), packageJsonFor(pkgName));
@@ -327,47 +329,97 @@ async function writeHook(w, hook, skipped) {
 // New-project mode
 // ----------------------------------------------------------------------------
 const DEFAULT_ACTIVE_SLOTS = ['types', 'lint', 'struct', 'dead', 'test', 'docs', 'links', 'spell'];
-async function initNew(options, cwd) {
-    const shape = options.shape ?? 'flat';
-    const name = options.name ?? (basename(cwd) || 'app');
-    const scope = options.scope ?? null;
-    const license = options.license ?? 'MIT';
-    const author = options.author ?? null;
-    const fullName = scope ? `${scope}/${name}` : name;
-    const adapters = options.adapters ?? ADAPTERS;
-    const slots = options.slots ?? SLOTS;
-    const checkrideSpec = options.checkrideSpec ?? `^${productVersion()}`;
-    const w = { cwd, dryRun: options.dryRun ?? false, written: [] };
+/** Emit every scaffold file for the shape into `w` (records paths; obeys dryRun). */
+async function writeNewScaffold(w, s) {
     await writeSharedStatic(w);
-    await put(w, 'tsconfig.json', render(readTemplate(join(shape, 'tsconfig.json')), { name }));
-    await put(w, 'fallow.toml', render(readTemplate(join(shape, 'fallow.toml')), { name }));
-    await put(w, 'pnpm-workspace.yaml', render(readTemplate(join(shape, 'pnpm-workspace.yaml')), { name }));
-    await put(w, 'cspell.json', cspellWithName(name, scope));
-    await put(w, 'package.json', rootPackageJson(fullName, license, author, collectDevDeps(adapters, slots, checkrideSpec), shape !== 'flat'));
-    await put(w, 'LICENSE', licenseText(license, author ?? fullName));
-    await put(w, 'README.md', readme(name));
+    await put(w, 'tsconfig.json', render(readTemplate(join(s.shape, 'tsconfig.json')), { name: s.name }));
+    await put(w, 'fallow.toml', render(readTemplate(join(s.shape, 'fallow.toml')), { name: s.name }));
+    await put(w, 'pnpm-workspace.yaml', render(readTemplate(join(s.shape, 'pnpm-workspace.yaml')), { name: s.name }));
+    await put(w, 'cspell.json', cspellWithName(s.name, s.scope));
+    await put(w, 'package.json', rootPackageJson(s.fullName, s.license, s.author, collectDevDeps(s.adapters, s.slots, s.checkrideSpec), s.shape !== 'flat'));
+    await put(w, 'LICENSE', licenseText(s.license, s.author ?? s.fullName));
+    await put(w, 'README.md', readme(s.name));
     await put(w, 'AGENTS.md', agentsMd(DEFAULT_ACTIVE_SLOTS));
     await put(w, 'CLAUDE.md', claudeMd());
-    if (shape === 'flat') {
-        await put(w, join('src', 'index.ts'), sourceModule(name));
-        await put(w, join('src', 'index.test.ts'), smokeTest(name));
+    if (s.shape === 'flat') {
+        await put(w, join('src', 'index.ts'), sourceModule(s.name));
+        await put(w, join('src', 'index.test.ts'), smokeTest(s.name));
     }
-    else if (shape === 'monorepo') {
-        await writePackage(w, join('libs', 'core'), scope ? `${scope}/core` : 'core', 'core');
-        await writePackage(w, join('apps', name), fullName, name);
+    else if (s.shape === 'monorepo') {
+        await writePackage(w, join('libs', 'core'), s.scope ? `${s.scope}/core` : 'core', 'core');
+        await writePackage(w, join('apps', s.name), s.fullName, s.name);
     }
     else {
-        await put(w, join('src', 'index.ts'), sourceModule(name));
-        await put(w, join('src', 'index.test.ts'), smokeTest(name));
-        await writePackage(w, join('packages', 'core'), scope ? `${scope}/core` : 'core', 'core');
+        await put(w, join('src', 'index.ts'), sourceModule(s.name));
+        await put(w, join('src', 'index.test.ts'), smokeTest(s.name));
+        await writePackage(w, join('packages', 'core'), s.scope ? `${s.scope}/core` : 'core', 'core');
+    }
+}
+/**
+ * Plan the scaffold on a dry writer and return the paths that already exist on
+ * disk — the files `init` would clobber. The Stop hook is excluded: it merges
+ * into `.claude/settings.json` idempotently rather than overwriting.
+ */
+async function planCollisions(s, cwd) {
+    const plan = { cwd, dryRun: true, written: [] };
+    await writeNewScaffold(plan, s);
+    return plan.written.filter((rel) => existsSync(join(cwd, rel)));
+}
+/** Resolve the project name, scope, and derived scoped `fullName` for a new project. */
+function resolveProjectName(options, cwd) {
+    const name = options.name ?? (basename(cwd) || 'app');
+    const scope = options.scope ?? null;
+    return { name, scope, fullName: scope ? `${scope}/${name}` : name };
+}
+/** Resolve the options for a new-project scaffold, applying every default. */
+function resolveNewScaffold(options, cwd) {
+    const { name, scope, fullName } = resolveProjectName(options, cwd);
+    return {
+        shape: options.shape ?? 'flat',
+        name,
+        scope,
+        license: options.license ?? 'MIT',
+        author: options.author ?? null,
+        fullName,
+        adapters: options.adapters ?? ADAPTERS,
+        slots: options.slots ?? SLOTS,
+        // Exact pin, no caret: pre-1.0 minors are breaking (docs/contract.md pin policy).
+        checkrideSpec: options.checkrideSpec ?? productVersion(),
+    };
+}
+/**
+ * Overwrite protection (D4): unless `force`, refuse rather than clobber any file
+ * the scaffold would write. Planning on a dry writer first means a collision
+ * bails before a single real byte is written — the refusal writes nothing.
+ */
+async function assertNoCollisions(scaffold, cwd, force) {
+    if (force)
+        return;
+    const collisions = await planCollisions(scaffold, cwd);
+    if (collisions.length > 0) {
+        throw new Error(`init: refusing to overwrite ${collisions.length} existing file(s) (pass --force to overwrite):\n` +
+            collisions.map((c) => `  ${c}`).join('\n'));
     }
+}
+/** Print the new-project summary and next steps. */
+function reportNew(stdout, shape, w, cwd) {
+    stdout.write(`checkride init: generated a ${shape} project (${w.written.length} files)${w.dryRun ? ' [dry run]' : ''}.\n`);
+    // A fresh project has no lockfile/field yet, so this resolves to `pnpm`,
+    // matching the generated scripts.
+    const pm = detectPackageManager({ cwd });
+    stdout.write(`  next: ${pm} install && ${pm} run check\n`);
+}
+async function initNew(options, cwd) {
+    const scaffold = resolveNewScaffold(options, cwd);
+    await assertNoCollisions(scaffold, cwd, options.force ?? false);
+    const w = { cwd, dryRun: options.dryRun ?? false, written: [] };
+    await writeNewScaffold(w, scaffold);
     // Claude Code Stop hook (opt-out; step 12). A fresh project has no PM lockfile
     // yet, so it resolves to the `pnpm` default — matching the generated scripts.
     await writeHook(w, options.hook);
-    if (options.stdout) {
-        options.stdout.write(`checkride init: generated a ${shape} project (${w.written.length} files)${w.dryRun ? ' [dry run]' : ''}.\n`);
-    }
-    return { mode: 'new', shape, written: w.written, skipped: [], disabled: [], grandfathered: [], exitCode: 0 };
+    if (options.stdout)
+        reportNew(options.stdout, scaffold.shape, w, cwd);
+    return { mode: 'new', shape: scaffold.shape, written: w.written, skipped: [], disabled: [], grandfathered: [], exitCode: 0 };
 }
 // ----------------------------------------------------------------------------
 // Existing-project mode
@@ -380,6 +432,133 @@ async function readIfExists(path) {
         return null;
     }
 }
+// ----------------------------------------------------------------------------
+// Publish-ready bundle (step 9): the library path scaffolds the opt-in artifact
+// checks into `checkride.config.json` so a buildable library orders itself out
+// of the box (build → pack/smoke/attw/publint/snippets, D4).
+// ----------------------------------------------------------------------------
+/**
+ * The publish-ready bundle, in wave order. Each slot's value is the adapter
+ * `init` writes into `checks`; `build` and `snippets` are gated (see
+ * {@link planPublishBundle}). publint/attw/pack/smoke each resolve to the
+ * same-named adapter, so their config value is just the slot name.
+ */
+const PUBLISH_BUNDLE_SLOTS = ['build', 'publint', 'attw', 'pack', 'smoke', 'snippets'];
+/** `--add` values that expand to the whole bundle. */
+const PUBLISH_BUNDLE_ALIASES = new Set(['publish', 'bundle']);
+/** Printed (and recorded in `skipped`) when snippets is requested but no tagged fence exists (Q12). */
+const SNIPPETS_POINTER = 'snippets-dist: no tagged fences found — add a `<!-- snippet: check -->` marker above a ' +
+    'ts/typescript fence in README.md or docs/*.md to enable the doc-snippet typecheck';
+/**
+ * Read package.json for the library path: its script names, and whether it is a
+ * publishable library (declares an `exports`/`main` entry and is not private).
+ */
+function readInitManifest(cwd) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
+        const hasEntry = pkg.exports !== undefined || (typeof pkg.main === 'string' && pkg.main.length > 0);
+        return { scripts: new Set(Object.keys(pkg.scripts ?? {})), isLibrary: hasEntry && pkg.private !== true };
+    }
+    catch {
+        return { scripts: new Set(), isLibrary: false };
+    }
+}
+/**
+ * True when README.md or a non-recursive docs/*.md carries at least one tagged
+ * snippet fence — the signal that gates scaffolding `snippets-dist` (Q12).
+ * Reuses step 7's pure discovery/plan primitives so the detection matches what
+ * the slot itself checks.
+ */
+async function hasTaggedSnippets(cwd) {
+    let docsEntries = [];
+    try {
+        docsEntries = await readdir(join(cwd, 'docs'));
+    }
+    catch {
+        // No docs/ directory — README.md alone can still carry a tagged fence.
+    }
+    const docs = [];
+    for (const relPath of selectDocFiles(docsEntries)) {
+        // oxlint-disable-next-line no-await-in-loop -- a handful of docs; sequential keeps it simple.
+        const text = await readIfExists(join(cwd, relPath));
+        if (text !== null)
+            docs.push({ relPath, text });
+    }
+    return planSnippets(docs).checked > 0;
+}
+/**
+ * Fold the requested publish slots into config entries, gating `build` on a
+ * build script and `snippets` (→ `snippets-dist`) on a tagged fence (Q12) — the
+ * two slots that would otherwise stand down as a skip (`build`) or hard-error on
+ * zero snippets (`snippets`).
+ */
+function planPublishBundle(requested, hasBuildScript, taggedSnippets) {
+    const checks = {};
+    let snippetsPointer = null;
+    for (const slot of PUBLISH_BUNDLE_SLOTS) {
+        if (!requested.has(slot))
+            continue;
+        if (slot === 'build') {
+            if (hasBuildScript)
+                checks['build'] = 'build';
+        }
+        else if (slot === 'snippets') {
+            if (taggedSnippets)
+                checks['snippets'] = 'snippets-dist';
+            else
+                snippetsPointer = SNIPPETS_POINTER;
+        }
+        else {
+            checks[slot] = slot; // publint / attw / pack / smoke — adapter name == slot name.
+        }
+    }
+    return { checks, snippetsPointer };
+}
+/**
+ * Partition the `--add` list and the library signal into (a) the publish slots
+ * to scaffold into `checks` and (b) the file-scaffold `--add` names left for
+ * {@link addConfigs}. The library path — a buildable, publishable package —
+ * requests the whole bundle; `--add` requests a named publish slot, or the
+ * whole bundle via the `publish`/`bundle` alias.
+ */
+function splitAdd(add, manifest) {
+    const publishRequested = new Set();
+    const fileAdds = [];
+    if (manifest.isLibrary && manifest.scripts.has('build')) {
+        for (const slot of PUBLISH_BUNDLE_SLOTS)
+            publishRequested.add(slot);
+    }
+    const bundleNames = new Set(PUBLISH_BUNDLE_SLOTS);
+    for (const name of add) {
+        if (PUBLISH_BUNDLE_ALIASES.has(name))
+            for (const slot of PUBLISH_BUNDLE_SLOTS)
+                publishRequested.add(slot);
+        else if (bundleNames.has(name))
+            publishRequested.add(name);
+        else
+            fileAdds.push(name);
+    }
+    return { publishRequested, fileAdds };
+}
+/**
+ * Write (or refresh) the AGENTS.md stanza for `slots`, idempotently: it writes
+ * only when the applied stanza differs from the current file, records the outcome
+ * on `w`/`skipped`, and honours dry-run. Shared by `initExisting` and
+ * `runAgentSetup` (both create-or-refresh the same stanza).
+ */
+async function writeAgentsStanza(w, cwd, slots, skipped) {
+    const agentsPath = join(cwd, 'AGENTS.md');
+    const existing = await readIfExists(agentsPath);
+    const nextAgents = applyStanza(existing ?? '', buildStanza(slots));
+    if (nextAgents !== existing) {
+        if (!w.dryRun)
+            await writeFile(agentsPath, nextAgents);
+        w.written.push(existing === null ? 'AGENTS.md' : 'AGENTS.md (refreshed stanza)');
+    }
+    else {
+        skipped.push('AGENTS.md (stanza unchanged)');
+    }
+}
 // Blessed-default config files `--add <slot>` scaffolds for an empty slot.
 // Shape-specific slots (types, dead) use the flat variant — existing repos
 // adopting checkride incrementally are overwhelmingly single-package.
@@ -395,6 +574,9 @@ const ADD_CONFIGS = {
         ['shared/rules/require-js-extension.yml', 'rules/require-js-extension.yml'],
     ],
     dead: [['flat/fallow.toml', 'fallow.toml']],
+    // dupes/health are the same fallow tool + config as `dead`, just other slots.
+    dupes: [['flat/fallow.toml', 'fallow.toml']],
+    health: [['flat/fallow.toml', 'fallow.toml']],
     test: [['shared/vitest.config.ts.template', 'vitest.config.ts']],
     docs: [['shared/markdownlint-cli2.jsonc', '.markdownlint-cli2.jsonc']],
     spell: [['shared/cspell.json', 'cspell.json']],
@@ -410,6 +592,7 @@ async function addConfigs(w, add, skipped) {
         for (const [from, to] of files) {
             if (existsSync(join(w.cwd, to)))
                 skipped.push(`${to} (exists)`);
+            // oxlint-disable-next-line no-await-in-loop -- one-shot `--add` scaffolding: writes are independent and perf-irrelevant, kept sequential for a deterministic progress list.
             else
                 await put(w, to, readTemplate(from));
         }
@@ -421,7 +604,17 @@ async function addCheckAlias(w, skipped) {
     const raw = await readIfExists(pkgPath);
     if (raw === null)
         return;
-    const pkg = JSON.parse(raw);
+    let pkg;
+    try {
+        pkg = JSON.parse(raw);
+    }
+    catch (err) {
+        // Name the file so a malformed consumer package.json reads as
+        // `invalid package.json: <reason>`, not a bare SyntaxError stack
+        // (mirrors `invalidConfig` in `config.ts`).
+        const reason = err instanceof Error ? err.message : String(err);
+        throw new Error(`invalid package.json: ${reason}`, { cause: err });
+    }
     if (pkg.scripts?.['check']) {
         skipped.push('package.json (check script exists)');
         return;
@@ -431,55 +624,57 @@ async function addCheckAlias(w, skipped) {
         await writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
     w.written.push('package.json (added check script)');
 }
-async function initExisting(options, cwd) {
-    const adapters = options.adapters ?? ADAPTERS;
-    const slots = options.slots ?? SLOTS;
-    const w = { cwd, dryRun: options.dryRun ?? false, written: [] };
-    const skipped = [];
-    // --add scaffolds blessed configs for empty slots before inventory, so the
-    // additions are detected and adopted in this same run.
-    await addConfigs(w, options.add ?? [], skipped);
-    const items = inventory({ cwd, slots, adapters });
-    const adopted = items.filter((i) => i.status === 'adopted');
-    // Run each adopted check once to see what currently fails.
-    const probe = options.probeFailures ?? defaultProbe;
-    const failing = new Set(await probe(adopted.map((i) => i.slot), cwd));
-    // Adoption path for the failures. `--baseline` (step 6 / c10) grandfathers a
-    // failing *fingerprintable* slot into checkride.baseline.json and keeps it
-    // enabled — the baseline masks its current debt on the next run, so it's the
-    // ratchet, not a disabled slot, that carries the cleanup. A failing slot with
-    // no extractor can't be grandfathered, so it still falls back to a `false`
-    // disable. Without `--baseline`, every failing slot is disabled (the original
-    // step-3 behavior): the first `pnpm check` is green-ish, re-enable as you fix.
-    const useBaseline = options.baseline ?? false;
+/**
+ * Classify each failing adopted slot. `--baseline` (step 6 / c10) grandfathers a
+ * failing *fingerprintable* slot (kept enabled; the baseline masks its debt and
+ * the ratchet carries the cleanup); a failing slot with no extractor can't be
+ * grandfathered, so it still falls back to a `false` disable. Without
+ * `--baseline`, every failing slot is disabled (re-enable as you fix).
+ */
+function resolveAdoptionPlan(adopted, failing, useBaseline) {
     const grandfathered = useBaseline
-        ? adopted.filter((i) => failing.has(i.slot) && i.adapter !== null && isFingerprintable(i.adapter)).map((i) => i.slot)
+        ? adopted
+            .filter((i) => failing.has(i.slot) && i.adapter !== null && isFingerprintable(i.adapter))
+            .map((i) => i.slot)
         : [];
     const grandfatheredSet = new Set(grandfathered);
-    if (grandfathered.length > 0) {
-        const capture = options.captureBaseline ?? ((at) => runBaseline({ cwd: at }).then(() => undefined));
-        await capture(cwd);
-    }
-    const disabled = adopted.filter((i) => failing.has(i.slot) && !grandfatheredSet.has(i.slot)).map((i) => i.slot);
-    const disabledSet = new Set(disabled);
-    // checkride.config.json reflecting adopted tools (and disabled failures). Never
-    // overwrite an existing one.
-    const configPath = join(cwd, 'checkride.config.json');
-    if (!existsSync(configPath)) {
-        const checks = {};
-        for (const i of adopted) {
-            if (disabledSet.has(i.slot))
-                checks[i.slot] = false;
-            else if (i.adapter)
-                checks[i.slot] = i.adapter;
-        }
-        const config = { $schema: configSchemaUrl(productVersion()), checks };
-        await put(w, 'checkride.config.json', `${JSON.stringify(config, null, 2)}\n`);
-    }
-    else {
+    const disabled = adopted
+        .filter((i) => failing.has(i.slot) && !grandfatheredSet.has(i.slot))
+        .map((i) => i.slot);
+    return { grandfathered, disabled };
+}
+/** Capture a fresh baseline when any slot was grandfathered (a no-op on dry-run). */
+async function captureBaselineIfNeeded(options, cwd, grandfathered, dryRun) {
+    if (grandfathered.length === 0 || dryRun)
+        return;
+    const capture = options.captureBaseline ?? ((at) => runBaseline({ cwd: at }).then(() => undefined));
+    await capture(cwd);
+}
+/**
+ * Write checkride.config.json for the adopted tools (disabled failures as
+ * `false`) plus the publish-ready bundle (step 9); never clobber an existing one.
+ */
+async function writeExistingConfig(w, cwd, adopted, disabledSet, bundleChecks, skipped) {
+    if (existsSync(join(cwd, 'checkride.config.json'))) {
         skipped.push('checkride.config.json (exists)');
+        return;
     }
-    // .gitignore: ensure .check/ is ignored (append, never clobber).
+    const checks = {};
+    for (const i of adopted) {
+        if (disabledSet.has(i.slot))
+            checks[i.slot] = false;
+        else if (i.adapter)
+            checks[i.slot] = i.adapter;
+    }
+    // The opt-in publish bundle follows the adopted default slots; explicit
+    // entries opt these slots into the run (D4 — the library orders itself).
+    for (const [slot, adapter] of Object.entries(bundleChecks))
+        checks[slot] = adapter;
+    const config = { $schema: configSchemaUrl(productVersion()), checks };
+    await put(w, 'checkride.config.json', `${JSON.stringify(config, null, 2)}\n`);
+}
+/** Ensure `.check/` is gitignored: create the file, append to it, or note it's already there. */
+async function ensureGitignore(w, cwd, skipped) {
     const gitignorePath = join(cwd, '.gitignore');
     const gi = await readIfExists(gitignorePath);
     if (gi === null) {
@@ -493,39 +688,80 @@ async function initExisting(options, cwd) {
     else {
         skipped.push('.gitignore (.check/ already ignored)');
     }
-    // package.json: add the `check: checkride` alias (decision 8) if missing.
-    await addCheckAlias(w, skipped);
-    // AGENTS.md stanza (create or refresh, idempotent).
-    const agentsPath = join(cwd, 'AGENTS.md');
-    const existing = await readIfExists(agentsPath);
-    const stanza = buildStanza(adopted.map((i) => i.slot));
-    const nextAgents = applyStanza(existing ?? '', stanza);
-    if (nextAgents !== existing) {
-        if (!w.dryRun)
-            await writeFile(agentsPath, nextAgents);
-        w.written.push(existing === null ? 'AGENTS.md' : 'AGENTS.md (refreshed stanza)');
-    }
-    else {
-        skipped.push('AGENTS.md (stanza unchanged)');
+}
+/** Write the CLAUDE.md pointer if absent. */
+async function writeClaudePointer(w, cwd, skipped) {
+    if (existsSync(join(cwd, 'CLAUDE.md'))) {
+        skipped.push('CLAUDE.md (exists)');
+        return;
     }
-    // CLAUDE.md pointer if absent.
-    const claudePath = join(cwd, 'CLAUDE.md');
-    if (!existsSync(claudePath)) {
-        await put(w, 'CLAUDE.md', claudeMd());
+    await put(w, 'CLAUDE.md', claudeMd());
+}
+/** Print the existing-repo adoption summary (adopted count + grandfathered/disabled slots). */
+function reportExisting(stdout, adopted, w, grandfathered, disabled) {
+    stdout.write(`checkride init: adopted ${adopted.length} slot(s); wrote ${w.written.length} file(s)${w.dryRun ? ' [dry run]' : ''}.\n`);
+    if (grandfathered.length > 0) {
+        stdout.write(`  grandfathered failing slots into ${BASELINE_FILE}: ${grandfathered.join(', ')}\n`);
     }
-    else {
-        skipped.push('CLAUDE.md (exists)');
+    if (disabled.length > 0) {
+        stdout.write(`  disabled failing slots (enable as you fix): ${disabled.join(', ')}\n`);
     }
+}
+/**
+ * Plan the publish-ready bundle (step 9) for existing-repo init. Only meaningful
+ * when a config will actually be written: `writeExistingConfig` never clobbers an
+ * existing `checkride.config.json`, so an existing config means the bundle has
+ * nowhere to land. The bundle is scaffolded *enabled* — not probed/disabled like
+ * adopted tools — because it is an ordered pipeline (build → artifacts) the user
+ * opts into by naming it.
+ */
+async function planInitBundle(publishRequested, manifest, cwd) {
+    if (existsSync(join(cwd, 'checkride.config.json')))
+        return { checks: {}, snippetsPointer: null };
+    const wantsSnippets = publishRequested.has('snippets');
+    return planPublishBundle(publishRequested, manifest.scripts.has('build'), wantsSnippets ? await hasTaggedSnippets(cwd) : false);
+}
+/** Append the enabled publish-bundle slots (and any snippets pointer) to the summary. */
+function reportInitBundle(stdout, bundle) {
+    const enabled = Object.keys(bundle.checks);
+    if (enabled.length > 0)
+        stdout.write(`  enabled publish bundle: ${enabled.join(', ')}\n`);
+    if (bundle.snippetsPointer)
+        stdout.write(`  ${bundle.snippetsPointer}\n`);
+}
+async function initExisting(options, cwd) {
+    const adapters = options.adapters ?? ADAPTERS;
+    const slots = options.slots ?? SLOTS;
+    const manifest = readInitManifest(cwd);
+    const w = { cwd, dryRun: options.dryRun ?? false, written: [] };
+    const skipped = [];
+    // Route --add: publish slots (and the library path) opt into the bundle; the
+    // rest scaffold blessed configs before inventory, so they're detected this run.
+    const { publishRequested, fileAdds } = splitAdd(options.add ?? [], manifest);
+    await addConfigs(w, fileAdds, skipped);
+    const items = inventory({ cwd, slots, adapters });
+    const adopted = items.filter((i) => i.status === 'adopted');
+    // Run each adopted check once to see what currently fails.
+    const probe = options.probeFailures ?? defaultProbe;
+    const failing = new Set(await probe(adopted.map((i) => i.slot), cwd));
+    const { grandfathered, disabled } = resolveAdoptionPlan(adopted, failing, options.baseline ?? false);
+    await captureBaselineIfNeeded(options, cwd, grandfathered, w.dryRun);
+    // Publish-ready bundle (step 9): planned only when a config will be written.
+    const bundle = await planInitBundle(publishRequested, manifest, cwd);
+    if (bundle.snippetsPointer)
+        skipped.push(bundle.snippetsPointer);
+    await writeExistingConfig(w, cwd, adopted, new Set(disabled), bundle.checks, skipped);
+    await ensureGitignore(w, cwd, skipped);
+    // package.json: add the `check: checkride` alias (decision 8) if missing.
+    await addCheckAlias(w, skipped);
+    // AGENTS.md stanza (create or refresh, idempotent).
+    await writeAgentsStanza(w, cwd, adopted.map((i) => i.slot), skipped);
+    await writeClaudePointer(w, cwd, skipped);
     // Claude Code Stop hook (opt-out; step 12), using the repo's detected PM (b7).
     await writeHook(w, options.hook, skipped);
     if (options.stdout) {
-        options.stdout.write(`checkride init: adopted ${adopted.length} slot(s); wrote ${w.written.length} file(s)${w.dryRun ? ' [dry run]' : ''}.\n`);
-        if (grandfathered.length > 0) {
-            options.stdout.write(`  grandfathered failing slots into ${BASELINE_FILE}: ${grandfathered.join(', ')}\n`);
-        }
-        if (disabled.length > 0) {
-            options.stdout.write(`  disabled failing slots (enable as you fix): ${disabled.join(', ')}\n`);
-        }
+        reportExisting(options.stdout, adopted, w, grandfathered, disabled);
+        reportInitBundle(options.stdout, bundle);
     }
     return { mode: 'existing', shape: null, written: w.written, skipped, disabled, grandfathered, exitCode: 0 };
 }
@@ -558,17 +794,7 @@ export async function runAgentSetup(options) {
     await addCheckAlias(w, skipped);
     // AGENTS.md stanza for the currently-adopted slots (create or refresh).
     const adopted = inventory({ cwd, slots, adapters }).filter((i) => i.status === 'adopted');
-    const agentsPath = join(cwd, 'AGENTS.md');
-    const existing = await readIfExists(agentsPath);
-    const nextAgents = applyStanza(existing ?? '', buildStanza(adopted.map((i) => i.slot)));
-    if (nextAgents !== existing) {
-        if (!w.dryRun)
-            await writeFile(agentsPath, nextAgents);
-        w.written.push(existing === null ? 'AGENTS.md' : 'AGENTS.md (refreshed stanza)');
-    }
-    else {
-        skipped.push('AGENTS.md (stanza unchanged)');
-    }
+    await writeAgentsStanza(w, cwd, adopted.map((i) => i.slot), skipped);
     await writeHook(w, options.hook, skipped);
     if (options.stdout) {
         options.stdout.write(`checkride agent-setup: wrote ${w.written.length} file(s)${w.dryRun ? ' [dry run]' : ''}.\n`);