@opennous/cli 0.15.0 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @opennous/cli changelog
 
+## 0.17.0
+
+### Added: `runner`, reading on your own plan all the time
+
+`backfill` reads your history once. `runner` keeps going: it reads your new calls and email on your
+own Claude or ChatGPT plan as they come in, with the same no-tools sandbox. `runner install` starts it
+now and every time you log in (launchd on macOS, systemd on Linux); `runner status` and
+`runner uninstall` check on it and remove it. When your plan hits its limit it waits and carries on
+by itself. The app's Settings → Your plan shows it as connected (GET-1289).
+
+## 0.16.0
+
+### Added: your Intelligence report after `backfill`
+
+When the read is done, `backfill` writes your Intelligence report: private to you, built from what it
+read. Its executive summary, recommended next steps and objection responses are written by your own model, from the report's data only,
+with no tools. The command prints the link. If that step fails, the report is still there (GET-1199).
+
 ## 0.15.0
 
 ### Added: Slack in `backfill`

package/README.md

@@ -1,16 +1,27 @@
 # @opennous/cli
 
-Nous CLI — set Nous up, connect it to your coding agent, and read the Context API from your terminal.
+Ownable CLI — set Ownable up, connect it to your coding agent, and read the Context API from your terminal.
 
 ## Get started
 
-One command. It signs you in (creating your account if you don't have one), registers the Nous MCP server with the agent on your machine, and hands off. The same command on macOS, Linux, and Windows (needs [Node 18+](https://nodejs.org)):
+One command. It signs you in (creating your account if you don't have one), registers the Ownable MCP server with the agent on your machine, and hands off. The same command on macOS, Linux, and Windows (needs [Node 18+](https://nodejs.org)):
 
 ```bash
 npx @opennous/cli@latest init
 ```
 
-Then tell your agent *"set up my Nous workspace"* — it reads your project, finds your ICP (or drafts one), and syncs it. On self-host, add `--url https://api.yourdomain.com`.
+Then tell your agent *"set up my Ownable workspace"* — it reads your project, finds your ICP (or drafts one), and syncs it. On self-host, add `--url https://api.yourdomain.com`.
+
+## Read on your own plan
+
+Reading your calls and email runs on your own Claude Code or Codex plan, not on credits:
+
+```bash
+npx @opennous/cli@latest backfill          # your history, once
+npx @opennous/cli@latest runner install    # what's new, from now on; starts at login
+```
+
+`runner status` says whether it's running, `runner uninstall` stops it. Settings → Your plan in the app shows each runner and what's waiting to be read.
 
 ## Event tracking
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennous/cli",
-  "version": "0.15.0",
-  "description": "Nous CLI — set up Nous, connect it to your coding agent, and read the Context API from your terminal",
+  "version": "0.17.0",
+  "description": "Ownable CLI — set up Ownable, connect it to your coding agent, and read the Context API from your terminal",
   "type": "module",
   "bin": {
     "nous": "src/index.js"

package/src/backfill.js

@@ -105,12 +105,41 @@ export function estimateLine(days, counts) {
   return `Last ${days} days: about ${counts?.email_thread ?? 0} email threads, ${counts?.meeting ?? 0} meetings, ${counts?.call ?? 0} calls${slack}.`;
 }
 
+/**
+ * "5 to review: https://…/review (12 not on file)", or null when there is nothing to decide. Pure.
+ * To review is Probably mentions plus open groups (GET-1152); a mention nothing on file could be is
+ * not on file and never counted. An older server sends only `mentions`.
+ */
+export function reviewLine(review) {
+  const n = Number(review?.to_review ?? review?.mentions ?? 0);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const quiet = Number(review?.not_on_file ?? 0);
+  return `${n} to review${review?.url ? `: ${review.url}` : ""}${quiet > 0 ? ` (${quiet} not on file)` : ""}`;
+}
+
+/**
+ * Who each person is, before anything is read (GET-1159): the people worth a look, as a short table,
+ * with where to confirm them. Null when there is nothing to show. Pure.
+ */
+export function proposalsLines(rel) {
+  if (!rel || !(rel.judged > 0)) return null;
+  const pct = (c) => `${Math.round(Number(c ?? 0) * 100)}%`;
+  const lines = [`Who's who: ${rel.judged} people judged, ${rel.to_confirm ?? 0} worth a look.`];
+  const top = (rel.top ?? []).slice(0, 15);
+  const w = Math.min(28, Math.max(4, ...top.map((p) => String(p.name ?? "Unknown").length)));
+  for (const p of top) lines.push(`  ${String(p.name ?? "Unknown").slice(0, w).padEnd(w)}  ${String(p.group ?? "").padEnd(14)} ${pct(p.confidence).padStart(4)}  ${p.reason ?? ""}`.trimEnd());
+  if (rel.url) lines.push(`Confirm or fix them: ${rel.url}`);
+  lines.push(rel.waiting ? "Waiting for you to confirm before reading (or Ctrl-C and run with --yes)." : rel.mode === "yes" ? "Accepted as proposed." : "Reading now; fixing someone later re-reads their calls.");
+  return lines;
+}
+
 /** Nothing to read in this window. Pure. */
 export const emptyEstimate = (counts) => !Object.values(counts ?? {}).some((n) => n > 0);
 
 /** One line on how far the job is, or null when there is nothing to say yet. Pure. */
 export function progressLine(reading, answered, rerun = RERUN) {
   if (reading?.finished) return "Wrapping up: last summaries for your accounts.";
+  if (reading?.kind === "relationships") return `Working out who each person is, before reading. ${`Stop any time with Ctrl-C; run \`${rerun}\` again to carry on.`}`;
   const stop = `Stop any time with Ctrl-C; run \`${rerun}\` again to carry on.`;
   const what = { meetings: "meetings", slack: "Slack conversations" }[reading?.kind] ?? "email threads";
   if (reading?.total) return `Read ${reading.done} of ${reading.total} ${what}. ${stop}`;
@@ -124,7 +153,7 @@ export function progressLine(reading, answered, rerun = RERUN) {
  * is saved, and unanswered calls come back to the next run.
  */
 export async function runBackfill({ api, agent, jobId, run, sleep, log, now = Date.now, workers = WORKERS, limitWaitMs = LIMIT_WAIT_MS, pollMs = POLL_MS, progressMs = PROGRESS_MS, rerun = RERUN }) {
-  let waitUntil = 0, answered = 0, lastLine = null, lastAt = -Infinity;
+  let waitUntil = 0, answered = 0, lastLine = null, lastAt = -Infinity, shownProposals = false;
   const say = (line) => {
     if (!line || (line === lastLine && now() - lastAt < progressMs) || now() - lastAt < Math.min(progressMs, 1000)) return;
     lastLine = line; lastAt = now(); log(line);
@@ -149,10 +178,15 @@ export async function runBackfill({ api, agent, jobId, run, sleep, log, now = Da
   };
   for (;;) {
     const page = await api.calls(jobId, workers);
-    if (page.status === "done") return { status: "done", answered, read: page.reading?.read ?? 0, failed: page.reading?.failed ?? 0 };
+    if (page.status === "done") return { status: "done", answered, read: page.reading?.read ?? 0, failed: page.reading?.failed ?? 0, ...(page.memory_review ? { memoryReview: page.memory_review } : {}) };
     if (page.status === "failed") throw new Error(page.error || "The backfill failed on our side.");
     // The server gave up waiting for us (a long sleep, say). We're back, so pick it up.
     if (page.status === "paused_own_model") { await api.resume?.(); await sleep(pollMs); continue; }
+    // Phase 1's proposals (GET-1159), once, as soon as they are in.
+    if (!shownProposals && page.relationships?.judged > 0) {
+      shownProposals = true;
+      for (const l of proposalsLines(page.relationships) ?? []) log(l);
+    }
     say(progressLine(page.reading, answered, rerun));
     if (!page.calls.length) { await sleep(pollMs); continue; }
     await Promise.all(page.calls.map((c) => answerOne(c, page.models)));
@@ -164,3 +198,21 @@ export function liveRun() {
   const cwd = mkdtempSync(join(tmpdir(), "nous-backfill-"));
   return (command) => runCommand(command, cwd);
 }
+
+/**
+ * The Intelligence report (GET-1199), once the read is done. The server builds it from what was
+ * filed; its Summary and Recommended actions are then written by your own model, from the report's
+ * data only, with no tools. If that fails the report keeps the ones code wrote. Returns its link,
+ * or null. Injected like runBackfill: `api` ({ report, writing }), `run`.
+ */
+export async function writeReport({ api, agent, jobId, run }) {
+  const r = await api.report(jobId);
+  const models = r?.models?.[agent];
+  if (r?.writing && models) {
+    try {
+      const { text } = parseAnswer(agent, await run(commandFor(agent, models, r.writing)));
+      await api.writing(jobId, { answer: text, model: models.model });
+    } catch { /* the report stands as code wrote it */ }
+  }
+  return r?.url ?? null;
+}

package/src/certHint.js

@@ -1,4 +1,4 @@
-// A self-hosted Nous on a laptop serves https://api.localhost with Caddy's own local CA, which
+// A self-hosted Ownable on a laptop serves https://api.localhost with Caddy's own local CA, which
 // Node does not trust. fetch then rejects with a bare "fetch failed" whose cause carries one of
 // these codes. Name the fix in one line instead of printing a stack trace (GET-1011).
 const UNTRUSTED_CERT_CODES = new Set([

package/src/hooks/icp-sync-reminder.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-// Nous ICP auto-sync reminder (installed by `npx @opennous/cli init`).
+// Ownable ICP auto-sync reminder (installed by `npx @opennous/cli init`).
 //
-// A Claude Code PostToolUse hook. After the agent edits a Nous context file, it
+// A Claude Code PostToolUse hook. After the agent edits an Ownable context file, it
 // reminds the agent that the file is INERT until synced: the app, the ICP tab, and
-// the ICP scoring model read the Nous GRAPH, not the repo file, so an edit does
+// the ICP scoring model read the Ownable GRAPH, not the repo file, so an edit does
 // nothing until mcp__nous__sync_icp runs. Standalone Node (no bash/jq) so it behaves
 // identically on Windows, macOS, and Linux.
 
@@ -25,8 +25,8 @@ process.stdin.on("end", () => {
     const base = norm.split("/").pop().toLowerCase();
 
     const ctx = base === "icp.md"
-      ? `You just edited ${rel}, your Nous ICP file. It is INERT until synced: the app, the ICP tab, and the ICP scoring model read the Nous graph, not this file. Call the mcp__nous__sync_icp tool THIS TURN with section "ICP" and source_path "${rel}", passing the file body as the section content, so the graph and the scoring model rebuild from your edit. Do not end the turn with the ICP file edited but unsynced.`
-      : `You edited a Nous context file (${rel}). It stays inert until synced into the Nous graph. If it is an ICP, positioning, pricing, competitors, or market file, call mcp__nous__sync_icp this turn with the matching section and its source_path so the graph updates.`;
+      ? `You just edited ${rel}, your Ownable ICP file. It is INERT until synced: the app, the ICP tab, and the ICP scoring model read the Ownable graph, not this file. Call the mcp__nous__sync_icp tool THIS TURN with section "ICP" and source_path "${rel}", passing the file body as the section content, so the graph and the scoring model rebuild from your edit. Do not end the turn with the ICP file edited but unsynced.`
+      : `You edited an Ownable context file (${rel}). It stays inert until synced into the Ownable graph. If it is an ICP, positioning, pricing, competitors, or market file, call mcp__nous__sync_icp this turn with the matching section and its source_path so the graph updates.`;
 
     process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: ctx } }));
   } catch { /* never block a tool call */ }

package/src/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// OpenNous CLI — the setup + auth utility. NOT a data surface.
+// Ownable CLI — the setup + auth utility. NOT a data surface.
 //
 // It signs you in (browser device flow → key in ~/.nous/config.json) and installs the
 // opennous plugin into your agent (`init`). All data work happens in the agent through
@@ -120,7 +120,8 @@ function apiClient(key) {
     process.exit(1);
   }
 
-  async function request(method, path, { body, query } = {}) {
+  // soft: a failure throws instead of ending the process, for a step that may fail on its own.
+  async function request(method, path, { body, query, soft = false } = {}) {
     const url = new URL(path, apiUrl);
     if (query) {
       for (const [k, v] of Object.entries(query)) {
@@ -135,11 +136,13 @@ function apiClient(key) {
         body: body ? JSON.stringify(body) : undefined,
       });
     } catch (e) {
+      if (soft) throw e;
       console.error(certHint(e) || `Couldn't reach ${apiUrl}: ${e.message}`);
       process.exit(1);
     }
     if (!res.ok) {
       const err = await res.json().catch(() => ({ message: res.statusText }));
+      if (soft) throw new Error(err.message || err.error || `HTTP ${res.status}`);
       console.error(`Error: ${err.message || err.error}`);
       process.exit(1);
     }
@@ -150,6 +153,7 @@ function apiClient(key) {
   return {
     get: (path, query) => request("GET", path, { query }),
     post: (path, body) => request("POST", path, { body }),
+    softPost: (path, body) => request("POST", path, { body, soft: true }),
   };
 }
 
@@ -163,7 +167,7 @@ program
   .addCommand(
     new Command("login")
       .description("Save your API key")
-      .requiredOption("--key <key>", "Your Nous API key")
+      .requiredOption("--key <key>", "Your Ownable API key")
       .option("--url <url>", "API base URL (default: https://api.opennous.cloud)")
       .action(({ key, url }) => {
         const cfg = readConfig();
@@ -205,7 +209,7 @@ program
 // ---------------------------------------------------------------------------
 // You're already signed in (the saved key identifies you), so there's no device-code
 // dance — we start a Composio consent, open it in your browser, and poll until the
-// account goes ACTIVE. Composio holds the OAuth token; Nous never sees it.
+// account goes ACTIVE. Composio holds the OAuth token; Ownable never sees it.
 const CONNECT_ALIASES = {
   gmail: "gmail_oauth",
   gmail_oauth: "gmail_oauth",
@@ -329,11 +333,11 @@ program
   });
 
 // ---------------------------------------------------------------------------
-// Connect OpenNous to whatever agent is on this machine — host-aware.
+// Connect Ownable to whatever agent is on this machine — host-aware.
 //
 // The MCP server (7 primitives) is the universal capability: any MCP host runs `npx @opennous/mcp`.
 // But the SKILLS + routing are the product surface, and those are delivered per host:
-//   • Claude Code  → the OpenNous PLUGIN (skills + routing hooks + the trimmed MCP, one install).
+//   • Claude Code  → the Ownable PLUGIN (skills + routing hooks + the trimmed MCP, one install).
 //   • Any other host (Cursor, Codex, Claude Desktop, …) → the trimmed MCP via a `.mcp.json`;
 //     each host's skills pack ships as we light it up.
 // So `init` installs the plugin on Claude Code, and writes the MCP config everywhere else — one
@@ -388,7 +392,7 @@ function writeJsonMcp(path, apiUrl) {
 const PLUGIN_MARKETPLACE = "NousC/revenue-plugin";
 const PLUGIN_ID = "opennous@opennous";
 
-// Claude Code → install the OpenNous PLUGIN (skills + routing hooks + the trimmed MCP, in one).
+// Claude Code → install the Ownable PLUGIN (skills + routing hooks + the trimmed MCP, in one).
 // We try the plugin CLI; if this Claude build has no `plugin` subcommand it returns null and the
 // caller prints the two slash-commands instead. We deliberately do NOT fall back to a bare
 // `claude mcp add` — a standalone MCP server would duplicate the plugin's and drop the skills.
@@ -404,11 +408,11 @@ function installClaudePlugin() {
 function registerMcpServer(apiUrl) {
   const path = join(process.cwd(), ".mcp.json");
   writeJsonMcp(path, apiUrl);
-  return `Wrote ${path} — your agent will pick up OpenNous (7 primitives) from it.`;
+  return `Wrote ${path} — your agent will pick up Ownable (7 primitives) from it.`;
 }
 
 // Install the ICP auto-sync hook into the project's Claude Code config. Once in place,
-// editing a Nous context file (context/**/icp.md, etc.) reminds the agent to call
+// editing an Ownable context file (context/**/icp.md, etc.) reminds the agent to call
 // sync_icp that turn — because an edited ICP file is INERT until synced into the graph.
 // Copies our packaged hook script into .claude/hooks/ and merges the PostToolUse entry
 // into .claude/settings.json WITHOUT clobbering any existing hooks or settings.
@@ -447,7 +451,7 @@ function installIcpSyncHook() {
 // This is the command the install script and the marketing site point to.
 program
   .command("init")
-  .description("Get started — sign in and connect Nous to your agent")
+  .description("Get started — sign in and connect Ownable to your agent")
   .option("--url <url>", "API base URL (default: https://api.opennous.cloud)")
   .option("--no-register", "Skip registering the MCP server (just sign in)")
   .action(async ({ url, register }) => {
@@ -460,41 +464,41 @@ program
         let installed = false;
         try { installed = installClaudePlugin(); } catch { /* fall through to instructions */ }
         if (installed) {
-          console.log("\n✓ Installed the OpenNous plugin into Claude Code — skills, routing, and the 8 primitives.");
-          console.log("  Open Claude Code and OpenNous starts onboarding automatically.");
+          console.log("\n✓ Installed the Ownable plugin into Claude Code — skills, routing, and the 8 primitives.");
+          console.log("  Open Claude Code and Ownable starts onboarding automatically.");
           console.log(dim("  (Already have it open? Start a new session so the skills load.)"));
         } else {
-          console.log("\nDetected Claude Code. Install the OpenNous plugin (skills + hooks + tools):");
+          console.log("\nDetected Claude Code. Install the Ownable plugin (skills + hooks + tools):");
           console.log("  /plugin marketplace add NousC/revenue-plugin");
           console.log("  /plugin install opennous@opennous");
-          console.log(dim("  Then open Claude Code — OpenNous starts onboarding on its own."));
+          console.log(dim("  Then open Claude Code — Ownable starts onboarding on its own."));
         }
       } else {
         try {
           console.log(`\n${registerMcpServer(apiUrl)}`);
         } catch {
-          console.log("\nCouldn't write .mcp.json automatically. Add OpenNous to your host's MCP config:");
+          console.log("\nCouldn't write .mcp.json automatically. Add Ownable to your host's MCP config:");
           console.log(`  command: ${MCP_CMD}  args: ${MCP_ARGS.join(" ")}  env: NOUS_SURFACE=plugin`);
         }
       }
 
       // Auto-sync the ICP: a Claude Code hook so editing your ICP file reminds the
-      // agent to sync it into Nous (the file is inert until synced). Best-effort —
+      // agent to sync it into Ownable (the file is inert until synced). Best-effort —
       // a convenience, never a reason to fail setup.
       try {
         const already = installIcpSyncHook();
-        if (!already) console.log("Installed the ICP auto-sync hook — edits to your ICP file now sync to Nous automatically.");
+        if (!already) console.log("Installed the ICP auto-sync hook — edits to your ICP file now sync to Ownable automatically.");
       } catch { /* non-fatal */ }
     }
 
-    console.log("\n✅ Signed in. Open Claude Code — OpenNous will walk you through onboarding on its own.");
+    console.log("\n✅ Signed in. Open Claude Code — Ownable will walk you through onboarding on its own.");
     console.log("\n" + dim("Docs: https://docs.opennous.cloud/mcp/introduction"));
   });
 
 // nous pull — write the Vault into ./context/*.md and hand authorship to the repo.
 //
 // The bridge for the Google road. A user who set up in the browser has a Vault whose author
-// is Nous (source 'nous', no file). The day they open a repo and connect an agent, that
+// is Ownable (source 'nous', no file). The day they open a repo and connect an agent, that
 // arrangement is backwards: they now live in files, and the Vault should mirror the files,
 // not the other way round. `pull` flips it — it writes each context doc to disk and re-syncs
 // it WITH its path, which sets source='claude_code'. From then on their repo is the author,
@@ -506,7 +510,7 @@ const PULL_KINDS = { icp: "icp.md" };
 
 program
   .command("pull")
-  .description("Write your Nous context docs into ./context and let your repo own them")
+  .description("Write your Ownable context docs into ./context and let your repo own them")
   .option("--dir <path>", "Where to write the context/ folder (default: cwd)", process.cwd())
   .option("--force", "Overwrite files that already exist", false)
   .action(async ({ dir, force }) => {
@@ -542,7 +546,7 @@ program
 
     console.log(`\n✓ ${written} written${skipped ? `, ${skipped} skipped` : ""}. Your repo now owns your context.`);
     if (synced < written) console.log(dim("  (some didn't sync back — re-run `nous pull` to finish)"));
-    console.log(dim("Edit these files and your agent syncs them with sync_foundation. Nous mirrors them."));
+    console.log(dim("Edit these files and your agent syncs them with sync_foundation. Ownable mirrors them."));
   });
 
 // nous logout — top-level alias of `auth logout`. Removes the saved API key.
@@ -552,10 +556,11 @@ program
   .option("--agent <agent>", "claude or codex (default: whichever you're signed in to)")
   .option("--days <days>", "how many days back to read, 1 to 730", "180")
   .option("--workspace <id>", "the workspace to read; the app's command fills this in")
-  .option("--yes", "start without asking")
+  .option("--yes", "start without asking, and accept who each person is as proposed")
+  .option("--confirm", "wait until you confirm who each person is in Routing before reading")
   .option("--url <url>", "API base URL (default: https://api.opennous.cloud)")
   .action(async (opts) => {
-    const { detectAgents, runBackfill, liveRun, emptyEstimate, estimateLine, rerunCommand, NO_AGENT } = await import("./backfill.js");
+    const { detectAgents, runBackfill, liveRun, emptyEstimate, estimateLine, rerunCommand, reviewLine, writeReport, NO_AGENT } = await import("./backfill.js");
     const days = Number(opts.days);
     if (!Number.isInteger(days) || days < 1 || days > 730) {
       console.error("--days must be a whole number from 1 to 730.");
@@ -602,7 +607,7 @@ program
     }
     console.log(`\nWorkspace: ${workspace}`);
     console.log(estimateLine(days, est.counts));
-    console.log(`They're filtered first, then read on your ${agent} plan. None of it uses your OpenNous credits.`);
+    console.log(`They're filtered first, then read on your ${agent} plan. None of it uses your Ownable credits.`);
     console.log("You can stop at any time and run this again: it carries on where it stopped.\n");
     if (!opts.yes) {
       const { createInterface } = await import("node:readline/promises");
@@ -611,25 +616,152 @@ program
       rl.close();
       if (!ok) return;
     }
-    const job = await api.post("/v2/backfill/own", { days });
+    // Who each person is (GET-1159): read with the proposals by default; --confirm waits for you, --yes accepts them.
+    const confirm = opts.confirm ? "wait" : opts.yes ? "yes" : "proceed";
+    const job = await api.post("/v2/backfill/own", { days, confirm });
     console.log(job.resumed ? "Picking up where you left off. Stop any time with Ctrl-C." : `Started. Stop any time with Ctrl-C; run \`${rerun}\` again to carry on.`);
     process.once("SIGINT", () => {
       console.log(`\nStopped. Everything read so far is saved. Run \`${rerun}\` to carry on.`);
       process.exit(130);
     });
+    const run = liveRun();
     const result = await runBackfill({
-      agent, jobId: job.job_id, run: liveRun(), log: console.log, rerun,
+      agent, jobId: job.job_id, run, log: console.log, rerun,
       sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
       api: {
         calls: (id, limit) => api.get(`/v2/backfill/own/${id}/calls`, { limit }),
         answer: (id, body) => api.post(`/v2/backfill/own/calls/${id}`, body),
-        resume: () => api.post("/v2/backfill/own", { days }),
+        resume: () => api.post("/v2/backfill/own", { days, confirm }),
       },
     });
     console.log(`Done. This run: ${result.read} conversations read, ${result.answered} model calls on your ${agent} plan.`);
     if (result.failed) console.log(`${result.failed} conversations couldn't be read. Run \`${rerun}\` again to retry them.`);
+    const review = reviewLine(result.memoryReview);
+    if (review) console.log(review);
+    // The Intelligence report (GET-1199): private to you, its summary written on your plan.
+    console.log("Writing your Intelligence report…");
+    const reportUrl = await writeReport({
+      agent, jobId: job.job_id, run,
+      api: {
+        report: (id) => api.softPost(`/v2/backfill/own/${id}/report`, {}),
+        writing: (id, body) => api.softPost(`/v2/backfill/own/${id}/report/writing`, body),
+      },
+    }).catch(() => null);
+    if (reportUrl) console.log(`Your Intelligence report is ready: ${reportUrl}`);
+  });
+
+// `nous runner` (GET-1293): keeps reading your new calls and email on your own plan. `install`
+// starts it at login; the app's "Your plan" page shows it as connected once it has polled.
+const runnerCmd = program
+  .command("runner")
+  .description("Keep reading your new calls and email on your own Claude or ChatGPT plan")
+  .option("--agent <agent>", "claude or codex (default: whichever you're signed in to)")
+  .option("--workspace <id>", "the workspace to read; the app's command fills this in")
+  .option("--url <url>", "API base URL (default: https://api.opennous.cloud)")
+  .action(async (opts) => {
+    const { detectAgents, liveRun, NO_AGENT } = await import("./backfill.js");
+    const { runRunner } = await import("./runner.js");
+    const agent = await pickAgent(opts.agent, detectAgents, NO_AGENT);
+    const key = await runnerKey(opts);
+    const api = apiClient(key);
+    const service = process.env.NOUS_RUNNER_SERVICE === "1";
+    const stamp = (line) => (service ? `${new Date().toISOString()} ${line}` : line);
+    console.log(stamp(`Reading on your ${agent} plan. ${service ? "" : "Stop with Ctrl-C; `nous runner install` keeps it going on its own."}`.trim()));
+    await runRunner({
+      agent, version, run: liveRun(), log: (l) => console.log(stamp(l)),
+      sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+      api: {
+        poll: (body) => api.softPost("/v2/runner/poll", body),
+        answer: (id, body) => api.softPost(`/v2/runner/calls/${id}`, body),
+      },
+    });
+  });
+
+runnerCmd
+  .command("install")
+  .description("Start the runner now and every time you log in")
+  .option("--agent <agent>", "claude or codex (default: whichever you're signed in to)")
+  .option("--workspace <id>", "the workspace to read; the app's command fills this in")
+  .option("--url <url>", "API base URL (default: https://api.opennous.cloud)")
+  .action(async (opts) => {
+    const { detectAgents, NO_AGENT } = await import("./backfill.js");
+    const { installService } = await import("./runner.js");
+    const agent = await pickAgent(opts.agent, detectAgents, NO_AGENT);
+    const key = await runnerKey(opts);
+    // One poll before installing, so a bad key or plan fails here and not silently in the background.
+    try {
+      await apiClient(key).softPost("/v2/runner/poll", { agent, host: hostname(), version, limit: 0 });
+    } catch (e) {
+      console.error(`Couldn't connect: ${e.message}`);
+      process.exit(1);
+    }
+    try {
+      const where = installService({ agent, workspace: opts.workspace ?? null });
+      console.log(`Connected. The runner reads on your ${agent} plan and starts every time you log in.`);
+      if (where.log) console.log(`Log: ${where.log}`);
+      console.log("Check on it with `npx @opennous/cli@latest runner status`. Stop it with `npx @opennous/cli@latest runner uninstall`.");
+    } catch (e) {
+      console.error(e.message);
+      process.exit(1);
+    }
   });
 
+runnerCmd
+  .command("uninstall")
+  .description("Stop the runner and stop it starting at login")
+  .action(async () => {
+    const { uninstallService } = await import("./runner.js");
+    console.log(uninstallService() ? "Stopped. It won't start at login any more." : "No runner is installed on this machine.");
+  });
+
+runnerCmd
+  .command("status")
+  .description("Whether the runner is installed and running on this machine")
+  .action(async () => {
+    const { serviceStatus } = await import("./runner.js");
+    const s = serviceStatus();
+    if (!s.installed) { console.log("Not installed. Run `npx @opennous/cli@latest runner install`."); return; }
+    console.log(s.running ? "Running." : "Installed, but not running right now.");
+    if (s.log) console.log(`Log: ${s.log}`);
+  });
+
+/** The agent to read with: the one asked for, or whichever is signed in. Exits with what to do. */
+async function pickAgent(asked, detectAgents, noAgent) {
+  const agents = detectAgents();
+  const agent = asked ?? agents[0];
+  if (!agent || !agents.includes(agent)) {
+    console.error(asked ? `You're not signed in to ${asked}. Run \`${asked === "codex" ? "codex login" : "claude"}\` first.` : noAgent);
+    process.exit(1);
+  }
+  return agent;
+}
+
+/** The key the runner reads with: for --workspace when given (signing in to it if needed), else the saved one. */
+async function runnerKey(opts) {
+  if (opts.url) writeConfig({ ...readConfig(), apiUrl: opts.url });
+  if (!hasKey()) await browserLogin(opts.url);
+  const cfg = readConfig();
+  const apiUrl = opts.url || process.env.NOUS_API_URL || cfg.apiUrl || "https://api.opennous.cloud";
+  let key = process.env.NOUS_API_KEY || cfg.apiKey;
+  if (!opts.workspace) return key;
+  const kept = cfg.workspaceKeys?.[opts.workspace];
+  for (const k of [key, kept].filter(Boolean)) {
+    if ((await fetchWhoami(apiUrl, k))?.workspace?.id === opts.workspace) {
+      if (k !== kept) writeConfig({ ...cfg, workspaceKeys: { ...cfg.workspaceKeys, [opts.workspace]: k } });
+      return k;
+    }
+  }
+  console.log("Sign in to the workspace this runner is for.");
+  key = await browserLogin(opts.url, { save: false });
+  if ((await fetchWhoami(apiUrl, key))?.workspace?.id !== opts.workspace) {
+    console.error("That sign-in is for another workspace. Open the right workspace in the app, then run this again.");
+    process.exit(1);
+  }
+  const saved = readConfig();
+  writeConfig({ ...saved, workspaceKeys: { ...saved.workspaceKeys, [opts.workspace]: key } });
+  return key;
+}
+
 program
   .command("logout")
   .description("Sign out — remove the saved API key")

package/src/runner.js

@@ -0,0 +1,205 @@
+// `nous runner` (GET-1293): reads your new calls and email on your own Claude or ChatGPT plan, all
+// the time. It is `nous backfill`'s loop that never ends: it polls the server, answers each model
+// call with the `claude` or `codex` CLI you are signed in to (no tools, the same sandbox as backfill:
+// a call's prompt holds other people's words), and posts the answer back. The server decides what to
+// read; this only answers. `nous runner install` starts it at login, so it keeps going on its own.
+
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, hostname, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { commandFor, parseAnswer, isPlanLimit } from "./backfill.js";
+
+export const WORKERS = 3;
+/** Busy: there is a read going, so ask again soon. */
+export const BUSY_MS = 2000;
+/** Idle: nothing going. A heartbeat still has to land well inside the server's two minutes. */
+export const IDLE_MS = 20_000;
+/** At the plan's limit: take nothing, keep the heartbeat. */
+export const LIMITED_POLL_MS = 60_000;
+export const LIMIT_WAIT_MS = 30 * 60_000;
+const RETRIES = 2;
+const ERROR_BACKOFF_MS = 30_000;
+
+export const LABEL = "cloud.opennous.runner";
+export const RUN_COMMAND = "npx -y @opennous/cli@latest runner";
+
+/** What the status line says about the read in progress, or null. Pure. */
+export function readingLine(reading) {
+  if (!reading) return null;
+  const what = reading.live ? "Reading what's new" : "Reading your history";
+  if (reading.status === "paused_own_model") return `${what}: picking it back up.`;
+  if (reading.finished) return `${what}: wrapping up.`;
+  if (reading.total) return `${what}: ${reading.done ?? 0} of ${reading.total}.`;
+  return `${what}.`;
+}
+
+/**
+ * The loop. Injected: `api` ({ poll, answer }), `run` (one command → stdout), `sleep`, `log`.
+ * `stop()` → true ends it (tests; the real one runs until the process is stopped).
+ */
+export async function runRunner({ api, agent, host = hostname(), version = null, run, sleep, log, now = Date.now,
+  workers = WORKERS, limitWaitMs = LIMIT_WAIT_MS, stop = () => false }) {
+  let limitedUntil = 0, answered = 0, lastLine = null, lastError = null, toldBackfill = false;
+  const answerOne = async (call, models) => {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        const { text, usage } = parseAnswer(agent, await run(commandFor(agent, models[agent], call)));
+        await api.answer(call.id, { answer: text, model: models[agent].model, usage });
+        answered++;
+        return;
+      } catch (err) {
+        // The plan's limit: drop the call (its lease runs out and it comes back) and stop taking
+        // more until the limit lifts. The heartbeat keeps going, so the app shows why.
+        if (isPlanLimit(err.message)) {
+          if (now() >= limitedUntil) log(`Your ${agent} plan hit its limit. Reading waits ${Math.round(limitWaitMs / 60000)} minutes, then carries on by itself.`);
+          limitedUntil = Math.max(limitedUntil, now() + limitWaitMs);
+          return;
+        }
+        if (attempt >= RETRIES) { await api.answer(call.id, { error: err.message }).catch(() => {}); return; }
+      }
+    }
+  };
+  while (!stop()) {
+    let page;
+    try {
+      page = await api.poll({ agent, host, version, answered, limit: workers,
+        limited_until: limitedUntil > now() ? new Date(limitedUntil).toISOString() : null });
+      if (lastError) { log("Back online."); lastError = null; }
+    } catch (err) {
+      if (err.message !== lastError) log(`Waiting on Ownable: ${err.message}. Trying again every ${ERROR_BACKOFF_MS / 1000} seconds.`);
+      lastError = err.message;
+      await sleep(ERROR_BACKOFF_MS);
+      continue;
+    }
+    if (page.needs_backfill && !toldBackfill) {
+      toldBackfill = true;
+      log("Your history hasn't been read yet. Run `npx @opennous/cli@latest backfill` once; after that this keeps it current.");
+    }
+    const line = readingLine(page.reading);
+    if (line && line !== lastLine) { log(line); }
+    lastLine = line;
+    const calls = page.calls ?? [];
+    if (!calls.length) { await sleep(limitedUntil > now() ? LIMITED_POLL_MS : page.reading ? BUSY_MS : IDLE_MS); continue; }
+    await Promise.all(calls.map((c) => answerOne(c, page.models)));
+  }
+  return { answered };
+}
+
+// ── Start at login ───────────────────────────────────────────────────────────────────────────
+
+/** The absolute path of a command, or null. */
+export function which(cmd, run = spawnSync) {
+  const r = run("/bin/sh", ["-c", `command -v ${cmd}`], { encoding: "utf8" });
+  const p = r.status === 0 ? String(r.stdout).trim().split("\n")[0] : "";
+  return p.startsWith("/") ? p : null;
+}
+
+/** PATH for the service: where node, npx and the agent CLIs live, then the usual places. Pure. */
+export function servicePath(binaries) {
+  const dirs = [...new Set(binaries.filter(Boolean).map((b) => dirname(b)))];
+  for (const d of ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"]) if (!dirs.includes(d)) dirs.push(d);
+  return dirs.join(":");
+}
+
+const xml = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+/** The launchd agent for macOS. Pure. */
+export function launchdPlist({ npx, agent, workspace = null, path, log }) {
+  const args = [npx, "-y", "@opennous/cli@latest", "runner", "--agent", agent, ...(workspace ? ["--workspace", workspace] : [])];
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args.map((a) => `    <string>${xml(a)}</string>`).join("\n")}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>${xml(path)}</string>
+    <key>NOUS_RUNNER_SERVICE</key><string>1</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>ThrottleInterval</key><integer>30</integer>
+  <key>StandardOutPath</key><string>${xml(log)}</string>
+  <key>StandardErrorPath</key><string>${xml(log)}</string>
+</dict>
+</plist>
+`;
+}
+
+/** The systemd user unit for Linux. Pure. */
+export function systemdUnit({ npx, agent, workspace = null, path }) {
+  const args = [npx, "-y", "@opennous/cli@latest", "runner", "--agent", agent, ...(workspace ? ["--workspace", workspace] : [])];
+  return `[Unit]
+Description=Ownable runner: reads on your own ${agent === "codex" ? "ChatGPT" : "Claude"} plan
+After=network-online.target
+
+[Service]
+ExecStart=${args.join(" ")}
+Environment=PATH=${path}
+Environment=NOUS_RUNNER_SERVICE=1
+Restart=always
+RestartSec=30
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+/** Where the service files live on this machine. Pure. */
+export function servicePaths(os = platform(), home = homedir()) {
+  if (os === "darwin") return { kind: "launchd", file: join(home, "Library", "LaunchAgents", `${LABEL}.plist`), log: join(home, "Library", "Logs", "opennous-runner.log") };
+  if (os === "linux") return { kind: "systemd", file: join(home, ".config", "systemd", "user", "opennous-runner.service"), log: null };
+  return null;
+}
+
+/** Install and start the runner as a service. Returns { kind, file, log } or throws with what to do. */
+export function installService({ agent, workspace = null, run = spawnSync, os = platform(), home = homedir() } = {}) {
+  const where = servicePaths(os, home);
+  if (!where) throw new Error(`Starting at login isn't supported on ${os} yet. Run \`${RUN_COMMAND}\` in a terminal you keep open instead.`);
+  const npx = which("npx", run);
+  if (!npx) throw new Error("Couldn't find npx. Install Node.js 20 or later, then run this again.");
+  const path = servicePath([npx, which("node", run), which(agent, run)]);
+  mkdirSync(dirname(where.file), { recursive: true });
+  if (where.kind === "launchd") {
+    mkdirSync(dirname(where.log), { recursive: true });
+    writeFileSync(where.file, launchdPlist({ npx, agent, workspace, path, log: where.log }));
+    run("launchctl", ["unload", where.file], { stdio: "ignore" });
+    const r = run("launchctl", ["load", "-w", where.file], { encoding: "utf8" });
+    if (r.status !== 0) throw new Error(`launchctl couldn't start it: ${(r.stderr || "").trim()}`);
+  } else {
+    writeFileSync(where.file, systemdUnit({ npx, agent, workspace, path }));
+    run("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+    const r = run("systemctl", ["--user", "enable", "--now", "opennous-runner.service"], { encoding: "utf8" });
+    if (r.status !== 0) throw new Error(`systemd couldn't start it: ${(r.stderr || "").trim()}`);
+    // Keeps it running after logout, where the machine allows it. Best effort.
+    run("loginctl", ["enable-linger"], { stdio: "ignore" });
+  }
+  return where;
+}
+
+/** Stop and remove the service. True when there was one. */
+export function uninstallService({ run = spawnSync, os = platform(), home = homedir() } = {}) {
+  const where = servicePaths(os, home);
+  if (!where || !existsSync(where.file)) return false;
+  if (where.kind === "launchd") run("launchctl", ["unload", "-w", where.file], { stdio: "ignore" });
+  else {
+    run("systemctl", ["--user", "disable", "--now", "opennous-runner.service"], { stdio: "ignore" });
+  }
+  rmSync(where.file, { force: true });
+  return true;
+}
+
+/** Whether the service is installed, and running as far as the OS says. */
+export function serviceStatus({ run = spawnSync, os = platform(), home = homedir() } = {}) {
+  const where = servicePaths(os, home);
+  if (!where || !existsSync(where.file)) return { installed: false, running: false, ...(where ?? {}) };
+  const r = where.kind === "launchd"
+    ? run("launchctl", ["list", LABEL], { encoding: "utf8" })
+    : run("systemctl", ["--user", "is-active", "opennous-runner.service"], { encoding: "utf8" });
+  return { installed: true, running: r.status === 0, ...where };
+}