@uluops/setup 0.7.0 → 0.9.0

package/dist/commands/setup.js

@@ -2,53 +2,155 @@ import chalk from "chalk";
 import { join } from "node:path";
 import { loadManifest, saveManifest, } from "../lib/manifest.js";
 import { findProjectRoot } from "../lib/paths.js";
-import { info, printSetupSummary } from "../lib/display.js";
+import { info, printSetupSummary, warn } from "../lib/display.js";
 import { getVersion } from "../lib/version.js";
 import { getProfile } from "../harnesses/index.js";
 import { acquireInstallLock, } from "../lib/install-lock.js";
-import { initContext, checkConflicts, configureMcpStep, installAgentsDefs, installCommandsDefs, configureMetricsStep, configureCliStep, configureAgentMetricsCliStep, runHealthCheck, configureShell, } from "./helpers.js";
+import { initContext, checkConflicts, configureMcpStep, installAgentsDefs, installCommandsDefs, installSkillsDefs, configureMetricsStep, configureCliStep, configureAgentMetricsCliStep, runHealthCheck, configureShell, } from "./helpers.js";
+import { ConflictRejectedError } from "./errors.js";
+import { classifyExit, } from "./per-harness.js";
 export async function runSetup(opts) {
+    if (opts.harnesses.length === 0) {
+        info(chalk.dim("Nothing to install — re-run with at least one harness selected.\n"));
+        return;
+    }
     const version = await getVersion();
-    const profile = getProfile(opts.harness);
+    // Resolve every harness up front so a typo fails fast before any state
+    // is touched. getProfile throws HarnessNotTestedError or a friendly
+    // unknown-name error; the top-level catch in cli.ts surfaces them.
+    const profiles = opts.harnesses.map((name) => getProfile(name));
     console.log();
     console.log(`  ${chalk.dim("⟨u⟩")} ${chalk.cyan.bold("ulu")}${chalk.bold("·ops")}`);
     console.log(`      ${chalk.dim("operating intelligence as infrastructure")}`);
     console.log();
-    console.log(`  Setup v${version} — ${chalk.bold(profile.displayName)}`);
+    const targetSummary = profiles.length === 1
+        ? profiles[0].displayName
+        : `${profiles.length} harnesses (${profiles.map((p) => p.displayName).join(", ")})`;
+    console.log(`  Setup v${version} — ${chalk.bold(targetSummary)}`);
     console.log();
     if (opts.dryRun) {
         info(chalk.dim("(dry run — no changes will be made)\n"));
     }
+    // === Once-per-run: BEFORE the per-harness loop ===
     const { env, apiKey } = await initContext(opts);
     console.log();
     // Acquire the install lock before touching any shared state. Skipped on
-    // dry-run (read-only). The lock excludes a second concurrent `uluops-setup`
+    // dry-run (read-only). The lock excludes a second concurrent uluops-setup
     // from racing the manifest / MCP config / shell-profile / settings.json
-    // read-merge-write windows. Released in `finally` below.
+    // read-merge-write windows. Held across the entire multi-harness loop —
+    // concurrent multi-harness installs from separate processes serialize
+    // (spec §10.6).
     let lock = null;
     if (!opts.dryRun) {
         lock = await acquireInstallLock();
     }
     try {
-        // Load existing manifest for update detection
         const existingManifest = await loadManifest();
-        const existingHarness = existingManifest?.harnesses[profile.name];
         if (existingManifest && existingManifest.version !== version) {
             info(`Updating ${chalk.dim(existingManifest.version)} → ${chalk.green(version)}`);
             console.log();
         }
-        else if (existingHarness) {
-            info(chalk.dim(`Already at v${version} — checking for changes`));
+        // === Per-harness loop ===
+        const perHarnessResults = [];
+        for (const profile of profiles) {
+            const harnessName = profile.name;
+            // Read each harness's own slice of prior state every iteration. Never
+            // reuse a single existingHarness across iterations — installAgents/
+            // Commands/Skills consume prev lists from existingHarness for drift
+            // detection; using the wrong harness's prev list silently orphans
+            // files (spec §7.6.1 per-iteration state isolation).
+            const existingHarness = existingManifest?.harnesses[harnessName];
+            console.log(chalk.dim(`▸ ${profile.displayName}`));
+            if (existingHarness && !existingHarness.partial) {
+                info(chalk.dim(`  Already installed at v${version} — checking for changes`));
+            }
+            // First-install conflict check, OR re-run after a partial install
+            // (the user never confirmed the conflict on the failing run, so we
+            // re-prompt — spec §7.6.5).
+            const needsConflictCheck = !opts.yes &&
+                !opts.dryRun &&
+                (!existingHarness || existingHarness.partial != null);
+            if (needsConflictCheck) {
+                try {
+                    await checkConflicts(profile, opts.localDefs);
+                }
+                catch (err) {
+                    if (err instanceof ConflictRejectedError) {
+                        perHarnessResults.push({
+                            harnessName,
+                            profile,
+                            status: "declined",
+                            error: err.message,
+                        });
+                        warn(`[${harnessName}] skipped (user declined conflict) — continuing with remaining harnesses`);
+                        console.log();
+                        continue;
+                    }
+                    throw err;
+                }
+            }
+            // MCP must succeed for a manifest entry to exist (the entry depends
+            // on mcpResult.configPath). An MCP throw means no manifest entry —
+            // harness marked failed and the loop continues to siblings.
+            let mcpResult;
+            try {
+                mcpResult = await configureMcpStep(profile, apiKey, opts);
+            }
+            catch (err) {
+                perHarnessResults.push({
+                    harnessName,
+                    profile,
+                    status: "failed",
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                warn(`[${harnessName}] MCP configuration failed — continuing with remaining harnesses`);
+                console.log();
+                continue;
+            }
+            // Subsequent steps may throw on pre-loop work (mkdir EACCES, etc.).
+            // If they do, build a partial manifest entry naming the failed step
+            // (spec §7.6.2 Case B). The per-file failures[] arrays on each
+            // result are surfaced inside the helper's warn() calls.
+            let agentsResult;
+            let commandsResult;
+            let skillsResult;
+            let metricsResult;
+            let failedStep = null;
+            let failedError;
+            try {
+                agentsResult = await installAgentsDefs(profile, opts, existingHarness?.agents);
+                commandsResult = await installCommandsDefs(profile, opts, existingHarness?.commands);
+                skillsResult = await installSkillsDefs(profile, opts, existingHarness?.skills);
+                metricsResult = await configureMetricsStep(profile, opts);
+            }
+            catch (err) {
+                failedError = err instanceof Error ? err.message : String(err);
+                failedStep = !agentsResult
+                    ? "agents"
+                    : !commandsResult
+                        ? "commands"
+                        : !skillsResult
+                            ? "skills"
+                            : "metrics";
+                warn(`[${harnessName}] ${failedStep} step failed: ${failedError} — recording partial state`);
+            }
+            perHarnessResults.push({
+                harnessName,
+                profile,
+                status: failedStep ? "failed" : "ok",
+                error: failedError,
+                mcpResult,
+                agentsResult,
+                commandsResult,
+                skillsResult,
+                metricsResult,
+                partial: failedStep,
+            });
             console.log();
         }
-        // Check for conflicts on first install for this harness
-        if (!existingHarness && !opts.yes && !opts.dryRun) {
-            await checkConflicts(profile, opts.localDefs);
-        }
-        const mcpResult = await configureMcpStep(profile, apiKey, opts);
-        const agentsResult = await installAgentsDefs(profile, opts, existingHarness?.agents);
-        const commandsResult = await installCommandsDefs(profile, opts, existingHarness?.commands);
-        const metricsResult = await configureMetricsStep(profile, opts);
+        // === Once-per-run: AFTER the per-harness loop ===
+        // Global @uluops/cli install — single prompt, single install across the
+        // whole run regardless of harness count.
         const cliResult = await configureCliStep({
             withCli: opts.withCli,
             cli: opts.cli,
@@ -56,10 +158,14 @@ export async function runSetup(opts) {
             apiKey: opts.apiKey,
             dryRun: opts.dryRun,
         });
-        // Only offer the agent-metrics CLI when the hook itself got configured —
-        // the CLI's purpose is reading captures the hook produces, so without the
-        // hook there's nothing for the CLI to surface.
-        const agentMetricsCliResult = metricsResult.hookConfigured
+        // Agent-metrics CLI install — gated on AT LEAST ONE harness having
+        // successfully configured the hook. Aggregate gate replaces the
+        // per-iteration gate from the single-harness version. Without this,
+        // a multi-harness run where only one harness supports hooks (e.g.,
+        // Claude Code among Codex/Gemini siblings) would never prompt for the
+        // agent-metrics CLI (spec §7.6.2 aggregation).
+        const anyHookConfigured = perHarnessResults.some((r) => r.status === "ok" && r.metricsResult?.hookConfigured);
+        const agentMetricsCliResult = anyHookConfigured
             ? await configureAgentMetricsCliStep({
                 withAgentMetricsCli: opts.withAgentMetricsCli,
                 agentMetricsCli: opts.agentMetricsCli,
@@ -70,23 +176,10 @@ export async function runSetup(opts) {
             : null;
         await runHealthCheck(opts);
         const shellModified = await configureShell(env, apiKey, opts);
-        // Save manifest
+        // Save manifest ONCE at end, aggregating every successful or partial
+        // harness entry. Declined harnesses and pre-MCP failures land no entry.
         if (!opts.dryRun) {
             const now = new Date().toISOString();
-            const harnessEntry = {
-                installedAt: now,
-                setupVersion: version,
-                mcpScope: opts.scope,
-                mcpConfigPath: mcpResult.configPath,
-                defsScope: opts.localDefs ? "local" : "global",
-                defsPath: opts.localDefs
-                    ? join(await findProjectRoot(), "uluops")
-                    : profile.paths.home,
-                agents: agentsResult.files,
-                commands: commandsResult.files,
-                hooksInstalled: metricsResult.hookConfigured,
-                hooksInstalledVersion: metricsResult.hooksInstalledVersion,
-            };
             const manifest = existingManifest ?? {
                 version,
                 installedAt: now,
@@ -96,30 +189,63 @@ export async function runSetup(opts) {
             manifest.version = version;
             manifest.installedAt = now;
             manifest.shellModified = shellModified || manifest.shellModified;
-            manifest.harnesses[profile.name] = harnessEntry;
-            // Only flip cliInstalled to true when WE installed it (not when user-installed).
-            // Once true, persist across re-runs so uninstall remains symmetric — until the
-            // user explicitly removes it with --no-cli + uninstall, this manifest owns it.
+            for (const r of perHarnessResults) {
+                if (!r.mcpResult)
+                    continue; // no MCP success → no entry
+                const harnessEntry = {
+                    installedAt: now,
+                    setupVersion: version,
+                    mcpScope: opts.scope,
+                    mcpConfigPath: r.mcpResult.configPath,
+                    defsScope: opts.localDefs ? "local" : "global",
+                    defsPath: opts.localDefs
+                        ? join(await findProjectRoot(), "uluops")
+                        : r.profile.paths.home,
+                    agents: r.agentsResult?.files ?? [],
+                    commands: r.commandsResult?.files ?? [],
+                    skills: r.skillsResult?.files ?? [],
+                    hooksInstalled: r.metricsResult?.hookConfigured ?? false,
+                    hooksInstalledVersion: r.metricsResult?.hooksInstalledVersion ?? null,
+                    partial: r.partial ?? null,
+                };
+                manifest.harnesses[r.harnessName] = harnessEntry;
+            }
+            // Same ownership rule as before — only manifest a global install we
+            // performed ourselves (not user-installed).
             if (cliResult && cliResult.installed && !cliResult.alreadyPresent) {
                 manifest.cliInstalled = true;
                 manifest.cliInstalledVersion = cliResult.version;
             }
-            // Same ownership rule for agent-metrics CLI — only manifest a global install
-            // we performed ourselves.
             if (agentMetricsCliResult &&
                 agentMetricsCliResult.installed &&
                 !agentMetricsCliResult.alreadyPresent) {
                 manifest.agentMetricsCliInstalled = true;
-                manifest.agentMetricsCliInstalledVersion = agentMetricsCliResult.version;
+                manifest.agentMetricsCliInstalledVersion =
+                    agentMetricsCliResult.version;
+            }
+            // Only save the manifest if it has at least one harness entry — the
+            // isNewManifest loader rejects empty-harnesses manifests, and saving
+            // one would write an unloadable file on every all-declined run.
+            if (Object.keys(manifest.harnesses).length > 0) {
+                await saveManifest(manifest);
             }
-            await saveManifest(manifest);
         }
+        // === Summary ===
+        // Single rendering call producing the full multi-harness block with
+        // per-harness status icons, partial markers, re-run hints, and the
+        // aggregate counts in the header. Single-harness path preserves
+        // today's Setup-complete banner format inside the same function.
         await printSetupSummary({
-            profile,
-            agentCount: agentsResult.files.length,
-            commandCount: commandsResult.files.length,
+            results: perHarnessResults,
             apiKey,
         });
+        // Exit-code classifier (spec §7.5 4-tier table). One call, one place.
+        // Empty perHarnessResults already short-circuited above with the
+        // "nothing to install" message; classifyExit handles defense-in-depth.
+        const exitCode = classifyExit(perHarnessResults);
+        if (exitCode !== 0) {
+            process.exit(exitCode);
+        }
     }
     finally {
         if (lock)

package/dist/commands/uninstall-filter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Filter parser for `runUninstall`. Mirrors the install-side selection
+ * syntax (`--harness all`, comma-split, `--all-detected` synonym, conflict
+ * detection) but resolves against the manifest's recorded harnesses
+ * rather than detection — uninstall only acts on what's actually
+ * installed.
+ *
+ * Returns the resolved subset of harness names to uninstall, or `null`
+ * meaning "every harness in the manifest" (the no-filter default —
+ * today's behavior preserved).
+ *
+ * Throws on:
+ *   - flag conflict: --harness <name> + --all-detected
+ *   - unknown harness in filter: every named harness must exist in the
+ *     manifest, otherwise the user typed something that won't do what
+ *     they expect (fail fast, don't pretend to uninstall a no-op)
+ */
+export declare class UninstallFilterError extends Error {
+    constructor(message: string);
+}
+export interface UninstallFilterInput {
+    /** Value of --harness (may be undefined when not passed). */
+    harnessArg?: string;
+    /** Whether --harness was actually passed on the CLI (not just defaulted). */
+    harnessFromCli: boolean;
+    /** Whether --all-detected was passed. */
+    allDetected: boolean;
+    /** Names of harnesses actually present in the on-disk manifest. */
+    manifestHarnesses: string[];
+}
+/**
+ * @returns string[] — subset of manifestHarnesses to uninstall
+ * @returns null — uninstall every harness in the manifest (today's
+ *                 default behavior; preserved for back-compat)
+ */
+export declare function resolveUninstallFilter(input: UninstallFilterInput): string[] | null;

package/dist/commands/uninstall-filter.js

@@ -0,0 +1,69 @@
+/**
+ * Filter parser for `runUninstall`. Mirrors the install-side selection
+ * syntax (`--harness all`, comma-split, `--all-detected` synonym, conflict
+ * detection) but resolves against the manifest's recorded harnesses
+ * rather than detection — uninstall only acts on what's actually
+ * installed.
+ *
+ * Returns the resolved subset of harness names to uninstall, or `null`
+ * meaning "every harness in the manifest" (the no-filter default —
+ * today's behavior preserved).
+ *
+ * Throws on:
+ *   - flag conflict: --harness <name> + --all-detected
+ *   - unknown harness in filter: every named harness must exist in the
+ *     manifest, otherwise the user typed something that won't do what
+ *     they expect (fail fast, don't pretend to uninstall a no-op)
+ */
+export class UninstallFilterError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UninstallFilterError";
+    }
+}
+/**
+ * @returns string[] — subset of manifestHarnesses to uninstall
+ * @returns null — uninstall every harness in the manifest (today's
+ *                 default behavior; preserved for back-compat)
+ */
+export function resolveUninstallFilter(input) {
+    // Conflict: --all-detected with --harness <specific-name> is ambiguous.
+    // The 'all' literal is exempt because both flags mean the same thing
+    // there (uninstall everything).
+    if (input.allDetected &&
+        input.harnessFromCli &&
+        input.harnessArg &&
+        input.harnessArg.trim() !== "all") {
+        throw new UninstallFilterError(`--harness ${input.harnessArg} conflicts with --all-detected; pick one`);
+    }
+    // --all-detected (with or without --harness all) → no filter, uninstall all.
+    if (input.allDetected)
+        return null;
+    // No --harness passed → no filter, uninstall all (today's behavior).
+    if (!input.harnessFromCli || !input.harnessArg)
+        return null;
+    // --harness all → no filter, uninstall all.
+    const trimmed = input.harnessArg.trim();
+    if (trimmed === "all")
+        return null;
+    // Otherwise parse comma-split subset.
+    const requested = trimmed
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    if (requested.length === 0)
+        return null; // pathological — treat as no filter
+    // Validate every requested name exists in the manifest. A typo or a
+    // harness the user never installed should fail fast — silently
+    // skipping would let `--uninstall --harness claude-coed` succeed with
+    // zero work and the user thinking they uninstalled something.
+    const unknown = requested.filter((n) => !input.manifestHarnesses.includes(n));
+    if (unknown.length > 0) {
+        const listed = input.manifestHarnesses.length > 0
+            ? input.manifestHarnesses.join(", ")
+            : "(none)";
+        throw new UninstallFilterError(`Unknown harness in --harness filter: ${unknown.join(", ")}. ` +
+            `Manifest contains: ${listed}`);
+    }
+    return requested;
+}

package/dist/commands/uninstall.d.ts

@@ -1,3 +1,13 @@
-export declare function runUninstall(opts: {
+export interface RunUninstallOpts {
     dryRun: boolean;
-}): Promise<void>;
+    /**
+     * Value of --harness (may be 'all', comma-split list, or a single name).
+     * Undefined when --harness wasn't passed.
+     */
+    harnessArg?: string;
+    /** Whether --harness was explicitly passed (vs. its commander default). */
+    harnessFromCli?: boolean;
+    /** Whether --all-detected was passed. */
+    allDetected?: boolean;
+}
+export declare function runUninstall(opts: RunUninstallOpts): Promise<void>;

package/dist/commands/uninstall.js

@@ -1,9 +1,10 @@
 import chalk from "chalk";
-import { loadManifest, deleteManifest, validateManifest, } from "../lib/manifest.js";
+import { loadManifest, saveManifest, deleteManifest, validateManifest, } from "../lib/manifest.js";
 import { acquireInstallLock, } from "../lib/install-lock.js";
 import { uninstallMcp } from "../steps/mcp.js";
 import { uninstallAgents } from "../steps/agents.js";
 import { uninstallCommands } from "../steps/commands.js";
+import { uninstallSkills } from "../steps/skills.js";
 import { removeShellExport } from "../steps/shell.js";
 import { uninstallMetrics } from "../steps/metrics.js";
 import { uninstallCli, CLI_PACKAGE } from "../steps/cli.js";
@@ -11,6 +12,7 @@ import { uninstallAgentMetricsCli, AGENT_METRICS_PACKAGE, } from "../steps/agent
 import { ok, warn, fail, info } from "../lib/display.js";
 import { getVersion } from "../lib/version.js";
 import { getProfile } from "../harnesses/index.js";
+import { resolveUninstallFilter, UninstallFilterError, } from "./uninstall-filter.js";
 export async function runUninstall(opts) {
     const version = await getVersion();
     console.log();
@@ -45,7 +47,40 @@ export async function runUninstall(opts) {
                 warn(w);
             console.log();
         }
-        for (const [harnessName, hm] of Object.entries(manifest.harnesses)) {
+        // Resolve the subset of harnesses to uninstall. `null` means "all
+        // harnesses in the manifest" (today's no-filter behavior). String[]
+        // means "only these — leave the rest of the manifest intact".
+        const manifestHarnesses = Object.keys(manifest.harnesses);
+        let filter;
+        try {
+            filter = resolveUninstallFilter({
+                harnessArg: opts.harnessArg,
+                harnessFromCli: opts.harnessFromCli ?? false,
+                allDetected: opts.allDetected ?? false,
+                manifestHarnesses,
+            });
+        }
+        catch (err) {
+            if (err instanceof UninstallFilterError) {
+                fail(err.message);
+                console.log();
+                process.exit(1);
+            }
+            throw err;
+        }
+        const toUninstall = filter ?? manifestHarnesses;
+        const isFullUninstall = toUninstall.length === manifestHarnesses.length;
+        if (!isFullUninstall) {
+            info(chalk.dim(`Uninstalling subset (${toUninstall.length} of ${manifestHarnesses.length}): ${toUninstall.join(", ")}`));
+            console.log();
+        }
+        for (const harnessName of toUninstall) {
+            const hm = manifest.harnesses[harnessName];
+            if (!hm) {
+                // Defense — filter already validated, but keep the guard so a
+                // mid-run manifest mutation doesn't crash.
+                continue;
+            }
             let profile;
             try {
                 profile = getProfile(harnessName);
@@ -71,6 +106,15 @@ export async function runUninstall(opts) {
                     ok(`Would remove ${hm.commands.length} command(s)`);
                 }
             }
+            if ((hm.skills?.length ?? 0) > 0) {
+                if (!opts.dryRun) {
+                    const skillCount = await uninstallSkills(hm.skills ?? [], hm.defsPath);
+                    ok(`Removed ${skillCount} skill file(s)`);
+                }
+                else {
+                    ok(`Would remove ${hm.skills?.length ?? 0} skill file(s)`);
+                }
+            }
             if (!opts.dryRun) {
                 try {
                     await uninstallMcp(profile, hm.mcpConfigPath);
@@ -94,62 +138,94 @@ export async function runUninstall(opts) {
             }
             console.log();
         }
-        // Remove global @uluops/cli if WE installed it (per manifest).
-        // We never auto-remove a user-installed CLI — manifest.cliInstalled gates this.
-        if (manifest.cliInstalled) {
-            const res = await uninstallCli({ dryRun: opts.dryRun });
-            if (opts.dryRun) {
-                ok(`Would remove ${CLI_PACKAGE} (global)`);
+        // Globals (CLI, agent-metrics CLI, shell export) are only removed on
+        // a FULL uninstall — they're shared infrastructure that may serve
+        // remaining harnesses or other tools after a subset uninstall.
+        if (isFullUninstall) {
+            if (manifest.cliInstalled) {
+                const res = await uninstallCli({ dryRun: opts.dryRun });
+                if (opts.dryRun) {
+                    ok(`Would remove ${CLI_PACKAGE} (global)`);
+                }
+                else if (res.removed) {
+                    ok(`Removed ${CLI_PACKAGE} (global)`);
+                }
+                else {
+                    warn(`Could not remove ${CLI_PACKAGE} (global) — try \`npm uninstall -g ${CLI_PACKAGE}\` manually`);
+                    if (res.error) {
+                        const oneLine = res.error.split("\n")[0]?.slice(0, 120) ?? "";
+                        if (oneLine)
+                            info(`  ${oneLine}`);
+                    }
+                }
             }
-            else if (res.removed) {
-                ok(`Removed ${CLI_PACKAGE} (global)`);
+            if (manifest.agentMetricsCliInstalled) {
+                const res = await uninstallAgentMetricsCli({ dryRun: opts.dryRun });
+                if (opts.dryRun) {
+                    ok(`Would remove ${AGENT_METRICS_PACKAGE} (global)`);
+                }
+                else if (res.removed) {
+                    ok(`Removed ${AGENT_METRICS_PACKAGE} (global)`);
+                }
+                else {
+                    warn(`Could not remove ${AGENT_METRICS_PACKAGE} (global) — try \`npm uninstall -g ${AGENT_METRICS_PACKAGE}\` manually`);
+                    if (res.error) {
+                        const oneLine = res.error.split("\n")[0]?.slice(0, 120) ?? "";
+                        if (oneLine)
+                            info(`  ${oneLine}`);
+                    }
+                }
             }
-            else {
-                warn(`Could not remove ${CLI_PACKAGE} (global) — try \`npm uninstall -g ${CLI_PACKAGE}\` manually`);
-                if (res.error) {
-                    const oneLine = res.error.split("\n")[0]?.slice(0, 120) ?? "";
-                    if (oneLine)
-                        info(`  ${oneLine}`);
+            if (manifest.shellModified) {
+                const { getShellProfile } = await import("../lib/paths.js");
+                const shellProfile = getShellProfile();
+                if (shellProfile && !opts.dryRun) {
+                    await removeShellExport(shellProfile.path);
+                    ok(`Removed export from ${shellProfile.path}`);
+                }
+                else if (shellProfile) {
+                    ok(`Would remove export from ${shellProfile.path}`);
                 }
             }
         }
-        // Same ownership rule for the agent-metrics CLI.
-        if (manifest.agentMetricsCliInstalled) {
-            const res = await uninstallAgentMetricsCli({ dryRun: opts.dryRun });
-            if (opts.dryRun) {
-                ok(`Would remove ${AGENT_METRICS_PACKAGE} (global)`);
-            }
-            else if (res.removed) {
-                ok(`Removed ${AGENT_METRICS_PACKAGE} (global)`);
+        else {
+            info(chalk.dim(`Preserving global @uluops/cli, @uluops/agent-metrics, and shell export — subset uninstall does not touch shared infrastructure`));
+            console.log();
+        }
+        // Manifest update / delete logic:
+        //   full uninstall → delete the manifest entirely (today's behavior)
+        //   subset uninstall, entries remain → save the trimmed manifest
+        //   subset uninstall, no entries remain → delete (manifest loader
+        //     would reject an empty-harnesses file)
+        if (!opts.dryRun) {
+            if (isFullUninstall) {
+                await deleteManifest();
+                ok("Manifest deleted");
             }
             else {
-                warn(`Could not remove ${AGENT_METRICS_PACKAGE} (global) — try \`npm uninstall -g ${AGENT_METRICS_PACKAGE}\` manually`);
-                if (res.error) {
-                    const oneLine = res.error.split("\n")[0]?.slice(0, 120) ?? "";
-                    if (oneLine)
-                        info(`  ${oneLine}`);
+                for (const name of toUninstall) {
+                    delete manifest.harnesses[name];
+                }
+                const remaining = Object.keys(manifest.harnesses).length;
+                if (remaining > 0) {
+                    await saveManifest(manifest);
+                    ok(`Manifest updated — ${remaining} harness(es) remain: ${Object.keys(manifest.harnesses).join(", ")}`);
+                }
+                else {
+                    await deleteManifest();
+                    ok("Manifest deleted (no harnesses remain)");
                 }
             }
         }
-        // Remove shell export
-        if (manifest.shellModified) {
-            const { getShellProfile } = await import("../lib/paths.js");
-            const shellProfile = getShellProfile();
-            if (shellProfile && !opts.dryRun) {
-                await removeShellExport(shellProfile.path);
-                ok(`Removed export from ${shellProfile.path}`);
-            }
-            else if (shellProfile) {
-                ok(`Would remove export from ${shellProfile.path}`);
-            }
+        console.log();
+        if (isFullUninstall) {
+            info("UluOps has been removed. Restart your harness to complete.");
         }
-        if (!opts.dryRun) {
-            await deleteManifest();
-            ok("Manifest deleted");
+        else {
+            const removed = toUninstall.join(", ");
+            info(`Removed UluOps from ${removed}. Restart the affected harness(es) to complete.`);
         }
         console.log();
-        info("UluOps has been removed. Restart your harness to complete.");
-        console.log();
     }
     finally {
         if (lock)

package/dist/harnesses/codex.d.ts

@@ -1,15 +1,10 @@
 /**
- * Codex Harness Profile (Scaffold)
+ * Codex Harness Profile
  *
- * Paths and metadata are verified from vendor docs.
- * Codex uses TOML config with `mcp_servers` key (nested tables).
+ * Codex uses TOML config with `mcp_servers` nested tables.
  * Agent definitions are TOML, not markdown.
- * Skills use a different path ($HOME/.agents/skills/) than agents (~/.codex/agents/).
- *
- * NOT YET TESTED with UluOps agents. McpConfigStrategy throws
- * until integration testing is complete.
- *
- * Will require `smol-toml` dependency when fully implemented.
+ * Skills live under ~/.codex/skills and are the preferred Codex-native
+ * surface for UluOps operator workflows.
  */
-import type { HarnessProfile } from "./types.js";
+import { type HarnessProfile } from "./types.js";
 export declare const codexProfile: HarnessProfile;