getprismo 0.1.51 → 0.1.53

package/docs/announcement.md

@@ -1,56 +1,69 @@
-# Announcement drafts
+# Launch drafts
 
-Working drafts for the autonomous-loop release (getprismo 0.1.42). Edit freely; numbers in brackets should be replaced with real figures from the dashboard once a week of verdicts has accumulated.
+Built on real numbers from a week of dogfooding (getprismo 0.1.52). Verified figures are measured against actual later sessions, never estimated — keep that distinction in every claim, it's the whole point.
+
+Snapshot used below (one developer, ~1 week, single machine):
+- **Verified saved: $22.81 (6,338,568 tokens)** — repairs whose savings were confirmed by a lower waste rate in later sessions.
+- Observed: 141 sessions, 11.69M tokens, ~5.3M flagged avoidable.
+- Per-developer annualized ≈ **$1,100/yr**; a 10-dev team ≈ **$11k/yr** — verified, not projected from a model.
 
 ---
 
 ## Show HN
 
-**Title:** Show HN: Prismo — an autonomous cost agent for AI coding that verifies its own fixes
+**Title:** Show HN: Prismo – an AI-coding cost agent that verifies its own savings ($22/wk/dev)
 
 **Body:**
 
-AI coding agents (Claude Code, Codex, Cursor) waste a surprising share of their tokens: re-reading the same file hundreds of times, dumping full test output into context, loading lockfiles and build artifacts, retrying the same failing command. Most tools in this space show you a dashboard of the damage and stop there.
+AI coding agents (Claude Code, Codex, Cursor) quietly waste a big share of their tokens: re-reading the same file hundreds of times, dumping full test output into context, loading lockfiles and build artifacts, retrying a failing command over and over. Most tools here show you a dashboard of the damage and stop. I wanted one that *fixes* it and then *proves* the fix worked.
 
-Prismo closes the loop. It runs locally (`npx getprismo doctor` to try it — no login, nothing leaves your machine), reads your agents' own session logs, and attributes waste to one of five causes. Then, if you connect it:
+Prismo runs locally — `npx getprismo doctor`, no login, nothing leaves your machine — reads your agents' own session logs, and attributes waste to one of five causes. Connect it and it closes the loop:
 
-- a local planner repairs the top cause automatically — each cause has a dedicated fix, not a generic one
-- after every repair, it measures the waste rate for that cause in your *later* sessions and stores a verdict: improved, no-change, or regressed
-- failed repairs escalate to a stronger tier (context firewall, tighter budgets); a cause that fails both tiers is held for human review instead of being retried forever
-- for Claude Code it goes further than advice: a PreToolUse hook actually denies reads into blocked context and the fourth retry of an identical command (fail-open, removable with one command)
-- savings are reported in dollars, verified against real usage — not estimated — with a weekly digest you can paste into Slack
-- and the planner learns from the fleet: anonymized repair verdicts (counts only) aggregate into priors, so your first repair starts at the tier that's known to work
+- A local planner repairs the top cause automatically. Each cause gets a dedicated fix (ignore rules + context packs, shielded commands, a context firewall, scoped session restarts) — not one generic "optimize."
+- After each repair it measures that cause's waste rate in your *later* sessions and stores a verdict: improved / no-change / regressed (14-day baseline, before/after rates, 1% epsilon — the math is in the repo).
+- A repair that doesn't help escalates to a stronger tier; one that fails both tiers is held for human review instead of being retried forever.
+- For Claude Code it goes past advice: a PreToolUse hook actually *denies* reads into blocked context and the 4th retry of an identical failing command (fail-open, removed with one command).
+- Savings are reported in dollars, **verified against real usage, not estimated**, with a weekly digest you can paste into Slack.
 
-In our own dogfooding it [verified ~$X saved across N sessions in the first week].
+I dogfooded it on my own machine for a week. It verified **$22.81 / 6.3M tokens saved** (≈ $1,100/yr/dev annualized) — and, more honestly, the week of dogfooding caught **six real bugs in Prismo itself**, including one where it silently dropped *all* Claude Code telemetry for any repo whose path contains a space (e.g. `~/Code Projects/...`), and a verification bug where mixing in Cursor (which can't report the signal) poisoned the baseline so nothing ever verified. Both are fixed; finding them this way is kind of the best argument for the verify-everything design.
 
-The CLI is MIT-licensed: https://github.com/shanirsh/prismodev — the verification loop math is in the repo (14-day baseline, before/after waste rates, 1% epsilon). Would love feedback on the enforcement design and the verdict thresholds.
+MIT-licensed, the verification and enforcement logic is all in the open: https://github.com/shanirsh/prismodev — would love feedback on the enforcement model and the verdict thresholds.
 
 ---
 
 ## X / Twitter thread
 
-1/ Every AI-coding-cost tool shows you a dashboard of waste. We built the thing that fixes it — and then proves the fix worked, in dollars.
+1/ Every AI-coding-cost tool shows you a dashboard of waste. I built the one that fixes it — then proves the fix worked, in dollars, measured against your real later sessions.
 
-2/ Prismo watches your Claude Code / Codex / Cursor sessions locally, attributes waste to 5 causes, and repairs the top one automatically. Ignore rules, shielded commands, context firewalls, scoped restarts — each cause gets its own fix.
+2/ One week dogfooding on my own machine: **$22.81 / 6.3M tokens verified saved** (~$1,100/yr/dev). "Verified" = a repair ran, then later sessions showed a measurably lower waste rate. Not an estimate.
 
-3/ The part nobody else does: after a repair, it measures that cause's waste rate in your NEXT sessions. Improved → stand down. No change → escalate to a stronger repair. Failed twice → stop and ask a human. It's a feedback controller, not a script.
+3/ How: it reads your Claude Code / Codex / Cursor logs locally, attributes waste to 5 causes, and repairs the top one — each cause gets its own fix, not a generic "optimize."
 
-4/ For Claude Code it's not advisory. `prismo enforce install` wires a hook that *denies* reads into node_modules/logs/build output and blocks the 4th retry of an identical failing command. Fail-open, one command to remove.
+4/ The part nobody else does: after a repair it re-measures that cause in your NEXT sessions. Improved → stand down. No change → escalate to a stronger repair. Failed twice → stop and ask a human. A feedback controller, not a script.
 
-5/ And it learns across every install: anonymized repair verdicts roll up into fleet priors, so your first repair starts at the tier the fleet already knows works. The more users, the smarter every agent gets.
+5/ For Claude Code it's not advisory — a PreToolUse hook *denies* reads into node_modules/logs/build output and blocks the 4th retry of an identical failing command. Fail-open, one command to remove.
 
-6/ Monday morning: `prismo digest` → "Prismo saved you ~$X this week — verified against your sessions." Paste it in Slack. The product re-justifies itself weekly.
+6/ Most honest part: a week of dogfooding caught 6 real bugs in Prismo itself — including one that silently hid ALL Claude Code data for any repo path with a space in it. Verifying everything is how you find that.
 
-7/ Try it in 10 seconds, no login, local-only: `npx getprismo doctor` — MIT licensed → github.com/shanirsh/prismodev
+7/ `npx getprismo doctor` — 10 seconds, no login, local-only. MIT: github.com/shanirsh/prismodev
 
 ---
 
-## Release notes (0.1.40 → 0.1.42)
+## Release notes (0.1.40 → 0.1.52)
 
-- **Cause-specific repair executors** — workspace actions with a `targetCause` run a targeted repair (repeated-file-reads, tool-output-flood, generated-artifacts, context-loop, long-session-buildup) instead of generic doctor; `prismo repair <cause>` runs them standalone.
-- **Autonomous repair planner** — `agent --watch` self-repairs on an interval with thresholds, per-cause cooldowns, local before/after verdicts, and mild→aggressive escalation; `prismo repair auto [--dry-run]`.
-- **Runtime enforcement** — `prismo enforce install` adds a Claude Code PreToolUse hook denying blocked-context reads and identical-command loops; fails open; `enforce uninstall` reverts.
-- **Verified savings in dollars** — `prismo digest [--days N]` prints the weekly verified-savings summary; the dashboard leads with dollars.
+- **Cause-specific repair executors** — targeted repairs per waste cause instead of generic doctor; `prismo repair <cause|auto>`.
+- **Autonomous repair planner** — `agent --watch` self-repairs with thresholds, per-cause cooldowns, local before/after verdicts, and mild→aggressive escalation.
+- **Runtime enforcement** — `prismo enforce install` adds Claude Code Pre/PostToolUse hooks that block blocked-context reads and failing-command loops; fail-open; outcome-aware.
+- **Verified savings in dollars** — `prismo digest`; the dashboard leads with verified dollars, with live prevention and early signals labeled separately.
 - **Fleet priors** — first repairs start at the tier the fleet's verified outcomes recommend (anonymized counts only; local verdicts always win).
-- **Cloud escalation + dedupe** — auto-queued repairs escalate after failed verdicts; duplicate actions are deduped at creation and claim.
+- **Multi-repo capture** — one connector observes every repo on the machine, each session attributed to its own repo.
+- **One-command protect** — `prismo protect` runs the full stack (safe fixes + context packs + enforcement + connector).
 - **CI releases** — tag push runs tests and publishes.
+
+### Bugs the dogfood week caught (and fixed)
+1. Digest counted background auto-detect scans as interventions (186 fake vs 3 real).
+2. Verification baseline poisoned by Cursor's blind zero-signals — now compares like-for-like across tools.
+3. Claude Code telemetry silently dropped for repo paths containing a space or dot (folder-name encoding mismatch).
+4. Connector was single-repo — now captures every repo.
+5. `prismo protect` silently repointed a running connector (checked a field that never existed).
+6. Dashboard polling (every 8s, loading a large unused column) blew past the DB egress quota — deferred the column, slowed/gated polling, windowed scans.

package/docs/privacy-telemetry.md

@@ -15,6 +15,8 @@ This page lists **exactly** what the connector sends after you connect, field by
 
 ## What session sync sends (`prismo sync`, and the connector on an interval)
 
+The background connector captures recent agent sessions from **every repo** on this machine (each attributed to its own repo), so all your agent activity is visible in one place — not just the repo the connector was started in. A one-off `prismo sync` covers only the current repo unless you pass `--all-repos`. Either way, only the numbers and labels below are sent; never code or prompts.
+
 Per machine:
 
 | field | example | note |

package/docs/validation-week.md

@@ -8,3 +8,8 @@ Paper cuts, observations, and metric notes from the measurement window. Fix bugs
 - 2026-06-12: follow-up dogfood found backend-summary.md could churn backups because generated .prismo context files influenced load-bearing text-reference counts. Excluded .prismo generated context from the reference corpus and added a regression test; repeated optimize on the SaaS repo now produces 0 new .bak files after the one-time old-report replacement.
 - 2026-06-12: connector dogfood found scoped `optimize frontend` and unscoped `optimize` could alternate optimize-report.md's Generated Files list and create metadata-only backups. Changed optimize-report metadata-only changes to update without backups and added a scoped/unscoped regression test.
 - 2026-06-12: connector dogfood found legitimate generated-context changes still left timestamped `.prismo/*.bak` files, which made the repo look dirty during validation. Changed `prismo optimize` context files to update in place because they are reproducible generated artifacts; user-authored files still keep backups.
+- 2026-06-14: THREE real bugs found via dogfooding, all fixed + shipped (v0.1.47-0.1.51):
+  1. Digest counted auto-detect health scans as interventions (186 fake vs 3 real).
+  2. Verification baseline poisoned by Cursor's blind 0-signals -> now compares like-for-like across tools.
+  3. CRITICAL: Claude Code telemetry silently dropped when repo path has a space/dot ("Code Projects") -> path encoding now matches Claude's. Was hiding the strongest signal for any user with a spaced path.
+- 2026-06-14: KNOWN BUG (not yet fixed): `prismo protect` reinstalls/repoints the single connector even when one is already running for another repo, silently hijacking which repo syncs. Connector is single-repo; working across multiple repos means only the watched one syncs to the dashboard. Post-freeze: make protect not move a running connector, and consider syncing all recent repos.

package/lib/prismo-dev/agent.js

@@ -752,7 +752,10 @@ module.exports = function createAgent(deps) {
     let syncResult = null;
     if (options.syncTelemetry) {
       try {
-        const result = await runSync(rootDir, { limit: options.syncLimit || 20 });
+        // The connector is the always-on capturer: observe every repo's agent
+        // activity, not just the one it was started in (each session is
+        // attributed to its own repo). Opt out with allRepos: false.
+        const result = await runSync(rootDir, { limit: options.syncLimit || 20, allRepos: options.allRepos !== false });
         syncResult = {
           synced: Boolean(result.synced),
           sessions: Number(result.aggregate?.sessions || 0),

package/lib/prismo-dev/cli.js

@@ -417,6 +417,7 @@ function createCli(deps) {
         preview: rest.includes("--preview"),
         limit: parsePositiveInt(limitIndex >= 0 ? rest[limitIndex + 1] : null, 20),
         tool: toolIndex >= 0 ? rest[toolIndex + 1] : "all",
+        allRepos: rest.includes("--all-repos"),
         endpoint: apiUrlIndex >= 0 ? `${String(rest[apiUrlIndex + 1] || "").replace(/\/$/, "")}/v1/dev/sessions/sync` : null,
       };
       if (rest.includes("--watch")) {
@@ -859,8 +860,15 @@ function createCli(deps) {
       const config = loadConfig();
       if (config?.token) {
         const connector = runConnectorStatus();
-        if (connector.running) {
-          steps.push({ step: "connector", ok: true, detail: "Background connector already running." });
+        if (connector.installed) {
+          // The connector already runs and now observes every repo's agent
+          // activity (all-repos sync), so do NOT repoint it to this repo —
+          // that would hijack which repo the dashboard treats as primary.
+          const watchedRoot = connector.state && connector.state.root;
+          const watched = watchedRoot && path.resolve(watchedRoot) !== path.resolve(target)
+            ? ` (watching ${path.basename(watchedRoot)}; it captures this repo too)`
+            : "";
+          steps.push({ step: "connector", ok: true, detail: `Background connector already installed${watched}.` });
         } else {
           runConnectorInstall(target, { mode: "autopilot" });
           steps.push({ step: "connector", ok: true, detail: "Background connector installed and started in autopilot." });

package/lib/prismo-dev/cloud-sync.js

@@ -86,7 +86,18 @@ module.exports = function createCloudSync(deps) {
     }
   }
 
-  function repoIdentity(root) {
+  function sameResolvedPath(a, b) {
+    if (!a || !b) return false;
+    try {
+      const ra = fs.existsSync(a) ? fs.realpathSync(a) : path.resolve(a);
+      const rb = fs.existsSync(b) ? fs.realpathSync(b) : path.resolve(b);
+      return ra === rb;
+    } catch {
+      return path.resolve(a) === path.resolve(b);
+    }
+  }
+
+  function repoIdentity(root, idOptions = {}) {
     const resolved = path.resolve(root || process.cwd());
     const remote = runGit(resolved, ["config", "--get", "remote.origin.url"]);
     const branch = runGit(resolved, ["branch", "--show-current"]);
@@ -96,7 +107,9 @@ module.exports = function createCloudSync(deps) {
       remote: redactRemote(remote),
       branch: branch || null,
       commit: commit || null,
-      pr: detectPullRequest(resolved),
+      // PR detection shells out to `gh` per repo; skip it for secondary repos
+      // in all-repos sync so a 60s poll doesn't fan out gh calls everywhere.
+      pr: idOptions.detectPr === false ? null : detectPullRequest(resolved),
     };
   }
 
@@ -176,11 +189,13 @@ module.exports = function createCloudSync(deps) {
 
   function buildSyncPayload(rootDir = process.cwd(), options = {}) {
     const root = path.resolve(rootDir);
+    const allRepos = Boolean(options.allRepos);
     const repo = repoIdentity(root);
     const usage = getUsageSummary({
       cwd: root,
       tool: options.tool || "all",
       limit: options.limit || 20,
+      allRepos,
     });
     let scan = null;
     try {
@@ -188,7 +203,28 @@ module.exports = function createCloudSync(deps) {
     } catch {
       scan = null;
     }
-    const sessions = (usage.sessions || []).map((session) => sanitizeSession(session, repo));
+
+    // In all-repos mode each session is attributed to its own repo, derived
+    // from the session's recorded cwd (git lookups cached per directory), so
+    // the dashboard groups activity by the repo it actually happened in.
+    const repoCache = new Map();
+    function repoForSession(session) {
+      if (!allRepos) return repo;
+      const sessionCwd = session && session.cwd ? path.resolve(session.cwd) : null;
+      if (!sessionCwd) return repo;
+      if (sameResolvedPath(sessionCwd, root)) return repo;
+      if (repoCache.has(sessionCwd)) return repoCache.get(sessionCwd);
+      let id;
+      try {
+        id = repoIdentity(sessionCwd, { detectPr: false });
+      } catch {
+        id = repo;
+      }
+      repoCache.set(sessionCwd, id);
+      return id;
+    }
+
+    const sessions = (usage.sessions || []).map((session) => sanitizeSession(session, repoForSession(session)));
     const aggregate = sessions.reduce((acc, session) => {
       acc.sessions += 1;
       acc.displayTokens += session.tokens.display;
@@ -347,6 +383,7 @@ module.exports = function createCloudSync(deps) {
     const payload = buildSyncPayload(rootDir, {
       limit: options.limit || config?.sync?.defaultLimit || 20,
       tool: options.tool || "all",
+      allRepos: Boolean(options.allRepos),
     });
     if (options.dryRun || options.preview) {
       return {

package/lib/prismo-dev/firewall.js

@@ -201,6 +201,13 @@ function renderFirewallPrompt(result) {
   ].join("\n");
 }
 
+function writeFirewallGeneratedFile(root, relPath, contents) {
+  const fullPath = path.join(root, relPath);
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+  fs.writeFileSync(fullPath, contents, "utf8");
+  return { path: relPath, backupPath: null };
+}
+
 function runFirewall(rootDir = process.cwd(), options = {}) {
   const ctx = createOptimizeContext(rootDir, options.scope || null);
   const task = options.task || options.scope || "general";
@@ -224,7 +231,7 @@ function runFirewall(rootDir = process.cwd(), options = {}) {
 
   if (!options.dryRun) {
     const write = (relPath, contents) => {
-      if (!options.live) return writeGeneratedFile(ctx.root, relPath, contents);
+      if (!options.live) return writeFirewallGeneratedFile(ctx.root, relPath, contents);
       const fullPath = path.join(ctx.root, relPath);
       fs.mkdirSync(path.dirname(fullPath), { recursive: true });
       fs.writeFileSync(fullPath, contents, "utf8");

package/lib/prismo-dev/help.js

@@ -15,7 +15,7 @@ Usage:
   prismo connect [--json] [--token TOKEN] [--api-url URL] [--org ORG] [--user USER] [--device NAME]
   prismo connector [status|install|start|stop|uninstall] [--json] [--interval N] [--sync-interval N] [--mode observe|suggest|autopilot] [path]
   prismo bridge [--json] [path]
-  prismo sync [--json] [--dry-run] [--watch] [--interval N] [--limit N] [--tool all|codex|claude|cursor] [path]
+  prismo sync [--json] [--dry-run] [--watch] [--all-repos] [--interval N] [--limit N] [--tool all|codex|claude|cursor] [path]
   prismo status [--json]
   prismo digest [--json] [--days N]
   prismo disconnect [--json]
@@ -485,7 +485,7 @@ Output:
 Usage:
   prismo connect [--json] [--token TOKEN] [--api-url URL] [--org ORG] [--user USER] [--device NAME]
   prismo connector [status|install|start|stop|uninstall] [--json] [--interval N] [--sync-interval N] [--mode observe|suggest|autopilot] [path]
-  prismo sync [--json] [--dry-run] [--watch] [--interval N] [--limit N] [--tool all|codex|claude|cursor] [path]
+  prismo sync [--json] [--dry-run] [--watch] [--all-repos] [--interval N] [--limit N] [--tool all|codex|claude|cursor] [path]
   prismo status [--json]
   prismo disconnect [--json]
 
@@ -556,7 +556,7 @@ Privacy:
   sync: `PrismoDev Sync
 
 Usage:
-  prismo sync [--json] [--dry-run] [--watch] [--interval N] [--limit N] [--tool all|codex|claude|cursor] [path]
+  prismo sync [--json] [--dry-run] [--watch] [--all-repos] [--interval N] [--limit N] [--tool all|codex|claude|cursor] [path]
 
 Examples:
   prismo sync --dry-run

package/lib/prismo-dev/usage-sessions.js

@@ -257,24 +257,53 @@ function sameResolvedPath(a, b) {
     return false;
   }
 }
+function safeMtimeMs(filePath) {
+  try {
+    return fs.statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
 function getUsageSummary(options = {}) {
   const tool = options.tool || "all";
   const limit = options.limit || 5;
   const cwd = options.cwd || process.cwd();
+  // allRepos: capture the most recent sessions across every repo on this
+  // machine (each retains its own cwd for per-repo attribution), so a single
+  // always-on connector observes all of the user's agent activity rather than
+  // only the one repo it was started in. Cursor is skipped here because it
+  // exposes no per-session signal and cannot be attributed per repo.
+  const allRepos = Boolean(options.allRepos);
   const sessions = [];
   if (tool === "all" || tool === "codex") {
-    for (const file of getCodexSessionFiles().slice(0, Math.max(limit * 8, 20))) {
-      const session = analyzeSessionFile(file, "codex");
-      if (!session.cwd || sameResolvedPath(session.cwd, cwd)) sessions.push(session);
-      if (sessions.filter((item) => item.tool === "codex").length >= limit) break;
+    if (allRepos) {
+      const recent = getCodexSessionFiles()
+        .map((file) => ({ file, m: safeMtimeMs(file) }))
+        .sort((a, b) => b.m - a.m)
+        .slice(0, Math.max(limit, 30));
+      for (const { file } of recent) sessions.push(analyzeSessionFile(file, "codex"));
+    } else {
+      for (const file of getCodexSessionFiles().slice(0, Math.max(limit * 8, 20))) {
+        const session = analyzeSessionFile(file, "codex");
+        if (!session.cwd || sameResolvedPath(session.cwd, cwd)) sessions.push(session);
+        if (sessions.filter((item) => item.tool === "codex").length >= limit) break;
+      }
     }
   }
   if (tool === "all" || tool === "claude") {
-    for (const file of getClaudeSessionFiles(cwd).slice(0, limit)) {
+    const claudeFiles = allRepos
+      ? getAllClaudeSessionFiles()
+          .map((file) => ({ file, m: safeMtimeMs(file) }))
+          .sort((a, b) => b.m - a.m)
+          .slice(0, Math.max(limit, 30))
+          .map((x) => x.file)
+      : getClaudeSessionFiles(cwd).slice(0, limit);
+    for (const file of claudeFiles) {
       sessions.push(analyzeSessionFile(file, "claude-code"));
     }
   }
-  if (tool === "all" || tool === "cursor") {
+  if (!allRepos && (tool === "all" || tool === "cursor")) {
     try {
       const cursorData = analyzeCursorSessions({ limit, cwd });
       if (cursorData.sessions.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getprismo",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "description": "Local AI coding workflow scanner for Codex, Claude Code, Cursor, and token-waste diagnostics.",
   "license": "MIT",
   "homepage": "https://github.com/shanirsh/prismodev#readme",