renor 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Renor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,78 @@
-# Temporary Holding Version
+# renor
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Connects the AI apps on your computer to [Renor](https://renor.cloud), so they share one memory: tell one of them something, and the others know it too.
+
+```sh
+npx renor setup
+```
+
+It finds the apps you have, adds Renor to each, signs you in, and installs the Renor skill, which tells your AI when to save and when to recall. Then it checks that Renor’s gateway answers, and lists anything left for you to do, app by app; anything that fails prints what happened and the exact fix.
+
+To prove the whole path, run `npx renor setup --verify` once Claude Code is signed in to Renor: it runs `claude -p` in an empty folder, with only Renor’s tools allowed and Claude Code’s own tools (Bash, Edit, Write, Read and the rest) denied, to save one test memory, recall it, and then retire that exact note again with `retire_memory` (by the id of its own save, so nothing else is touched) and check it no longer comes back. That uses a little of its model quota. If the check ends before that is confirmed, setup runs a second pass that finds the note by its exact random code and retires it; if even that cannot be confirmed, the run fails and prints the code. The other apps are not launched by setup, because their one-shot modes cannot be limited to Renor’s tools; setup tells you what to say to them instead.
+
+| App | How Renor is added | Sign-in |
+|---|---|---|
+| Claude Code | `claude mcp add --transport http --scope user renor …` | in Claude Code: `/mcp`, then Authenticate |
+| Codex | `codex mcp add renor --url …` | opens your browser right away |
+| Cursor | adds `renor` to `~/.cursor/mcp.json` (a backup of the old file is kept) | `cursor-agent mcp login renor`, or in Cursor's settings |
+| OpenCode | `opencode mcp add renor --url … --global` | `opencode mcp auth renor` |
+| Gemini CLI | adds `renor` (`httpUrl`) to `~/.gemini/settings.json` (a backup is kept) | in Gemini CLI: `/mcp auth renor` |
+| Pi (0.99 or later) | `pi mcp add renor --url … --exposure direct` | `pi mcp login renor` |
+| VS Code | `code --add-mcp …` | when Copilot first uses Renor |
+
+Every app gets the same address, `https://mcp.renor.cloud/mcp`. No key is stored anywhere: you approve Renor in your browser, and each app keeps its own sign-in.
+
+## What it does not do
+
+- It never changes anything else in an app's config. A file with comments in it is left alone and you get the line to add by hand.
+- If an app already has a server named `renor` that points somewhere else, it is left as it is unless you pass `--force`.
+- It sends nothing anywhere itself. The only network use is the apps' own sign-ins and `npx skills` installing the skill.
+
+## The one question
+
+At the end, at a terminal, it asks once whether to share anonymous usage signals with Renor (numbers only: never memory text, queries, names or paths). The answer is **No** unless you type `y`, and it is asked once: your answer is saved in `~/.config/renor/sharing.json` (or `$RENOR_SHARING_DIR`), the file the open-source engine reads, so `renor-engine telemetry status` shows it and `renor-engine telemetry off` changes it. `--yes`, `--dry-run`, a machine with no terminal, `DO_NOT_TRACK=1` and `RENOR_SHARING=off` never ask. This command sends nothing either way; a hosted workspace has its own switch in Settings on https://app.renor.cloud.
+
+## Options
+
+```
+--dry-run      Say what would happen and change nothing
+-y, --yes      Do not ask before adding
+--no-login     Add Renor but leave the sign-ins for later
+--no-skill     Do not install the skill
+--verify       Also have Claude Code save and recall one test memory
+--force        Replace a renor server that points somewhere else
+--only <apps>  Only some apps: claude-code, codex, cursor, opencode, gemini, pi, vscode
+```
+
+## Your rules in every review
+
+```sh
+gh pr diff 123 | RENOR_API_KEY=… npx renor review-rules
+```
+
+It prints the standing rules and preferences you saved in Renor that bear on the diff, to put at the top of a review prompt: each one quoted exactly as saved, with the day it was saved and its memory id, most relevant first, about 600 tokens at most (`--max-tokens`). The block ends by asking the reviewer to cite a rule's id when a finding rests on it. A value you later replaced is never quoted.
+
+```
+--diff <file|->      The diff (default: standard input)
+--export [file]      Write the rules into one marked section of REVIEW.md (or AGENTS.md); nothing else in the file changes
+--propose <dir>      Read past reviews (Markdown) and propose rules from findings that recur; saves nothing
+--url <url>          A local engine: http://127.0.0.1:3471/mcp (default: RENOR_URL, else the hosted address)
+--rules-file <json>  Rules from a file instead of Renor
+--json               JSON instead of text
+```
+
+Every call it makes to Renor is a read (`memory_map`, `get_context`, `retrieve_memory`, `read_memory`).
+
+ChatGPT and Claude in the browser are set up from your dashboard at https://app.renor.cloud.
+
+Needs Node.js 18 or later.
+
+## Sync your agents' memory files
+
+```sh
+npx renor sync add ~/.claude/CLAUDE.md ./AGENTS.md   # choose what Renor may read (files or folders of .md)
+RENOR_TOKEN=… npx renor sync                          # import what is new or changed; --dry-run to preview
+npx renor sync remove <path>                          # stop syncing it
+```
+
+Opt-in: only the paths you add are read, only `.md` files. Each note lands under `Imported/synced/` with a first line naming its source path; a changed file is imported again (alternating between `Imported/synced/` and `Imported/synced-2/`) and the earlier copy is retired only once the new one is in, so a failed run never costs you the old note. Links inside a chosen folder are skipped; a file you choose by name may be a link. A file Renor would leave out (it looks like a secret, or is empty) is reported as failed and its earlier copy is kept. A file you delete locally is listed as `gone`; Renor keeps its note until you forget it in the dashboard. `RENOR_TOKEN` is a connect token from the dashboard and is never stored. It is sent only to https (or `http://127.0.0.1` / `[::1]` for a local engine) when `RENOR_MCP_URL` is set; redirects are refused.

package/bin/renor.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * renor — connects the AI apps on this computer to Renor, the memory they share.
+ * Usage: npx renor setup [--yes] [--dry-run] [--no-login] [--no-skill] [--force] [--only claude-code,codex]
+ *        npx renor review-rules [--diff <file>] [--export [file]] [--propose <dir>]
+ */
+import { readFileSync } from 'node:fs'
+import { HELP, parse } from '../lib/args.mjs'
+import { CLIENTS } from '../lib/clients.mjs'
+import { reviewRules } from '../lib/review-rules-cli.mjs'
+import { setup } from '../lib/setup.mjs'
+import { sync } from '../lib/sync.mjs'
+
+function version() {
+  try {
+    return JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version
+  } catch {
+    return 'unknown'
+  }
+}
+
+async function main() {
+  // review-rules has options of its own, so it reads its own arguments.
+  if (process.argv[2] === 'review-rules') return reviewRules(process.argv.slice(3))
+  const options = parse(process.argv.slice(2))
+  if (options.version) {
+    process.stdout.write(version() + '\n')
+    return 0
+  }
+  if (options.help || !options.command) {
+    process.stdout.write(HELP + '\n')
+    return 0
+  }
+  if (options.command === 'sync') return sync(process.argv.slice(3))
+  if (options.command !== 'setup') {
+    process.stderr.write(`Unknown command: ${options.command}\n\n${HELP}\n`)
+    return 2
+  }
+  if (options.unknown.length > 0) {
+    process.stderr.write(`Unknown option: ${options.unknown.join(' ')}\n\n${HELP}\n`)
+    return 2
+  }
+  if (options.only && options.only.length === 0) {
+    process.stderr.write(`--only needs a list of apps: ${CLIENTS.map((client) => client.id).join(', ')}\n`)
+    return 2
+  }
+  const unknownApps = (options.only || []).filter((id) => !CLIENTS.some((client) => client.id === id))
+  if (unknownApps.length > 0) {
+    process.stderr.write(`Unknown app: ${unknownApps.join(', ')}. Known: ${CLIENTS.map((client) => client.id).join(', ')}\n`)
+    return 2
+  }
+  const { code } = await setup(options)
+  return code
+}
+
+const [major] = process.versions.node.split('.').map(Number)
+if (major < 18) {
+  process.stderr.write(`renor needs Node.js 18 or later; this is ${process.versions.node}.\n`)
+  process.exit(1)
+}
+main().then(
+  (code) => process.exit(code),
+  (error) => {
+    process.stderr.write(`renor ${process.argv[2] === 'review-rules' ? 'review-rules' : 'setup'} failed: ${error instanceof Error ? error.message : String(error)}\n`)
+    process.exit(1)
+  },
+)

package/lib/args.mjs

@@ -0,0 +1,48 @@
+/** The command line of `renor`: what it accepts, and its help text. */
+import { CLIENTS } from './clients.mjs'
+
+export const HELP = `renor — connect your AI apps to Renor, the memory they share.
+
+Usage
+  npx renor setup             Find your AI apps, add Renor to each, sign in, install the skill, check that Renor answers
+  npx renor setup --dry-run   Say what would happen and change nothing
+  npx renor review-rules      Your standing rules from Renor, for a code review (--help for more)
+  npx renor sync add <path>   Choose memory files (CLAUDE.md, AGENTS.md, a notes folder) to keep in Renor
+  npx renor sync              Send what changed in them (needs RENOR_TOKEN; --dry-run to preview)
+
+Options
+  -y, --yes       Do not ask before adding
+  --no-login      Add Renor but leave the sign-ins for later
+  --no-skill      Do not install the Renor skill
+  --verify        Also have Claude Code save and recall one test memory (saves a test note, then retires it; uses a little model quota)
+  --force         Replace a renor server that points somewhere else
+  --only <apps>   Only these apps: ${CLIENTS.map((client) => client.id).join(', ')}
+  -h, --help      Show this help
+  -v, --version   Show the version
+
+ChatGPT and Claude in the browser are set up from https://app.renor.cloud.`
+
+/** `--only`'s value as app ids; a missing value is an empty list, which the command refuses. */
+function appList(value) {
+  return (value || '').split(',').map((id) => id.trim()).filter(Boolean)
+}
+
+export function parse(argv) {
+  const options = { command: null, yes: false, dryRun: false, login: true, skill: true, verify: false, force: false, only: null, help: false, version: false, unknown: [] }
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg === '-y' || arg === '--yes') options.yes = true
+    else if (arg === '--dry-run') options.dryRun = true
+    else if (arg === '--no-login') options.login = false
+    else if (arg === '--no-skill') options.skill = false
+    else if (arg === '--verify') options.verify = true
+    else if (arg === '--force') options.force = true
+    else if (arg === '--only') options.only = appList(argv[i + 1]?.startsWith('-') ? '' : argv[++i])
+    else if (arg.startsWith('--only=')) options.only = appList(arg.slice(7))
+    else if (arg === '-h' || arg === '--help') options.help = true
+    else if (arg === '-v' || arg === '--version') options.version = true
+    else if (!arg.startsWith('-') && !options.command) options.command = arg
+    else options.unknown.push(arg)
+  }
+  return options
+}

package/lib/clients.mjs

@@ -0,0 +1,271 @@
+/**
+ * One adapter per AI app `renor setup` knows. Each says how to find the app, whether Renor is already in its config,
+ * how to add it (the app's own command where it has one, a careful file merge where it does not), and how to sign in.
+ *
+ * The commands are the ones the dashboard's setup prompt gives people (src/lib/landing-setup-prompt.ts). What each
+ * app does with them was checked against the real apps on 2026-10-19 in a throwaway home folder: Claude Code 2.1.303,
+ * Codex 0.163.0, OpenCode 2.0.32, Pi 1.3.0 and cursor-agent 2026.10.16.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { GATEWAY_URL, SERVER_NAME } from './constants.mjs'
+import { atLeast, backupFile, capture, home, interactive, readJsonc, stripJsonComments, stripTrailingCommas, versionOf, which, writeJsonWithBackup } from './system.mjs'
+
+/** What an adapter's add reports. */
+const added = (detail = null, signedIn = false) => ({ ok: true, detail, signedIn })
+const failed = (detail) => ({ ok: false, detail, signedIn: false })
+
+/** The URL a config entry points at, from the shapes the apps use (`url`, or `serverUrl` in older files). */
+function urlOf(entry) {
+  if (!entry || typeof entry !== 'object') return null
+  return typeof entry.url === 'string' ? entry.url : typeof entry.httpUrl === 'string' ? entry.httpUrl : typeof entry.serverUrl === 'string' ? entry.serverUrl : null
+}
+
+/** A JSON file we may rewrite: it parsed, and it held no comments that a rewrite would drop. */
+function plainJson(read) {
+  if (!read.ok) return false
+  if (!read.exists || !read.text) return true
+  return stripJsonComments(read.text).trim() === stripTrailingCommas(read.text).trim()
+}
+
+function vscodeUserDir(env) {
+  if (process.platform === 'darwin') return join(home(env), 'Library', 'Application Support', 'Code', 'User')
+  if (process.platform === 'win32') return join(env.APPDATA || join(home(env), 'AppData', 'Roaming'), 'Code', 'User')
+  return join(env.XDG_CONFIG_HOME || join(home(env), '.config'), 'Code', 'User')
+}
+
+/** Claude Code keeps its user config in CLAUDE_CONFIG_DIR when that is set, in the home folder otherwise. */
+function claudeConfig(env) {
+  return join(env.CLAUDE_CONFIG_DIR || home(env), '.claude.json')
+}
+
+function opencodeDir(env) {
+  return join(env.XDG_CONFIG_HOME || join(home(env), '.config'), 'opencode')
+}
+
+function codexConfig(env) {
+  return join(env.CODEX_HOME || join(home(env), '.codex'), 'config.toml')
+}
+
+/** Renor's table in Codex's config.toml, if any, and the url it holds. */
+function codexEntry(text) {
+  const lines = text.split(/\r?\n/)
+  const start = lines.findIndex((line) => /^\s*\[\s*mcp_servers\s*\.\s*(?:renor|"renor"|'renor')\s*\]\s*(#.*)?$/.test(line))
+  if (start < 0) return null
+  for (let i = start + 1; i < lines.length && !/^\s*\[/.test(lines[i]); i++) {
+    const match = lines[i].match(/^\s*url\s*=\s*"([^"]*)"/)
+    if (match) return { url: match[1] }
+  }
+  return { url: null }
+}
+
+/** Claude Code's own tools, denied during the check: allowing mcp__renor alone would still leave them to the person's own permission rules. */
+const CLAUDE_BUILT_IN_TOOLS = 'Bash,Edit,MultiEdit,Write,NotebookEdit,Read,Glob,Grep,WebFetch,WebSearch,Task,TodoWrite'
+
+export const CLIENTS = [
+  {
+    id: 'claude-code',
+    label: 'Claude Code',
+    detect: (ctx) => {
+      const bin = which('claude', ctx.env)
+      return bin ? { found: true, version: versionOf('claude', ctx.env) } : { found: false }
+    },
+    current: (ctx) => {
+      const read = readJsonc(claudeConfig(ctx.env))
+      const entry = read.value?.mcpServers?.[SERVER_NAME]
+      return { readable: read.ok, configured: Boolean(entry), url: urlOf(entry) }
+    },
+    add: (ctx, { replace }) => {
+      if (replace) capture('claude', ['mcp', 'remove', SERVER_NAME, '-s', 'user'], { env: ctx.env })
+      const out = capture('claude', ['mcp', 'add', '--transport', 'http', '--scope', 'user', SERVER_NAME, GATEWAY_URL], { env: ctx.env })
+      return out.ok ? added() : failed((out.stderr || out.stdout || out.error || '').trim())
+    },
+    // The one app whose one-shot mode can be limited to Renor's tools (the others would approve shell and file edits).
+    check: (prompt) => ['claude', ['-p', prompt, '--allowedTools', `mcp__${SERVER_NAME}`, '--disallowedTools', CLAUDE_BUILT_IN_TOOLS]],
+    login: null,
+    signIn: 'Restart Claude Code, type /mcp, choose renor, then Authenticate.',
+    byHand: `claude mcp add --transport http --scope user ${SERVER_NAME} ${GATEWAY_URL}`,
+  },
+  {
+    id: 'codex',
+    label: 'Codex',
+    detect: (ctx) => (which('codex', ctx.env) ? { found: true, version: versionOf('codex', ctx.env) } : { found: false }),
+    current: (ctx) => {
+      const path = codexConfig(ctx.env)
+      if (!existsSync(path)) return { readable: true, configured: false, url: null }
+      try {
+        const entry = codexEntry(readFileSync(path, 'utf8'))
+        return { readable: true, configured: Boolean(entry), url: entry?.url ?? null }
+      } catch {
+        return { readable: false, configured: false, url: null }
+      }
+    },
+    // `codex mcp add` writes the config, then starts the browser sign-in and waits for it. Run in front of the person
+    // that is the whole setup; where nobody can approve a sign-in, the table is written directly instead, so nothing waits.
+    add: (ctx, { replace }) => {
+      if (replace) capture('codex', ['mcp', 'remove', SERVER_NAME], { env: ctx.env })
+      if (ctx.canSignIn) {
+        ctx.say(`Adding Renor to Codex. Codex opens your browser: sign in to Renor and approve.`)
+        const status = interactive('codex', ['mcp', 'add', SERVER_NAME, '--url', GATEWAY_URL], { env: ctx.env })
+        const nowThere = existsSync(codexConfig(ctx.env)) && codexEntry(readFileSync(codexConfig(ctx.env), 'utf8'))
+        if (status === 0) return added(null, true)
+        return nowThere ? added('The sign-in did not finish.') : failed(`codex mcp add exited with ${status}`)
+      }
+      const path = codexConfig(ctx.env)
+      mkdirSync(dirname(path), { recursive: true })
+      const before = existsSync(path) ? readFileSync(path, 'utf8') : ''
+      // A renor table that is still there (the remove above failed) would be written twice, which Codex cannot read.
+      if (codexEntry(before)) return failed(`${path} still has a [mcp_servers.${SERVER_NAME}] table that could not be removed, so it was left as it is.`)
+      const backup = before ? backupFile(path) : null
+      const table = `[mcp_servers.${SERVER_NAME}]\nurl = "${GATEWAY_URL}"\n`
+      appendFileSync(path, (before && !before.endsWith('\n') ? '\n' : '') + (before ? '\n' : '') + table)
+      return added(backup ? `The previous file is saved as ${backup}.` : null)
+    },
+    login: null,
+    signIn: 'Run codex mcp login renor, then restart Codex.',
+    byHand: `codex mcp add ${SERVER_NAME} --url ${GATEWAY_URL}`,
+  },
+  {
+    id: 'cursor',
+    label: 'Cursor',
+    detect: (ctx) => {
+      const bin = which('cursor-agent', ctx.env)
+      if (bin) return { found: true, version: versionOf('cursor-agent', ctx.env) }
+      return existsSync(join(home(ctx.env), '.cursor')) ? { found: true, version: null } : { found: false }
+    },
+    current: (ctx) => {
+      const read = readJsonc(join(home(ctx.env), '.cursor', 'mcp.json'))
+      const entry = read.value?.mcpServers?.[SERVER_NAME]
+      return { readable: read.ok, configured: Boolean(entry), url: urlOf(entry) }
+    },
+    add: (ctx) => {
+      const path = join(home(ctx.env), '.cursor', 'mcp.json')
+      const read = readJsonc(path)
+      if (!plainJson(read)) return failed(`${path} has comments or is not valid JSON, so it was left as it is.`)
+      const value = read.value && typeof read.value === 'object' ? read.value : {}
+      value.mcpServers = { ...(value.mcpServers || {}), [SERVER_NAME]: { url: GATEWAY_URL } }
+      const backup = writeJsonWithBackup(path, value)
+      return added(backup ? `The previous file is saved as ${backup}.` : null)
+    },
+    login: (ctx) => (which('cursor-agent', ctx.env) ? ['cursor-agent', ['mcp', 'login', SERVER_NAME]] : null),
+    signIn: 'Restart Cursor, open Settings › MCP, find renor and sign in.',
+    byHand: `Add { "mcpServers": { "${SERVER_NAME}": { "url": "${GATEWAY_URL}" } } } to ~/.cursor/mcp.json`,
+  },
+  {
+    id: 'opencode',
+    label: 'OpenCode',
+    detect: (ctx) => {
+      if (which('opencode', ctx.env)) return { found: true, version: versionOf('opencode', ctx.env) }
+      return existsSync(opencodeDir(ctx.env)) ? { found: true, version: null } : { found: false }
+    },
+    current: (ctx) => {
+      // OpenCode reads both files, so Renor in either one counts.
+      let readable = true
+      for (const name of ['opencode.jsonc', 'opencode.json']) {
+        const read = readJsonc(join(opencodeDir(ctx.env), name))
+        readable &&= read.ok
+        // OpenCode 1 keeps servers under `mcp`, OpenCode 2 under `mcp.servers`; it reads both.
+        const entry = read.value?.mcp?.servers?.[SERVER_NAME] ?? read.value?.mcp?.[SERVER_NAME]
+        if (entry) return { readable: read.ok, configured: true, url: urlOf(entry) }
+      }
+      return { readable, configured: false, url: null }
+    },
+    add: (ctx, { replace }) => {
+      // OpenCode's own command keeps the file's comments and format; an older OpenCode without it gets a careful merge.
+      if (!replace && which('opencode', ctx.env) && capture('opencode', ['mcp', 'add', '--help'], { env: ctx.env }).ok) {
+        const out = capture('opencode', ['mcp', 'add', SERVER_NAME, '--url', GATEWAY_URL, '--global'], { env: ctx.env })
+        if (out.ok) return added()
+      }
+      const path = join(opencodeDir(ctx.env), existsSync(join(opencodeDir(ctx.env), 'opencode.jsonc')) ? 'opencode.jsonc' : 'opencode.json')
+      const read = readJsonc(path)
+      if (!plainJson(read)) return failed(`${path} has comments or is not valid JSON, so it was left as it is.`)
+      const value = read.value && typeof read.value === 'object' ? read.value : {}
+      const mcp = { ...(value.mcp || {}) }
+      if (mcp.servers && typeof mcp.servers === 'object') mcp.servers = { ...mcp.servers, [SERVER_NAME]: { type: 'remote', url: GATEWAY_URL } }
+      else mcp[SERVER_NAME] = { type: 'remote', url: GATEWAY_URL }
+      value.mcp = mcp
+      const backup = writeJsonWithBackup(path, value)
+      return added(backup ? `The previous file is saved as ${backup}.` : null)
+    },
+    login: (ctx) => (which('opencode', ctx.env) ? ['opencode', ['mcp', 'auth', SERVER_NAME]] : null),
+    signIn: 'Run opencode mcp auth renor, then restart OpenCode.',
+    byHand: `opencode mcp add ${SERVER_NAME} --url ${GATEWAY_URL} --global`,
+  },
+  {
+    id: 'gemini',
+    label: 'Gemini CLI',
+    detect: (ctx) => {
+      if (which('gemini', ctx.env)) return { found: true, version: versionOf('gemini', ctx.env) }
+      return existsSync(join(home(ctx.env), '.gemini')) ? { found: true, version: null } : { found: false }
+    },
+    current: (ctx) => {
+      const read = readJsonc(join(home(ctx.env), '.gemini', 'settings.json'))
+      const entry = read.value?.mcpServers?.[SERVER_NAME]
+      return { readable: read.ok, configured: Boolean(entry), url: urlOf(entry) }
+    },
+    // Gemini CLI reads `httpUrl` for a streamable-HTTP server (`url` would make it try SSE).
+    add: (ctx) => {
+      const path = join(home(ctx.env), '.gemini', 'settings.json')
+      const read = readJsonc(path)
+      if (!plainJson(read)) return failed(`${path} has comments or is not valid JSON, so it was left as it is.`)
+      const value = read.value && typeof read.value === 'object' ? read.value : {}
+      value.mcpServers = { ...(value.mcpServers || {}), [SERVER_NAME]: { httpUrl: GATEWAY_URL } }
+      const backup = writeJsonWithBackup(path, value)
+      return added(backup ? `The previous file is saved as ${backup}.` : null)
+    },
+    login: null,
+    signIn: 'Start Gemini CLI, type /mcp auth renor, and approve Renor in your browser.',
+    byHand: `Add { "mcpServers": { "${SERVER_NAME}": { "httpUrl": "${GATEWAY_URL}" } } } to ~/.gemini/settings.json`,
+  },
+  {
+    id: 'pi',
+    label: 'Pi',
+    detect: (ctx) => {
+      if (!which('pi', ctx.env)) return { found: false }
+      const version = versionOf('pi', ctx.env)
+      // `pi mcp` arrived in Pi 0.99.
+      return version && !atLeast(version, '0.99') ? { found: true, version, blocked: 'Update Pi first (pi update): Pi adds MCP servers from 0.99 on.' } : { found: true, version }
+    },
+    current: (ctx) => {
+      const read = readJsonc(join(home(ctx.env), '.pi', 'agent', 'mcp.json'))
+      const entry = read.value?.mcpServers?.[SERVER_NAME]
+      return { readable: read.ok, configured: Boolean(entry), url: urlOf(entry) }
+    },
+    // `pi mcp add` adds or replaces, so the same command serves a replacement.
+    add: (ctx) => {
+      const out = capture('pi', ['mcp', 'add', SERVER_NAME, '--url', GATEWAY_URL, '--exposure', 'direct'], { env: ctx.env })
+      return out.ok ? added() : failed((out.stderr || out.stdout || out.error || '').trim())
+    },
+    login: () => ['pi', ['mcp', 'login', SERVER_NAME]],
+    signIn: 'Run pi mcp login renor, then /reload in Pi.',
+    byHand: `pi mcp add ${SERVER_NAME} --url ${GATEWAY_URL} --exposure direct`,
+  },
+  {
+    id: 'vscode',
+    label: 'VS Code',
+    detect: (ctx) => (which('code', ctx.env) ? { found: true, version: versionOf('code', ctx.env) } : { found: false }),
+    current: (ctx) => {
+      const read = readJsonc(join(vscodeUserDir(ctx.env), 'mcp.json'))
+      const entry = read.value?.servers?.[SERVER_NAME]
+      return { readable: read.ok, configured: Boolean(entry), url: urlOf(entry) }
+    },
+    add: (ctx, { replace }) => {
+      if (replace) {
+        const path = join(vscodeUserDir(ctx.env), 'mcp.json')
+        const read = readJsonc(path)
+        if (!plainJson(read)) return failed(`${path} has comments or is not valid JSON, so it was left as it is.`)
+        const value = read.value || {}
+        value.servers = { ...(value.servers || {}), [SERVER_NAME]: { type: 'http', url: GATEWAY_URL } }
+        const backup = writeJsonWithBackup(path, value)
+        return added(backup ? `The previous file is saved as ${backup}.` : null)
+      }
+      const out = capture('code', ['--add-mcp', JSON.stringify({ name: SERVER_NAME, type: 'http', url: GATEWAY_URL })], { env: ctx.env })
+      return out.ok ? added() : failed((out.stderr || out.stdout || out.error || '').trim())
+    },
+    login: null,
+    signIn: 'Open VS Code. Copilot asks you to sign in to Renor the first time it uses it.',
+    byHand: `code --add-mcp '${JSON.stringify({ name: SERVER_NAME, type: 'http', url: GATEWAY_URL })}'`,
+  },
+]
+
+export { codexEntry }

package/lib/constants.mjs

@@ -0,0 +1,27 @@
+/**
+ * What `renor setup` adds and installs. The same values the dashboard's setup prompt gives
+ * (src/lib/landing-setup-prompt.ts); tests/cli-setup.test.ts in the platform suite fails if they drift apart.
+ */
+
+/** Renor's one public MCP address. Sign-in is OAuth in the browser, so nothing here carries a key. */
+export const GATEWAY_URL = 'https://mcp.renor.cloud/mcp'
+
+/** The server's name in every client's config. */
+export const SERVER_NAME = 'renor'
+
+/** The public skill, pinned: the exact `skills` CLI version and the renor-skills commit it fetches. */
+export const SKILLS_CLI_VERSION = '1.7.2'
+export const RENOR_SKILLS_COMMIT = '018fddc51e6066c30c6919fdf27bbb1c8b64187a'
+export const SKILL_INSTALL_ARGS = [
+  '-y',
+  `skills@${SKILLS_CLI_VERSION}`,
+  'add',
+  `https://github.com/renorai/renor-skills/tree/${RENOR_SKILLS_COMMIT}`,
+  '--agent',
+  '*',
+  '-y',
+]
+
+/** What to tell the person to try once everything is connected (FIRST_MEMORY_CHECK in the platform). */
+export const FIRST_MEMORY_SAVE = 'Save to Renor: my favorite editor is Neovim.'
+export const FIRST_MEMORY_RECALL = 'What is my favorite editor?'

package/lib/mcp-client.mjs

@@ -0,0 +1,66 @@
+/**
+ * A small MCP client over Streamable HTTP, enough to call Renor's read tools: initialize, then tools/call. Plain fetch, no
+ * dependency. A reply may come as JSON or as an event stream (text/event-stream); both are read. The session id the server
+ * hands out on initialize (Mcp-Session-Id) is sent back on every later request.
+ */
+
+const PROTOCOL_VERSION = '2025-06-18'
+
+/** The JSON-RPC message answering request `id`, from a JSON body or from the `data:` lines of an event stream. */
+function messageFor(body, contentType, id) {
+  const messages = []
+  if (contentType.includes('text/event-stream')) {
+    for (const event of body.split(/\r?\n\r?\n/)) {
+      const data = event.split(/\r?\n/).filter((line) => line.startsWith('data:')).map((line) => line.slice(5).replace(/^ /, '')).join('\n')
+      if (data.trim()) messages.push(JSON.parse(data))
+    }
+  } else if (body.trim()) {
+    const parsed = JSON.parse(body)
+    messages.push(...(Array.isArray(parsed) ? parsed : [parsed]))
+  }
+  return messages.find((message) => message && message.id === id)
+}
+
+/**
+ * `connect({ url, token, fetchImpl })` → `{ callTool(name, args) }`. `callTool` returns the tool's text content parsed as
+ * JSON (Renor's read tools answer one JSON text block), and throws with the tool's own message when it answers isError.
+ */
+export async function connect({ url, token, fetchImpl = globalThis.fetch, clientName = 'renor-cli' }) {
+  let session = null
+  let nextId = 1
+
+  async function post(payload) {
+    const headers = { 'content-type': 'application/json', accept: 'application/json, text/event-stream', 'mcp-protocol-version': PROTOCOL_VERSION }
+    if (token) headers.authorization = `Bearer ${token}`
+    if (session) headers['mcp-session-id'] = session
+    const res = await fetchImpl(url, { method: 'POST', headers, body: JSON.stringify(payload) })
+    const sid = res.headers.get('mcp-session-id')
+    if (sid) session = sid
+    const body = await res.text()
+    if (res.status === 401) throw new Error(`Renor refused the key (401 from ${url}). Set RENOR_API_KEY to an API key from https://app.renor.cloud.`)
+    if (!res.ok && res.status !== 202) throw new Error(`Renor answered ${res.status} from ${url}: ${body.slice(0, 200)}`)
+    return { body, contentType: res.headers.get('content-type') || '' }
+  }
+
+  async function request(method, params) {
+    const id = nextId++
+    const { body, contentType } = await post({ jsonrpc: '2.0', id, method, params })
+    const message = messageFor(body, contentType, id)
+    if (!message) throw new Error(`Renor sent no answer to ${method}`)
+    if (message.error) throw new Error(`Renor ${method} failed: ${message.error.message}`)
+    return message.result
+  }
+
+  await request('initialize', { protocolVersion: PROTOCOL_VERSION, capabilities: {}, clientInfo: { name: clientName, version: '1' } })
+  await post({ jsonrpc: '2.0', method: 'notifications/initialized' })
+
+  return {
+    async callTool(name, args = {}) {
+      const result = await request('tools/call', { name, arguments: args })
+      const text = (result.content || []).filter((part) => part.type === 'text').map((part) => part.text)[0] ?? ''
+      if (result.isError) throw new Error(`${name}: ${text.slice(0, 300)}`)
+      if (result.structuredContent) return result.structuredContent
+      return JSON.parse(text)
+    },
+  }
+}

package/lib/mcp.mjs

@@ -0,0 +1,60 @@
+/** A minimal MCP client over HTTP: one session, tools/call only. The same handshake the dashboard import uses. */
+
+const LOOPBACK = /^(127(\.\d{1,3}){3}|\[::1\])$/
+
+/** The token goes only to https, or http on a literal loopback address (a name like localhost can be pointed elsewhere). */
+export function checkUrl(value) {
+  let url
+  try { url = new URL(value) } catch { throw new Error(`RENOR_MCP_URL is not a URL: ${value}`) }
+  if (url.username || url.password) throw new Error('RENOR_MCP_URL must not carry a user name or password.')
+  if (url.protocol !== 'https:' && !(url.protocol === 'http:' && LOOPBACK.test(url.hostname))) {
+    throw new Error('RENOR_MCP_URL must be https (http only for 127.0.0.1 or [::1]); the token is not sent anywhere else.')
+  }
+  return url.href
+}
+
+/** Opens a session at `url` with a connect token and returns `{ call, close }`. `call` resolves to the tool's JSON or throws. */
+export async function openSession(target, token, fetchImpl = fetch) {
+  const url = checkUrl(target)
+  const headers = { authorization: `Bearer ${token}`, 'content-type': 'application/json', accept: 'application/json, text/event-stream' }
+  const post = (body) => fetchImpl(url, { method: 'POST', headers, body: JSON.stringify(body), redirect: 'error' })
+  const init = await post({
+    jsonrpc: '2.0', id: 1, method: 'initialize',
+    params: { protocolVersion: '2025-03-26', capabilities: {}, clientInfo: { name: 'renor-sync', version: '1' } },
+  })
+  if (init.status === 401) throw new Error('Renor did not accept the token (RENOR_TOKEN). Make a new connect token in the dashboard.')
+  if (!init.ok) throw new Error(`Renor answered ${init.status} to the first request.`)
+  await reply(init, 1)
+  const session = init.headers.get('mcp-session-id')
+  if (session) headers['mcp-session-id'] = session
+  await (await post({ jsonrpc: '2.0', method: 'notifications/initialized' })).text()
+  let id = 1
+  return {
+    async call(tool, args) {
+      const n = ++id
+      const res = await post({ jsonrpc: '2.0', id: n, method: 'tools/call', params: { name: tool, arguments: args } })
+      if (!res.ok) throw new Error(`${tool}: Renor answered ${res.status}.`)
+      const message = await reply(res, n)
+      if (message.error) throw new Error(`${tool}: ${message.error.message}`)
+      const text = message.result?.content?.find((part) => part?.type === 'text')?.text ?? ''
+      if (message.result?.isError) throw new Error(`${tool}: ${text.slice(0, 300) || 'refused'}`)
+      return JSON.parse(text)
+    },
+    async close() {
+      if (session) await fetchImpl(url, { method: 'DELETE', headers, redirect: 'error' }).then((r) => r.text(), () => {})
+    },
+  }
+}
+
+async function reply(res, id) {
+  const text = await res.text()
+  const events = (res.headers.get('content-type') ?? '').includes('text/event-stream')
+    ? text.split(/\r?\n/).filter((line) => line.startsWith('data:')).map((line) => line.slice(5))
+    : [text]
+  for (const event of events) {
+    try {
+      for (const message of [JSON.parse(event)].flat()) if (message?.id === id) return message
+    } catch { /* not JSON */ }
+  }
+  throw new Error('Renor sent no usable reply.')
+}