@nurix/etna 0.19.64 → 0.19.65

package/bin/etna.js

@@ -14,559 +14,157 @@
 // Harnesses are addressed by their harness/<folder> name; several harnesses may
 // share one plugin.
 
-import {
-    existsSync,
-    mkdirSync,
-    readFileSync,
-    writeFileSync,
-    renameSync,
-    cpSync,
-    readdirSync,
-    lstatSync,
-    rmSync,
-} from 'node:fs';
+import { existsSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
 import * as p from '@clack/prompts';
-import { projectCodexArtifacts } from '../lib/codex/index.mjs';
+import { materializeHarness, readJson as readJsonOrThrow } from '../lib/install/materialize.mjs';
+
+// WHERE A HARNESS'S FILES LAND is not decided here — `lib/install/materialize.mjs` owns that
+// mapping, because the Apollo push ships the same tree and the two must never diverge. This
+// file owns the CLI around it: argument parsing, the interactive pick, and the reporting.
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgRoot = resolve(__dirname, '..');
 const dataDir = join(pkgRoot, 'data');
 
-// Subfolders bundled inside each harness payload that map 1:1 onto
-// <project>/.claude/<name>/. Order matches Claude Code's own folder layout.
-// hooks/ carries the hook scripts + lib/ (and hooks.json, copied harmlessly —
-// the settings merge reads it from the bundle, not the project copy).
-const PLUGIN_SUBDIRS = ['skills', 'agents', 'rules', 'scripts', 'hooks'];
-
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
 // True when both stdin and stdout are a terminal — clack prompts can't resolve
 // otherwise (CI, piped stdin), so the no-arg pick must fall back to an error.
 function isInteractive() {
-    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
 
 // Boxed list of installable harnesses (name + description), for --help and error paths.
 function printHarnessList(harnesses) {
-    const entries = Object.entries(harnesses);
-    if (!entries.length) {
-        p.log.warn('No harnesses are bundled. Run `npm run build:data` from the package root.');
-        return;
-    }
-    const width = Math.max(...entries.map(([folder]) => folder.length));
-    const lines = entries.map(
-        ([folder, meta]) => `${folder.padEnd(width)}${meta?.description ? `  ${meta.description}` : ''}`,
-    );
-    p.note(lines.join('\n'), 'Available harnesses');
+  const entries = Object.entries(harnesses);
+  if (!entries.length) {
+    p.log.warn('No harnesses are bundled. Run `npm run build:data` from the package root.');
+    return;
+  }
+  const width = Math.max(...entries.map(([folder]) => folder.length));
+  const lines = entries.map(
+    ([folder, meta]) =>
+      `${folder.padEnd(width)}${meta?.description ? `  ${meta.description}` : ''}`,
+  );
+  p.note(lines.join('\n'), 'Available harnesses');
 }
 
 function loadHarnessIndex() {
-    const path = join(dataDir, 'harness-index.json');
-    if (!existsSync(path)) {
-        die('harness-index.json missing — run `npm run build:data` from the package root.');
-    }
-    return JSON.parse(readFileSync(path, 'utf8'));
+  const path = join(dataDir, 'harness-index.json');
+  if (!existsSync(path)) {
+    die('harness-index.json missing — run `npm run build:data` from the package root.');
+  }
+  return readJson(path);
 }
 
 function die(msg, code = 1) {
-    p.log.error(msg);
-    process.exit(code);
-}
-
-function isSymlink(path) {
-    try {
-        return lstatSync(path).isSymbolicLink();
-    } catch {
-        return false;
-    }
-}
-
-// Move <path> to <path>.bak.<timestamp> if it exists. Returns the backup path, or null.
-function backupIfExists(path) {
-    if (!existsSync(path) && !isSymlink(path)) return null;
-    const ts = new Date().toISOString().replace(/[:.]/g, '-');
-    const backup = `${path}.bak.${ts}`;
-    renameSync(path, backup);
-    return backup;
-}
-
-// Copy a directory to <path>.bak.<timestamp>, leaving the original in place. Returns the
-// backup path, or null. Used for .claude/, which is refreshed in place (not overwritten
-// wholesale), so the live tree must survive for the in-place update — snapshot, don't move.
-function snapshotDirIfExists(path) {
-    if (!existsSync(path)) return null;
-    const ts = new Date().toISOString().replace(/[:.]/g, '-');
-    const backup = `${path}.bak.${ts}`;
-    cpSync(path, backup, { recursive: true });
-    return backup;
+  p.log.error(msg);
+  process.exit(code);
 }
 
+// The shared reader throws so it can serve the CI push too; the CLI turns that into its own
+// one-line death rather than a stack trace.
 function readJson(path) {
-    if (!existsSync(path)) return {};
-    try {
-        return JSON.parse(readFileSync(path, 'utf8'));
-    } catch (e) {
-        die(`failed to parse ${path}: ${e.message}`);
-    }
-}
-
-// 2-space indent matches Claude Code's own writes to settings.json.
-function writeJson(path, value) {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify(value, null, 2) + '\n');
-}
-
-// Copy the harness's bundled .claude/<subdir>/ contents into <project>/.claude/<subdir>/,
-// merging with whatever's already there. Existing same-named entries are overwritten so
-// re-running `etna` always refreshes harness-provided content. Returns count copied.
-function copyHarnessSubdir(bundledSubdir, projectSubdir) {
-    if (!existsSync(bundledSubdir)) return 0;
-    mkdirSync(projectSubdir, { recursive: true });
-    let copied = 0;
-    for (const entry of readdirSync(bundledSubdir, { withFileTypes: true })) {
-        const src = join(bundledSubdir, entry.name);
-        const dest = join(projectSubdir, entry.name);
-        cpSync(src, dest, { recursive: true, force: true });
-        copied += 1;
-    }
-    return copied;
-}
-
-// Clean up any leftover marketplace/enabledPlugins entries from a previous 0.1.x
-// install. After 0.2.0 we don't use the marketplace flow at all — leaving stale
-// entries causes Claude Code to also resolve the plugin from the global cache,
-// double-loading the same skills under a different namespace.
-function migrateFromPluginInstall(targetDir, pluginName) {
-    const removed = [];
-    const projectSettingsPath = join(targetDir, '.claude', 'settings.json');
-    if (existsSync(projectSettingsPath)) {
-        const s = readJson(projectSettingsPath);
-        if (s.enabledPlugins) {
-            const keys = Object.keys(s.enabledPlugins).filter((k) =>
-                k.startsWith(`${pluginName}@`),
-            );
-            for (const k of keys) {
-                delete s.enabledPlugins[k];
-                removed.push(`enabledPlugins["${k}"] in ${projectSettingsPath}`);
-            }
-            if (Object.keys(s.enabledPlugins).length === 0) delete s.enabledPlugins;
-            writeJson(projectSettingsPath, s);
-        }
-    }
-    return removed;
-}
-
-// Hook scripts shipped by earlier harness versions (the legacy memory-ledger tier) and since retired.
-// mergeHooks is additive, so an upgrade must explicitly remove both the stale settings.json
-// entries pointing at these and the leftover script files they reference.
-const RETIRED_HOOKS = [
-    'session-stop.js',
-    'post-tool-failure.js',
-    'post-commit.js',
-    'generate-ownership-index.mjs', // folded into awareness.mjs — unretired, the index would inject twice
-];
-
-// Remove settings.json hook entries and .claude/hooks/ files for retired hook scripts.
-// Bundle-aware: a name on the retired list is skipped while THIS bundle still ships it —
-// several harnesses share the list, and they retire the same script at different versions.
-function retireOldHooks(targetDir, bundledHarnessDir) {
-    const removed = [];
-    const bundledHooksDir = join(bundledHarnessDir, 'hooks');
-    const stillShipped = new Set(
-        existsSync(bundledHooksDir)
-            ? readdirSync(bundledHooksDir, { withFileTypes: true })
-                  .filter((e) => e.isFile())
-                  .map((e) => e.name)
-            : [],
-    );
-    const retired = RETIRED_HOOKS.filter((name) => !stillShipped.has(name));
-    const settingsPath = join(targetDir, '.claude', 'settings.json');
-    if (existsSync(settingsPath)) {
-        const settings = readJson(settingsPath);
-        const isRetired = (h) =>
-            retired.some((name) => (h.command || '').includes(`/hooks/${name}`));
-        let pruned = 0;
-        for (const [event, groups] of Object.entries(settings.hooks || {})) {
-            for (const group of groups) {
-                const before = (group.hooks || []).length;
-                group.hooks = (group.hooks || []).filter((h) => !isRetired(h));
-                pruned += before - group.hooks.length;
-            }
-            settings.hooks[event] = groups.filter((g) => (g.hooks || []).length > 0);
-            if (settings.hooks[event].length === 0) delete settings.hooks[event];
-        }
-        if (pruned > 0) {
-            writeJson(settingsPath, settings);
-            removed.push(`${pruned} retired hook entr${pruned === 1 ? 'y' : 'ies'} in settings.json`);
-        }
-    }
-    for (const name of retired) {
-        const file = join(targetDir, '.claude', 'hooks', name);
-        if (existsSync(file)) {
-            rmSync(file, { force: true });
-            removed.push(`stale hook script ${name}`);
-        }
-    }
-    return removed;
-}
-
-// Component subdirs whose membership is tracked so a removed-from-the-harness component
-// can be pruned on refresh. Hooks are excluded — retireOldHooks owns them (it must also
-// prune the matching settings.json entry, which a name-only diff can't reach).
-const PRUNABLE_SUBDIRS = ['skills', 'agents', 'rules', 'scripts'];
-
-// The set of component names the bundle ships, per prunable subdir — the manifest of what
-// THIS harness owns. Written into the installed harness.json so the next refresh can diff.
-function bundledOwned(bundledHarnessDir) {
-    const owned = {};
-    for (const sub of PRUNABLE_SUBDIRS) {
-        const dir = join(bundledHarnessDir, sub);
-        owned[sub] = existsSync(dir) ? readdirSync(dir).sort() : [];
-    }
-    return owned;
-}
-
-// Read the `owned` manifest the PREVIOUS install recorded in the project's harness.json.
-// Absent (first install, or pre-pruning version) ⇒ {} ⇒ nothing is pruned this round.
-function readInstalledOwned(targetDir) {
-    const path = join(targetDir, '.claude', 'harness.json');
-    if (!existsSync(path)) return {};
-    const owned = readJson(path).owned;
-    return owned && typeof owned === 'object' ? owned : {};
-}
-
-// Remove vendored components a prior harness version owned but this one no longer ships
-// (e.g. a retired agent like harness-manager). Only names present in the PRIOR `owned`
-// manifest are eligible, so a project's own components — never in that manifest — survive.
-function pruneOrphanedComponents(targetDir, priorOwned, newOwned) {
-    const removed = [];
-    for (const sub of PRUNABLE_SUBDIRS) {
-        const had = priorOwned[sub] || [];
-        const has = new Set(newOwned[sub] || []);
-        for (const name of had) {
-            if (has.has(name)) continue;
-            const target = join(targetDir, '.claude', sub, name);
-            if (existsSync(target)) {
-                rmSync(target, { recursive: true, force: true });
-                removed.push(`orphaned ${sub.replace(/s$/, '')} ${name}`);
-            }
-        }
-    }
-    return removed;
-}
-
-// Every file inside dir, as paths relative to dir.
-function listFilesRecursive(dir, prefix = '') {
-    const out = [];
-    if (!existsSync(dir)) return out;
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) out.push(...listFilesRecursive(join(dir, entry.name), rel));
-        else out.push(rel);
-    }
-    return out;
-}
-
-// Remove directories left empty by a prune, depth-first.
-function removeEmptyDirs(dir) {
-    if (!existsSync(dir)) return;
-    for (const entry of readdirSync(dir, { withFileTypes: true }))
-        if (entry.isDirectory()) removeEmptyDirs(join(dir, entry.name));
-    if (readdirSync(dir).length === 0) rmSync(dir, { recursive: true, force: true });
-}
-
-// Remove files inside an installed component that this bundle no longer ships. copyHarnessSubdir
-// merges, so a component that SURVIVES an upgrade while shedding a file keeps the stale copy
-// forever — that is how a retired reference file goes on being read as live doctrine. Scoped to
-// components the bundle still ships (a project's own components are never in that set, so they
-// are never touched), and needs no prior manifest, so one refresh clears orphans left by any
-// earlier version. Whole components that disappear are pruneOrphanedComponents' job.
-function pruneStaleComponentFiles(bundledSubdir, projectSubdir) {
-    const removed = [];
-    if (!existsSync(bundledSubdir)) return removed;
-    for (const entry of readdirSync(bundledSubdir, { withFileTypes: true })) {
-        if (!entry.isDirectory()) continue;
-        const shipped = new Set(listFilesRecursive(join(bundledSubdir, entry.name)));
-        const installedDir = join(projectSubdir, entry.name);
-        for (const rel of listFilesRecursive(installedDir)) {
-            if (shipped.has(rel)) continue;
-            rmSync(join(installedDir, rel), { force: true });
-            removed.push(`${entry.name}/${rel}`);
-        }
-        removeEmptyDirs(installedDir);
-    }
-    return removed;
-}
-
-// True if an event's matcher-group already carries a hook with this command string.
-function groupHasCommand(group, command) {
-    return (group.hooks || []).some((h) => h.command === command);
-}
-
-// Deep-merge the bundle's hooks.json object into <project>/.claude/settings.json under
-// "hooks", preserving every existing key. Idempotent: for each event, an incoming entry
-// merges into the matcher-group of the same matcher, skipping any hook whose command
-// already exists there; a new matcher creates a new group. Returns count of hooks added.
-function mergeHooks(targetDir, bundledHooksJson) {
-    if (!existsSync(bundledHooksJson)) return 0;
-    const bundled = readJson(bundledHooksJson);
-    const incoming = bundled.hooks || {};
-    const settingsPath = join(targetDir, '.claude', 'settings.json');
-    const settings = readJson(settingsPath);
-    settings.hooks = settings.hooks || {};
-    let added = 0;
-    // Harness-shipped permission defaults (e.g. Edit on docs/** flows without prompts —
-    // the deny hooks still hard-block frozen/protected paths underneath). Additive, idempotent.
-    for (const rule of bundled.permissions?.allow || []) {
-        settings.permissions = settings.permissions || {};
-        const allowList = (settings.permissions.allow = settings.permissions.allow || []);
-        if (!allowList.includes(rule)) {
-            allowList.push(rule);
-            added += 1;
-        }
-    }
-    for (const [event, groups] of Object.entries(incoming)) {
-        const existingGroups = (settings.hooks[event] = settings.hooks[event] || []);
-        for (const group of groups) {
-            const match = existingGroups.find((g) => g.matcher === group.matcher);
-            if (!match) {
-                existingGroups.push(group);
-                added += (group.hooks || []).length;
-                continue;
-            }
-            match.hooks = match.hooks || [];
-            for (const hook of group.hooks || []) {
-                if (groupHasCommand(match, hook.command)) continue;
-                match.hooks.push(hook);
-                added += 1;
-            }
-        }
-    }
-    if (added > 0) writeJson(settingsPath, settings);
-    return added;
+  try {
+    return readJsonOrThrow(path);
+  } catch (e) {
+    die(e.message);
+  }
 }
 
 // Resolve the harness to install: the --name value, or — in a TTY — an interactive pick
 // showing each harness's description. Returns the chosen folder, or null on cancel.
 async function resolveHarnessName(name, harnesses) {
-    const names = Object.keys(harnesses);
-    if (name !== null) {
-        if (!name || !harnesses[name]) {
-            p.log.error(name ? `Unknown harness '${name}'.` : 'Empty --name value.');
-            printHarnessList(harnesses);
-            p.outro('Pass --name=<harness> with one of the names above.');
-            process.exit(1);
-        }
-        return name;
-    }
-    if (!isInteractive()) {
-        p.log.error('No --name given, and not running in an interactive terminal.');
-        printHarnessList(harnesses);
-        p.outro('Re-run as `npx @nurix/etna --name=<harness>`.');
-        process.exit(1);
-    }
-    const choice = await p.select({
-        message: 'Which harness do you want to install here?',
-        options: names.map((folder) => ({
-            value: folder,
-            label: folder,
-            hint: harnesses[folder]?.description || undefined,
-        })),
-    });
-    if (p.isCancel(choice)) {
-        p.cancel('Cancelled — nothing installed.');
-        return null;
-    }
-    return choice;
+  const names = Object.keys(harnesses);
+  if (name !== null) {
+    if (!name || !harnesses[name]) {
+      p.log.error(name ? `Unknown harness '${name}'.` : 'Empty --name value.');
+      printHarnessList(harnesses);
+      p.outro('Pass --name=<harness> with one of the names above.');
+      process.exit(1);
+    }
+    return name;
+  }
+  if (!isInteractive()) {
+    p.log.error('No --name given, and not running in an interactive terminal.');
+    printHarnessList(harnesses);
+    p.outro('Re-run as `npx @nurix/etna --name=<harness>`.');
+    process.exit(1);
+  }
+  const choice = await p.select({
+    message: 'Which harness do you want to install here?',
+    options: names.map((folder) => ({
+      value: folder,
+      label: folder,
+      hint: harnesses[folder]?.description || undefined,
+    })),
+  });
+  if (p.isCancel(choice)) {
+    p.cancel('Cancelled — nothing installed.');
+    return null;
+  }
+  return choice;
 }
 
 // Copy one harness's bundled payload into the current directory. All file ops run
 // inside a spinner; the per-item detail + any warnings are emitted after it stops.
 async function installHarness(harnessName, harnesses) {
-    const harnessFolder = harnessName;
-    const bundledHarnessDir = join(dataDir, 'harnesses', harnessFolder);
-    const bundledClaudeMd = join(bundledHarnessDir, 'CLAUDE.md');
-    if (!existsSync(bundledClaudeMd)) {
-        die(`Bundled CLAUDE.md missing for harness '${harnessFolder}'. Rebuild package data.`);
-    }
-
-    const targetDir = process.cwd();
-    const claudeMdDest = join(targetDir, 'CLAUDE.md');
-
-    // Bundled harness marker — names the version for the banner and carries the
-    // `files` list (project-root config shipped outside the plugin route).
-    const bundledHarnessJson = join(bundledHarnessDir, 'harness.json');
-    const harnessMeta = existsSync(bundledHarnessJson) ? readJson(bundledHarnessJson) : {};
-    const versionTag = harnessMeta.version ? ` v${harnessMeta.version}` : '';
-    // The underlying plugin's name — may differ from the harness name, and several
-    // harnesses may share it. Used only for legacy marketplace-entry cleanup.
-    const pluginName = harnessMeta.name || harnesses[harnessName]?.plugin || harnessName;
-
-    const spin = p.spinner();
-    spin.start(`Installing ${harnessName}${versionTag} into ${targetDir}`);
-
-    const installed = [];
-    const notices = [];
-    const warnings = [];
-
-    // CLAUDE.md ships frontmatter-free, so it installs as a verbatim copy — no stripping.
-    // It's harness-owned and overwritten in place. If the project is a git repo the old copy
-    // is recoverable from history, so we skip the backup; if it isn't, there's no safety net,
-    // so we back it up and tell the user. (Backup applies to CLAUDE.md only.)
-    const claudeExisted = existsSync(claudeMdDest) || isSymlink(claudeMdDest);
-    const projectHasGit = existsSync(join(targetDir, '.git'));
-    if (claudeExisted) {
-        if (projectHasGit) {
-            notices.push('Overwrote existing CLAUDE.md (tracked by git — `git checkout CLAUDE.md` to restore).');
-        } else {
-            const claudeBackup = backupIfExists(claudeMdDest);
-            warnings.push(
-                `No .git here, so no version-control safety net — backed up existing CLAUDE.md → ${claudeBackup}`,
-            );
-        }
-    }
-    cpSync(bundledClaudeMd, claudeMdDest, { force: true });
-    installed.push('CLAUDE.md → ./');
-
-    // Same safety net for the .claude/ tree, mirroring the CLAUDE.md rule above. The tree is
-    // refreshed in place — owned files overwritten, orphaned owned components pruned — so a
-    // user's edits to owned files and any pruned component are the loss surface. A git repo
-    // recovers them from history, so we skip the backup; without git there's no net, so we
-    // snapshot the whole tree first and tell the user. (Snapshot, not move: the live tree has
-    // to stay for the in-place refresh below.)
-    const claudeDir = join(targetDir, '.claude');
-    if (existsSync(claudeDir)) {
-        if (projectHasGit) {
-            notices.push('Refreshed existing .claude/ in place (tracked by git — `git checkout .claude` to restore).');
-        } else {
-            const claudeDirBackup = snapshotDirIfExists(claudeDir);
-            if (claudeDirBackup) {
-                warnings.push(
-                    `No .git here, so no version-control safety net — snapshotted existing .claude/ → ${claudeDirBackup}`,
-                );
-            }
-        }
-    }
-
-    // What a prior install recorded as harness-owned — read before we overwrite the marker,
-    // so we can prune anything this bundle has since dropped.
-    const priorOwned = readInstalledOwned(targetDir);
-
-    for (const sub of PLUGIN_SUBDIRS) {
-        const count = copyHarnessSubdir(join(bundledHarnessDir, sub), join(targetDir, '.claude', sub));
-        if (count > 0) installed.push(`${count} ${sub} → .claude/${sub}/`);
-    }
-
-    // Prune components a prior harness version owned but this bundle no longer ships (e.g. a
-    // retired agent). Only prior-owned names are eligible, so the user's own files survive.
-    const newOwned = bundledOwned(bundledHarnessDir);
-    for (const r of pruneOrphanedComponents(targetDir, priorOwned, newOwned)) notices.push(`removed ${r}`);
-
-    // Then prune stale files INSIDE components the bundle still ships — the case the
-    // name-level diff above cannot see, since the component itself is still present.
-    for (const sub of PRUNABLE_SUBDIRS) {
-        const stale = pruneStaleComponentFiles(
-            join(bundledHarnessDir, sub),
-            join(targetDir, '.claude', sub),
-        );
-        for (const r of stale) notices.push(`removed stale ${sub.replace(/s$/, '')} file ${r}`);
-    }
-
-    // Dual-runtime: derive the repo's Codex artifacts (AGENTS.md, .agents/skills/,
-    // .codex/agents/, .codex/hooks.json) from the just-installed Claude tree + bundle, so the
-    // same project works under Codex too. Pure-derived — no MCP, no settings/config.toml
-    // (owner decision). See docs/features/codex-support.md. The `codex` owned-list lets a
-    // future version prune a Codex target it stops shipping.
-    const codex = projectCodexArtifacts({
-        targetDir,
-        bundledHarnessDir,
-        bundledClaudeMd,
-        projectHasGit,
-        priorCodexOwned: priorOwned.codex || [],
+  const bundledHarnessDir = join(dataDir, 'harnesses', harnessName);
+  const targetDir = process.cwd();
+
+  // Bundled harness marker — names the version for the banner. Everything else it carries
+  // (the `files` and `seeds` lists) is read by materializeHarness, which owns placement.
+  const harnessMeta = readJson(join(bundledHarnessDir, 'harness.json'));
+  const versionTag = harnessMeta.version ? ` v${harnessMeta.version}` : '';
+  // The underlying plugin name — may differ from the harness name, and several harnesses may
+  // share it. Used only for legacy marketplace-entry cleanup.
+  const pluginName = harnessMeta.name || harnesses[harnessName]?.plugin || harnessName;
+
+  const spin = p.spinner();
+  spin.start(`Installing ${harnessName}${versionTag} into ${targetDir}`);
+
+  let result;
+  try {
+    result = materializeHarness({
+      bundledHarnessDir,
+      targetDir,
+      pluginName,
+      projectHasGit: existsSync(join(targetDir, '.git')),
     });
-    for (const line of codex.installed) installed.push(line);
-    for (const n of codex.notices) notices.push(n);
-    for (const w of codex.warnings) warnings.push(w);
-    newOwned.codex = codex.owned;
-
-    // Write the harness marker — plus the `owned` manifest the next refresh diffs against —
-    // so the maintenance agent (baseline mode) can resolve the installed version.
-    if (existsSync(bundledHarnessJson)) {
-        const harnessJsonDest = join(targetDir, '.claude', 'harness.json');
-        mkdirSync(dirname(harnessJsonDest), { recursive: true });
-        const marker = readJson(bundledHarnessJson);
-        marker.owned = newOwned;
-        writeJson(harnessJsonDest, marker);
-    }
-
-    // Verbatim project-root files bundled outside the plugin route (.prettierrc.json,
-    // .vscode/settings.json, …), listed in harness.json's `files`. They land at the project
-    // root at their relative path — NOT under .claude/ — and overwrite unconditionally with no
-    // backup: the harness owns this config, and re-running etna refreshes it.
-    for (const rel of harnessMeta.files || []) {
-        const src = join(bundledHarnessDir, rel);
-        if (!existsSync(src)) continue;
-        const dest = join(targetDir, rel);
-        mkdirSync(dirname(dest), { recursive: true });
-        cpSync(src, dest, { recursive: true, force: true });
-        installed.push(`${rel} → ./${rel}`);
-    }
-
-    // Seed files listed in harness.json's `seeds` (e.g. a pre-baked docs/ scaffold). Same
-    // project-root landing as `files`, opposite ownership: a seed is written only when its
-    // path is absent. Once present it is the project's living copy — a refresh never
-    // overwrites it and never prunes it.
-    for (const rel of harnessMeta.seeds || []) {
-        const src = join(bundledHarnessDir, rel);
-        if (!existsSync(src)) continue;
-        const dest = join(targetDir, rel);
-        if (existsSync(dest)) continue;
-        mkdirSync(dirname(dest), { recursive: true });
-        cpSync(src, dest, { recursive: true });
-        installed.push(`${rel} → ./${rel} (seeded)`);
-    }
-
-    // Retire hooks earlier harness versions shipped before merging, so the additive merge
-    // never resurrects an entry pointing at a script this bundle no longer carries.
-    for (const r of retireOldHooks(targetDir, bundledHarnessDir)) notices.push(`removed ${r}`);
-
-    // Merge the bundle's hooks.json into the project's settings.json (idempotent).
-    const added = mergeHooks(targetDir, join(bundledHarnessDir, 'hooks', 'hooks.json'));
-    if (added > 0) installed.push(`${added} hook(s) → .claude/settings.json`);
+  } catch (error) {
+    spin.stop(`Could not install ${harnessName}`);
+    die(error.message);
+  }
 
-    for (const entry of migrateFromPluginInstall(targetDir, pluginName)) {
-        notices.push(`removed stale ${entry}`);
-    }
-
-    spin.stop(`Installed ${harnessName}${versionTag}`);
+  spin.stop(`Installed ${harnessName}${versionTag}`);
 
-    p.note(installed.join('\n'), 'Written');
-    for (const notice of notices) p.log.info(notice);
-    for (const warning of warnings) p.log.warn(warning);
+  p.note(result.installed.join('\n'), 'Written');
+  for (const notice of result.notices) p.log.info(notice);
+  for (const warning of result.warnings) p.log.warn(warning);
 
-    p.outro(
-        `${harnessName}${versionTag} ready in ${targetDir}. ` +
-            `Re-run \`npx @nurix/etna --name=${harnessName}\` anytime to refresh harness content.`,
-    );
+  p.outro(
+    `${harnessName}${versionTag} ready in ${targetDir}. ` +
+      `Re-run \`npx @nurix/etna --name=${harnessName}\` anytime to refresh harness content.`,
+  );
 }
 
 // Parse argv. `--name=<harness>` / `--name <harness>` selects a harness; -h/--help shows
 // help; any other bare token is the dropped positional form (a breaking change in 0.18.0).
 function parseArgs(args) {
-    let name = null;
-    let help = false;
-    let positional = null;
-    for (let i = 0; i < args.length; i++) {
-        const a = args[i];
-        if (a === '-h' || a === '--help') help = true;
-        else if (a.startsWith('--name=')) name = a.slice('--name='.length);
-        else if (a === '--name') name = args[++i] ?? '';
-        else if (!a.startsWith('-') && positional === null) positional = a;
-    }
-    return { name, help, positional };
+  let name = null;
+  let help = false;
+  let positional = null;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '-h' || a === '--help') help = true;
+    else if (a.startsWith('--name=')) name = a.slice('--name='.length);
+    else if (a === '--name') name = args[++i] ?? '';
+    else if (!a.startsWith('-') && positional === null) positional = a;
+  }
+  return { name, help, positional };
 }
 
 // npx caches aggressively: a bare `npx @nurix/etna` can re-run a STALE cached copy
@@ -582,62 +180,62 @@ function parseArgs(args) {
 // falls through to running THIS copy. @nurix/etna publishes with public access, so the
 // `npm view` and the re-exec `npx` both resolve unauthenticated — no npm token needed.
 function selfUpdateOrReexec() {
-    if (process.env.ETNA_SELFUPDATED || process.env.ETNA_NO_SELFUPDATE) return;
-    const here = readJson(join(pkgRoot, 'package.json')).version;
-    if (!here) return;
-    const view = spawnSync('npm', ['view', '@nurix/etna', 'version', '--prefer-online'], {
-        encoding: 'utf8',
-    });
-    const latest = view.status === 0 ? (view.stdout || '').trim() : null;
-    if (!latest || latest === here) return; // current, offline, or unauthed → run this copy
-    const child = spawnSync(
-        'npx',
-        ['-y', '--prefer-online', `@nurix/etna@${latest}`, ...process.argv.slice(2)],
-        { stdio: 'inherit', env: { ...process.env, ETNA_SELFUPDATED: '1' } },
-    );
-    if (!child.error) process.exit(child.status ?? 0); // re-exec ran → hand off complete
-    // npx unavailable (child.error) → fall through and run this (older) copy.
+  if (process.env.ETNA_SELFUPDATED || process.env.ETNA_NO_SELFUPDATE) return;
+  const here = readJson(join(pkgRoot, 'package.json')).version;
+  if (!here) return;
+  const view = spawnSync('npm', ['view', '@nurix/etna', 'version', '--prefer-online'], {
+    encoding: 'utf8',
+  });
+  const latest = view.status === 0 ? (view.stdout || '').trim() : null;
+  if (!latest || latest === here) return; // current, offline, or unauthed → run this copy
+  const child = spawnSync(
+    'npx',
+    ['-y', '--prefer-online', `@nurix/etna@${latest}`, ...process.argv.slice(2)],
+    { stdio: 'inherit', env: { ...process.env, ETNA_SELFUPDATED: '1' } },
+  );
+  if (!child.error) process.exit(child.status ?? 0); // re-exec ran → hand off complete
+  // npx unavailable (child.error) → fall through and run this (older) copy.
 }
 
 async function main(args) {
-    const idx = loadHarnessIndex();
-    const harnesses = idx.harnesses || {};
-    const { name, help, positional } = parseArgs(args);
-
-    if (help) {
-        p.intro('@nurix/etna — Nurix harness installer');
-        p.log.message(
-            'Usage:\n' +
-                '  npx @nurix/etna                   pick a harness from the menu\n' +
-                '  npx @nurix/etna --name=<harness>  install that harness directly',
-        );
-        printHarnessList(harnesses);
-        p.outro('No args → interactive menu. --name=<harness> → direct install.');
-        return;
-    }
+  const idx = loadHarnessIndex();
+  const harnesses = idx.harnesses || {};
+  const { name, help, positional } = parseArgs(args);
 
+  if (help) {
     p.intro('@nurix/etna — Nurix harness installer');
+    p.log.message(
+      'Usage:\n' +
+        '  npx @nurix/etna                   pick a harness from the menu\n' +
+        '  npx @nurix/etna --name=<harness>  install that harness directly',
+    );
+    printHarnessList(harnesses);
+    p.outro('No args → interactive menu. --name=<harness> → direct install.');
+    return;
+  }
+
+  p.intro('@nurix/etna — Nurix harness installer');
+
+  // Breaking change (0.18.0): the positional form `etna <harness>` was replaced by
+  // `--name=<harness>`. Fail loudly with the new syntax rather than silently misfiring.
+  if (positional && name === null) {
+    p.log.error(
+      `Positional arguments are no longer supported. Install with \`npx @nurix/etna --name=${positional}\`.`,
+    );
+    printHarnessList(harnesses);
+    p.outro('Use --name=<harness> to install, or no args to pick from the menu.');
+    process.exit(1);
+  }
 
-    // Breaking change (0.18.0): the positional form `etna <harness>` was replaced by
-    // `--name=<harness>`. Fail loudly with the new syntax rather than silently misfiring.
-    if (positional && name === null) {
-        p.log.error(
-            `Positional arguments are no longer supported. Install with \`npx @nurix/etna --name=${positional}\`.`,
-        );
-        printHarnessList(harnesses);
-        p.outro('Use --name=<harness> to install, or no args to pick from the menu.');
-        process.exit(1);
-    }
-
-    const boot = p.spinner();
-    boot.start('Starting up');
-    await sleep(2000);
-    boot.stop('Ready');
+  const boot = p.spinner();
+  boot.start('Starting up');
+  await sleep(2000);
+  boot.stop('Ready');
 
-    const harnessName = await resolveHarnessName(name, harnesses);
-    if (!harnessName) return; // user cancelled the interactive pick
+  const harnessName = await resolveHarnessName(name, harnesses);
+  if (!harnessName) return; // user cancelled the interactive pick
 
-    await installHarness(harnessName, harnesses);
+  await installHarness(harnessName, harnesses);
 }
 
 // Before anything else: if a newer @nurix/etna is published, re-exec it (so a stale
@@ -645,6 +243,6 @@ async function main(args) {
 selfUpdateOrReexec();
 
 main(process.argv.slice(2)).catch((e) => {
-    p.log.error(e?.stack || String(e));
-    process.exit(1);
+  p.log.error(e?.stack || String(e));
+  process.exit(1);
 });