getprismo 0.1.52 → 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getprismo",
-  "version": "0.1.52",
+  "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",