getprismo 0.1.52 → 0.1.54

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/lib/prismo-dev/help.js

@@ -475,9 +475,13 @@ Tools exposed:
   prismo_firewall
   prismo_cc_timeline
   prismo_cursor_sessions
+  prismo_should_shield   (agent-native: should I shield this command?)
+  prismo_loop_check      (agent-native: am I looping?)
+  prismo_context_guard   (agent-native: what repo am I in / what to avoid rereading?)
 
 Output:
   Starts a local JSON-RPC MCP server over stdio. Use it from MCP-compatible clients so agents can scan context waste, search shielded command output, and request scoped context without loading huge logs into chat.
+  The agent-native tools answer single mid-session questions directly so Claude Code, Codex, and Cursor can call Prismo while they work, not just after.
 
   prismo mcp doctor validates the local MCP tool surface and prints a ready-to-use client config snippet.`,
   connect: `PrismoDev Connect

package/lib/prismo-dev/mcp.js

@@ -1,3 +1,40 @@
+const path = require("path");
+
+// Commands whose output reliably floods agent context and should run through
+// shield (full output to disk, compact summary to the model).
+const NOISY_COMMAND_PATTERNS = [
+  { re: /(^|\s)(jest|vitest|mocha|pytest|rspec|phpunit|ava|tap)(\s|$)|(\b(npm|yarn|pnpm|bun)\s+(run\s+)?test\b)|\b(go|cargo)\s+test\b/, why: "test runs emit large pass/fail output" },
+  { re: /(^|\s)(webpack|rollup|esbuild|vite|tsc)(\s|$)|\b(next|nuxt|astro)\s+build\b|\b(npm|yarn|pnpm|bun)\s+(run\s+)?build\b|\b(go|cargo)\s+build\b|(^|\s)make(\s|$)/, why: "builds emit long compiler/bundler output" },
+  { re: /\b(npm|pnpm|bun)\s+(install|ci|i)\b|\byarn(\s+install)?\b|\bpip\s+install\b|\bbundle\s+install\b/, why: "installs print large dependency trees" },
+  { re: /(^|\s)(eslint|ruff|flake8|mypy|pylint)(\s|$)|\b(npm|yarn|pnpm)\s+(run\s+)?lint\b|tsc\s+--noEmit/, why: "linters/type-checkers emit many diagnostics" },
+  { re: /\b(playwright|cypress|e2e)\b/, why: "e2e runs dump verbose logs" },
+  { re: /\bdocker\s+build\b|\bterraform\b|\bkubectl\s+logs\b|\bcoverage\b|--verbose\b/, why: "infra/coverage/verbose commands flood output" },
+];
+const QUICK_COMMAND_PATTERNS = [
+  /(^|\s)(git\s+(status|log|diff|branch|show)|ls|pwd|whoami|which|echo|cat|head|tail|wc|env|date|node\s+-v|--version)(\s|$)/,
+];
+
+function classifyCommandForShield(command, repeatedCommands = []) {
+  const cmd = String(command || "").trim();
+  if (!cmd) return { shouldShield: false, confidence: "low", reason: "No command provided." };
+  const normalized = cmd.replace(/\s+/g, " ");
+  const repeated = (repeatedCommands || []).some((item) => {
+    const value = String(item.value || "").replace(/\s+/g, " ");
+    return value && (normalized.includes(value) || value.includes(normalized)) && Number(item.count || 0) >= 3;
+  });
+  if (repeated) {
+    return { shouldShield: true, confidence: "high", reason: "This command has already repeated several times in recent sessions; shield it so each retry costs a summary, not full output." };
+  }
+  const noisy = NOISY_COMMAND_PATTERNS.find((entry) => entry.re.test(normalized));
+  if (noisy) {
+    return { shouldShield: true, confidence: "high", reason: `Shield recommended: ${noisy.why}.` };
+  }
+  if (QUICK_COMMAND_PATTERNS.some((re) => re.test(normalized))) {
+    return { shouldShield: false, confidence: "high", reason: "Quick, low-output command; shielding is unnecessary." };
+  }
+  return { shouldShield: false, confidence: "low", reason: "No known flooding pattern; shield only if you expect large output." };
+}
+
 function createTextResult(payload) {
   const text = typeof payload === "string" ? payload : JSON.stringify(payload, null, 2);
   return {
@@ -147,6 +184,20 @@ function createMcpTools(deps) {
       tool: { type: "string", enum: ["all", "codex", "claude", "cursor"], description: "Which local session logs to inspect." },
       limit: limitProperty,
     }),
+    // Agent-native, mid-loop decision tools: tight yes/no answers an agent can
+    // act on during a session, not analysis dumps.
+    makeTool("prismo_should_shield", "Decide whether a shell command should be run through Prismo shield (full output to disk, compact summary to context) before you run it. Call this before any command that might print a lot.", {
+      command: { type: "string", description: "The exact shell command you are about to run." },
+      path: pathProperty,
+    }, ["command"]),
+    makeTool("prismo_loop_check", "Check whether the current coding session is stuck in a loop (repeating the same command or failing repeatedly). Call this when you have retried something more than once.", {
+      path: pathProperty,
+      tool: { type: "string", enum: ["all", "codex", "claude", "cursor"], description: "Which local session logs to inspect." },
+    }),
+    makeTool("prismo_context_guard", "Get what repo you are in, which paths to avoid rereading, files you have already read repeatedly, and the compact context pack to start from. Call this at the start of a session or before broad exploration.", {
+      path: pathProperty,
+      scope: scopeProperty,
+    }),
   ];
 
   function resolveRoot(args) {
@@ -292,6 +343,75 @@ function createMcpTools(deps) {
       }));
     }
 
+    if (name === "prismo_should_shield") {
+      let repeatedCommands = [];
+      try {
+        const summary = getUsageSummary({ cwd: target, limit: 3, tool: "all" });
+        const latest = (summary.sessions || [])[0];
+        repeatedCommands = (latest && latest.repeatedCommands) || [];
+      } catch { /* command classification still works without session context */ }
+      const decision = classifyCommandForShield(args.command, repeatedCommands);
+      return createTextResult({
+        schemaVersion: 1,
+        command: args.command,
+        shouldShield: decision.shouldShield,
+        confidence: decision.confidence,
+        reason: decision.reason,
+        recommended: decision.shouldShield
+          ? `npx -y getprismo@latest shield -- ${String(args.command || "").trim()}`
+          : null,
+        note: "Shield stores full stdout/stderr locally and returns a compact summary, so the output never floods context.",
+      });
+    }
+
+    if (name === "prismo_loop_check") {
+      const summary = getUsageSummary({ cwd: target, limit: 3, tool: args.tool || "all" });
+      const latest = (summary.sessions || [])[0] || null;
+      const repeatedCommands = (latest && latest.repeatedCommands) || [];
+      const looping = Boolean(latest && latest.loopSuspicion) || repeatedCommands.some((c) => Number(c.count || 0) >= 4);
+      const topRepeat = repeatedCommands[0] || null;
+      return createTextResult({
+        schemaVersion: 1,
+        looping,
+        confidence: latest ? (latest.loopConfidence || (looping ? "medium" : "low")) : "low",
+        signals: {
+          repeatedCommands: repeatedCommands.slice(0, 5),
+          failureMentions: latest ? Number(latest.failureMentions || 0) : 0,
+          turns: latest ? Number(latest.turns || 0) : 0,
+        },
+        advice: looping
+          ? `You appear to be looping${topRepeat ? ` on \`${topRepeat.value}\` (${topRepeat.count}x)` : ""}. Stop retrying, change the approach, and capture the command once with \`npx -y getprismo@latest shield -- <command>\` instead of re-running it.`
+          : "No loop detected. Keep going.",
+      });
+    }
+
+    if (name === "prismo_context_guard") {
+      const scope = args.scope || null;
+      const scan = scanRepo(target, { includeUsage: true, usageLimit: 3 });
+      const ctx = createOptimizeContext(target, scope);
+      const usage = scan.realUsage && scan.realUsage.sessions ? scan.realUsage.sessions : [];
+      const repeatedlyRead = [];
+      for (const session of usage) {
+        for (const item of session.repeatedPathMentions || []) {
+          if (Number(item.count || 0) >= 4) repeatedlyRead.push({ path: item.value, reads: item.count });
+        }
+      }
+      const blocked = (scan.recommendedClaudeIgnore || []).slice(0, 24);
+      return createTextResult({
+        schemaVersion: 1,
+        repo: path.basename(path.resolve(target)),
+        avoidRereading: {
+          blockedContext: blocked,
+          alreadyReadRepeatedly: repeatedlyRead.slice(0, 12),
+        },
+        startFrom: {
+          contextFile: scope ? `.prismo/${scope}-summary.md` : ".prismo/architecture-summary.md",
+          starterPrompt: renderStarterPrompt(ctx, scope),
+        },
+        advice: "Read the start-from context pack first. Do not reread blocked paths or files you have already read several times; quote what you already saw instead.",
+      });
+    }
+
     throw new Error(`Unknown MCP tool: ${name}`);
   }
 
@@ -397,6 +517,9 @@ async function runMcpDoctor(deps) {
     "prismo_timeline",
     "prismo_replay",
     "prismo_boundaries",
+    "prismo_should_shield",
+    "prismo_loop_check",
+    "prismo_context_guard",
   ];
   const toolNames = tools.map((tool) => tool.name);
   const missingTools = requiredTools.filter((name) => !toolNames.includes(name));

package/package.json

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