renor 0.1.0 → 0.2.0

package/README.md

@@ -6,7 +6,9 @@ Connects the AI apps on your computer to [Renor](https://renor.cloud), so they s
 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. At the end it lists anything left for you to do, app by app.
+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 |
 |---|---|---|
@@ -14,6 +16,7 @@ It finds the apps you have, adds Renor to each, signs you in, and installs the R
 | 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 |
 
@@ -25,6 +28,10 @@ Every app gets the same address, `https://mcp.renor.cloud/mcp`. No key is stored
 - 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
 
 ```
@@ -32,10 +39,40 @@ Every app gets the same address, `https://mcp.renor.cloud/mcp`. No key is stored
 -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, pi, vscode
+--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

@@ -2,11 +2,14 @@
 /**
  * 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 {
@@ -17,6 +20,8 @@ function version() {
 }
 
 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')
@@ -26,6 +31,7 @@ async function main() {
     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
@@ -34,6 +40,10 @@ async function main() {
     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`)
@@ -51,7 +61,7 @@ if (major < 18) {
 main().then(
   (code) => process.exit(code),
   (error) => {
-    process.stderr.write(`renor setup failed: ${error instanceof Error ? error.message : String(error)}\n`)
+    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

@@ -4,13 +4,17 @@ 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
+  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
@@ -18,17 +22,23 @@ Options
 
 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, force: false, only: null, help: false, version: false, unknown: [] }
+  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 = (argv[++i] || '').split(',').map((id) => id.trim()).filter(Boolean)
-    else if (arg.startsWith('--only=')) options.only = arg.slice(7).split(',').map((id) => id.trim()).filter(Boolean)
+    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

package/lib/clients.mjs

@@ -18,7 +18,7 @@ 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.serverUrl === 'string' ? entry.serverUrl : 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. */
@@ -34,6 +34,11 @@ function vscodeUserDir(env) {
   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')
 }
@@ -54,6 +59,9 @@ function codexEntry(text) {
   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',
@@ -63,7 +71,7 @@ export const CLIENTS = [
       return bin ? { found: true, version: versionOf('claude', ctx.env) } : { found: false }
     },
     current: (ctx) => {
-      const read = readJsonc(join(home(ctx.env), '.claude.json'))
+      const read = readJsonc(claudeConfig(ctx.env))
       const entry = read.value?.mcpServers?.[SERVER_NAME]
       return { readable: read.ok, configured: Boolean(entry), url: urlOf(entry) }
     },
@@ -72,6 +80,8 @@ export const CLIENTS = [
       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}`,
@@ -149,14 +159,16 @@ export const CLIENTS = [
       return existsSync(opencodeDir(ctx.env)) ? { found: true, version: null } : { found: false }
     },
     current: (ctx) => {
-      for (const name of ['opencode.json', 'opencode.jsonc']) {
+      // 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))
-        if (!read.exists) continue
+        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]
-        return { readable: read.ok, configured: Boolean(entry), url: urlOf(entry) }
+        if (entry) return { readable: read.ok, configured: true, url: urlOf(entry) }
       }
-      return { readable: true, configured: false, url: null }
+      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.
@@ -179,6 +191,32 @@ export const CLIENTS = [
     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',
@@ -230,8 +268,4 @@ export const CLIENTS = [
   },
 ]
 
-export function findClient(id) {
-  return CLIENTS.find((client) => client.id === id) ?? null
-}
-
-export { codexEntry, plainJson }
+export { codexEntry }

package/lib/constants.mjs

@@ -16,7 +16,7 @@ export const SKILL_INSTALL_ARGS = [
   '-y',
   `skills@${SKILLS_CLI_VERSION}`,
   'add',
-  `https://github.com/patrickpassosb/renor-skills/tree/${RENOR_SKILLS_COMMIT}`,
+  `https://github.com/renorai/renor-skills/tree/${RENOR_SKILLS_COMMIT}`,
   '--agent',
   '*',
   '-y',

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.')
+}

package/lib/review-rules-cli.mjs

@@ -0,0 +1,144 @@
+/**
+ * `renor review-rules`: the owner's standing rules for a review prompt (default), a marked section of a guidelines file
+ * (--export), or proposed rules from past reviews (--propose, which never reaches Renor).
+ */
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { GATEWAY_URL } from './constants.mjs'
+import { connect } from './mcp-client.mjs'
+import { fetchRules } from './review-rules-source.mjs'
+import {
+  DEFAULT_EXPORT_MAX_TOKENS, DEFAULT_MAX_TOKENS, buildReviewRulesBlock, formatProposals, proposeRules, renderRulesSection, updateMarkedSection,
+} from './review-rules.mjs'
+
+export const REVIEW_RULES_HELP = `renor review-rules — the owner's standing rules from Renor, for a code review.
+
+Usage
+  gh pr diff 123 | npx renor review-rules        Print the rules that bear on the diff, to put at the top of a review prompt
+  npx renor review-rules --diff change.patch     The same, from a file
+  npx renor review-rules --export [REVIEW.md]    Write the rules into one marked section of REVIEW.md (or AGENTS.md)
+  npx renor review-rules --propose reviews/      Propose rules from recurring findings in past reviews (Markdown); saves nothing
+
+Options
+  --diff <file|->       The diff to match rules against (default: standard input when it is not a terminal)
+  --max-tokens <n>      Cap the block at about n tokens (default ${DEFAULT_MAX_TOKENS}; ${DEFAULT_EXPORT_MAX_TOKENS} for --export)
+  --url <url>           Renor's MCP address (default RENOR_URL, else ${GATEWAY_URL}); a local engine is http://127.0.0.1:3471/mcp
+  --rules-file <json>   Read the rules from a JSON file (an array of rules) instead of Renor
+  --min-reviews <n>     --propose: how many reviews a finding must recur in (default 2)
+  --json                Print JSON (the block, or the proposals) instead of text
+
+The key is RENOR_API_KEY (an API key from https://app.renor.cloud). Every call to Renor is a read.`
+
+export function parseReviewRules(argv) {
+  const options = { diff: null, maxTokens: null, url: null, rulesFile: null, export: null, propose: null, minReviews: 2, json: false, help: false, unknown: [] }
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    const value = () => {
+      const eq = arg.indexOf('=')
+      return eq > 0 ? arg.slice(eq + 1) : argv[++i]
+    }
+    const name = arg.includes('=') ? arg.slice(0, arg.indexOf('=')) : arg
+    if (name === '--diff') options.diff = value()
+    else if (name === '--max-tokens') options.maxTokens = Number(value())
+    else if (name === '--url') options.url = value()
+    else if (name === '--rules-file') options.rulesFile = value()
+    else if (name === '--min-reviews') options.minReviews = Number(value())
+    else if (name === '--propose') options.propose = value()
+    else if (name === '--export') {
+      if (arg.includes('=')) options.export = value()
+      else options.export = argv[i + 1] && !argv[i + 1].startsWith('-') ? argv[++i] : ''
+    } else if (arg === '--json') options.json = true
+    else if (arg === '-h' || arg === '--help') options.help = true
+    else options.unknown.push(arg)
+  }
+  return options
+}
+
+function readStdin() {
+  try {
+    return readFileSync(0, 'utf8')
+  } catch {
+    return ''
+  }
+}
+
+/** The rules: from --rules-file, or from Renor. */
+async function loadRules(options, { env, diff, err, fetchImpl }) {
+  if (options.rulesFile) return JSON.parse(readFileSync(options.rulesFile, 'utf8'))
+  const url = options.url || env.RENOR_URL || GATEWAY_URL
+  const token = env.RENOR_API_KEY || ''
+  if (!token && url === GATEWAY_URL) throw new Error('Set RENOR_API_KEY to an API key from https://app.renor.cloud (or pass --url for a local engine, or --rules-file).')
+  const client = await connect({ url, token, fetchImpl })
+  return fetchRules(client, { diff, warn: (message) => err.write(`renor review-rules: ${message}\n`) })
+}
+
+/**
+ * Runs `renor review-rules` with `argv` (the words after the command). Returns the exit code. `io` is for tests:
+ * { env, out, err, stdin: () => string, stdinIsTTY, cwd, fetchImpl }.
+ */
+export async function reviewRules(argv, io = {}) {
+  const env = io.env || process.env
+  const out = io.out || process.stdout
+  const err = io.err || process.stderr
+  const cwd = io.cwd || process.cwd()
+  const options = parseReviewRules(argv)
+  if (options.help) {
+    out.write(REVIEW_RULES_HELP + '\n')
+    return 0
+  }
+  if (options.unknown.length > 0) {
+    err.write(`Unknown option: ${options.unknown.join(' ')}\n\n${REVIEW_RULES_HELP}\n`)
+    return 2
+  }
+  if (options.maxTokens !== null && !(Number.isInteger(options.maxTokens) && options.maxTokens > 0)) {
+    err.write('--max-tokens takes a whole number above 0\n')
+    return 2
+  }
+
+  if (options.propose !== null) {
+    // Reads the folder only: no connection to Renor is opened in this mode, so it cannot save anything there.
+    const dir = options.propose || '.'
+    const reviews = readdirSync(dir).filter((name) => name.toLowerCase().endsWith('.md')).sort()
+      .map((name) => ({ name, text: readFileSync(join(dir, name), 'utf8') }))
+    const proposals = proposeRules(reviews, { minReviews: Number.isInteger(options.minReviews) && options.minReviews > 0 ? options.minReviews : 2 })
+    out.write(options.json ? JSON.stringify(proposals, null, 2) + '\n' : formatProposals(proposals, reviews.length))
+    return 0
+  }
+
+  let diff = ''
+  if (options.diff === '-') diff = (io.stdin || readStdin)()
+  else if (options.diff) diff = readFileSync(options.diff, 'utf8')
+  else if (options.export === null && !(io.stdinIsTTY ?? process.stdin.isTTY)) diff = (io.stdin || readStdin)()
+  if (options.export === null && diff.trim() === '') {
+    err.write('No diff: pipe one in (gh pr diff 123 | npx renor review-rules) or pass --diff <file>.\n')
+    return 2
+  }
+
+  const rules = await loadRules(options, { env, diff, err, fetchImpl: io.fetchImpl })
+
+  if (options.export !== null) {
+    const target = options.export || (existsSync(join(cwd, 'REVIEW.md')) || !existsSync(join(cwd, 'AGENTS.md')) ? 'REVIEW.md' : 'AGENTS.md')
+    const path = join(cwd, target)
+    const before = existsSync(path) ? readFileSync(path, 'utf8') : ''
+    const { section, included, omitted } = renderRulesSection({ rules, diff, maxTokens: options.maxTokens ?? DEFAULT_EXPORT_MAX_TOKENS })
+    const after = updateMarkedSection(before, section)
+    if (after === before) {
+      out.write(`${target}: unchanged (${included.length} rule(s)).\n`)
+      return 0
+    }
+    writeFileSync(path, after)
+    out.write(`${target}: wrote ${included.length} rule(s) into the Renor section${omitted.length ? `; ${omitted.length} more did not fit --max-tokens` : ''}. Nothing outside the section changed.\n`)
+    return 0
+  }
+
+  const { block, included, omitted } = buildReviewRulesBlock({ rules, diff, maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS })
+  if (options.json) {
+    out.write(JSON.stringify({ block, included: included.map((rule) => rule.id), omitted: omitted.map((rule) => rule.id) }, null, 2) + '\n')
+    return 0
+  }
+  out.write(block)
+  err.write(block
+    ? `renor review-rules: ${included.length} rule(s) quoted${omitted.length ? `, ${omitted.length} left out by --max-tokens` : ''}.\n`
+    : 'renor review-rules: no current rule bears on this diff; nothing printed.\n')
+  return 0
+}

package/lib/review-rules-source.mjs

@@ -0,0 +1,83 @@
+/**
+ * Where `renor review-rules` gets the owner's rules: Renor's own read tools, over MCP, hosted or local. No engine tool was
+ * added for this; the existing ones are enough:
+ *
+ *   memory_map (no query)     the newest facts, history included: the subjects that hold a rule-like predicate
+ *   get_context (the diff)    current facts the diff's words reach, beyond the newest ones: more such subjects
+ *   retrieve_memory (subject) each subject's facts, every one marked current or superseded, with its event id and date,
+ *                             its value whole (get_context may cut a value, and gives no id)
+ *   memory_map (rule words)   plain-words memories that hold "always", "never", "prefer", "rule", ...
+ *   read_memory (id)          each such memory's full text, and whether a later correction replaced it
+ *
+ * Only `current: true` facts and memories nobody replaced are kept, so a superseded value never reaches the block. Every
+ * call is a read: nothing here saves, retires or changes anything in Renor.
+ */
+import { diffFiles, isRulePredicate, looksLikeRule, terms } from './review-rules.mjs'
+
+const RULE_WORDS = 'rule always never must prefer avoid policy decision decided convention guideline'
+
+/** The question get_context is asked: the changed files and the diff's most frequent words, inside its 1000-character limit. */
+export function contextQuery(diff) {
+  const counts = new Map()
+  for (const line of String(diff || '').split('\n')) {
+    if (!/^[+-]/.test(line) || /^(\+\+\+|---) /.test(line)) continue
+    for (const t of terms(line.slice(1))) counts.set(t, (counts.get(t) || 0) + 1)
+  }
+  const top = [...counts].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 30).map(([t]) => t)
+  return `Standing rules, preferences and decisions for a code review of changes to ${diffFiles(diff).slice(0, 20).join(', ')}. Topics: ${top.join(' ')}`.slice(0, 1000)
+}
+
+const day = (iso) => (typeof iso === 'string' ? iso.slice(0, 10) : undefined)
+
+/**
+ * fetchRules(client, { diff?, maxSubjects = 40, maxMemories = 40, warn? }) → Rule[]
+ *
+ * `client.callTool(name, args)` answers a Renor tool's JSON (mcp-client.mjs). A tool that fails is skipped with a warning
+ * (`warn(message)`), so one refused read leaves the rest of the rules; nothing is guessed in its place.
+ */
+export async function fetchRules(client, { diff = '', maxSubjects = 40, maxMemories = 40, warn = () => {} } = {}) {
+  const call = async (name, args) => {
+    try {
+      return await client.callTool(name, args)
+    } catch (error) {
+      warn(`${name} failed: ${error instanceof Error ? error.message : String(error)}`)
+      return null
+    }
+  }
+
+  const subjects = []
+  const addSubject = (subject) => {
+    if (typeof subject === 'string' && subject.trim() !== '' && !subjects.includes(subject)) subjects.push(subject)
+  }
+  const map = await call('memory_map', { limit: 200 })
+  for (const fact of map?.facts || []) if (isRulePredicate(fact.predicate)) addSubject(fact.subject)
+  if (String(diff).trim() !== '') {
+    const context = await call('get_context', { query: contextQuery(diff), max_tokens: 4000 })
+    for (const fact of context?.facts || []) if (isRulePredicate(fact.predicate) && fact.untrusted !== true) addSubject(fact.subject)
+  }
+
+  const rules = []
+  const seen = new Set()
+  for (const subject of subjects.slice(0, maxSubjects)) {
+    const read = await call('retrieve_memory', { subject })
+    for (const fact of read?.facts || []) {
+      if (fact.current !== true || fact.validTo || fact.untrusted === true || !isRulePredicate(fact.predicate)) continue
+      if (!fact.eventId || seen.has(fact.eventId)) continue
+      seen.add(fact.eventId)
+      rules.push({ id: fact.eventId, date: day(fact.validFrom), text: fact.object, kind: 'fact', subject, predicate: fact.predicate, scope: fact.scope, current: true })
+    }
+  }
+
+  const found = await call('memory_map', { query: RULE_WORDS, limit: 200 })
+  const candidates = (found?.memories || []).filter((memory) => memory.untrusted !== true && memory.origin !== 'import')
+  for (const memory of candidates.slice(0, maxMemories)) {
+    if (seen.has(memory.id)) continue
+    const read = await call('read_memory', { id: memory.id })
+    if (!read || read.ok === false || read.replaced || read.textTruncated || typeof read.text !== 'string') continue
+    const detail = read.memory || memory
+    if (detail.untrusted === true || detail.origin === 'import' || !looksLikeRule(read.text)) continue
+    seen.add(memory.id)
+    rules.push({ id: memory.id, date: day(detail.session_date || detail.at), text: read.text, kind: 'memory', current: true })
+  }
+  return rules
+}