@pharaoh-so/mcp 0.3.53 → 0.3.54

package/.mcp.json

@@ -3,7 +3,7 @@
 		"pharaoh": {
 			"command": "npx",
 			"args": [
-				"@pharaoh-so/mcp@0.3.53"
+				"@pharaoh-so/mcp@0.3.54"
 			]
 		}
 	}

package/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to `@pharaoh-so/mcp` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.54] - 2026-10-24
+
+### Added
+- The interactive setup (`npx @pharaoh-so/mcp` in a terminal) asks once whether to add one line to `~/.claude/CLAUDE.md`: "In repos Pharaoh has mapped, before searching or reading files, ask Pharaoh where the relevant code is, what calls it, and whether what you need already exists." Enter means yes. In Pharaoh's adoption benchmark, Claude Code called Pharaoh first when this line was in a CLAUDE.md, and rarely when the same sentence came from the server instructions or a plugin hook.
+- The line sits between `<!-- pharaoh-mcp:start … -->` and `<!-- pharaoh-mcp:end -->` markers. Setup appends that block or replaces the line inside it, and nothing else in the file changes. A symlinked file is left alone, and a proxy start (Claude Code launching the server) never asks or writes. Your answer is saved in `~/.pharaoh/claude-md-answer`, so a no stands.
+
+### Changed
+- `--clean` and `--logout` also remove that block, leaving the rest of the file byte for byte, and delete the saved answer so the next setup asks again.
+- `--logout` deletes the saved credentials first, so a cleanup step that fails can't leave them behind.
+
 ## [0.3.53] - 2026-10-23
 
 ### Changed

package/dist/helpers.d.ts

@@ -1,13 +1,23 @@
-/**
- * Pure helper functions for the mcp-proxy CLI — no side effects on import.
- * Separated from index.ts so tests can import without triggering main().
- */
 import type { TokenResponse } from "./auth.js";
 import type { Credentials } from "./credentials.js";
 /** The npx command users run to set up Pharaoh. Single source of truth for all output. */
 export declare const NPX_COMMAND = "npx @pharaoh-so/mcp";
 /** Write one or more lines to stderr. */
 export declare function printLines(...lines: string[]): void;
+/**
+ * Ask a yes/no question that defaults to yes: Enter, `y` or `yes` is yes; `n`
+ * or `no` is no; anything else asks again. Ctrl-C exits (130). On a terminal,
+ * keys pressed before the question showed (an Enter while sign-in waited) are
+ * dropped, so only a key pressed after reading it answers.
+ *
+ * @param question - The prompt, ending in something like `[Y/n] `.
+ * @param input - Where the answer is read (defaults to stdin).
+ * @param output - Where the prompt is written (defaults to stderr, like every other line).
+ * @returns The answer, or null when input ended before one.
+ */
+export declare function askYesNo(question: string, input?: NodeJS.ReadableStream & {
+    isTTY?: boolean;
+}, output?: NodeJS.WritableStream): Promise<boolean | null>;
 /** Parse CLI arguments. */
 export declare function parseArgs(argv?: string[]): {
     server: string;

package/dist/helpers.js

@@ -1,3 +1,8 @@
+/**
+ * Pure helper functions for the mcp-proxy CLI — no side effects on import.
+ * Separated from index.ts so tests can import without triggering main().
+ */
+import { createInterface } from "node:readline/promises";
 import { isExpired } from "./credentials.js";
 const DEFAULT_SERVER = "https://mcp.pharaoh.so";
 /** The npx command users run to set up Pharaoh. Single source of truth for all output. */
@@ -6,6 +11,54 @@ export const NPX_COMMAND = "npx @pharaoh-so/mcp";
 export function printLines(...lines) {
     process.stderr.write(`${lines.join("\n")}\n`);
 }
+/** How long to read and drop input that was typed before a question showed. */
+const TYPE_AHEAD_MS = 50;
+/**
+ * Ask a yes/no question that defaults to yes: Enter, `y` or `yes` is yes; `n`
+ * or `no` is no; anything else asks again. Ctrl-C exits (130). On a terminal,
+ * keys pressed before the question showed (an Enter while sign-in waited) are
+ * dropped, so only a key pressed after reading it answers.
+ *
+ * @param question - The prompt, ending in something like `[Y/n] `.
+ * @param input - Where the answer is read (defaults to stdin).
+ * @param output - Where the prompt is written (defaults to stderr, like every other line).
+ * @returns The answer, or null when input ended before one.
+ */
+export async function askYesNo(question, input = process.stdin, output = process.stderr) {
+    if (input.isTTY)
+        await dropTypedAhead(input);
+    const rl = createInterface({ input, output });
+    rl.on("SIGINT", () => {
+        output.write("\n");
+        process.exit(130);
+    });
+    rl.setPrompt(question);
+    rl.prompt();
+    try {
+        // The iterator ends on EOF; rl.question never settles then.
+        for await (const reply of rl) {
+            const answer = reply.trim().toLowerCase();
+            if (answer === "" || answer === "y" || answer === "yes")
+                return true;
+            if (answer === "n" || answer === "no")
+                return false;
+            rl.prompt();
+        }
+        return null;
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Read and drop the input already waiting, in raw mode so a half-typed line goes too. */
+async function dropTypedAhead(input) {
+    input.setRawMode?.(true);
+    const drop = () => { };
+    input.on("data", drop);
+    await new Promise((resolve) => setTimeout(resolve, TYPE_AHEAD_MS));
+    input.off("data", drop);
+    input.pause();
+}
 /** Parse CLI arguments. */
 export function parseArgs(argv = process.argv.slice(2)) {
     let server = DEFAULT_SERVER;
@@ -42,7 +95,7 @@ export function parseArgs(argv = process.argv.slice(2)) {
     return { server, logout };
 }
 export function printUsage() {
-    printLines("Usage: pharaoh-mcp [options]", "", "Options:", "  --server <url>    Pharaoh server URL (default: https://mcp.pharaoh.so)", "  --logout          Clear credentials, MCP config and the Claude Code plugin, then exit", "  --clean           Remove Pharaoh's MCP entries and plugin from Claude Code config", "  --install-skills  Reinstall the Claude Code plugin and OpenClaw skills", "  --version, -v     Print the version", "  --help, -h        Show this help", "", "Get started:", `  ${NPX_COMMAND}`, "");
+    printLines("Usage: pharaoh-mcp [options]", "", "Options:", "  --server <url>    Pharaoh server URL (default: https://mcp.pharaoh.so)", "  --logout          Clear credentials, MCP config, the Claude Code plugin and the CLAUDE.md line, then exit", "  --clean           Remove Pharaoh's MCP entries, plugin and CLAUDE.md line from Claude Code", "  --install-skills  Reinstall the Claude Code plugin and OpenClaw skills", "  --version, -v     Print the version", "  --help, -h        Show this help", "", "Get started:", `  ${NPX_COMMAND}`, "");
 }
 /**
  * Validate that a server-supplied SSE URL shares the same origin as the configured server.

package/dist/index.js

@@ -16,8 +16,8 @@ import { pollForToken, printActivationPrompt, printAuthSuccess, requestDeviceCod
 import { AuthRequiredBackend, createSseBackend } from "./backend.js";
 import { deleteCredentials, readCredentials, writeCredentials, } from "./credentials.js";
 import { createGateway } from "./gateway.js";
-import { formatTtl, parseArgs, printLines, printUsage, resolveSseUrl, tokenToCredentials, } from "./helpers.js";
-import { allowReadTools, describeAllowReadTools, formatKeptCommands, runInstallSkills, } from "./install-skills.js";
+import { askYesNo, formatTtl, parseArgs, printLines, printUsage, resolveSseUrl, tokenToCredentials, } from "./helpers.js";
+import { allowReadTools, CLAUDE_MD_QUESTION, describeAllowReadTools, describeClaudeMdOutcome, formatKeptCommands, offerClaudeMdLine, runInstallSkills, } from "./install-skills.js";
 import { handleRefreshFailure, tryMidSessionRefresh } from "./lifecycle.js";
 import { TenantSuspendedError, TokenExpiredError } from "./proxy.js";
 import { startInAuthRequiredMode, startInSseMode } from "./proxy-server.js";
@@ -61,17 +61,18 @@ async function main() {
         const { uninstallClaudePlugin } = await import("./install-skills.js");
         cleanSlate();
         uninstallClaudePlugin();
-        printLines("Pharaoh: cleaned all MCP entries and the plugin from Claude Code config");
+        printLines("Pharaoh: removed its MCP entries, plugin and ~/.claude/CLAUDE.md line from Claude Code");
         process.exit(0);
     }
     const { server, logout } = parseArgs(args);
     if (logout) {
         const { cleanSlate } = await import("./setup.js");
         const { uninstallClaudePlugin } = await import("./install-skills.js");
+        // Credentials first: a cleanup step that fails must never leave the tokens behind.
+        deleteCredentials();
         cleanSlate();
         uninstallClaudePlugin();
-        deleteCredentials();
-        printLines("Pharaoh: credentials, MCP config and the Claude Code plugin cleared");
+        printLines("Pharaoh: credentials, MCP config, the Claude Code plugin and the ~/.claude/CLAUDE.md line cleared");
         process.exit(0);
     }
     const isInteractive = Boolean(process.stdin.isTTY);
@@ -113,6 +114,11 @@ async function main() {
         const kept = formatKeptCommands(keptCommands);
         if (kept)
             printLines(kept);
+        // The one line agents act on (bench #1305) goes in the user's own
+        // ~/.claude/CLAUDE.md, so it's asked about once, here, never on a start.
+        const claudeMd = describeClaudeMdOutcome(await offerClaudeMdLine(() => askYesNo(CLAUDE_MD_QUESTION), Boolean(process.stdin.isTTY && process.stderr.isTTY)));
+        if (claudeMd)
+            printLines(claudeMd);
         // The registration is pinned to this version; upgrading is a deliberate
         // re-run. Interactive only, and quiet when the registry can't be reached.
         const latest = await fetchLatestVersion();

package/dist/install-skills.d.ts

@@ -7,8 +7,9 @@ import { type ClaudeCli } from "./setup.js";
  */
 export declare function claudePluginState(home?: string): "enabled" | "disabled" | "absent";
 /**
- * Uninstall Pharaoh's Claude Code plugin: through the CLI, then the local
- * marketplace directory and any pre-marketplace install.
+ * Uninstall Pharaoh's Claude Code plugin (through the CLI, then the local
+ * marketplace directory and any pre-marketplace install) and its block in
+ * ~/.claude/CLAUDE.md. Run by --clean and --logout.
  *
  * @param home - Home directory override (defaults to os.homedir()).
  * @param claude - `claude` CLI runner (defaults to the real CLI for `home`).
@@ -83,6 +84,29 @@ export declare function allowReadTools(home?: string): AllowReadToolsResult;
  * @param result - What `allowReadTools` returned.
  */
 export declare function describeAllowReadTools(result: AllowReadToolsResult): string;
+/** What the interactive setup asks before writing the line. */
+export declare const CLAUDE_MD_QUESTION = "Pharaoh: add one line to ~/.claude/CLAUDE.md so Claude checks Pharaoh before searching your code?\n  \"In repos Pharaoh has mapped, before searching or reading files, ask Pharaoh where the relevant code is, what calls it, and whether what you need already exists.\"\n[Y/n] ";
+/** What `offerClaudeMdLine` did; `describeClaudeMdOutcome` words it. */
+export type ClaudeMdOutcome = "added" | "updated" | "declined" | "kept" | "failed" | "current" | "answered" | "cancelled" | "no-terminal" | "no-claude";
+/**
+ * Offer the Pharaoh-first line in ~/.claude/CLAUDE.md. Interactive setup only,
+ * never a proxy start. Asks only when the block is absent and the user hasn't
+ * answered before; a stale block (an earlier yes) is updated without asking.
+ * The line is appended inside markers, and nothing else in the file changes.
+ *
+ * @param ask - Asks the user: true for yes, false for no, null when input ended.
+ * @param isTerminal - Whether stdin and stderr are a terminal; false asks and writes nothing.
+ * @param home - Home directory override (defaults to os.homedir()).
+ * @returns What happened, for `describeClaudeMdOutcome`.
+ */
+export declare function offerClaudeMdLine(ask: () => Promise<boolean | null>, isTerminal: boolean, home?: string): Promise<ClaudeMdOutcome>;
+/**
+ * The line the interactive setup prints for an `offerClaudeMdLine` outcome, or
+ * null when there is nothing to say (already current, already answered, no terminal).
+ *
+ * @param outcome - What `offerClaudeMdLine` returned.
+ */
+export declare function describeClaudeMdOutcome(outcome: ClaudeMdOutcome): string | null;
 /** What `runInstallSkills` wants the caller to tell the user. */
 export interface InstallResult {
     /** Files in ~/.claude/commands/ left as they were because they are not Pharaoh's. */

package/dist/install-skills.js

@@ -6,7 +6,7 @@
  * and OpenClaw skills in ~/.openclaw/skills/. Also merges the Pharaoh MCP
  * server config into OpenClaw.
  */
-import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { closeSync, constants, cpSync, existsSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -202,8 +202,9 @@ function removeLegacyClaudePlugin(home) {
 /** Plugin id the pre-marketplace installer wrote into installed_plugins.json. */
 const LEGACY_PLUGIN_ID = "pharaoh@pharaoh-so";
 /**
- * Uninstall Pharaoh's Claude Code plugin: through the CLI, then the local
- * marketplace directory and any pre-marketplace install.
+ * Uninstall Pharaoh's Claude Code plugin (through the CLI, then the local
+ * marketplace directory and any pre-marketplace install) and its block in
+ * ~/.claude/CLAUDE.md. Run by --clean and --logout.
  *
  * @param home - Home directory override (defaults to os.homedir()).
  * @param claude - `claude` CLI runner (defaults to the real CLI for `home`).
@@ -213,6 +214,7 @@ export function uninstallClaudePlugin(home = homedir(), claude = claudeCliFor(ho
     claude(["plugin", "marketplace", "remove", MARKETPLACE_NAME]);
     rmSync(claudeMarketplaceDir(home), { recursive: true, force: true });
     removeLegacyClaudePlugin(home);
+    removeClaudeMdBlock(home);
 }
 /**
  * Copy every skill directory from `srcDir` to `dstDir`, prefixing both the
@@ -675,6 +677,199 @@ export function describeAllowReadTools(result) {
             return "Pharaoh: ~/.claude/settings.json is not valid JSON; left as is. Pharaoh's tools ask before they run.";
     }
 }
+// ── Claude Code instructions (~/.claude/CLAUDE.md) ──────────────────
+//
+// Agents acted on the Pharaoh-first line only from a CLAUDE.md, not from server
+// instructions or a hook (benchmarks/adoption/results/2026-10-23-everyday-auto-line.md).
+// The file is the user's: the interactive setup adds the line on a yes, inside
+// markers, and --clean/--logout remove exactly what it wrote.
+/** The Pharaoh-first line; same text as PHARAOH_SCOPED_LINE in scripts/adoption-grade.ts. */
+const PHARAOH_CLAUDE_MD_LINE = "In repos Pharaoh has mapped, before searching or reading files, ask Pharaoh where the relevant code is, what calls it, and whether what you need already exists.";
+/** What the interactive setup asks before writing the line. */
+export const CLAUDE_MD_QUESTION = `Pharaoh: add one line to ~/.claude/CLAUDE.md so Claude checks Pharaoh before searching your code?\n  "${PHARAOH_CLAUDE_MD_LINE}"\n[Y/n] `;
+/** File under ~/.pharaoh holding the user's answer, so setup asks once. */
+const CLAUDE_MD_ANSWER_FILE = "claude-md-answer";
+/**
+ * Open flags that refuse a symlink even if one is swapped in after the check
+ * (SC-7; O_NOFOLLOW is undefined on Windows). A new block is appended, so the
+ * user's bytes are never rewritten; a stale block or a removal rewrites the file.
+ */
+const NO_FOLLOW = constants.O_NOFOLLOW ?? 0;
+const APPEND_NO_FOLLOW = constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | NO_FOLLOW;
+const REWRITE_NO_FOLLOW = constants.O_WRONLY | constants.O_TRUNC | NO_FOLLOW;
+/** Write `text` to `path` opened with `flags` (APPEND_NO_FOLLOW or REWRITE_NO_FOLLOW). */
+function writeNoFollow(path, text, flags) {
+    const fd = openSync(path, flags);
+    try {
+        writeFileSync(fd, text);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Pharaoh's block. `pharaoh-mcp:start+nl` records that the installer also added
+ * the newline before it (the file didn't end in one), so removal takes it back too.
+ */
+function claudeMdBlock(addedNewline) {
+    const start = `<!-- pharaoh-mcp:start${addedNewline ? "+nl" : ""} (managed by npx ${PACKAGE_NAME}; --clean or --logout removes it) -->`;
+    return `${start}\n${PHARAOH_CLAUDE_MD_LINE}\n<!-- pharaoh-mcp:end -->\n`;
+}
+/**
+ * Find the one Pharaoh block in `text`: null when there is none, "broken"
+ * when a marker is missing its pair, repeated or out of order.
+ */
+function findClaudeMdBlock(text) {
+    const starts = [...text.matchAll(/^<!-- pharaoh-mcp:start(\+nl)?\b[^\n]*\n/gm)];
+    const ends = [...text.matchAll(/^<!-- pharaoh-mcp:end -->\n?/gm)];
+    if (starts.length === 0 && ends.length === 0)
+        return null;
+    const [start, end] = [starts[0], ends[0]];
+    const body = start ? start.index + start[0].length : 0;
+    if (starts.length !== 1 || ends.length !== 1 || end.index < body)
+        return "broken";
+    return {
+        from: start.index,
+        body,
+        to: end.index,
+        through: end.index + end[0].length,
+        addedNewline: start[1] !== undefined,
+    };
+}
+/** Read ~/.claude/CLAUDE.md without following a symlink. */
+function readClaudeMd(home) {
+    const path = join(home, ".claude", "CLAUDE.md");
+    const dir = lstatSync(join(home, ".claude"), { throwIfNoEntry: false });
+    if (!dir)
+        return { state: "no-claude", path, text: "", block: null };
+    const file = lstatSync(path, { throwIfNoEntry: false });
+    if (!dir.isDirectory() || (file && !file.isFile())) {
+        return { state: "kept", path, text: "", block: null };
+    }
+    const text = file ? readFileSync(path, "utf-8") : "";
+    const block = findClaudeMdBlock(text);
+    if (block === "broken")
+        return { state: "kept", path, text, block: null };
+    if (!block) {
+        return {
+            state: text.includes(PHARAOH_CLAUDE_MD_LINE) ? "current" : "absent",
+            path,
+            text,
+            block,
+        };
+    }
+    const current = text.slice(block.body, block.to) === `${PHARAOH_CLAUDE_MD_LINE}\n`;
+    return { state: current ? "current" : "stale", path, text, block };
+}
+/**
+ * Offer the Pharaoh-first line in ~/.claude/CLAUDE.md. Interactive setup only,
+ * never a proxy start. Asks only when the block is absent and the user hasn't
+ * answered before; a stale block (an earlier yes) is updated without asking.
+ * The line is appended inside markers, and nothing else in the file changes.
+ *
+ * @param ask - Asks the user: true for yes, false for no, null when input ended.
+ * @param isTerminal - Whether stdin and stderr are a terminal; false asks and writes nothing.
+ * @param home - Home directory override (defaults to os.homedir()).
+ * @returns What happened, for `describeClaudeMdOutcome`.
+ */
+export async function offerClaudeMdLine(ask, isTerminal, home = homedir()) {
+    if (!isTerminal)
+        return "no-terminal";
+    const answerPath = join(home, ".pharaoh", CLAUDE_MD_ANSWER_FILE);
+    try {
+        let file = readClaudeMd(home);
+        // A saved answer also silences the add-it-yourself line of "kept": a no stands.
+        const answered = lstatSync(answerPath, { throwIfNoEntry: false }) !== undefined;
+        if (answered && (file.state === "absent" || file.state === "kept"))
+            return "answered";
+        if (file.state === "absent") {
+            const yes = await ask();
+            if (yes === null)
+                return "cancelled";
+            if (!yes) {
+                saveClaudeMdAnswer(home, answerPath, "no");
+                return "declined";
+            }
+            file = readClaudeMd(home); // again: it may have changed while the user answered
+        }
+        if (file.state === "absent") {
+            const newline = file.text !== "" && !file.text.endsWith("\n");
+            writeNoFollow(file.path, `${newline ? "\n" : ""}${claudeMdBlock(newline)}`, APPEND_NO_FOLLOW);
+            saveClaudeMdAnswer(home, answerPath, "yes");
+            return "added";
+        }
+        if (file.state === "stale") {
+            const { body, to } = file.block;
+            const next = `${file.text.slice(0, body)}${PHARAOH_CLAUDE_MD_LINE}\n${file.text.slice(to)}`;
+            writeNoFollow(file.path, next, REWRITE_NO_FOLLOW);
+            return "updated";
+        }
+        return file.state;
+    }
+    catch {
+        // ALLOWED-CATCH: setup is done; the user gets the line to add by hand, and no saved answer, so the next setup asks again
+        return "failed";
+    }
+}
+/** Save the user's answer (0600). Never through a symlink: `wx` refuses any existing path. */
+function saveClaudeMdAnswer(home, answerPath, answer) {
+    try {
+        ensurePharaohHome(join(home, ".pharaoh"));
+        writeFileSync(answerPath, `${answer}\n`, { mode: 0o600, flag: "wx" });
+    }
+    catch {
+        // ALLOWED-CATCH: an answer that can't be saved only means the next setup asks again
+    }
+}
+/**
+ * The line the interactive setup prints for an `offerClaudeMdLine` outcome, or
+ * null when there is nothing to say (already current, already answered, no terminal).
+ *
+ * @param outcome - What `offerClaudeMdLine` returned.
+ */
+export function describeClaudeMdOutcome(outcome) {
+    const byHand = `To have Claude check Pharaoh first, add this line to it yourself:\n  ${PHARAOH_CLAUDE_MD_LINE}`;
+    switch (outcome) {
+        case "added":
+            return `Pharaoh: added the line to ~/.claude/CLAUDE.md, between pharaoh-mcp markers. npx ${PACKAGE_NAME} --clean removes it.`;
+        case "updated":
+            return "Pharaoh: updated its line in ~/.claude/CLAUDE.md.";
+        case "declined":
+            return "Pharaoh: left ~/.claude/CLAUDE.md as it is. Setup won't ask again.";
+        case "kept":
+            return `Pharaoh: left ~/.claude/CLAUDE.md as it is (it's a symlink, or its Pharaoh markers don't pair up). ${byHand}`;
+        case "failed":
+            return `Pharaoh: couldn't write ~/.claude/CLAUDE.md. ${byHand}`;
+        default:
+            return null;
+    }
+}
+/**
+ * Remove Pharaoh's block from ~/.claude/CLAUDE.md, taking out only bytes the
+ * installer wrote, and forget the answer so the next setup asks again. A file
+ * left empty stays: there's no telling whether the user had it before. Never
+ * throws: --clean and --logout go on to their other steps.
+ *
+ * @param home - Home directory override (defaults to os.homedir()).
+ */
+function removeClaudeMdBlock(home) {
+    try {
+        const { path, text, block } = readClaudeMd(home);
+        if (block) {
+            // The newline before a start+nl marker is Pharaoh's only while the block
+            // ends the file; once the user writes below it, it ends their line.
+            const ownsNewline = block.addedNewline && block.from > 0 && block.through === text.length;
+            const from = ownsNewline ? block.from - 1 : block.from;
+            writeNoFollow(path, text.slice(0, from) + text.slice(block.through), REWRITE_NO_FOLLOW);
+        }
+        rmSync(join(home, ".pharaoh", CLAUDE_MD_ANSWER_FILE), { force: true });
+    }
+    catch (err) {
+        // ALLOWED-CATCH: the other cleanup steps (credentials on --logout) must still run; the user is told what's left
+        const code = err.code;
+        process.stderr.write(`Pharaoh: couldn't remove its line from ~/.claude/CLAUDE.md${code ? ` (${code})` : ""}. Delete the pharaoh-mcp block by hand.\n`);
+    }
+}
 /**
  * Main entry point for --install-skills, also run on every proxy start.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@pharaoh-so/mcp",
 	"mcpName": "so.pharaoh/pharaoh",
-	"version": "0.3.53",
+	"version": "0.3.54",
 	"description": "MCP proxy for Pharaoh — maps codebases into queryable knowledge graphs for AI agents. Enables Claude Code in headless environments (VPS, SSH, CI) via device flow auth.",
 	"type": "module",
 	"main": "dist/index.js",