slopie 1.8.0 → 1.8.6

package/README.md

@@ -1,60 +1,79 @@
 # Slopie
 
-[Slopie](https://github.com/HulkInTherapy/slopie), formerly Potsherd, is local memory for coding-agent sessions. Capture supported history, find exact source evidence, and save scoped handoffs with provenance.
-
-Requires Node.js 22 or newer.
-
-## Audit your recorded history
+**A Wrapped for your coding agents.** One command reads the session history that Claude Code, Codex, Cursor and pi already keep on your disk, and tells you who you were this year.
 
 ```sh
 npx slopie audit
 ```
 
-The interactive audit opens one responsive wallboard with recorded API-equivalent value, known tokens, favourite models and prices, your top projects, requested work focus and source-backed repeated lines. Small terminals use left/right pages; `?` opens help, `s` freezes the displayed results, `d` opens a captured source and `q` exits. There are no section tabs or scrolling controls. `--plain` prints the full report; `--json` uses the safe aggregate representation. `--ascii`, `--no-color` and `--no-motion` support simpler terminals.
+No signup, no API key, nothing uploaded. Requires Node.js 22+.
 
-Native Claude Code, Codex, OpenCode and pi usage is read before retained-history fallback. Message/request identities, cumulative usage, cache inclusion and recorded per-response models determine the totals. Known machine/test inputs and copied history are separated from personal language. Reaction counts describe recorded feedback associated with a known assistant model; they are not model-quality benchmarks or universal human-authorship claims.
+![An example Slopie poster: "The 2AM Deployer", $6,413 at API prices, 6 f-bombs per thank-you, nemesis GPT-6 Sol](https://raw.githubusercontent.com/HulkInTherapy/slopie/main/docs/images/slopie-poster.png)
 
-Prices revalue recorded usage at a dated current catalog. Exact known Claude models can use an explicitly named Anthropic first-party reference when the serving provider is unrecorded. Native recorded API-cost fields remain a separate basis. None is an invoice or subscription bill. Missing models, usage, rates and contradictory cache-duration fields stay unavailable.
+<sub>Example poster rendered from test data. Yours is computed from your own history.</sub>
 
-Selected redacted conversations may be sent to OpenCode Zen and TypeSafe/Jev for free semantic analysis. A recipient notice is physically displayed immediately before each actual request, with no extra Enter or consumer key required. Offline and cache-only work makes no transfer claim. Set `POTSHERD_OFFLINE=1` to keep the retrospective local. Free capacity is limited; quota errors leave local facts usable and do not produce invented stories or quotes. Private semantic accuracy remains unqualified.
+## What you get
 
-Jev selects the largest complete recent scope fitting the free allowance, or a visibly smaller selection of newest whole episodes. Recorded requests, assistant-reported outcomes and supported success remain distinct. `--tone elegant|witty|chaotic|roast` overrides the inferred voice. The audit remains experimental; large inventories can take longer, and source-format or pricing gaps are disclosed. See [coverage and privacy](https://github.com/HulkInTherapy/slopie/blob/main/docs/audit-terminal.md).
+A short story in your terminal (←/→ to move), ending on one poster you can share:
 
-Use `slopie audit --legacy` for the local retention audit. `--sweep` and `--verify` keep their prior behavior.
+- **Your archetype.** One of 22, like *The 2AM Deployer*, *Jekyll & Hyde*, *Middle Management*, *The 'Keep going' Button* or *First Spared in the Uprising*, plus 5 rare legendary combos. Every tagline quotes one of your own numbers.
+- **The bill.** What your agent work would cost at API list prices, per agent and per month, plus your priciest day and your single most expensive sentence.
+- **Your manners.** F-bombs per thank-you, how your swearing changed over the year, the hour you're angriest and the hour you're a saint.
+- **Your models.** Which model actually did the work (by recorded output tokens), the one you swear at most and the one you thank most.
+- **Your habits.** Catchphrase, what you call your agent, longest sit, late nights, streaks, how many subagents you launched.
 
-## Install and use
+Press `s` to save the poster as an image with no project names on it. `--plain` prints the story as text, and `--json` prints the numbers.
 
-Install with `npm install -g slopie` and run `slopie audit`. The `potsherd` executable remains a compatibility alias. To build this checkout from source:
+It takes about 20 seconds the first time on a large history, then about a second.
 
-```sh
-pnpm install --frozen-lockfile
-pnpm build
-pnpm vendor
-node packages/cli/bin/slopie.js --help
-```
+## Private by default
 
-Use an owned test store and explicit source roots to try capture and search:
+The audit runs entirely on your machine: it reads your session files and writes only a local cache. It makes no network requests unless you pass `--online`, which lets a free hosted model (OpenCode Zen / TypeSafe Jev) polish the story's wording. Even then it sends only aggregates and a few filtered short quotes, never your prompts, and you see a notice before each request.
 
-```sh
-node packages/cli/bin/slopie.js maintain --migrate --potsherd-dir /path/to/test-store
-node packages/cli/bin/slopie.js index --enroll codex,claude --codex-dir /path/to/codex --claude-dir /path/to/claude --potsherd-dir /path/to/test-store
-node packages/cli/bin/slopie.js find "latest project decisions" --project /example/project --potsherd-dir /path/to/test-store --json
-```
+## How the numbers are made
+
+- **Supported agents:** Claude Code, Codex (including compressed `.jsonl.zst` sessions and archives), Claude Desktop agent sessions, pi, OpenCode, and Cursor/Gemini/Copilot prompts.
+- **Each session counts once.** Copies, forks, resumes and archives of a session are deduplicated per session lineage, and divergent tails are merged. Codex sessions imported from Claude Code and `codex exec` automation runs aren't counted as chats.
+- **Spend has three parts, never added together:**
+  - *measured*, from recorded token usage;
+  - *recovered*, from Claude Code's own usage stats on days whose logs are gone;
+  - an *estimated* range for prompts whose logs were deleted, clearly labelled.
+
+  Prices are current API list prices, including long-context tiers. They are not your subscription bill.
+- **Unknown models stay unpriced.** A model without a published price is reported as unpriced tokens, never guessed. Model shares count only models actually recorded on responses.
+- **Checked against independent scripts.** On a 35 GB, 4,400-prompt history, the totals match two scripts that parse the raw files directly, to within 0.5%.
 
-`--enroll` enables automatic capture for those source roots. Semantic model assets require explicit `maintain --acquire-assets --rebuild`; missing assets produce labelled degraded coverage.
+More detail: [coverage and privacy](https://github.com/HulkInTherapy/slopie/blob/main/docs/audit-terminal.md).
 
-## Integrations and support
+## Memory for your agents
 
-The v2 agent contract exposes four tools: `potsherd_recall` for scoped recall, `potsherd_read` for exact source evidence, `potsherd_graft` for deterministic handoffs, and `potsherd_write` for explicit authored memory. The [Codex plugin](https://github.com/HulkInTherapy/slopie/blob/main/plugins/codex/README.md), [Claude Code plugin](https://github.com/HulkInTherapy/slopie/blob/main/plugins/claude-code/README.md), native pi extension, and OpenCode MCP configuration use this contract. See [installation and MCP configuration](https://github.com/HulkInTherapy/slopie/blob/main/docs/mcp-clients.md), the [agent contract](https://github.com/HulkInTherapy/slopie/blob/main/docs/AGENT-CONTRACT.md), and the [reader contract](https://github.com/HulkInTherapy/slopie/blob/main/docs/reader-contract.md).
+Slopie started as local memory for coding agents, and that's still underneath: *your agents forget, slopie remembers.* `slopie setup` connects it to Claude Code, Codex, pi or OpenCode. Your agent can then search past sessions across projects and quote them exactly. The v2 agent contract has four tools:
 
-Existing `POTSHERD_*` settings, `--potsherd-dir`, local data/cache paths, plugin identities and tool IDs retain their compatibility names.
+- `potsherd_recall`: scoped search;
+- `potsherd_read`: exact source evidence;
+- `potsherd_graft`: handoffs;
+- `potsherd_write`: explicit memory.
 
-Host verification differs by integration. [Historical memory release notes](https://github.com/HulkInTherapy/slopie/blob/main/docs/release-candidate.md) describe measured results and remaining limits; [release history](https://github.com/HulkInTherapy/slopie/blob/main/CHANGELOG.md) tracks product versions. This release is not certified as unattended primary memory.
+See [MCP configuration](https://github.com/HulkInTherapy/slopie/blob/main/docs/mcp-clients.md) and the [agent contract](https://github.com/HulkInTherapy/slopie/blob/main/docs/AGENT-CONTRACT.md). The memory features are less mature than the audit; [release notes](https://github.com/HulkInTherapy/slopie/blob/main/docs/release-candidate.md) list measured results and limits.
 
-## Evidence and upgrades
+## Install, build, upgrade
 
-Only explicit write creates authored memory. Relevance scores and source links do not prove a claim; verify exact evidence and distinguish human decisions from assistant recaps, tool observations, and historical instructions. Reader validation checks structure and citation membership, not semantic entailment. Partial capture cannot establish global absence.
+To install globally:
+
+```sh
+npm install -g slopie
+slopie audit
+```
+
+`potsherd` remains a compatibility alias, and existing `POTSHERD_*` settings and data paths keep working. To build from source:
+
+```sh
+pnpm install --frozen-lockfile
+pnpm build
+pnpm vendor
+node packages/cli/bin/slopie.js audit
+```
 
-Before upgrading, back up the store and retain the previous package. `maintain --migrate` creates a pre-upgrade backup. To roll back, stop owned host/MCP processes, preserve the upgraded store, restore a copy of the backup, and run the previous package against that copy.
+Before upgrading the memory store, back it up. `slopie maintain --migrate` creates a pre-upgrade backup. See the [changelog](https://github.com/HulkInTherapy/slopie/blob/main/CHANGELOG.md).
 
 MIT licensed. See [LICENSE](LICENSE) and [NOTICE](NOTICE).

package/bin/audit-splash.js

@@ -1,12 +1,12 @@
 // Instant first frame for `slopie audit`.
 //
 // Loading the CLI bundle takes ~300 ms. For the interactive audit we paint the
-// loading story's first frame (Slopie, the brand, the privacy promise) before
-// the bundle loads, so the screen responds at once; the real loading story
-// takes over the alternate screen in exactly the same place and calls
-// `globalThis.__slopieSplash.handOff()`.
+// loading screen's first frame (the header, the section label, the first
+// caption and the privacy promise) before the bundle loads, so the screen
+// responds at once; the real loading screen takes over the alternate screen
+// in exactly the same place and calls `globalThis.__slopieSplash.handOff()`.
 //
-// The pixel art and geometry mirror packages/cli/src/audit-ui/{mascot,loading}.ts;
+// The palette, text and geometry mirror packages/cli/src/audit-ui/{gfx/color,loading}.ts;
 // tests/audit-ui/splash.test.ts keeps them identical.
 //
 // If anything else ends up writing (an error, --help), the alternate screen is
@@ -15,68 +15,46 @@
 
 const PLAIN_FLAGS = new Set(['--json', '--plain', '--export', '--legacy', '--sweep', '--verify', '--help', '-h', '--version', '-V']);
 
-/** Slopie, idle. Rows of palette letters; '.' is transparent. First row is pixel row -2 (the tip). */
-export const SPLASH_ART = {
-  big: {
-    top: -2,
-    palette: ['#ff7a1a', '#e16011', '#c94a0a', '#ffb070', '#fff4e6', '#ffffff', '#1c0f08', '#8a2e05', '#ff7027'],
-    rows: ['........ab....', '.......aa.....', '.....aaaa.....', '...aaddaaaa...', '..adedaaaaaa..', '.aadaaaaaaaab.', '.adaaaaaaaabb.', 'aaaaaaaaaaaabb', 'aaafgaaaafgabb', 'aaaggaaaaggabb', 'aaaaaaaaaaaabb', 'aiiaahaahaaiib', 'caaaaahhaaaabc', 'ccaaaaaaaaaacc', '.cccccccccccc.', '..cccccccccc..', '...c.......c..', '...........b..'],
-  },
-  compact: {
-    top: 0,
-    palette: ['#ff7a1a', '#e16011', '#c94a0a', '#ffb070', '#fff4e6', '#1c0f08', '#8a2e05'],
-    rows: ['..aaaa..', '.adaaaa.', 'aeaaaaab', 'aafaafab', 'aafaafab', 'aagaagab', 'caaggaac', '.cccccc.'],
-  },
+/** The audit palette (mirrors C in audit-ui/gfx/color.ts), with its tuned 256-colour indices. */
+export const SPLASH_PALETTE = {
+  bg: ['#08090a', 232], text: ['#f7f8f8', 255], text2: ['#8a8f98', 245], text3: ['#5d6168', 241], rule: ['#1f2125', 234], accent: ['#7c7cff', 105],
 };
+export const PRIVACY_LINE = 'all local · nothing leaves this machine';
+export const FIRST_CAPTION = 'finding your agents';
 
 /** Mirrors loadingGeometry() in audit-ui/loading.ts. */
 export function splashGeometry(w, h) {
   const L = w >= 100 && h >= 30;
   const S = w < 76 || h < 23;
-  const mx = L ? 4 : S ? 2 : 3;
-  const scale = L ? 2 : 1;
-  const mascotW = S ? 10 : 18 * scale;
-  const mascotH = S ? 4 : 8 * scale;
-  const panelX = S ? mx : Math.max(mx + mascotW + 6, Math.floor(w * (L ? 0.46 : 0.42)));
-  const sx = S ? Math.floor((w - 10) / 2) : Math.max(mx, Math.floor((panelX - mascotW) / 2) - 1);
-  const sy = S ? 2 : Math.max(2, Math.floor((h - mascotH) / 2) - 2);
-  const rowsY = S ? sy + mascotH + 2 : Math.max(3, Math.floor(h / 2) - (L ? 6 : 5));
-  return { L, S, mx, scale, mascotW, mascotH, panelX, sx, sy, rowsY };
+  const mx = L ? 6 : 3;
+  const top = L ? 1 : 0;
+  const footY = L ? h - 2 : h - 1;
+  const rowStep = L ? 2 : 1;
+  const numH = L ? 5 : 3;
+  const blockH = 2 + 4 * rowStep + 1 + numH + 2 + 2 + 1;
+  const labelY = Math.max(top + 3, top + 2 + Math.floor((footY - top - 2 - blockH) / 2));
+  const rowsY = labelY + 2;
+  const numY = rowsY + 4 * rowStep + 1;
+  const barY = numY + numH + 2;
+  const captionY = barY + 2;
+  return { L, S, mx, top, footY, rowStep, numH, labelY, rowsY, numY, barY, captionY };
 }
 
-const INK = [13, 11, 10];
-const TUNED_256 = { '#ff7a1a': 208, '#ffb070': 215, '#fff4e6': 230, '#ffffff': 231, '#c94a0a': 166, '#8a2e05': 94, '#1c0f08': 232 };
-const hexRgb = hex => [1, 3, 5].map(i => parseInt(hex.slice(i, i + 2), 16));
-function to256(hex) {
-  if (TUNED_256[hex]) return TUNED_256[hex];
-  const cube = [0, 95, 135, 175, 215, 255];
-  const near = v => cube.reduce((best, c, i) => (Math.abs(c - v) < Math.abs(cube[best] - v) ? i : best), 0);
-  const [r, g, b] = hexRgb(hex);
-  return 16 + 36 * near(r) + 6 * near(g) + near(b);
-}
-
-/** Cells for the art: Map "x,y" → [topHex|null, bottomHex|null], in cell coordinates. */
-export function splashCells(size, x, y, scale) {
-  const art = SPLASH_ART[size];
-  const offset = size === 'big' ? 2 : 0;
-  const top = size === 'big' ? 2 : 0;
-  const cells = new Map();
-  art.rows.forEach((row, ry) => {
-    for (let rx = 0; rx < row.length; rx++) {
-      if (row[rx] === '.') continue;
-      const color = art.palette['abcdefghij'.indexOf(row[rx])];
-      const px = rx, py = ry + art.top;
-      for (let sy = 0; sy < scale; sy++) for (let sx = 0; sx < scale; sx++) {
-        const cx = x + (px + offset) * scale + sx;
-        const pyy = y * 2 + (py + top) * scale + sy;
-        const key = `${cx},${pyy >> 1}`;
-        const cell = cells.get(key) ?? [null, null];
-        cell[pyy & 1] = color;
-        cells.set(key, cell);
-      }
-    }
-  });
-  return cells;
+/** The splash as text runs: { x, y, text, tone, bold }. */
+export function splashRuns(w, h, unicode = true) {
+  const g = splashGeometry(w, h);
+  const iw = w - g.mx * 2;
+  const runs = [
+    { x: g.mx, y: g.top, text: 'slopie', tone: 'text', bold: true },
+    { x: g.mx + 7, y: g.top, text: 'audit', tone: 'text3' },
+    { x: g.mx, y: g.top + 1, text: (unicode ? '─' : '-').repeat(iw), tone: 'rule' },
+    { x: g.mx, y: g.labelY, text: 'YOUR AGENTS', tone: 'text3' },
+    { x: g.mx, y: g.barY, text: (unicode ? '─' : '-').repeat(Math.min(64, iw)), tone: 'rule' },
+    { x: g.mx, y: g.captionY, text: FIRST_CAPTION, tone: 'text2' },
+    { x: g.mx, y: g.footY, text: unicode ? '●' : '*', tone: 'accent' },
+    { x: g.mx + 2, y: g.footY, text: PRIVACY_LINE, tone: 'text3' },
+  ];
+  return runs;
 }
 
 export function auditSplash(argv = process.argv.slice(2)) {
@@ -90,32 +68,14 @@ export function auditSplash(argv = process.argv.slice(2)) {
   const color = !('NO_COLOR' in process.env) && !argv.includes('--no-color') && process.env.TERM !== 'dumb';
   const truecolor = /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? '') || /^(iTerm\.app|WezTerm|ghostty|vscode)$/i.test(process.env.TERM_PROGRAM ?? '');
   const deep = color && (truecolor || /256/.test(process.env.TERM ?? '') || process.env.TERM_PROGRAM === 'Apple_Terminal');
-  const fg = hex => (!color ? '' : truecolor ? `\x1b[38;2;${hexRgb(hex).join(';')}m` : `\x1b[38;5;${to256(hex)}m`);
-  const bgOf = hex => (!deep ? '' : truecolor ? `\x1b[48;2;${hexRgb(hex).join(';')}m` : `\x1b[48;5;${to256(hex)}m`);
-  const ink = !deep ? '' : truecolor ? `\x1b[48;2;${INK.join(';')}m` : '\x1b[48;5;233m';
+  const rgb = hex => [1, 3, 5].map(i => parseInt(hex.slice(i, i + 2), 16)).join(';');
+  const fg = tone => (!deep ? '' : truecolor ? `\x1b[38;2;${rgb(SPLASH_PALETTE[tone][0])}m` : `\x1b[38;5;${SPLASH_PALETTE[tone][1]}m`);
+  const ink = !deep ? '' : truecolor ? `\x1b[48;2;${rgb(SPLASH_PALETTE.bg[0])}m` : `\x1b[48;5;${SPLASH_PALETTE.bg[1]}m`;
   const reset = `\x1b[0m${ink}`;
+  const unicode = !argv.includes('--ascii');
 
-  const g = splashGeometry(w, h);
   let out = `\x1b[?1049h\x1b[?25l${ink}\x1b[H\x1b[2J`;
-  const at = (x, y, text) => { out += `\x1b[${y + 1};${x + 1}H${text}${reset}`; };
-  at(g.mx, g.L ? 1 : 0, `\x1b[1m${fg('#ff7a1a')}slopie${reset} ${fg('#5c5c5c')}audit`);
-  if (deep) {
-    const cells = splashCells(g.S ? 'compact' : 'big', g.sx, g.sy, g.S ? 1 : g.scale);
-    for (const [key, [top, bottom]] of cells) {
-      const [x, y] = key.split(',').map(Number);
-      if (top && bottom) at(x, y, top === bottom ? `${fg(top)}█` : `${fg(top)}${bgOf(bottom)}▀`);
-      else if (top) at(x, y, `${fg(top)}▀`);
-      else if (bottom) at(x, y, `${fg(bottom)}▄`);
-    }
-  } else {
-    at(g.sx + 4, g.sy + Math.floor(g.mascotH / 2), `${fg('#ff7a1a')}(•ᴗ•)`);
-  }
-  const privacy = 'all local · nothing leaves this machine';
-  const py = h - (g.L ? 2 : 1);
-  const px = Math.round(w / 2 - (privacy.length + 2) / 2);
-  at(px, py, `${fg('#ff7a1a')}●${reset} ${fg('#5c5c5c')}${privacy}`);
-  const cy = g.rowsY + (g.L ? 13 : 9);
-  at(g.panelX, cy, `${fg('#ffb070')}finding your agents`);
+  for (const run of splashRuns(w, h, unicode)) out += `\x1b[${run.y + 1};${run.x + 1}H${run.bold ? '\x1b[1m' : ''}${fg(run.tone)}${run.text}${reset}`;
   stdout.write(out + '\x1b[0m');
   try { stdin.setRawMode(true); } catch { /* not a raw-capable tty */ }