renor 0.1.0 → 0.2.0

package/lib/review-rules.mjs

@@ -0,0 +1,390 @@
+/**
+ * The owner's standing rules in every review: the pure core of `renor review-rules`. Nothing here touches the network or
+ * the disk; the CLI (review-rules-cli.mjs) fetches rules from Renor (review-rules-source.mjs) and hands them in.
+ *
+ * A rule, as every function here takes it:
+ *   { id, date, text, kind: 'fact' | 'memory', subject?, predicate?, scope?, current?, replaced?, untrusted? }
+ * `id` is the Renor memory id (a fact's event id, `mem_…`, or a note's id from memory_map), `date` the day it was saved
+ * (YYYY-MM-DD), `text` the stored words, quoted byte for byte. `current: false` (a superseded fact), `replaced: true` (a
+ * note a later correction replaced) and `untrusted: true` (an import, or a reserved source) are never quoted.
+ *
+ * The plain function to run on a private set (firstmate's laptop gate) is `buildReviewRulesBlock({ rules, diff, maxTokens })`.
+ */
+
+/**
+ * The predicate words a standing rule, preference or decision is saved under. The first group is the engine's own
+ * GOVERNANCE_PREDICATES (engine/src/mvp/agentMemory.ts), the words its facts lane reads as a standing rule; the second is
+ * what a preference is saved under. A predicate counts when it is one of these or has one as a word (`test_policy`,
+ * `ui preference`).
+ */
+export const RULE_PREDICATE_WORDS = [
+  'rule', 'rules', 'policy', 'policies', 'decision', 'decisions', 'guideline', 'guidelines',
+  'constraint', 'constraints', 'requirement', 'requirements', 'must', 'convention', 'conventions',
+  'principle', 'principles', 'guardrail', 'guardrails', 'permission', 'permissions', 'approval', 'approvals',
+  'preference', 'preferences', 'prefer', 'prefers', 'preferred', 'style', 'avoid', 'never', 'always', 'standard', 'standards',
+]
+
+export function isRulePredicate(predicate) {
+  if (typeof predicate !== 'string') return false
+  return predicate.toLowerCase().split(/[^\p{L}\p{N}]+/u).some((word) => word !== '' && RULE_PREDICATE_WORDS.includes(word))
+}
+
+/** Whether a plain-words memory reads as a standing rule, preference or decision rather than a note of what happened. */
+export function looksLikeRule(text) {
+  if (typeof text !== 'string') return false
+  if (/^\s*(rule|preference|decision|policy|convention|guideline|standing rule)s?\s*[:\-—]/i.test(text)) return true
+  return /\b(always|never|must|must not|do not|don't|prefer|prefers|avoid|decided)\b/i.test(text)
+}
+
+/** About how many tokens a text costs: one per four UTF-8 bytes, rounded up (o200k averages a little over that on English). */
+export function estimateTokens(text) {
+  return Math.ceil(Buffer.byteLength(text, 'utf8') / 4)
+}
+
+const STOP_WORDS = new Set(('the a an and or but if then else for to of in on at by with from as is are was were be been it its this that these '
+  + 'those not no do does did done can could should would will shall may might must always never only also any all each every '
+  + 'one two our we you your they them their there here what when where which who why how than too very more most such into '
+  + 'out over under about after before again just use used using new old get set add const let var return true false null '
+  + 'undefined import export function class type interface diff git index file files line lines same like way thing').split(' '))
+
+/** Words of a text, for matching: lower case, camelCase and snake_case split, stop words and one- or two-letter words out, light stemming. */
+export function terms(text) {
+  const words = String(text)
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .toLowerCase()
+    .split(/[^\p{L}\p{N}]+/u)
+  const out = []
+  for (const word of words) {
+    if (word.length < 3 || STOP_WORDS.has(word) || /^\d+$/.test(word)) continue
+    const stemmed = stem(word)
+    if (!STOP_WORDS.has(stemmed)) out.push(stemmed)
+  }
+  return out
+}
+
+/** A doubled final consonant left by cutting -ing or -ed (`logg`, `mapp`) back to one, as the plain word has it. */
+const undouble = (word) => (word.length >= 4 && /([b-df-hj-np-tv-z])\1$/.test(word) && !/(ss|ll|ff|zz)$/.test(word) ? word.slice(0, -1) : word)
+
+function stem(word) {
+  if (word.length > 5 && word.endsWith('ing')) return undouble(word.slice(0, -3))
+  if (word.length > 4 && word.endsWith('ies')) return word.slice(0, -3) + 'y'
+  if (word.length > 4 && word.endsWith('ed')) return undouble(word.slice(0, -2))
+  if (word.length > 4 && word.endsWith('es') && /(ss|x|ch|sh)es$/.test(word)) return word.slice(0, -2)
+  if (word.length > 3 && word.endsWith('s') && !word.endsWith('ss')) return word.slice(0, -1)
+  return word
+}
+
+/** The language a file extension names, as a rule would say it. */
+const LANGUAGES = { ts: 'typescript', tsx: 'typescript', mts: 'typescript', cts: 'typescript', js: 'javascript', jsx: 'javascript', mjs: 'javascript', cjs: 'javascript', py: 'python', rs: 'rust', go: 'golang', sql: 'sql', md: 'markdown', css: 'css' }
+
+function pathTerms(path) {
+  const ext = /\.([a-z]+)$/i.exec(path)?.[1]?.toLowerCase()
+  const language = ext && LANGUAGES[ext]
+  return terms(language ? `${path} ${language}` : path)
+}
+
+/**
+ * The diff's words, path words apart: `{ paths: Set, body: Set }`. Only changed lines (+/-) and file names count, never
+ * context lines. Two things a rule names that no word of the diff says are added as words: an added line indented with a
+ * tab (`tab`, `indentation`), and a gendered pronoun in an added line (`pronoun`).
+ */
+export function diffTerms(diff) {
+  const paths = new Set()
+  const body = new Set()
+  for (const line of String(diff || '').split('\n')) {
+    let m
+    if ((m = /^diff --git a\/(.*) b\/(.*)$/.exec(line))) {
+      for (const t of pathTerms(m[1]).concat(pathTerms(m[2]))) paths.add(t)
+    } else if ((m = /^(?:\+\+\+|---) (?:[ab]\/)?(.*)$/.exec(line))) {
+      if (m[1] !== '/dev/null') for (const t of pathTerms(m[1])) paths.add(t)
+    } else if (/^[+-]/.test(line)) {
+      for (const t of terms(line.slice(1))) body.add(t)
+      if (line[0] === '+' && line[1] === '\t') body.add('tab').add(stem('indentation'))
+      if (line[0] === '+' && /\b(he|she|him|her|his|hers)\b/i.test(line.slice(1))) body.add(stem('pronoun'))
+    }
+  }
+  return { paths, body }
+}
+
+/** The changed files of a diff, in order. */
+export function diffFiles(diff) {
+  const files = []
+  for (const line of String(diff || '').split('\n')) {
+    const m = /^diff --git a\/(.*) b\/(.*)$/.exec(line)
+    if (m && !files.includes(m[2])) files.push(m[2])
+  }
+  return files
+}
+
+/**
+ * The subjects a rule can name that make it bear on every review: a rule about reviews, PRs or the code as a whole. Such a
+ * rule is kept even when no word of the diff matches it, and then ranks after every rule that one did.
+ */
+const GENERAL_SUBJECTS = new Set(['review', 'reviews', 'code review', 'code reviews', 'reviewer', 'reviewers', 'pr', 'prs',
+  'pull request', 'pull requests', 'code', 'codebase', 'all code', 'everything', 'general', 'repo', 'repository'])
+
+/** Whether a rule may be quoted at all: current, not replaced, not untrusted, with an id and words. */
+export function quotable(rule) {
+  return Boolean(rule && typeof rule.id === 'string' && rule.id !== '' && typeof rule.text === 'string' && rule.text.trim() !== ''
+    && rule.current !== false && rule.replaced !== true && rule.untrusted !== true)
+}
+
+/**
+ * Every quotable rule with its relevance to `diff`, most relevant first; a rule the diff does not bear on is left out.
+ *
+ * A shared word weighs more the fewer rules have it (so `migration` outweighs `test` when most rules mention tests). A word
+ * of a changed file's path counts double, and so does a word of a fact's predicate that is not itself a rule word (the
+ * `migration` of `migration_rule`): the predicate names what the rule is about. A rule whose score is under `minShare` of
+ * the best rule's is left out, so one coincidental word (`default`, `tenant`) does not bring in an unrelated rule; a rule
+ * about reviews or the code as a whole (GENERAL_SUBJECTS) is always kept, after the matched ones. Ties go to the newer
+ * rule, then the id, so the order is stable. Without a diff every quotable rule is kept, newest first.
+ */
+export function rankRules(rules, diff, { minShare = 0.3 } = {}) {
+  const usable = dedupe(rules.filter(quotable))
+  const ruleTerms = usable.map((rule) => new Set(terms([rule.subject, rule.predicate, rule.text].filter(Boolean).join(' '))))
+  const topicTerms = usable.map((rule) => new Set(terms(rule.predicate || '').filter((t) => !RULE_PREDICATE_WORDS.includes(t))))
+  const df = new Map()
+  for (const set of ruleTerms) for (const t of set) df.set(t, (df.get(t) || 0) + 1)
+  const n = usable.length
+  const haveDiff = typeof diff === 'string' && diff.trim() !== ''
+  const { paths, body } = diffTerms(diff)
+  const ranked = usable.map((rule, i) => {
+    let score = 0
+    const matched = []
+    if (haveDiff) {
+      for (const t of ruleTerms[i]) {
+        const weight = (paths.has(t) ? 2 : 0) + (body.has(t) ? 1 : 0)
+        if (weight === 0) continue
+        score += weight * (topicTerms[i].has(t) ? 2 : 1) * Math.log(1 + n / df.get(t))
+        matched.push(t)
+      }
+    }
+    const general = GENERAL_SUBJECTS.has(String(rule.subject || '').trim().toLowerCase())
+    return { rule, score, matched, general }
+  })
+  const best = Math.max(0, ...ranked.map((entry) => entry.score))
+  const kept = haveDiff
+    ? ranked.filter((entry) => entry.score > 0 && entry.score >= minShare * best).concat(
+      ranked.filter((entry) => entry.general && !(entry.score > 0 && entry.score >= minShare * best)).map((entry) => ({ ...entry, score: 0 })))
+    : ranked
+  return kept
+    .sort((a, b) => b.score - a.score || String(b.rule.date || '').localeCompare(String(a.rule.date || '')) || a.rule.id.localeCompare(b.rule.id))
+    .map(({ general: _general, ...entry }) => entry)
+}
+
+/** One rule per id; a second copy (the same fact found twice) is dropped. */
+function dedupe(rules) {
+  const seen = new Set()
+  return rules.filter((rule) => (seen.has(rule.id) ? false : (seen.add(rule.id), true)))
+}
+
+export const CITE_INSTRUCTION = 'When a finding rests on one of these rules, cite its id in that finding as "(rule <id>)", the id in brackets above the rule. '
+  + 'Cite a rule only for a finding it supports, and never quote a rule other than as written here.'
+
+const BLOCK_INTRO = 'The owner\'s standing rules that bear on this change, from Renor, most relevant first. Each is quoted exactly as it was saved, with the day it was saved and its memory id.'
+
+/** One rule as the block shows it: a header line, then the stored text, untouched (one line as a `>` quote, more in a fence). */
+export function formatRule(rule) {
+  const where = rule.kind === 'fact' && rule.subject ? ` · ${rule.subject} · ${rule.predicate}` : ''
+  const head = `[${rule.id}] saved ${rule.date || 'on an unknown day'}${where}`
+  if (!/[\r\n]/.test(rule.text)) return `${head}\n> ${rule.text}\n`
+  const longest = Math.max(0, ...[...rule.text.matchAll(/`+/g)].map((m) => m[0].length))
+  const fence = '`'.repeat(Math.max(3, longest + 1))
+  return `${head}\n${fence}\n${rule.text}${rule.text.endsWith('\n') ? '' : '\n'}${fence}\n`
+}
+
+/**
+ * Rules in rank order, as many as fit `maxTokens` with the frame around them. A rule that does not fit is skipped whole
+ * (never cut) and a later, shorter one may still fit. Returns `{ text, included, omitted }`; `text` is '' when no rule fits.
+ */
+function fitRules(ranked, { maxTokens, intro, outro }) {
+  const frame = `${intro}\n\n${outro}\n`
+  let used = estimateTokens(frame)
+  const included = []
+  const omitted = []
+  for (const entry of ranked) {
+    const piece = formatRule(entry.rule) + '\n'
+    const cost = estimateTokens(piece)
+    if (used + cost > maxTokens) {
+      omitted.push(entry.rule)
+      continue
+    }
+    used += cost
+    included.push(entry.rule)
+  }
+  if (included.length === 0) return { text: '', included, omitted }
+  return { text: `${intro}\n\n${included.map((rule) => formatRule(rule) + '\n').join('')}${outro}\n`, included, omitted }
+}
+
+export const DEFAULT_MAX_TOKENS = 600
+
+/**
+ * The block to put at the top of a review prompt.
+ *
+ * buildReviewRulesBlock({ rules: Rule[], diff: string, maxTokens?: number = 600 })
+ *   → { block: string, included: Rule[], omitted: Rule[], ranked: Array<{ rule, score, matched }> }
+ *
+ * `block` is '' when no current rule bears on the diff. Superseded, replaced and untrusted rules are never in it.
+ */
+export function buildReviewRulesBlock({ rules, diff, maxTokens = DEFAULT_MAX_TOKENS }) {
+  const ranked = rankRules(rules, diff)
+  const fitted = fitRules(ranked, { maxTokens, intro: BLOCK_INTRO, outro: CITE_INSTRUCTION })
+  return { block: fitted.text, included: fitted.included, omitted: fitted.omitted, ranked }
+}
+
+// --- --export: one marked section of a guidelines file -----------------------------------------------------------------
+
+export const SECTION_START = '<!-- renor:review-rules:start -->'
+export const SECTION_END = '<!-- renor:review-rules:end -->'
+const SECTION_NOTE = '<!-- Written by `npx renor review-rules --export`. Everything between these markers is replaced on the next export; edit the rules in Renor. -->'
+const SECTION_HEADING = '## The owner\'s standing rules (from Renor)'
+const SECTION_INTRO = 'Each rule is quoted exactly as the owner saved it in Renor, with the day it was saved and its memory id.'
+
+export const DEFAULT_EXPORT_MAX_TOKENS = 1500
+
+/** The section's text, markers included, with `\n` line ends. Same rules in, same bytes out: nothing in it depends on the clock. */
+export function renderRulesSection({ rules, diff, maxTokens = DEFAULT_EXPORT_MAX_TOKENS }) {
+  const ranked = rankRules(rules, diff)
+  const fitted = fitRules(ranked, { maxTokens, intro: `${SECTION_HEADING}\n\n${SECTION_INTRO}`, outro: CITE_INSTRUCTION })
+  const body = fitted.text || `${SECTION_HEADING}\n\nRenor holds no standing rule to list yet.\n`
+  return { section: `${SECTION_START}\n${SECTION_NOTE}\n\n${body}${SECTION_END}\n`, included: fitted.included, omitted: fitted.omitted }
+}
+
+/**
+ * `fileText` with its marked section replaced by `section`, or with `section` appended when it has none. Nothing outside
+ * the markers changes. Throws when the markers are not one well-formed pair, rather than guess which text is ours. The
+ * file's own line ending (CRLF or LF) is kept.
+ */
+export function updateMarkedSection(fileText, section) {
+  const crlf = /\r\n/.test(fileText)
+  const ours = crlf ? section.replace(/\n/g, '\r\n') : section
+  const eol = crlf ? '\r\n' : '\n'
+  const lineStarts = (marker) => {
+    const at = []
+    const re = new RegExp(`(^|\\n)${marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[ \\t]*(\\r?\\n|$)`, 'g')
+    let m
+    while ((m = re.exec(fileText))) {
+      at.push({ index: m.index + m[1].length, end: m.index + m[0].length })
+      re.lastIndex = m.index + m[0].length - m[2].length
+    }
+    return at
+  }
+  const starts = lineStarts(SECTION_START)
+  const ends = lineStarts(SECTION_END)
+  if (starts.length === 0 && ends.length === 0) {
+    if (fileText === '') return ours
+    const sep = fileText.endsWith(eol + eol) ? '' : fileText.endsWith(eol) ? eol : eol + eol
+    return fileText + sep + ours
+  }
+  if (starts.length !== 1 || ends.length !== 1 || ends[0].index < starts[0].index) {
+    throw new Error(`the file has ${starts.length} start and ${ends.length} end marker(s) for the Renor rules section; expected one pair, start first. Fix it by hand, then export again.`)
+  }
+  // The section is replaced through the end marker's line end; a file whose end marker is its last line, with no line
+  // end, keeps having none after it.
+  const tail = fileText.slice(ends[0].end)
+  const endHadEol = /\r?\n$/.test(fileText.slice(ends[0].index, ends[0].end))
+  const replacement = endHadEol ? ours : ours.replace(/\r?\n$/, '')
+  return fileText.slice(0, starts[0].index) + replacement + tail
+}
+
+// --- --propose: recurring findings of past reviews ---------------------------------------------------------------------
+
+/** The findings of one review: its list items and its bold-led lines, with their text as written. */
+export function findingsOf(text) {
+  const out = []
+  for (const raw of String(text).split(/\r?\n/)) {
+    const m = /^\s*(?:[-*+]|\d+[.)])\s+(.*\S)\s*$/.exec(raw) || /^\s*(\*\*.*\S)\s*$/.exec(raw)
+    if (!m) continue
+    const finding = m[1]
+    if (terms(cleanFinding(finding)).length < 3) continue
+    out.push(finding)
+  }
+  return out
+}
+
+/** A finding without its severity tag, emphasis, `file:line` references or code spans: the words a rule would keep. */
+export function cleanFinding(finding) {
+  return finding
+    .replace(/\[(?:P\d|nit|blocker|major|minor)\]/gi, '')
+    .replace(/`[^`]*`/g, '')
+    .replace(/\b[\w./-]+\.[a-z]{1,5}(?::\d+(?:-\d+)?)?\b/gi, '')
+    .replace(/[*_]+/g, '')
+    .replace(/\s+/g, ' ')
+    .replace(/^[\s:.\-—]+|[\s:—-]+$/g, '')
+    .trim()
+}
+
+/**
+ * Recurring findings across past reviews, as proposed rules for the owner to approve. Reads only what it is given and
+ * saves nothing anywhere.
+ *
+ * proposeRules(reviews: Array<{ name, text }>, { minReviews = 2, similarity = 0.5 })
+ *   → Array<{ rule, reviews: string[], findings: Array<{ review, text }>, shared: string[] }>, most reviews first
+ *
+ * Two findings are the same finding when they share at least `minShared` words and at least `similarity` of the shorter
+ * one's words (findings that chain this way are one group); a group counts when its findings come from at least
+ * `minReviews` different reviews. Words are matched as written, so two findings that say one thing in different words stay
+ * apart: this proposes what recurs in so many words, and the owner judges the rest.
+ */
+export function proposeRules(reviews, { minReviews = 2, similarity = 0.33, minShared = 2 } = {}) {
+  const items = []
+  for (const review of reviews) {
+    for (const text of findingsOf(review.text)) items.push({ review: review.name, text, terms: new Set(terms(cleanFinding(text))) })
+  }
+  const parent = items.map((_, i) => i)
+  const find = (i) => (parent[i] === i ? i : (parent[i] = find(parent[i])))
+  const sim = (a, b) => {
+    let shared = 0
+    for (const t of a) if (b.has(t)) shared++
+    return shared >= minShared ? shared / Math.min(a.size, b.size) : 0
+  }
+  for (let i = 0; i < items.length; i++) {
+    for (let j = i + 1; j < items.length; j++) {
+      if (sim(items[i].terms, items[j].terms) >= similarity) parent[find(i)] = find(j)
+    }
+  }
+  const groups = new Map()
+  items.forEach((item, i) => {
+    const root = find(i)
+    if (!groups.has(root)) groups.set(root, [])
+    groups.get(root).push(item)
+  })
+  const proposals = []
+  for (const group of groups.values()) {
+    const names = [...new Set(group.map((item) => item.review))].sort()
+    if (names.length < minReviews) continue
+    // The finding closest to all the others speaks for the group; ties go to the shorter one.
+    const central = group
+      .map((item) => ({ item, total: group.reduce((sum, other) => sum + (other === item ? 0 : sim(item.terms, other.terms)), 0) }))
+      .sort((a, b) => b.total - a.total || a.item.text.length - b.item.text.length)[0].item
+    const counts = new Map()
+    for (const item of group) for (const t of item.terms) counts.set(t, (counts.get(t) || 0) + 1)
+    const surface = surfaceWords(group.map((item) => cleanFinding(item.text)).join(' '))
+    const shared = [...counts].filter(([, c]) => c * 2 >= group.length).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([t]) => surface.get(t) || t)
+    proposals.push({ rule: cleanFinding(central.text), reviews: names, findings: group.map(({ review, text }) => ({ review, text })), shared })
+  }
+  return proposals.sort((a, b) => b.reviews.length - a.reviews.length || b.findings.length - a.findings.length || a.rule.localeCompare(b.rule))
+}
+
+/** Each stem of a text, mapped to the first word it was cut from, so a proposal shows `enabled`, not `enabl`. */
+function surfaceWords(text) {
+  const map = new Map()
+  for (const word of text.toLowerCase().split(/[^\p{L}\p{N}]+/u)) {
+    const [t] = terms(word)
+    if (t && !map.has(t)) map.set(t, word)
+  }
+  return map
+}
+
+/** Proposals as the owner reads them in the terminal. */
+export function formatProposals(proposals, totalReviews) {
+  if (proposals.length === 0) return `No finding recurs across ${totalReviews} review(s); nothing to propose.\n`
+  const lines = [`${proposals.length} finding(s) recur across ${totalReviews} review(s). Nothing was saved. To make one a standing rule, tell your agent "Remember this review rule: …" in the words you approve.`, '']
+  proposals.forEach((p, i) => {
+    lines.push(`${i + 1}. Proposed rule, in one review's words: ${p.rule}`)
+    lines.push(`   Seen in ${p.reviews.length} reviews (${p.reviews.join(', ')}), ${p.findings.length} finding(s). Shared words: ${p.shared.slice(0, 8).join(', ')}`)
+    for (const f of p.findings) lines.push(`   - ${f.review}: ${f.text}`)
+    lines.push('')
+  })
+  return lines.join('\n')
+}

package/lib/setup.mjs

@@ -4,6 +4,8 @@
  */
 import { CLIENTS } from './clients.mjs'
 import { FIRST_MEMORY_RECALL, FIRST_MEMORY_SAVE, GATEWAY_URL, SKILL_INSTALL_ARGS } from './constants.mjs'
+import { checkCode, cleanupClient, probeGateway, verifyClient } from './verify.mjs'
+import { askAboutSharing, outcomeLine } from './sharing.mjs'
 import { confirm, interactive, which } from './system.mjs'
 
 /**
@@ -12,6 +14,7 @@ import { confirm, interactive, which } from './system.mjs'
  * @param {boolean} options.dryRun    say what would happen, change nothing
  * @param {boolean} options.login     run the sign-ins the apps offer from the terminal
  * @param {boolean} options.skill     install the Renor skill
+ * @param {boolean} options.verify    also have Claude Code save and recall one test memory (the gateway is always probed)
  * @param {boolean} options.force     replace a renor entry that points somewhere else
  * @param {string[]|null} options.only  limit to these app ids
  */
@@ -35,7 +38,7 @@ export async function setup(options, io = defaultIo()) {
   }
 
   if (found.length === 0) {
-    say('No supported app was found: Claude Code, Codex, Cursor, OpenCode, Pi or VS Code.')
+    say('No supported app was found: Claude Code, Codex, Cursor, OpenCode, Gemini CLI, Pi or VS Code.')
     say('For ChatGPT or Claude in the browser, open https://app.renor.cloud and follow the steps there.')
     return { code: 0, results: [] }
   }
@@ -66,7 +69,14 @@ export async function setup(options, io = defaultIo()) {
 
   const results = []
   for (const { client, detection } of found) {
-    results.push(await setUpOne(client, detection, { ...options, canSignIn }, { env, say }))
+    try {
+      results.push(await setUpOne(client, detection, { ...options, canSignIn }, { env, say }))
+    } catch (error) {
+      // One app's config that cannot be written (a permission, a file where a folder should be) is that app's failure,
+      // not the end of the run: the other apps are still set up and the report still says what is left.
+      const detail = error instanceof Error ? error.message : String(error)
+      results.push({ id: client.id, label: client.label, state: 'failed', next: `${detail} Add Renor by hand: ${client.byHand}` })
+    }
   }
 
   let skill = null
@@ -80,14 +90,80 @@ export async function setup(options, io = defaultIo()) {
     }
   }
 
+  await verifyAll(found, results, { env, say, paint, io, options })
+
   report(results, skill, { say, paint })
-  const failures = results.filter((result) => result.state === 'failed').length + (skill && !skill.ok ? 1 : 0)
+  const sharing = await askAboutSharing(io, options)
+  const sharingLine = outcomeLine(sharing, env)
+  if (sharingLine) say(sharingLine)
+  const failures = results.filter((result) => result.state === 'failed' || result.verified === false).length + (skill && !skill.ok ? 1 : 0)
   return { code: failures > 0 ? 1 : 0, results, skill }
 }
 
+/** The proof: the gateway answers; with --verify, Claude Code (the app that can be limited to Renor's tools) saves and recalls one test memory. */
+async function verifyAll(found, results, { env, say, paint, io, options }) {
+  say()
+  const gateway = await probeGateway(io.fetch)
+  if (gateway.ok) say(`${paint.ok('✓')} Renor’s gateway answers.`)
+  else {
+    say(`${paint.warn('!')} ${gateway.detail}`)
+    say(`  Fix: ${gateway.fix}`)
+  }
+  if (!options.verify) return gateway.ok
+
+  const hasCheck = (result) => Boolean(found.find(({ client }) => client.id === result.id).client.check)
+  for (const result of results) {
+    if ((result.state === 'already' || result.state === 'added') && !hasCheck(result)) result.unchecked = true
+  }
+  const checkable = results.filter((result) => (result.state === 'already' || (result.state === 'added' && result.signedIn)) && hasCheck(result))
+  if (checkable.length === 0) {
+    say(paint.dim('Nothing to check from here yet: Claude Code is the app setup can test, and it is not signed in to Renor. Sign in as listed below, then run npx renor setup --verify.'))
+    return gateway.ok
+  }
+  if (!gateway.ok) {
+    for (const result of checkable) result.verified = false
+    return false
+  }
+  say(paint.dim('Checking Claude Code: it saves one test memory to Renor and recalls it. This can take a minute and uses a little of its model quota.'))
+  for (const result of checkable) {
+    const { client } = found.find((item) => item.client.id === result.id)
+    const code = checkCode()
+    result.checkCode = code
+    const check = verifyClient(client, { env, code, run: io.run })
+    result.verified = check.ok
+    let retiredId = check.retiredId
+    result.noteRetired = check.retired
+    if (!check.retired) {
+      const cleanup = cleanupClient(client, { env, code, savedId: check.savedId, run: io.run })
+      result.noteRetired = cleanup.retired
+      retiredId = cleanup.retiredId ?? retiredId
+    }
+    if (check.wrongRetire) {
+      check.ok = false
+      check.detail = `${client.label} retired a different memory (id ${check.wrongRetire.retired}) than the one it saved (id ${check.wrongRetire.saved}).`
+      check.fix = `put it back with restore_memory and the id ${check.wrongRetire.retired} (ask any connected AI, or use the dashboard's memory list). Setup then retired the test note itself.`
+    } else if (result.noteRetired && check.recalledOk) {
+      // The recall worked and the cleanup pass confirmed the retire the app had not.
+      check.ok = true
+    } else if (!result.noteRetired) {
+      check.ok = false
+      check.detail = `${check.detail ?? 'The check finished'}; setup could not retire the test note Renor setup check ${code}.`
+      check.fix = `Run npx renor setup --verify again; if it persists, write to hello@renor.cloud with the code ${code}.`
+    }
+    result.noteId = retiredId
+    result.verified = check.ok
+    if (!check.ok) {
+      result.verifyDetail = check.detail
+      result.verifyFix = check.fix
+    }
+  }
+  if (checkable.every((result) => result.noteRetired)) say(`${paint.ok('✓')} The test note${checkable.length === 1 && checkable[0].noteId ? ` (id ${checkable[0].noteId})` : ''} was retired again: it no longer comes back in search.`)
+  return gateway.ok
+}
+
 function planFor(client, detection, now, options) {
   if (detection.blocked) return detection.blocked
-  if (now.configured && now.url === GATEWAY_URL) return 'already has Renor; nothing to do.'
+  if (now.configured && now.url === GATEWAY_URL && !options.force) return 'already has Renor; nothing to do.'
   if (now.configured && !options.force) return `has a renor server at ${now.url ?? 'another address'}; it would be left alone (use --force to replace it).`
   if (now.configured) return 'its renor server would be replaced with Renor’s address.'
   return client.login ? 'Renor would be added, then signed in.' : 'Renor would be added.'
@@ -136,6 +212,9 @@ async function setUpOne(client, detection, options, { env, say }) {
 function report(results, skill, { say, paint }) {
   say()
   say(paint.bold('Done.'))
+  const wired = results.filter((result) => result.state === 'already' || result.state === 'added').length
+  const verified = results.filter((result) => result.verified === true).length
+  say(`${wired} of ${results.length} wired${results.some((result) => result.verified !== undefined) ? `, ${verified} verified` : ''}.`)
   const width = Math.max(...results.map((result) => result.label.length))
   for (const result of results) {
     const name = result.label.padEnd(width)
@@ -144,6 +223,12 @@ function report(results, skill, { say, paint }) {
     else if (result.state === 'added') say(`  ${paint.todo('•')} ${name}  added. Left for you: ${result.next}`)
     else say(`  ${paint.warn('!')} ${name}  ${result.next}`)
     if (result.detail) say(`    ${paint.dim(result.detail)}`)
+    if (result.verified === true) say(`    ${paint.ok('✓')} verified: saved a test memory and recalled it`)
+    if (result.unchecked) say(`    ${paint.dim(`not checked by setup: tell it "${FIRST_MEMORY_SAVE}", then ask "${FIRST_MEMORY_RECALL}" in a new chat.`)}`)
+    if (result.verified === false) {
+      say(`    ${paint.warn('!')} not verified: ${result.verifyDetail ?? 'Renor’s gateway could not be reached.'}`)
+      if (result.verifyFix) say(`      Fix: ${result.verifyFix}`)
+    }
   }
   if (skill) {
     say(skill.ok ? `  ${paint.ok('✓')} ${'Skill'.padEnd(width)}  installed` : `  ${paint.warn('!')} ${'Skill'.padEnd(width)}  not installed: ${skill.detail}`)

package/lib/sharing-gate.mjs

@@ -0,0 +1,42 @@
+/**
+ * Whether `renor setup` may ask the sharing question (#778): only while the operator's gate is open. The switch lives on the
+ * server (app_settings 'learning_sharing', supabase/migrations/20261024120000_learning_sharing_gate.sql) and the gateway reports
+ * it, as one public bit, at GET /sharing/status ({"open": true|false}). Anything but an answer of exactly {"open": true} (no
+ * network, a timeout, an older gateway without the route, a malformed body) means closed: the question is not asked.
+ *
+ * Opening the switch only lets setup ASK. Whether a row is ever stored is decided again by the server from the authenticated
+ * identity and that user's recorded consent; client-supplied workspace ids never decide it.
+ */
+import { GATEWAY_URL } from './constants.mjs'
+
+export const SHARING_STATUS_URL = new URL('/sharing/status', GATEWAY_URL).href
+
+/** True only when the gateway answers {"open": true} within `timeoutMs`. */
+export async function sharingPromptOpen({ fetchImpl = globalThis.fetch, url = SHARING_STATUS_URL, timeoutMs = 3000 } = {}) {
+  if (typeof fetchImpl !== 'function') return false
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    const response = await fetchImpl(url, {
+      headers: { accept: 'application/json' },
+      redirect: 'error',
+      signal: controller.signal,
+    })
+    if (!response.ok) return false
+    const body = await response.json()
+    return body !== null && typeof body === 'object' && body.open === true
+  } catch {
+    return false
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+/**
+ * Runs `ask` (the question #778 asks) only while the gate is open; otherwise returns 'closed' without asking or writing anything.
+ * #778's askAboutSharing calls it as its first step after its own not-interactive / environment / answered checks.
+ */
+export async function whenSharingOpen(ask, options = {}) {
+  if (!(await sharingPromptOpen(options))) return 'closed'
+  return ask()
+}