@uluops/setup 0.11.0 → 0.12.0

package/dist/lib/version.js

@@ -5,6 +5,23 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 /** Read the package version from package.json. */
 export async function getVersion() {
     const pkgPath = join(__dirname, "..", "..", "package.json");
-    const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
-    return pkg.version;
+    let pkg;
+    try {
+        pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+    }
+    catch (err) {
+        // A truncated package.json (interrupted npx cache write) should surface
+        // as the same deliberate broken-publish error as a missing version.
+        throw new Error(`Malformed package.json at ${pkgPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const version = typeof pkg === "object" && pkg !== null
+        ? pkg.version
+        : undefined;
+    if (typeof version !== "string" || !version) {
+        // Our own package.json — this firing means a broken publish, not user
+        // error. Fail loudly rather than stamping "undefined" into banners and
+        // the manifest's setupVersion.
+        throw new Error(`Malformed package.json at ${pkgPath}: missing version`);
+    }
+    return version;
 }

package/dist/lib/write-coordinator.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Per-file write coordinator.
+ *
+ * Two jobs, one choke point:
+ *
+ * 1. **Serialization** — every read-merge-write cycle against a config file
+ *    goes through `serialize(path, op)`, a per-resolved-path promise chain.
+ *    Harness profiles where two steps target the same file (Gemini CLI's
+ *    MCP config and hook both live in `~/.gemini/settings.json`) get their
+ *    cycles strictly ordered, so no cycle can read a file another cycle is
+ *    mid-way through rewriting — including if step orchestration ever
+ *    becomes concurrent.
+ *
+ * 2. **Write attestation** — `recordWrite` keeps a sha-256 of the last bytes
+ *    this process wrote to each path (called from `atomicWrite`, so every
+ *    config write is attested with no call-site churn). NOTE:
+ *    `fileMatchesLastWrite`/`hasRecordedWrite` have NO production consumer
+ *    today — the package deliberately has no backup/rollback mechanism
+ *    (see CHANGELOG: backups were removed as never-read). They exist as the
+ *    guard any future rollback MUST use before writing over a file: only
+ *    content this process provably wrote may be replaced. Until such a
+ *    caller exists, attestation is bookkeeping, not an active safety
+ *    property.
+ *
+ * Why not coalesce to one physical write per file per run: the hook entry
+ * can only be written after the metrics tool files land on disk (a hook
+ * pointing at a nonexistent hook.js fires a failing command in the user's
+ * harness), so the MCP write and the hook write have a real data dependency.
+ * Coalescing would couple MCP-config success to the metrics step's file
+ * operations; serialized, attested, individually-atomic writes do not.
+ */
+/**
+ * Run `op` exclusively with respect to every other serialized operation on
+ * the same (resolved) path. Failures propagate to the caller but never
+ * poison the chain for subsequent operations.
+ */
+export declare function serialize<T>(path: string, op: () => Promise<T>): Promise<T>;
+/** Attest that this process wrote exactly `content` to `path`. */
+export declare function recordWrite(path: string, content: string): void;
+/**
+ * Restore guard: true when the file's current bytes are exactly the last
+ * bytes this process wrote to it (or the file is missing — a failed write
+ * can legitimately leave no file). False when we never wrote the path, or
+ * when someone else has touched it since our write.
+ */
+export declare function fileMatchesLastWrite(path: string): Promise<boolean>;
+/** Whether this process has attested a write to `path` at all. */
+export declare function hasRecordedWrite(path: string): boolean;
+/** Test seam: clear all coordinator state. */
+export declare function resetCoordinatorForTests(): void;

package/dist/lib/write-coordinator.js

@@ -0,0 +1,89 @@
+/**
+ * Per-file write coordinator.
+ *
+ * Two jobs, one choke point:
+ *
+ * 1. **Serialization** — every read-merge-write cycle against a config file
+ *    goes through `serialize(path, op)`, a per-resolved-path promise chain.
+ *    Harness profiles where two steps target the same file (Gemini CLI's
+ *    MCP config and hook both live in `~/.gemini/settings.json`) get their
+ *    cycles strictly ordered, so no cycle can read a file another cycle is
+ *    mid-way through rewriting — including if step orchestration ever
+ *    becomes concurrent.
+ *
+ * 2. **Write attestation** — `recordWrite` keeps a sha-256 of the last bytes
+ *    this process wrote to each path (called from `atomicWrite`, so every
+ *    config write is attested with no call-site churn). NOTE:
+ *    `fileMatchesLastWrite`/`hasRecordedWrite` have NO production consumer
+ *    today — the package deliberately has no backup/rollback mechanism
+ *    (see CHANGELOG: backups were removed as never-read). They exist as the
+ *    guard any future rollback MUST use before writing over a file: only
+ *    content this process provably wrote may be replaced. Until such a
+ *    caller exists, attestation is bookkeeping, not an active safety
+ *    property.
+ *
+ * Why not coalesce to one physical write per file per run: the hook entry
+ * can only be written after the metrics tool files land on disk (a hook
+ * pointing at a nonexistent hook.js fires a failing command in the user's
+ * harness), so the MCP write and the hook write have a real data dependency.
+ * Coalescing would couple MCP-config success to the metrics step's file
+ * operations; serialized, attested, individually-atomic writes do not.
+ */
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+const chains = new Map();
+const lastWritten = new Map();
+function sha256(content) {
+    return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+/**
+ * Run `op` exclusively with respect to every other serialized operation on
+ * the same (resolved) path. Failures propagate to the caller but never
+ * poison the chain for subsequent operations.
+ */
+export async function serialize(path, op) {
+    const key = resolve(path);
+    const prev = chains.get(key) ?? Promise.resolve();
+    const run = prev.then(op, op);
+    // Store a settled-safe tail so one failed op doesn't reject the chain.
+    chains.set(key, run.then(() => undefined, () => undefined));
+    return run;
+}
+/** Attest that this process wrote exactly `content` to `path`. */
+export function recordWrite(path, content) {
+    lastWritten.set(resolve(path), sha256(content));
+}
+/**
+ * Restore guard: true when the file's current bytes are exactly the last
+ * bytes this process wrote to it (or the file is missing — a failed write
+ * can legitimately leave no file). False when we never wrote the path, or
+ * when someone else has touched it since our write.
+ */
+export async function fileMatchesLastWrite(path) {
+    const key = resolve(path);
+    const expected = lastWritten.get(key);
+    if (expected === undefined)
+        return false;
+    let current;
+    try {
+        current = await readFile(key, "utf-8");
+    }
+    catch (err) {
+        // ONLY a missing file means "nothing of anyone else's to clobber". An
+        // unreadable-but-present file (EACCES/EIO) is unverifiable — a guard
+        // that answers true on an error it never inspected authorizes exactly
+        // the clobber it exists to prevent.
+        return err?.code === "ENOENT";
+    }
+    return sha256(current) === expected;
+}
+/** Whether this process has attested a write to `path` at all. */
+export function hasRecordedWrite(path) {
+    return lastWritten.has(resolve(path));
+}
+/** Test seam: clear all coordinator state. */
+export function resetCoordinatorForTests() {
+    chains.clear();
+    lastWritten.clear();
+}

package/dist/steps/agent-metrics-cli.d.ts

@@ -33,6 +33,12 @@ export interface AgentMetricsCliExecutor {
  * Exported for direct unit testing — keeps the JSON shape contract explicit.
  */
 export declare function parseGlobalAgentMetricsVersion(stdout: string | undefined): string | null;
+/**
+ * Detect a globally-installed `@uluops/agent-metrics` via `npm ls -g`.
+ * Returns the installed version string, or null when absent (or when npm
+ * itself fails/times out — absence and detection failure are deliberately
+ * indistinguishable: both mean "offer the install").
+ */
 export declare function detectGlobalAgentMetrics(): string | null;
 /** Default executor — queries npm directly to avoid npx-transient-PATH false positives. */
 export declare const defaultAgentMetricsExecutor: AgentMetricsCliExecutor;

package/dist/steps/agent-metrics-cli.js

@@ -55,16 +55,34 @@ const DETECT_TIMEOUT_MS = 30_000;
 function summarizeNpmResult(r, op) {
     if (r.status === 0)
         return { ok: true };
+    // Timeout FIRST: a spawnSync timeout sets BOTH r.error (ETIMEDOUT) and
+    // signal SIGTERM — the specific diagnosis must win over the generic one.
     if (r.signal === "SIGTERM" && r.status === null) {
         return {
             ok: false,
             error: `npm ${op} exceeded ${NPM_TIMEOUT_MS / 1000}s timeout and was terminated`,
         };
     }
+    // Spawn failure (npm not on PATH, ENOENT) sets r.error with status null —
+    // mirror src/steps/cli.ts so it never renders as "exit null".
+    if (r.error) {
+        return { ok: false, error: `npm could not be run: ${r.error.message}` };
+    }
     const stderr = (r.stderr ?? "").toString().trim();
     const stdout = (r.stdout ?? "").toString().trim();
-    return { ok: false, error: stderr || stdout || `exit ${r.status}` };
+    let error = stderr || stdout || `exit ${r.status}`;
+    // Mirror src/steps/cli.ts: name the root-owned-prefix cause on EACCES.
+    if (/EACCES|EPERM|permission denied/i.test(error)) {
+        error += ` — your npm global prefix isn't writable. A Node version manager (nvm/fnm) avoids this permanently; see docs.npmjs.com/resolving-eacces-permissions-errors`;
+    }
+    return { ok: false, error };
 }
+/**
+ * Detect a globally-installed `@uluops/agent-metrics` via `npm ls -g`.
+ * Returns the installed version string, or null when absent (or when npm
+ * itself fails/times out — absence and detection failure are deliberately
+ * indistinguishable: both mean "offer the install").
+ */
 export function detectGlobalAgentMetrics() {
     const r = spawnSync("npm", ["ls", "-g", AGENT_METRICS_PACKAGE, "--depth=0", "--json"], {
         encoding: "utf-8",

package/dist/steps/agents.js

@@ -1,7 +1,7 @@
 import { readdir, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { ASSETS_DIR, findProjectRoot } from "../lib/paths.js";
-import { copyIfChanged, unlinkFiles, removeStaleFiles, } from "../lib/file-ops.js";
+import { copyIfChanged, unlinkFiles, removeStaleFiles, isEnoent, } from "../lib/file-ops.js";
 /** Copy pre-rendered agent definitions from harness-specific assets to the target directory. */
 export async function installAgents(profile, localDefs, dryRun, existingManifestAgents) {
     const srcDir = join(ASSETS_DIR, profile.name, "agents");
@@ -16,7 +16,12 @@ export async function installAgents(profile, localDefs, dryRun, existingManifest
     try {
         files = (await readdir(srcDir)).filter((f) => f.endsWith(ext));
     }
-    catch {
+    catch (err) {
+        // ENOENT = this harness ships no agents (legit empty). Anything else
+        // must THROW: returning files:[] here is persisted to the manifest as
+        // authoritative and orphans every previously-recorded agent.
+        if (!isEnoent(err))
+            throw err;
         return { copied: 0, skipped: 0, removed: 0, files: [], failures: [] };
     }
     let copied = 0;
@@ -49,8 +54,21 @@ export async function installAgents(profile, localDefs, dryRun, existingManifest
             });
         }
     }
-    const removed = await removeStaleFiles(destDir, existingManifestAgents, installedFiles, dryRun);
-    return { copied, skipped, removed, files: installedFiles, failures };
+    // Stale = "no longer SHIPPED", never "failed to copy today": reconciling
+    // against installedFiles deleted a previously-working file whenever its
+    // copy failed (ENOSPC wiped the whole installed set). Reconcile against
+    // the source list; a failed file's prior copy survives on disk.
+    const removed = await removeStaleFiles(destDir, existingManifestAgents, files, dryRun);
+    // The manifest record keeps failed files that were previously installed —
+    // their prior copy is still on disk (see above) and uninstall must be able
+    // to remove it. Never-installed failures stay out (nothing to unlink).
+    const recordedFiles = [
+        ...installedFiles,
+        ...failures
+            .map((f) => f.file)
+            .filter((f) => existingManifestAgents?.includes(f) ?? false),
+    ];
+    return { copied, skipped, removed, files: recordedFiles, failures };
 }
 /** Remove previously installed agent files by name. */
 export async function uninstallAgents(files, defsPath) {

package/dist/steps/auth.js

@@ -3,6 +3,18 @@ import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { extractEmail } from "../lib/json-guards.js";
 import { atomicWrite } from "../lib/atomic-write.js";
+import { isEnoent } from "../lib/file-ops.js";
+/**
+ * Expected API-key prefix, overridable via ULUOPS_KEY_PREFIX for dev/test
+ * environments whose local API mints differently-prefixed keys.
+ *
+ * ADVISORY ONLY — deliberate divergence from @uluops/sdk-core, which
+ * hardcodes "ulr_". The prefix here gates nothing: a mismatched key gets a
+ * hint in the prompt and a proceed-anyway warning, and server validation
+ * remains the sole authority. Keep it that way: making this blocking would
+ * turn the env override into a footgun (keys accepted here, rejected by
+ * every sdk-core consumer).
+ */
 function getKeyPrefix() {
     return process.env["ULUOPS_KEY_PREFIX"] ?? "ulr_";
 }
@@ -19,8 +31,10 @@ export async function hasCredentialsFile() {
         await access(credentialsPath());
         return true;
     }
-    catch {
-        return false;
+    catch (err) {
+        // Unreadable-but-present counts as PRESENT: answering "absent" steers a
+        // returning user into the new-account branch and a duplicate signup.
+        return !isEnoent(err);
     }
 }
 /**
@@ -36,18 +50,33 @@ export async function writeCredentialsFile(apiKey, opts) {
         return;
     const credsPath = credentialsPath();
     await mkdir(dirname(credsPath), { recursive: true, mode: 0o700 });
-    // Merge: preserve any non-default profiles already on disk.
+    // Merge: preserve any non-default profiles already on disk. The preserve
+    // promise means we may only start fresh when the file is genuinely ABSENT
+    // — an unreadable or unparseable file may hold profiles (e.g. @uluops/cli's
+    // `work` profile) that a fresh write would destroy.
     let existing = {};
+    let raw = null;
     try {
-        const raw = await readFile(credsPath, "utf-8");
-        const parsed = JSON.parse(raw);
+        raw = await readFile(credsPath, "utf-8");
+    }
+    catch (err) {
+        if (!isEnoent(err)) {
+            throw new Error(`Could not read ${credsPath} (${err instanceof Error ? err.message : String(err)}) — refusing to write credentials over a file that exists but could not be read. Nothing was modified.`);
+        }
+        // Absent — fresh file.
+    }
+    if (raw !== null) {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`Existing credentials file at ${credsPath} contains invalid JSON — it may hold other profiles, so it will not be overwritten. Fix or remove it and re-run. Nothing was modified.`);
+        }
         if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
             existing = parsed;
         }
     }
-    catch {
-        // No existing file, or unparseable — start fresh.
-    }
     const merged = {
         ...existing,
         default: {
@@ -116,8 +145,10 @@ async function readCredentialsFile() {
     try {
         raw = await readFile(credsPath, "utf-8");
     }
-    catch {
-        return undefined; // File doesn't exist
+    catch (err) {
+        if (isEnoent(err))
+            return undefined; // File doesn't exist
+        throw new Error(`Could not read credentials file at ${credsPath}: ${err instanceof Error ? err.message : String(err)}`);
     }
     let creds;
     try {
@@ -130,7 +161,14 @@ async function readCredentialsFile() {
         return undefined;
     const profiles = creds;
     const defaultProfile = profiles["default"];
-    return defaultProfile?.apiKey ?? defaultProfile?.api_key;
+    if (typeof defaultProfile !== "object" || defaultProfile === null) {
+        return undefined;
+    }
+    const p = defaultProfile;
+    // Only ever return a string — a malformed file (apiKey: 42, apiKey: {...})
+    // must read as "no stored key", not flow a non-string into Bearer headers.
+    const candidate = p.apiKey ?? p.api_key;
+    return typeof candidate === "string" && candidate ? candidate : undefined;
 }
 async function validateKey(apiKey) {
     // Self-identity lives in ops-uluops-api (`/api/v1/auth/me`), not the
@@ -163,9 +201,11 @@ async function validateKey(apiKey) {
         return { email: extractEmail(body) };
     }
     catch (err) {
-        // fetch() throws TypeError for network failures (ENOTFOUND, ECONNREFUSED).
+        // fetch() throws TypeError for network failures (ENOTFOUND, ECONNREFUSED);
+        // AbortSignal.timeout rejects with a DOMException named "TimeoutError" —
+        // the slow-network case this friendly message was written for.
         // Re-thrown errors from the res.status checks above are plain Error instances.
-        if (err instanceof TypeError) {
+        if (err instanceof TypeError || err?.name === "TimeoutError") {
             throw new Error("Can't reach api.uluops.ai — check your connection. Use --skip-validation to continue offline.");
         }
         throw err;

package/dist/steps/cli.js

@@ -15,15 +15,28 @@ const DETECT_TIMEOUT_MS = 30_000;
 export function summarizeSpawnResult(r, op) {
     if (r.status === 0)
         return { ok: true };
+    // Timeout FIRST: a spawnSync timeout sets BOTH r.error (ETIMEDOUT) and
+    // signal SIGTERM — the specific diagnosis must win over the generic one.
     if (r.signal === "SIGTERM" && r.status === null) {
         return {
             ok: false,
             error: `npm ${op} exceeded ${NPM_TIMEOUT_MS / 1000}s timeout and was terminated`,
         };
     }
+    // Spawn failure (npm not on PATH, ENOENT) sets r.error with status null —
+    // without this check it renders as the useless "exit null".
+    if (r.error) {
+        return { ok: false, error: `npm could not be run: ${r.error.message}` };
+    }
     const stderr = (r.stderr ?? "").toString().trim();
     const stdout = (r.stdout ?? "").toString().trim();
-    return { ok: false, error: stderr || stdout || `exit ${r.status}` };
+    let error = stderr || stdout || `exit ${r.status}`;
+    // The most common global-install failure is a root-owned npm prefix —
+    // "try manually" without saying so sends the user into the same wall.
+    if (/EACCES|EPERM|permission denied/i.test(error)) {
+        error += ` — your npm global prefix isn't writable. A Node version manager (nvm/fnm) avoids this permanently; see docs.npmjs.com/resolving-eacces-permissions-errors`;
+    }
+    return { ok: false, error };
 }
 /** Default executor — shells out to `ulu` and `npm`. */
 export const defaultExecutor = {

package/dist/steps/commands.js

@@ -1,7 +1,7 @@
 import { readdir, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { ASSETS_DIR, findProjectRoot } from "../lib/paths.js";
-import { copyIfChanged, unlinkFiles, removeStaleFiles, } from "../lib/file-ops.js";
+import { copyIfChanged, unlinkFiles, removeStaleFiles, isEnoent, } from "../lib/file-ops.js";
 const SUBDIRS = ["agents", "workflows", "pipelines"];
 /** Install pre-rendered command files from harness-specific assets. */
 export async function installCommands(profile, localDefs, dryRun, existingManifestCommands) {
@@ -15,7 +15,12 @@ export async function installCommands(profile, localDefs, dryRun, existingManife
         await readdir(srcBase);
         hasSrcDir = true;
     }
-    catch {
+    catch (err) {
+        // Only genuine absence means "this harness ships no commands" — an
+        // EACCES here previously rendered as the 'coming soon' capability
+        // message while wiping the manifest's commands list.
+        if (!isEnoent(err))
+            throw err;
         hasSrcDir = false;
     }
     if (!hasSrcDir) {
@@ -35,6 +40,7 @@ export async function installCommands(profile, localDefs, dryRun, existingManife
     let pipelineCommands = 0;
     let skipped = 0;
     const allFiles = [];
+    const sourceFiles = [];
     const failures = [];
     for (const subdir of SUBDIRS) {
         const srcDir = join(srcBase, subdir);
@@ -46,7 +52,9 @@ export async function installCommands(profile, localDefs, dryRun, existingManife
         try {
             files = (await readdir(srcDir)).filter((f) => f.endsWith(".md") || f.endsWith(".toml"));
         }
-        catch {
+        catch (err) {
+            if (!isEnoent(err))
+                throw err; // see the srcBase probe above
             continue;
         }
         for (const file of files) {
@@ -64,11 +72,6 @@ export async function installCommands(profile, localDefs, dryRun, existingManife
                 else {
                     skipped++;
                 }
-                // Only track files that actually made it into a known state. Failed
-                // copies do NOT enter allFiles — otherwise the manifest's "remove
-                // stale entries on re-run" diff would treat a never-copied file as
-                // present, and an `--uninstall` would later try to unlink something
-                // that was never written.
                 allFiles.push(relativePath);
             }
             catch (err) {
@@ -78,16 +81,31 @@ export async function installCommands(profile, localDefs, dryRun, existingManife
                     error: err instanceof Error ? err.message : String(err),
                 });
             }
+            finally {
+                // Source census regardless of copy outcome — stale reconciliation
+                // must compare against what the package SHIPS, or a failed copy
+                // reads as "no longer shipped" and the prior working file is
+                // deleted (the ENOSPC-wipes-everything shape).
+                sourceFiles.push(relativePath);
+            }
         }
     }
-    const removed = await removeStaleFiles(destBase, existingManifestCommands, allFiles, dryRun);
+    const removed = await removeStaleFiles(destBase, existingManifestCommands, sourceFiles, dryRun);
+    // Record keeps failed-but-previously-installed files (prior copy is still
+    // on disk after source-based reconciliation) so uninstall can remove them.
+    const recordedCommandFiles = [
+        ...allFiles,
+        ...failures
+            .map((f) => f.file)
+            .filter((f) => existingManifestCommands?.includes(f) ?? false),
+    ];
     return {
         agentCommands,
         workflowCommands,
         pipelineCommands,
         skipped,
         removed,
-        files: allFiles,
+        files: recordedCommandFiles,
         failures,
     };
 }

package/dist/steps/mcp.js

@@ -3,21 +3,28 @@ import { join } from "node:path";
 import { checkMcpPackageAvailability } from "../lib/config-merger.js";
 import { findProjectRoot } from "../lib/paths.js";
 import { atomicWrite } from "../lib/atomic-write.js";
+import { serialize } from "../lib/write-coordinator.js";
+import { warn } from "../lib/display.js";
 /** Write UluOps MCP server entries into a harness's config file. */
 export async function installMcp(profile, apiKey, scope, dryRun) {
     const configPath = scope === "global"
         ? profile.paths.globalMcpConfig
         : join(await findProjectRoot(), profile.paths.localMcpConfig);
-    const config = await profile.mcpConfig.read(configPath);
-    const merged = profile.mcpConfig.merge(config, apiKey);
     const packageWarnings = [];
     const { missing } = await checkMcpPackageAvailability();
     if (missing.length > 0) {
         packageWarnings.push(`npm packages not found in registry: ${missing.join(", ")}. MCP servers may fail to start.`);
     }
-    if (!dryRun) {
-        await profile.mcpConfig.write(configPath, merged);
-    }
+    // Serialized read-merge-write: on profiles where the MCP config file is
+    // also the hooks settings file (Gemini CLI), this cycle and the hook
+    // install's cycle must never interleave.
+    await serialize(configPath, async () => {
+        const config = await profile.mcpConfig.read(configPath);
+        const merged = profile.mcpConfig.merge(config, apiKey);
+        if (!dryRun) {
+            await profile.mcpConfig.write(configPath, merged);
+        }
+    });
     if (scope === "local" && !dryRun) {
         await addToGitignore(profile.paths.localMcpConfig);
     }
@@ -25,9 +32,11 @@ export async function installMcp(profile, apiKey, scope, dryRun) {
 }
 /** Remove UluOps MCP server entries from the harness config. */
 export async function uninstallMcp(profile, configPath) {
-    const config = await profile.mcpConfig.read(configPath);
-    const cleaned = profile.mcpConfig.remove(config);
-    await profile.mcpConfig.write(configPath, cleaned);
+    await serialize(configPath, async () => {
+        const config = await profile.mcpConfig.read(configPath);
+        const cleaned = profile.mcpConfig.remove(config);
+        await profile.mcpConfig.write(configPath, cleaned);
+    });
 }
 async function addToGitignore(localConfigFilename) {
     const root = await findProjectRoot();
@@ -60,7 +69,7 @@ export async function ensureGitignoreEntry(gitignorePath, entry, reader = (p) =>
             await atomicWrite(gitignorePath, `${entry}\n`);
             return;
         }
-        console.warn(`Warning: could not read ${gitignorePath} (${err.message}). Skipping .gitignore update.`);
+        warn(`Could not read ${gitignorePath} (${err.message}). Skipping .gitignore update.`);
         return;
     }
     if (content.includes(entry))