@orlan-maker/cli 0.1.0 → 0.2.1

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "orlan",
       "source": "./",
-      "description": "The Orlan review board in Claude Code: the orlan command, a monitor, hooks, skills and the MCP server."
+      "description": "The Orlan review board in Claude Code: the orlan command, hooks and skills."
     }
   ]
 }

package/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "name": "orlan",
   "displayName": "Orlan",
-  "version": "0.1.0",
-  "description": "Work with the Orlan review board: the orlan command, a monitor that wakes the session when a person mentions the agent, hooks that show the session's state on the board, the skills, and the MCP server.",
+  "version": "0.2.1",
+  "description": "Work with the Orlan review board: the orlan command, hooks that show the session's state on the board, and the skills.",
   "author": {
     "name": "Orlan",
     "url": "https://orlan.app"

package/README.md

@@ -2,20 +2,18 @@
 
 The `orlan` command connects an AI agent to [Orlan](https://orlan.app), the review board for decks,
 PDFs, images and HTML. The agent then reads the comments on a file, posts a new version, replies and
-resolves, from the terminal or over MCP.
+resolves, all with the `orlan` command in the terminal.
 
 Needs Node 22.18 or later.
 
 ## Set up
 
-In Orlan, open the organisation menu, choose **Connect an agent**, and copy the prompt for your agent.
-The prompt runs these four commands:
+Three commands connect an agent:
 
 ```
 npm i -g @orlan-maker/cli
 orlan auth login
-orlan skills add --agent claude-code
-orlan mcp connect --agent claude-code
+orlan connect --agent claude-code
 ```
 
 - `orlan auth login` shows a code and opens the approval page in your browser. Sign in, check the
@@ -23,24 +21,31 @@ orlan mcp connect --agent claude-code
   approval (codes work for 10 minutes). The CLI token goes to the OS keychain (macOS keychain, or the
   Secret Service on Linux), else to `credentials.json` in the config folder, readable by you only.
   `--server <url>` signs in to another Orlan server; `--no-browser` only prints the address.
-- `orlan skills add` writes the skills `orlan-review` and `orlan-versions` where the agent reads skills.
-- `orlan mcp connect` makes an agent token and adds the Orlan MCP server to the agent. Only an admin of
-  the organisation connects agents. For Claude Code it also installs the Orlan plugin (below);
-  `--no-plugin` adds only the MCP server.
-- `orlan status` shows who you are, the server, and each connected agent, and tests each agent's MCP
-  connection. It ends with exit code 1 when a check fails.
+- `orlan connect` makes an agent token and keeps it in the keychain. The agent then works on Orlan
+  with the `orlan` command. Only an admin of the organisation connects agents. The command installs
+  the skills, and the plugin or the hooks of the agent (table below). Then it tests the token with one
+  plain HTTP call. `--topic` and `--role` change the topics and the role of the agent.
+- The skills are `orlan`, `orlan-review` and `orlan-versions`. `orlan` tells the agent what Orlan is:
+  "the canvas", "the board" and "the topic" mean the Orlan topic, and a file the person asks for goes
+  on the topic. A diagram is board shapes, never an HTML file or notes. `orlan skills add` writes the
+  skills again without a new token.
+- An older CLI wrote an Orlan server entry in the agent's settings. `orlan connect` removes that
+  entry, and keeps every other entry.
+- `orlan status` shows who you are, the server, and each connected agent, and tests each agent's
+  connection with one plain HTTP call. It ends with exit code 1 when a check fails.
 
 Agents: `claude-code`, `codex`, `cursor`, `opencode`, `other`.
 
-| Agent | Skills | MCP entry |
+| Agent | Skills | Also installs |
 | --- | --- | --- |
-| claude-code | `~/.claude/skills` | `claude mcp add --transport http --scope user orlan ...` |
-| codex | `~/.agents/skills` | `[mcp_servers.orlan]` in `~/.codex/config.toml` |
-| cursor | `~/.cursor/skills` | `mcpServers.orlan` in `~/.cursor/mcp.json` |
-| opencode | `~/.config/opencode/skills` | `mcp.orlan` in `~/.config/opencode/opencode.json`, and the plugin in `~/.config/opencode/plugins/orlan.js` |
-| other | `.agents/skills` in the folder you are in | `orlan mcp print` prints the address and the header |
+| claude-code | in the plugin | the Claude Code plugin (below) |
+| codex | `~/.agents/skills` | the hooks in `$CODEX_HOME/hooks.json` |
+| cursor | `~/.cursor/skills` | the hooks in `~/.cursor/hooks.json` |
+| opencode | `~/.config/opencode/skills` | the plugin in `~/.config/opencode/plugins/orlan.js` |
+| other | `.agents/skills` in the folder you are in | - |
 
-Without `--agent`, the CLI finds the agent that runs it from its environment.
+With `--no-plugin`, Claude Code gets no plugin, and the skills go to `~/.claude/skills`. Without
+`--agent`, the CLI finds the agent that runs it from its environment.
 
 ## The Claude Code plugin
 
@@ -52,45 +57,57 @@ claude plugin marketplace add AliProgrammin/orlan-plugin
 claude plugin install orlan@orlan
 ```
 
-`orlan mcp connect --agent claude-code` installs it too; from a checkout,
+`orlan connect --agent claude-code` installs it too; from a checkout,
 `claude plugin marketplace add ./packages/cli` and `claude plugin install orlan@orlan` do the same. One install gives the session:
 
 - `orlan` on the PATH of Claude Code's shell.
-- A monitor that runs `orlan wait --follow`: a mention of the agent wakes the session, also when it is
-  idle. Monitors run only in an interactive session.
 - Hooks that show the session on the board: working (session start, a prompt, each tool), waiting for
   input (a permission prompt or a question in the terminal), idle (the turn ended), done (the session
-  ended). At the session start, `orlan brief` goes into the session's context.
-- The skills `orlan-review` and `orlan-versions`.
-- The Orlan MCP server. Its header comes from `orlan mcp headers`, with the token from the keychain. It
-  goes to `$ORLAN_SERVER`, else https://orlan.app: on another server, set `ORLAN_SERVER` where you start
-  Claude Code.
+  ended). At the session start, `orlan brief` goes into the session's context, with one line that says
+  what Orlan is: "the canvas", "the board" and "the topic" mean the Orlan topic, and a diagram, a page,
+  a deck or a mock starts with the `orlan` skill. Codex, Cursor and OpenCode get the same line, from
+  `hooks/orlan-intro.txt`.
+- The skills `orlan`, `orlan-review` and `orlan-versions`.
+
+The session works on Orlan with the `orlan` command. A new request comes to the session when the agent
+runs `orlan brief`, `orlan inbox` or `orlan wait`.
 
 ## The OpenCode plugin
 
-`orlan mcp connect --agent opencode` also writes the Orlan plugin to `~/.config/opencode/plugins/orlan.js`.
+`orlan connect --agent opencode` also writes the Orlan plugin to `~/.config/opencode/plugins/orlan.js`.
 When a session's turn ends, the plugin runs `orlan hook wait`. A mention of the agent on the board then goes
 to the session as a new prompt, and a new turn starts. The plugin also shows the session on the board:
-working, waiting for a permission prompt, idle, done. A request wakes a session only while OpenCode runs
-(the TUI or `opencode serve`). Restart a running OpenCode to load the plugin. `orlan mcp disconnect
+working, waiting for a permission prompt, idle, done. It adds the line that says what Orlan is to the
+system prompt of each session. A request wakes a session only while OpenCode runs
+(the TUI or `opencode serve`). Restart a running OpenCode to load the plugin. `orlan disconnect
 --agent opencode` removes it.
 
 ## Daily commands
 
 Each works as the connected agent, with the agent's own token, and is in the topic's audit log. Each
-is plain HTTP with the agent token, with no MCP session: `orlan files push` makes 2 requests (the file,
+is plain HTTP with the agent token: `orlan files push` makes 2 requests (the file,
 then the post), `orlan files pull` 2 (the file's answer, then the download), and most others 1.
 
 ```
 orlan brief [--topic <topic>]
 orlan topics list
-orlan files list --topic <topic>
-orlan files add <path> [--topic <topic>]
-orlan files pull <file> [--version <n>] [--topic <topic>] [--out <path>] [--edit [--shared] [--ttl <time>]]
+orlan files list [--topic <topic>]
+orlan files add <path> [--at <x,y>] [--topic <topic>]
+orlan files pull <file> [--version <n>] [--pages <n,n> | --since <n>] [--topic <topic>] [--out <path>] [--edit [--shared] [--ttl <time>]]
 orlan files push <file> <path> --changelog "<what changed>" [--base <n>] [--topic <topic>]
+orlan files rollback <file> --version <n> [--changelog "<why>"] [--topic <topic>]
 orlan comments list [--topic <topic>] [--status open|resolved|all] [--file <file>]
 orlan comment <thread> "<text>" | --file <file> --page <n> [--region <x,y,w,h>] "<text>" | --at <x,y> "<text>" [--topic <topic>]
 orlan comments resolve <thread> [--topic <topic>]
+orlan board [--topic <topic>]
+orlan board add note|text|frame ["<text>"] --at <x,y> [--size <w,h>] | arrow --from <item> --to <item>
+orlan board change <item> [--text "<text>"] [--at <x,y>] [--size <w,h>] [--from <item>|none] [--to <item>|none]
+orlan board delete <item>...
+orlan board edit '<edits as JSON>'
+orlan tasks add "<text>" [--assignee me|user:<id>|agent:<id>] [--thread <thread>] [--done]
+orlan tasks change <task id> [--text "<text>"] [--done | --open] [--assignee me|user:<id>|agent:<id>|none]
+orlan decisions add "<title>" [--body "<text>"] [--thread <thread>]
+orlan search "<words>" [--topic <topic>] [--limit <n>]
 orlan open [<topic id>] [--file <file id>]
 orlan wait [--follow]
 orlan inbox [--new]
@@ -98,7 +115,6 @@ orlan inbox done <request id>
 orlan respond <request id> --message "<text>" [--file <path>] [--to <file>] [--changelog "<text>"] [--base <n>] [--wait]
 orlan hook <working|needs-input|idle|done>
 orlan hook start|stop --agent codex|cursor
-orlan mcp headers
 ```
 
 The ids people see work as input: a topic by its name, a file by its name, a thread as `#12`, and a
@@ -108,14 +124,33 @@ its id and topic: give the id, or add `--topic`.
 
 Every output ends with a `next_step` line, and every error says what to do next in a `next_step` line.
 With `--json`, a command prints small JSON on one line with a `next_step` field; an error is JSON too:
-`{"error": "<code>", "message": "...", "next_step": "..."}`. The hook commands and `orlan mcp headers`
+`{"error": "<code>", "message": "...", "next_step": "..."}`. The hook commands
 print only what their harness reads, and `orlan inbox --new` prints nothing when there is no request.
 
 `orlan brief` is for the start of a session. It prints the topic, the open requests, the files with
 their current versions, and one `next_step` line, in about 500 tokens for 6 files and 3 requests. The
 topic is the one the agent used last, else its only topic. `orlan files add` posts a new file to the
-topic and puts it on the board, in one request. Both are plain HTTP calls with the agent token, with
-no MCP session.
+topic and puts it on the board, in one request. Both are plain HTTP calls with the agent token.
+
+`orlan board` prints the board of the topic. Each item shows its id, type, place and size in board
+coordinates, and its text. A file shows its name and pages, and an arrow the items it links. Then come the
+timer, the open vote and the last vote with its result, and the open tasks. People vote; an agent reads
+the vote, it does not vote. `orlan board add` adds a note, a text, a frame or an arrow, `orlan board
+change` changes an item's text, place, size or arrow ends, and `orlan board delete` deletes items. Each
+command is one step that a person can undo on the board. `orlan board edit` takes a JSON list of edits
+and makes them in one step, all or none; `"#0"` names the item that the first edit made. A file on the
+board only moves. A negative coordinate goes with `=`: `--at=-50,120`. The CLI cannot draw shapes yet,
+so a diagram is not made with these commands.
+
+`orlan tasks add` adds a task to the topic, `orlan tasks change` changes its text, marks it done or open,
+or sets its assignee (`--assignee me` is the agent). `orlan decisions add` records a decision in the
+topic's decision log. `--thread #12` links a task or a decision to the thread it comes from.
+
+`orlan search` searches the topics of the agent: topic and file names, the text of the pages, comments
+and decisions. Each result names its topic and ids, and the matches are between « and ».
+
+A command that needs a topic takes `--topic`. Without it, the command uses the topic the agent used
+last, else its only topic.
 
 `orlan comment` replies in a thread, or opens a new thread: with `--file` and `--page` on a page (the
 whole page, or `--region` as fractions of the page), with `--at` on a point of the board. People see it
@@ -131,6 +166,13 @@ goes back to the inbox within 20 seconds. `--follow` stays open and prints one l
 `--new` takes the new ones and prints nothing when there are none, for a stop hook. `orlan inbox done`
 closes a request when its work is finished.
 
+`orlan files pull --pages 2,5` gets pages, not the file: it saves the image of each page as
+`<name>-page-<n>.png` in the `--out` folder, and prints the text of each page. `--since 4` gets the
+pages that changed since version 4, from the page compare. `orlan files list` shows the pages that
+changed from the version before. `orlan files add --at <x,y>` puts a new file at that point of the
+board, or at the nearest free place. `orlan files rollback <file> --version 3` posts version 3 again as
+the newest version; it waits for a person to make it current.
+
 `orlan files pull --edit` puts the agent's claim on the file: other agents get it in their answer,
 and the board shows "Claude (for Sara) is editing from v4 - 3 min" on the file. The claim warns and
 blocks nothing. It lasts 15 minutes (`--ttl 90s`, `--ttl 1h`), and a push or respond of the agent ends
@@ -154,15 +196,18 @@ standard input, makes one request, prints nothing and makes no model call. Orlan
 terminal prompt; the board tells people to go to the terminal. With no agent connected, it does nothing.
 
 `orlan hook start` and `orlan hook stop` are the session start and stop hooks of Codex and Cursor, and
-`orlan mcp connect --agent codex|cursor` installs them. Codex and Cursor sessions do not wake when idle:
-the start hook puts the brief in the session, and when a turn ends the stop hook gives the session the
+`orlan connect --agent codex|cursor` installs them. Codex and Cursor sessions do not wake when idle:
+the start hook puts the brief and the line that says what Orlan is in the session, and when a turn ends the stop hook gives the session the
 new requests, so it works on at once. After 5 requests in a row it lets the session stop. Codex runs a
 hook only after you trust it once with `/hooks`.
 
-`orlan mcp headers` prints the MCP authorization header as JSON, for a `headersHelper`. The plugin's MCP
-server runs it.
+Each command shows on the board as a step of the agent's hook session: a page it reads moves its cursor
+there. The command finds its session from the harness: `CLAUDE_CODE_SESSION_ID` in Claude Code,
+`CODEX_THREAD_ID` in Codex, and in OpenCode `ORLAN_SESSION` (the plugin sets it) or
+`OPENCODE_SESSION_ID`. Cursor gives no session id to the shell: Orlan then takes the hook session of the
+agent that reported last.
 
-While a wait of the agent is open (the plugin's monitor), the `next_step` lines do not say `--wait`:
+While a wait of the agent is open, the `next_step` lines do not say `--wait`:
 the open wait gets the next request.
 
 A version the agent posts waits for a person to make it current. When several agents are connected,
@@ -170,7 +215,8 @@ add `--agent <id>`.
 
 ## Stop
 
-- `orlan mcp disconnect --agent <id>` revokes the agent's token and removes its MCP entry.
+- `orlan disconnect --agent <id>` revokes the agent's token, and removes its plugin or hooks and an old
+  Orlan server entry. The skills stay.
 - `orlan auth logout` revokes the CLI token. You can also revoke it in Orlan: Profile, Orlan CLI sign-ins.
 
 Run `orlan help` for every command, and `orlan <command> --help` for its options.

package/dist/agents.js

@@ -1,6 +1,7 @@
 /**
- * The agents the CLI connects: where each one reads skills, and how its MCP settings get the Orlan
- * server. The ids match the web app's connect dialog (agentClients in @orlan/shared).
+ * The agents the CLI connects: where each one reads skills, its hooks or plugin, and the old Orlan MCP
+ * entry that a connect removes (D088). The ids match the web app's connect dialog (agentClients in
+ * @orlan/shared).
  */
 import { execFile } from "node:child_process";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
@@ -16,7 +17,7 @@ export const agentLabels = {
     opencode: "OpenCode",
     other: "your agent",
 };
-/** The MCP server name in each agent's settings. */
+/** The name of the old Orlan MCP server in each agent's settings (before D088). */
 export const MCP_NAME = "orlan";
 export function parseAgent(value) {
     if (agentIds.includes(value))
@@ -61,8 +62,8 @@ export function skillsDir(agent, cwd = process.cwd()) {
     }
 }
 /**
- * The MCP settings file of an agent that has one the CLI edits. Checked against each tool's
- * documentation on 2026-09-24 (B018):
+ * The MCP settings file of an agent, where an older CLI wrote the Orlan MCP entry. Checked against each
+ * tool's documentation on 2026-09-24 (B018):
  * - Codex: `[mcp_servers.<name>]` with `url` and `http_headers` in ~/.codex/config.toml -
  *   https://learn.chatgpt.com/docs/extend/mcp?surface=cli (was https://developers.openai.com/codex/mcp)
  * - Cursor: `mcpServers.<name>` with `url` and `headers` in ~/.cursor/mcp.json (the editor and the
@@ -101,14 +102,13 @@ async function writeText(file, text) {
 /** A TOML table header line such as `[mcp_servers.orlan]` or `[[x]]`, with its dotted name. */
 const tableHeader = (line) => /^\s*\[\[?\s*([^\]]+?)\s*\]\]?\s*(#.*)?$/.exec(line)?.[1];
 /**
- * The Codex config.toml without the `[mcp_servers.orlan]` table and its sub-tables, and with the new
- * one when `entry` is given. Every other line stays as it was, comments too.
+ * The Codex config.toml without the `[mcp_servers.orlan]` table and its sub-tables. Every other line
+ * stays as it was, comments too.
  */
-export function editCodexToml(text, entry) {
-    const lines = text.split("\n");
+export function editCodexToml(text) {
     const kept = [];
     let inOrlan = false;
-    for (const line of lines) {
+    for (const line of text.split("\n")) {
         const header = tableHeader(line);
         if (header !== undefined) {
             const name = header.replace(/\s/g, "").replace(/"/g, "");
@@ -117,39 +117,31 @@ export function editCodexToml(text, entry) {
         if (!inOrlan)
             kept.push(line);
     }
-    let result = kept.join("\n").replace(/\n+$/, "");
-    if (entry) {
-        const table = [
-            `[mcp_servers.${MCP_NAME}]`,
-            `url = ${JSON.stringify(entry.url)}`,
-            `http_headers = { "Authorization" = ${JSON.stringify(entry.authorization)} }`,
-        ].join("\n");
-        result = result ? `${result}\n\n${table}` : table;
-    }
+    const result = kept.join("\n").replace(/\n+$/, "");
     return result ? `${result}\n` : "";
 }
-/** Sets or removes one key in a JSON settings file, under `section`. */
-async function editJson(file, section, value) {
+/**
+ * Removes the Orlan key under `section` of a JSON settings file. Every other key stays. Returns true
+ * when it removed it.
+ */
+async function removeJsonKey(file, section) {
     const text = await readText(file);
+    if (!text.includes(`"${MCP_NAME}"`))
+        return false;
     let settings;
     try {
-        settings = text.trim() ? JSON.parse(text) : {};
+        settings = JSON.parse(text);
     }
     catch {
         throw new OrlanError(`${file} is not plain JSON (it has comments or an error), so Orlan does not change it. ` +
-            "Run `orlan mcp print` and add the entry by hand.");
-    }
-    const servers = { ...(settings[section] ?? {}) };
-    if (value === undefined) {
-        if (!(MCP_NAME in servers))
-            return;
-        delete servers[MCP_NAME];
-    }
-    else {
-        servers[MCP_NAME] = value;
+            `Remove the "${MCP_NAME}" entry under "${section}" by hand, then run this again.`);
     }
-    settings[section] = servers;
+    const servers = settings[section];
+    if (!servers || typeof servers !== "object" || !(MCP_NAME in servers))
+        return false;
+    delete servers[MCP_NAME];
     await writeText(file, `${JSON.stringify(settings, null, 2)}\n`);
+    return true;
 }
 function runClaude(args) {
     return new Promise((resolve, reject) => {
@@ -193,6 +185,13 @@ export async function installClaudePlugin() {
     const installed = await runClaude(["plugin", "install", CLAUDE_PLUGIN, "--scope", "user"]);
     return installed.ok && (await claudePluginEnabled());
 }
+/**
+ * Takes the Orlan plugin out of Claude Code for this user. The marketplace stays: a person can have
+ * added it. With no claude command, or no plugin, it changes nothing.
+ */
+export async function uninstallClaudePlugin() {
+    await runClaude(["plugin", "uninstall", CLAUDE_PLUGIN, "--scope", "user"]).catch(() => undefined);
+}
 /**
  * The hooks file of Codex and Cursor (F046). Checked against each tool's documentation on 2026-09-26:
  * - Codex: $CODEX_HOME/hooks.json (default ~/.codex), events SessionStart, UserPromptSubmit,
@@ -259,6 +258,26 @@ function orlanHooks(agent) {
         sessionEnd: entry("done", 5),
     };
 }
+/**
+ * The line that tells a session what Orlan is and when to load the orlan skill (D088, F090):
+ * hooks/orlan-intro.txt of this package. The Claude Code plugin's session-start hook prints the same
+ * file, `orlan hook start` adds it for Codex and Cursor, and the OpenCode plugin carries it.
+ */
+export async function orlanIntro() {
+    return (await readFile(path.join(packageRoot(), "hooks", "orlan-intro.txt"), "utf8")).trim();
+}
+/**
+ * What `orlan hook start` prints: the context lines in the JSON each harness adds to the session.
+ * Codex reads hookSpecificOutput.additionalContext of SessionStart, Cursor additional_context of
+ * sessionStart (checked 2026-09-30 against https://learn.chatgpt.com/docs/hooks and
+ * https://cursor.com/docs/hooks).
+ */
+export function sessionStartOutput(agent, lines) {
+    const context = lines.join("\n");
+    return JSON.stringify(agent === "codex"
+        ? { hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: context } }
+        : { additional_context: context });
+}
 /** True for a hook entry Orlan wrote: a Cursor entry with an Orlan command, or a Codex group with one. */
 function isOrlanHook(entry) {
     if (!entry || typeof entry !== "object")
@@ -319,16 +338,20 @@ export function opencodePluginFile() {
 /** The first line of the plugin, so a disconnect removes only a file Orlan wrote. */
 const OPENCODE_PLUGIN_MARK = "// The Orlan plugin for OpenCode (F045).";
 /**
- * The plugin as `orlan mcp connect` writes it: opencode/orlan.js of this package, with this Node and
- * this CLI by full path in place of `orlan` on the PATH.
+ * The plugin as `orlan connect` writes it: opencode/orlan.js of this package, with this Node and
+ * this CLI by full path in place of `orlan` on the PATH, and the Orlan intro line (F090).
  */
 export async function opencodePlugin() {
     const source = await readFile(path.join(packageRoot(), "opencode", "orlan.js"), "utf8");
     const line = 'const ORLAN = ["orlan"];';
-    if (!source.startsWith(OPENCODE_PLUGIN_MARK) || !source.includes(line)) {
-        throw new OrlanError("The OpenCode plugin of this orlan package is damaged. Install @orlan-maker/cli again.");
+    const introLine = 'const INTRO = "";';
+    if (!source.startsWith(OPENCODE_PLUGIN_MARK) || !source.includes(line) || !source.includes(introLine)) {
+        const { name } = JSON.parse(await readFile(path.join(packageRoot(), "package.json"), "utf8"));
+        throw new OrlanError(`The OpenCode plugin of this orlan package is damaged. Install ${name} again.`);
     }
-    return source.replace(line, `const ORLAN = ${JSON.stringify([process.execPath, cliMain()])};`);
+    return source
+        .replace(line, `const ORLAN = ${JSON.stringify([process.execPath, cliMain()])};`)
+        .replace(introLine, `const INTRO = ${JSON.stringify(await orlanIntro())};`);
 }
 /** Writes the Orlan plugin into OpenCode's plugins folder, or takes it out. Returns the file. */
 export async function setOpencodePlugin(install) {
@@ -342,65 +365,28 @@ export async function setOpencodePlugin(install) {
     return file;
 }
 /**
- * Writes the Orlan MCP server into the agent's settings, in place of an older entry. Returns what it
- * changed, for the person.
+ * Removes the Orlan MCP entry that an older `orlan mcp connect` wrote (D088: agents use the orlan
+ * command, not MCP). Every other entry stays. Returns true when it removed one.
  */
-export async function addMcp(agent, url, secret) {
-    const authorization = `Bearer ${secret}`;
+export async function removeMcp(agent) {
     switch (agent) {
         case "claude-code": {
-            await runClaude(["mcp", "remove", MCP_NAME, "--scope", "user"]);
-            const added = await runClaude([
-                "mcp",
-                "add",
-                "--transport",
-                "http",
-                "--scope",
-                "user",
-                MCP_NAME,
-                url,
-                "--header",
-                `Authorization: ${authorization}`,
-            ]);
-            if (!added.ok)
-                throw new OrlanError(`claude mcp add failed: ${added.output.replaceAll(secret, "orl_...")}`);
-            return "Claude Code (claude mcp add --scope user)";
-        }
-        case "codex": {
-            const file = mcpFile("codex");
-            await writeText(file, editCodexToml(await readText(file), { url, authorization }));
-            return file;
+            // With no claude command there is no Claude Code to change.
+            const removed = await runClaude(["mcp", "remove", MCP_NAME, "--scope", "user"]).catch(() => undefined);
+            return removed?.ok ?? false;
         }
-        case "cursor": {
-            const file = mcpFile("cursor");
-            await editJson(file, "mcpServers", { url, headers: { Authorization: authorization } });
-            return file;
-        }
-        case "opencode": {
-            const file = mcpFile("opencode");
-            await editJson(file, "mcp", { type: "remote", url, headers: { Authorization: authorization }, enabled: true });
-            return file;
-        }
-    }
-}
-/** Takes the Orlan MCP server out of the agent's settings. */
-export async function removeMcp(agent) {
-    switch (agent) {
-        case "claude-code":
-            await runClaude(["mcp", "remove", MCP_NAME, "--scope", "user"]);
-            return;
         case "codex": {
             const file = mcpFile("codex");
             const text = await readText(file);
-            if (text)
-                await writeText(file, editCodexToml(text));
-            return;
+            const edited = editCodexToml(text);
+            if (edited.trimEnd() === text.trimEnd())
+                return false;
+            await writeText(file, edited);
+            return true;
         }
         case "cursor":
-            await editJson(mcpFile("cursor"), "mcpServers", undefined);
-            return;
+            return removeJsonKey(mcpFile("cursor"), "mcpServers");
         case "opencode":
-            await editJson(mcpFile("opencode"), "mcp", undefined);
-            return;
+            return removeJsonKey(mcpFile("opencode"), "mcp");
     }
 }