gaslamp 1.0.1 → 2.1.0

package/README.md

@@ -6,18 +6,34 @@
 [![node](https://img.shields.io/node/v/gaslamp)](https://www.npmjs.com/package/gaslamp)
 [![license](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)](LICENSE)
 
-Minimal MCP server that lets Claude and Codex talk to each other.
+Let Claude Code and Codex consult each other from the shell.
 
-Gaslamp wires the two CLIs to each other as plain MCP servers:
+```sh
+gaslamp codex  "review this diff for races: …"     # Claude asks Codex
+gaslamp claude "verify this proof sketch: …"       # Codex asks Claude
+git diff | gaslamp codex "review for races:"       # piped stdin rides as evidence
+gaslamp codex - < notes/design-spar.md             # or: the whole prompt from a file
+gaslamp claude --thread api-spar "counterpoint: …" # named session, continued
+```
+
+Each call blocks until the reply, then prints it plus a greppable trailer:
+
+```
+lamplight
+[gaslamp] job: cx-20260612-142457-744e · session: 019ebdb9-… · resume: gaslamp codex --resume 019ebdb9-… · tok: 32k→60
+```
 
-| direction | server | tools |
-|-----------|-----------|----------------------|
-| **Claude → Codex** | `codex mcp-server` registered in Claude as `gaslamp` | `gaslamp/codex`, `gaslamp/codex-reply` |
-| **Codex → Claude** | this package, registered in Codex as `gaslamp` | `gaslamp`, `gaslamp-reply` |
+The agent backgrounds the call with its own facility (Claude Code:
+`run_in_background`; Codex: its background terminal), keeps working, and gets
+the reply when it lands — so several consults run in parallel and replies
+trickle in. No MCP servers, no daemon: asynchrony is the harness's job, and
+gaslamp stays a thin wrapper around `claude -p` / `codex exec`.
 
-`claude mcp serve` only exposes Claude's
-*tools* and a one-shot `Agent`, not a persistent
-conversation, so we need a shim in `src/server.mjs`.
+> 1.x was a pair of MCP servers. 2.0 replaced them with this CLI: MCP tool
+> calls are blocking and serial, Codex's MCP client enforced a per-call
+> timeout that killed long consults, and its per-directory trust gate could
+> stall calls invisibly. All three problems are structural to MCP and absent
+> from a shell call.
 
 ## Requirements
 
@@ -28,54 +44,243 @@ and [Codex](https://developers.openai.com/codex). Node ≥ 18.
 
 ```sh
 npm install -g gaslamp
-gaslamp setup           # register both directions
-gaslamp doctor          # verify binaries + registrations
+gaslamp setup           # allowlist the command in ~/.claude/settings.json
+gaslamp setup --skill   # …and install the gaslamp skill for BOTH agents
 ```
 
-Zero-install also works:
+`setup` allowlists the command so a consult doesn't stall on a permission
+prompt. It does **not** touch your agent instructions: a CLI can't
+self-advertise the way MCP tools did, so each agent needs to learn gaslamp
+exists from somewhere. The clean way is `--skill`: both CLIs speak the same
+SKILL.md standard, so one flag installs a direction-aware skill on each side
+(`~/.claude/skills/gaslamp/` teaching Claude to consult Codex,
+`$CODEX_HOME/skills/gaslamp/` teaching Codex to consult Claude). The manual
+alternative is a short note pasted into each agent's instruction file.
 
-```sh
-npx gaslamp setup
-```
+**`~/.claude/CLAUDE.md`** — so Claude consults Codex:
+
+> Hand work to Codex for a second pair of eyes — verify a fix, spar on a design,
+> review a diff, diagnose with fresh context. Send raw evidence (errors, diffs,
+> commands), not just your framing.
+>
+> ```
+> gaslamp codex [--thread <name>] [--model <m>] [--sandbox <mode>] "<prompt>"
+> git diff | gaslamp codex "…"      # piped stdin rides as an evidence block
+> gaslamp codex --json --schema '<json-schema>' "…"   # typed reply in .data
+> gaslamp fleet codex -n N "…"      # fan out N takes in one command
+> ```
+>
+> Run it as a background shell task (`run_in_background`) and keep working — the
+> reply lands when it's done; several can run in parallel. A consult is one hop
+> (the consulted agent can't consult back), so own the synthesis. `gaslamp jobs`
+> lists records, `gaslamp poll <job|--last>` fetches one (exit 10 = running),
+> `gaslamp threads` lists named sessions.
+
+**`~/.codex/AGENTS.md`** — so Codex consults Claude: the same block with
+`claude`/`Claude` in place of `codex`/`Codex`, and "run it in your background
+terminal, check back between steps" in place of the `run_in_background` line.
 
 ### From source
 
 ```sh
 git clone https://github.com/a9lim/gaslamp
 cd gaslamp
-./setup.sh              # === node bin/gaslamp.mjs setup --local
+./setup.sh              # === gaslamp setup --local (pins this checkout's path)
 ```
 
 ## CLI
 
 ```
-gaslamp [serve]        Run the MCP server on stdio (what Codex spawns).
-gaslamp setup          Register both directions (add --local for this checkout).
-gaslamp doctor         Check binaries + registrations.
-gaslamp --version      Print version.
-gaslamp --help         Print help.
+gaslamp claude [opts] <prompt|->   Consult Claude (blocks until the reply).
+gaslamp codex  [opts] <prompt|->   Consult Codex  (blocks until the reply).
+gaslamp fleet <backend> [opts]     Fan out a fleet of consults in one command.
+gaslamp fleet --resume <fleet-id>  Finish an interrupted fleet.
+gaslamp jobs [-n N] [--json]       List consult records, newest first.
+gaslamp threads                    List named threads, latest activity first.
+gaslamp poll <job|fleet|--last> [--json]   One record's reply/status (exit 10 = running).
+gaslamp tail <job|--last>          Follow one consult's events as one-liners.
+gaslamp setup [--local] [--skill]  Allowlist the command; --skill installs the
+                                   gaslamp skill for both agents.
+
+Consult options:
+  --resume <session|job>   Continue a session (a prior job id works too).
+  --thread <name>          Named session: continue if bound, else start + bind.
+  --model <m>              Backend model override.
+  --effort <level>         Reasoning effort (native on both backends).
+  --schema <file|json>     JSON Schema for the reply; --json gains data.
+  --label <s>              Tag the job record (shows in gaslamp jobs).
+  --sandbox <mode>         claude: read-only | danger-full-access
+                           codex:  read-only | workspace-write | danger-full-access
+  --raw                    Skip the consult preamble.
+  --cwd <dir>              Working directory for the consult.
+  --json                   {backend, jobId, sessionId, status, exitCode,
+                            content, label?, usage?, data?}
+
+Fleet options (plus the consult options above, applied to every consult):
+  -n, --count N            Replicate the prompt across N fresh sessions.
+  -j, --concurrency N      Max consults in flight (default 4).
+  --stream                 Print replies as they complete (--json: JSONL).
+  - < tasks.jsonl          One task per line: {"prompt", model?, sandbox?,
+                           effort?, cwd?, resume?, thread?, label?, schema?,
+                           raw?} or a bare prompt.
+```
+
+## Evidence on stdin
+
+A prompt argument plus piped stdin composes them: the prompt frames, stdin is
+the evidence, appended as a `<stdin>` block (codex's own convention for the
+case, applied to both backends):
+
+```sh
+git diff | gaslamp codex "review this diff for races:"
+cargo test 2>&1 | gaslamp claude "why is this failing?"
+```
+
+Send raw evidence — errors, diffs, failing output — not just your framing of
+it; the fresh-context advantage works on facts. A bare `-` (or piping with no
+prompt argument) still reads the whole prompt from stdin.
+
+## Threads
+
+`--thread <name>` is a named session: continue it if the name is bound, start
+and bind it if not — idempotent, no fishing session UUIDs out of old trailers.
+
+```sh
+gaslamp codex --thread api-spar "opening take: …"
+gaslamp codex --thread api-spar "counterpoint: …"    # same conversation
+gaslamp threads                                      # list them
+```
+
+A thread is one pointer file under `~/.gaslamp/threads/`, re-pointed on every
+consult. This matters doubly for claude, where each resume forks a *new*
+session id — the pointer chases it automatically, which manual `--resume`
+juggling cannot.
+
+## Typed replies
+
+`--schema <file|inline-json>` plumbs a JSON Schema to each backend's native
+structured output (`claude --json-schema` / `codex exec --output-schema`); the
+`--json` envelope then carries `data`, the parsed object. A reply that fails to
+parse marks the consult **failed** — trust the exit code.
+
+```sh
+gaslamp codex --json --schema '{"type":"object","properties":{"verdict":
+{"type":"string","enum":["correct","broken","unsure"]}},"required":["verdict"]}' \
+  "is this fix correct? …" | jq .data.verdict
+```
+
+One backend asymmetry, papered over: OpenAI's endpoint only accepts *strict*
+schemas (every object needs `additionalProperties:false` and all properties
+required), so gaslamp strictifies schemas on the way to codex — spell optional
+fields nullable (`{"type":["string","null"]}`) rather than leaving them out of
+`required`. Claude takes the schema as written.
+
+## The consult preamble
+
+A consulted agent gets a few fixed lines of framing (claude via
+`--append-system-prompt`, codex prepended as a `<gaslamp_consult>` block): it
+is a one-hop consult, its final message returns verbatim to the calling agent,
+deliver the deliverable. Without this, consulted agents reply conversationally
+or promise work instead of doing it. `--raw` drops it. It is fixed and tiny by
+design — not a context-injection hook.
+
+## Fleets
+
+`gaslamp fleet` fires a whole batch of consults from one command and blocks
+until every reply is in — `-n N "<prompt>"` runs one prompt across N fresh
+sessions (voting, diverse sampling), or a JSONL manifest on stdin runs one
+`{prompt, model?, sandbox?, cwd?, resume?, label?}` task per line:
+
+```sh
+gaslamp fleet codex -n 5 "spot the worst bug in this diff: …"   # 5 takes, vote
+gaslamp fleet claude - < tasks.jsonl                            # one task/line
+gaslamp fleet codex -n 8 --json "…" | jq '.results[].content'   # structured
+gaslamp fleet codex -n 4 --stream --json "…"                    # JSONL as they land
+gaslamp fleet --resume fl-20260702-…                            # finish an interrupted one
 ```
 
+Each task is a normal consult — its own job record and resumable session — so a
+killed fleet costs in-flight turns, not sessions. Two safety defaults at N:
+fleets run `--sandbox read-only` unless you opt into writes (N agents writing one
+directory race), and a manifest that resumes the same session or thread twice is
+refused (they'd deadlock on the session lock). `gaslamp poll <fleet-id>` regroups
+a fleet's replies later. It's the same move as backgrounding one consult, one
+layer up — and it's the only one-command fan-out Codex has, since (unlike Claude
+Code) it has no built-in agent-workflow tool.
+
+`--stream` prints each reply the moment it completes (completion order) so the
+caller can peek partial output mid-run; with `--json` it becomes explicit JSONL —
+one result line per reply, then a `fleet.done` line — leaving the collected
+single-object `--json` contract untouched.
+
+`fleet --resume <fleet-id>` finishes an interrupted fleet from its stored
+manifest: done children replay their recorded replies, a killed child whose
+session was captured is resumed with a fixed finish-and-deliver nudge (the
+session already holds the prompt and partial work), and everything else reruns
+fresh. The new fleet record points back via `resumedFrom`.
+
+## Job records
+
+Every consult writes through to `~/.gaslamp/jobs/<id>/` as it runs: the
+prompt, the raw backend event stream, the reply, stderr, and a `meta.json`
+whose session id is recorded the moment the backend reports it. If the
+harness kills a consult mid-flight, the whole child process group dies with
+it (no orphans silently burning API quota) — but the session survives on the
+backend's side, so recovery is `--resume <session>`, not a lost half hour.
+
+Token usage lands in the record too (claude's result usage + cost; codex's
+per-turn usage, summed) and shows in the trailer — fleets are quota-shaped,
+so quota is visible. `gaslamp jobs --json` and `gaslamp poll <id> --json`
+make the records scriptable; `gaslamp tail <job|--last>` follows a running
+consult's events as uniform one-liners across both backends' schemas.
+
+Two concurrent consults into the same session would race, so gaslamp refuses
+the second (exit 5) until the first finishes.
+
 ## Permissions
 
-A Codex→Claude consult with no `sandbox` arg runs with your own Claude config
-(permission mode, allow/deny rules, model, MCP) — just as your interactive Claude
-would. Per-call overrides: `read-only` (advisory, no edits) or `danger-full-access`
-(full read/write). Claude has no filesystem sandbox, so there's no `workspace-write`.
+A consult with no `--sandbox` runs with the consulted agent's own config —
+exactly as that agent would behave if you drove it yourself. Overrides:
+`read-only` forces an advisory, no-edit reviewer on either backend;
+`danger-full-access` forces full read/write. Claude has no filesystem
+sandbox, so `workspace-write` there is a usage error rather than a silent
+lie (Codex supports all three).
+
+Note for sandboxed Codex setups: the gaslamp CLI runs *inside* Codex's
+per-command sandbox (1.x's MCP server ran outside it). Under the default
+`workspace-write` sandbox, network is disabled and a consulted agent could
+reach neither Anthropic nor OpenAI — gaslamp detects this
+(`CODEX_SANDBOX_NETWORK_DISABLED=1`) and refuses with instructions instead of
+timing out. Grant the call escalated permissions, or set
+`network_access = true` / `danger-full-access` in `~/.codex/config.toml`.
+
+## Recursion
+
+A consult is **one hop**: agents gaslamp spawns carry `GASLAMP_NESTED=1`
+(forced into Codex's shell env via config override, since a strict
+`shell_environment_policy` would strip it) and the consult verbs refuse under
+it. This is loop prevention, not a security boundary. Set
+`GASLAMP_ALLOW_RECURSION=1` to restore unbounded handoffs.
 
 ## Env knobs
 
 | var | default | meaning |
 |-----|---------|---------|
-| `GASLAMP_ALLOWED_TOOLS` | `Read Grep Glob WebFetch WebSearch` | tools the `read-only` override permits |
-| `GASLAMP_LOGFILE` | `~/.codex/gaslamp.log` | transcript path; `off` to disable |
-| `GASLAMP_DEBUG` | unset | verbose stderr (raw JSON-RPC) |
-| `CLAUDE_BIN` | autodetected | path to the `claude` binary |
+| `GASLAMP_HOME` | `~/.gaslamp` | state dir (jobs + locks + threads) |
+| `GASLAMP_ALLOWED_TOOLS` | `Read,Grep,Glob,WebFetch,WebSearch` + read-only git (`Bash(git diff:*)` etc) | tools the claude `read-only` override permits, comma-separated |
+| `GASLAMP_ALLOW_RECURSION` | unset | allow consulted agents to consult back |
+| `GASLAMP_DEBUG` | unset | verbose stderr (spawn argv) |
+| `CLAUDE_BIN` / `CODEX_BIN` | autodetected | backend binaries |
+| `CODEX_HOME` | `~/.codex` | where `setup --skill` puts Codex's copy |
+
+Exit codes: `0` ok · `1` consult failed/killed · `2` usage · `3` nested
+refusal · `4` network-disabled sandbox · `5` session busy · `poll`: `10`
+still running.
 
 ## Development
 
 ```sh
-npm test                # node --test against a stub claude binary
+npm test                # node --test against stub claude and codex binaries
 npm run check           # node -c syntax check on every source file
 ```
 

package/bin/gaslamp.mjs

@@ -1,15 +1,14 @@
 #!/usr/bin/env node
-// gaslamp: Minimal MCP server that lets Claude and Codex talk to each other.
+// gaslamp: let Claude Code and Codex consult each other from the shell.
 //
-//   gaslamp            run the MCP server on stdio (what Codex spawns)
-//   gaslamp serve      same as above, explicit
-//   gaslamp setup      register both directions (add --local for this checkout)
-//   gaslamp doctor     verify the install without a round-trip
-//   gaslamp --version  print the version
-//   gaslamp --help     print this help
+//   gaslamp claude … / codex …   one blocking consult (the heart of it)
+//   gaslamp fleet <backend> …    fan out a bounded fleet of consults
+//   gaslamp jobs / poll          read the durable consult records
+//   gaslamp setup [--local]      allowlist the command for Claude Code
 //
-// The bare/`serve` path speaks newline-delimited JSON-RPC on stdout and must
-// stay quiet otherwise; `setup`/`doctor` are interactive and print freely.
+// Each agent backgrounds the call with its own facility, so consults run in
+// parallel and replies trickle in as they finish. No MCP servers, no daemon:
+// asynchrony is the harness's job.
 
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -18,34 +17,128 @@ import { fileURLToPath } from "node:url";
 const HERE = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(HERE, "..", "package.json"), "utf8"));
 
-const HELP = `gaslamp ${pkg.version}: Minimal MCP server that lets Claude and Codex talk to each other.
+const HELP = `gaslamp ${pkg.version}: let Claude Code and Codex consult each other from the shell.
 
 Usage:
-  gaslamp [serve]        Run the MCP server on stdio (what Codex spawns).
-  gaslamp setup          Register both directions as \`gaslamp\` (published / npx).
-  gaslamp setup --local  Register THIS checkout instead of the published package.
-  gaslamp doctor         Check binaries + registrations (no round-trip).
-  gaslamp --version      Print the version.
-  gaslamp --help         Print this help.
+  gaslamp claude [opts] <prompt|->   Consult Claude (blocks until the reply).
+  gaslamp codex  [opts] <prompt|->   Consult Codex  (blocks until the reply).
+  gaslamp fleet <backend> [opts]     Fan out a fleet of consults (one command).
+    -n N <prompt>                    Replicate one prompt across N fresh sessions.
+    - < tasks.jsonl                  Or one task per line on stdin (see below).
+  gaslamp fleet --resume <fleet-id>  Finish an interrupted fleet: done children
+                                     replay their recorded replies, killed ones
+                                     are nudged to conclude via their sessions,
+                                     the rest rerun from the stored manifest.
+  gaslamp jobs [-n N] [--json]       List consult records, newest first.
+  gaslamp threads                    List named threads, latest activity first.
+  gaslamp poll <job|fleet|--last> [--json]
+                                     Print one record's reply/status.
+  gaslamp tail <job|--last>          Follow one consult's events as one-liners
+                                     (both backends' schemas, uniformly).
+  gaslamp setup [--local] [--skill]  Allowlist the command in Claude Code so
+                                     consults don't stall on a permission prompt.
+                                     --local pins this checkout's bin path.
+                                     --skill also installs the gaslamp skill
+                                     for BOTH agents (~/.claude/skills/,
+                                     $CODEX_HOME/skills/).
 
-A Codex->Claude consult with no \`sandbox\` arg uses the user's own ~/.claude
-config (permission mode, allow/deny, model, MCP). \`read-only\` and
-\`danger-full-access\` are per-call overrides.
+Consult options:
+  --resume <session|job>   Continue a session (a prior job id works too).
+  --thread <name>          Named session: continue it if the name is bound,
+                           else start fresh and bind it. The pointer chases
+                           claude's forked session ids so the name stays hot.
+  --model <m>              Backend model override.
+  --effort <level>         Reasoning effort (claude --effort / codex
+                           model_reasoning_effort).
+  --label <s>              Tag the job record (shows in gaslamp jobs).
+  --sandbox <mode>         claude: read-only | danger-full-access
+                           codex:  read-only | workspace-write | danger-full-access
+                           Omit to defer to the consulted agent's own config.
+  --cwd <dir>              Working directory for the consult (default: here).
+  --schema <file|json>     JSON Schema for the reply (native on both backends:
+                           claude --json-schema / codex --output-schema). The
+                           --json envelope gains data (the parsed object); a
+                           reply that doesn't parse marks the consult failed.
+  --raw                    Skip the consult preamble (the few fixed lines that
+                           tell the consultee its reply returns verbatim).
+  --json                   Machine envelope on stdout:
+                           {backend, jobId, sessionId, status, exitCode,
+                            content, data?}
+  -                        Read the prompt from stdin (default when piped).
+                           With a prompt argument, piped stdin is instead
+                           appended as a <stdin> evidence block:
+                           git diff | gaslamp codex "review for races:"
 
-Env knobs (read by the server):
-  GASLAMP_ALLOWED_TOOLS  tools the \`read-only\` override permits (space/comma list)
-  GASLAMP_LOGFILE        transcript path (default ~/.codex/gaslamp.log; "off" disables)
-  GASLAMP_DEBUG          verbose stderr (raw JSON-RPC)
-  CLAUDE_BIN             path to the claude binary (autodetected otherwise)
+Fleet options (in addition to --model / --sandbox / --cwd / --json, applied to
+every consult unless a per-task field on a stdin manifest overrides it):
+  -n, --count N            Replicate the prompt across N fresh sessions.
+  -j, --concurrency N      Max consults in flight (default 4 — quota-shaped).
+  --stream                 Print each reply the moment it completes instead of
+                           collecting to the end (with --json: JSONL — one
+                           result line per reply, then a fleet.done line).
+  - < tasks.jsonl          One task per line: a {"prompt",…} JSON object (also
+                           model/sandbox/effort/cwd/resume/thread/label/schema/
+                           raw — schema may be an inline JSON object), or a
+                           bare prompt.
+                           A prompt argument + piped stdin shares one <stdin>
+                           evidence block across every replica.
+A fleet defaults its consults to --sandbox read-only (N writers in one cwd
+race); pass --sandbox to opt into writes. It blocks until every consult is in,
+then prints them all (--json: a results array, manifest order). A killed fleet
+leaves each child resumable; gaslamp poll <fleet-id> regroups them later.
+
+Run a consult (or a fleet) as a background shell task and keep working — several
+can run in parallel, replies land as the tasks finish. Every consult writes through to
+~/.gaslamp/jobs/<id>/ (prompt, raw events, reply, stderr), and the session id
+is recorded the moment the backend reports it: a killed consult costs the
+in-flight turn, not the session. Recovery is --resume, not orphans.
+
+Exit codes:
+  0 ok · 1 consult failed/killed · 2 usage · 3 nested (one-hop) refusal ·
+  4 network-disabled sandbox · 5 session busy · poll: 10 still running
+
+Env knobs:
+  GASLAMP_HOME             state dir (default ~/.gaslamp)
+  GASLAMP_ALLOWED_TOOLS    tools the claude read-only override permits,
+                           comma-separated (default: Read,Grep,Glob,WebFetch,
+                           WebSearch + read-only git via Bash(git diff:*) etc)
+  GASLAMP_ALLOW_RECURSION  let consulted agents consult back (off = one hop)
+  GASLAMP_DEBUG            verbose stderr (spawn argv)
+  CLAUDE_BIN / CODEX_BIN   backend binaries (autodetected otherwise)
 `;
 
 const [cmd, ...rest] = process.argv.slice(2);
 
 switch (cmd) {
-  case undefined:
-  case "serve": {
-    const { startServer } = await import(new URL("../src/server.mjs", import.meta.url));
-    startServer();
+  case "claude":
+  case "codex": {
+    const { runConsult } = await import(new URL("../src/consult.mjs", import.meta.url));
+    runConsult(cmd, rest);
+    break;
+  }
+  case "fleet": {
+    const { runFleet } = await import(new URL("../src/fleet.mjs", import.meta.url));
+    runFleet(rest[0], rest.slice(1));
+    break;
+  }
+  case "jobs": {
+    const { runJobs } = await import(new URL("../src/jobs.mjs", import.meta.url));
+    runJobs(rest);
+    break;
+  }
+  case "threads": {
+    const { runThreads } = await import(new URL("../src/threads.mjs", import.meta.url));
+    runThreads();
+    break;
+  }
+  case "tail": {
+    const { runTail } = await import(new URL("../src/tail.mjs", import.meta.url));
+    runTail(rest);
+    break;
+  }
+  case "poll": {
+    const { runPoll } = await import(new URL("../src/jobs.mjs", import.meta.url));
+    runPoll(rest);
     break;
   }
   case "setup": {
@@ -53,15 +146,11 @@ switch (cmd) {
     runSetup(rest);
     break;
   }
-  case "doctor": {
-    const { runDoctor } = await import(new URL("../src/doctor.mjs", import.meta.url));
-    runDoctor(rest);
-    break;
-  }
   case "-v":
   case "--version":
     process.stdout.write(pkg.version + "\n");
     break;
+  case undefined:
   case "-h":
   case "--help":
     process.stdout.write(HELP);

package/package.json

@@ -1,14 +1,11 @@
 {
   "name": "gaslamp",
-  "version": "1.0.1",
-  "description": "Minimal MCP server that lets Claude and Codex talk to each other.",
+  "version": "2.1.0",
+  "description": "Let Claude Code and Codex consult each other from the shell.",
   "type": "module",
   "bin": {
     "gaslamp": "bin/gaslamp.mjs"
   },
-  "exports": {
-    ".": "./src/server.mjs"
-  },
   "files": [
     "bin/",
     "src/",
@@ -18,20 +15,18 @@
   "scripts": {
     "test": "node --test tests/*.test.mjs",
     "check": "for f in bin/gaslamp.mjs src/*.mjs tests/*.mjs; do node -c \"$f\"; done",
-    "setup": "node bin/gaslamp.mjs setup",
-    "doctor": "node bin/gaslamp.mjs doctor"
+    "setup": "node bin/gaslamp.mjs setup"
   },
   "keywords": [
-    "mcp",
-    "model-context-protocol",
     "claude",
     "claude-code",
     "codex",
     "llm",
     "agent",
     "ai",
+    "cli",
     "code-review",
-    "stdio"
+    "consult"
   ],
   "author": "a9lim <mx@a9l.im>",
   "license": "AGPL-3.0-or-later",