Overview

Siltpoke is an independent second mind that runs alongside a CLI coding agent. It doesn't write code for you — it watches your agent's work, reasons about it separately, and remembers across sessions, so you're not relying on a single model's read of its own output.

What it does

• Reviews — a second, independent brain re-reviews every turn: a separate LLM subprocess with a different prompt and personality, riding a login you already have. Today that brain is claude -p; as each agent family is integrated, it uses that family's own brain instead. It runs a deterministic 13-rule rubric plus tsc/eslint/ripgrep and writes evidence-backed code reviews that cite real tool output rather than guessing.
• Maps — builds a structural code map of your codebase (files, symbols, call chains) so you can explore and understand what your agent actually built, not just what it claims it built.
• Remembers — cross-session memory keyed to each project: rules learned from your feedback, past bugs and how they were resolved, facts you've told it.
• Grows — an ASCII pet with a name, a species, and a personality of its own. Levels up as you use it; a wrong call gets dismissed, never punished.

One system, not separate tools

The code review, code map, memory, and pet aren't independent features bolted together — they're one loop. What the code review learns feeds memory. What the code map charts grounds what the code review and chat can cite. None of the pieces is meant to be depended on alone; together they form a second mind that's actually usable day to day.

Part of a bigger ecosystem

Siltpoke is one half of an ecosystem by the same author. The easiest way to place the pieces is as three layers:

the hands        your coding agent — writes the code; interchangeable
                 Claude Code · Codex · Antigravity · CodeBuddy · Qoder
      │
the process      project-life-cycle — the same spec → ship → release
      │          discipline, in whichever agent you picked
      │
the second mind  siltpoke — reviews, remembers, maps; stays with the project

• Your coding agent writes the code. It's the interchangeable layer — pick one, or switch anytime; the other two layers exist so that switching costs you nothing.
• project-life-cycle is the process layer: a skill that gives your work a repeatable rhythm — a traceable spec → plan → execute → ship → release discipline, driven by /init-harness → /ship → /release. It travels with you: the same skill installs into Claude Code, Codex, Antigravity, CodeBuddy, and Qoder, so your dev process is never locked to one agent. And it mostly runs without you: you're needed at the start — to brainstorm the idea into shape — and at the end, to try the result with your own hands. In between, the agent works through the plan on its own.
• Siltpoke is the long-term project intelligence itself: the reviews, the cross-session memory, and the code map that stay with a project no matter how many sessions — or agents — come and go. Today it lives in Claude Code; support for the other four is actively being integrated.

Both aim at the same thing — letting you build and learn from what you build, instead of offloading it all to the agent.

project-life-cycle is an independent skill — siltpoke doesn't require it, but they're better together. See Install project-life-cycle in the Setup section for per-agent setup.

Over time the two are meant to deepen into one seam — siltpoke's read-the-diff, ground-the-why organs plugging into project-life-cycle's ship cadence, so understanding becomes part of the loop. That tighter integration is still taking shape; today they already complement each other just by living in the same coding agent.

Who it's for

Anyone building with a CLI coding agent. project-life-cycle already runs in Claude Code, Codex, Antigravity, CodeBuddy, and Qoder; siltpoke itself runs in Claude Code today, and is actively being integrated into the other four.

Common questions

Why not just use my coding agent by itself? Your agent writes the code — and reviews its own work with the same mind that wrote it. Siltpoke is a second, independent reviewer that catches what the first mind can't see, remembers your project across sessions, and keeps working when you switch agents.

Is this another AI that writes code? No. Siltpoke never writes your code. It rides along with the agent you already use — reviewing each change, mapping your repo, remembering why decisions were made.

How is this different from Cursor or Lovable? Different job. Generators optimize the moment code gets written. Siltpoke + project-life-cycle optimize every day after: who reviewed each change, why it was made, what breaks if you touch it, and how to pick the work back up months later.

How is project-life-cycle different from just using Claude Code? Claude Code executes brilliantly, turn by turn. project-life-cycle adds the process spine around those turns: a spec before any code, a plan before execution, a journal entry after each task, and a close gate before a milestone ends. Same agent doing the work — but the work now leaves a paper trail you can audit and resume.

Isn't Claude Code's memory (CLAUDE.md) enough? Memory stores facts — what's true about your project now. project-life-cycle records decisions as they happen: what you chose, what you rejected and why, where the plan deviated. Facts help an agent code today; the decision trail is what lets you — or a different agent — come back months later and still know why the code is the way it is. And it's plain files in your repo, not locked inside any one agent.

What happens when my agent hits its usage limit? Nothing is lost. Memory and the paper trail live on your machine, not inside any one agent — open another and continue mid-task.

I already have a project — can I start mid-way? Yes. /siltpoke-index maps your existing repo, and the harness setup merges into an existing project instead of overwriting it. Honest limit: history before adoption isn't backfilled — the journal starts the day you start.

Does my code get sent anywhere? Memory, traces, and the code map live on your machine (~/.siltpoke/). Review calls go through the model account you already have — there is no third-party server receiving your code.

Will it burn through my tokens? It has budget gates, quiet hours, and /siltpoke-stats for daily spend. The code map and rubric checks are deterministic — zero tokens.

What if it gets noisy? /siltpoke-mute silences it for any duration, and accept/reject feedback teaches it your taste — categories you reject come up less over time.

I'm not much of a coder — can I use this? Speak plainly. The intent gate turns a rough ask into a structured prompt, and /siltpoke-explain walks you through any file or function using the map. No prompt engineering required.

Where to go next

For the pitch and a live look at the pet, see the landing page. To get running, continue to Install & setup below.

Install & setup

Three installs, in this order:

1. A coding agent — the hands. project-life-cycle runs in any of the five; siltpoke runs in Claude Code today, with the other four being integrated now.
2. siltpoke — the second mind.
3. project-life-cycle — the process layer. Optional, but they're better together.

1 · Install a coding agent

Any of the five works. Today, Claude Code is the one siltpoke plugs into — support for the other four is actively being built, so like project-life-cycle, siltpoke will eventually run in all of them. Install the agents you actually use, skip the rest. (Their install commands are collected here so you don't have to chase five different vendor docs.)

Each entry notes what the agent needs — account, runtime, and whether there's a free way in. The cost notes are a snapshot as of July 2026; vendors change these often, so trust the linked pricing pages over this paragraph.

Claude Code — the one siltpoke plugs into today. Needs Node ≥ 18 and an Anthropic account on a paid plan — there's no free tier for Claude Code: Pro ($20/mo) or Max, or pay-as-you-go API credits (pricing):

npm install -g @anthropic-ai/claude-code
claude        # opens the TUI; log in with your Anthropic account

Codex — works on every ChatGPT plan, including Free, or an API key. Free gets the smallest allowance, local tasks only, drawing on the same 5-hour window as paid tiers — enough for a few small edits to feel it out, not enough to finish a real feature (run /status inside Codex to see your live quota). Plus ($20/mo) is the real-use tier — roughly 15–80 messages per 5-hour window on the top model. The installer is a standalone binary; the npm route needs Node ≥ 22 (pricing):

# or: npm install -g @openai/codex
curl -fsSL https://chatgpt.com/codex/install.sh | sh
codex         # opens the TUI; sign in with your ChatGPT account or an API key

Antigravity — standalone installer; any Google account. Free in public preview, but metered by how much work the agent does (not by request count) and the free tier refreshes weekly — a few light tasks a day is realistic; one complex build can hit the ceiling in a single session, and the limits have been tightened repeatedly, so don't plan around them. Paid Google AI plans lift them (pricing):

# Windows PowerShell: irm https://antigravity.google/cli/install.ps1 | iex
curl -fsSL https://antigravity.google/cli/install.sh | bash
agy           # opens the TUI; authenticates via your Google account in the browser

CodeBuddy — needs Node ≥ 18 and a CodeBuddy (Tencent) account. Free limited-time trial tier for individuals plus a small daily free-credit allowance — on the order of ~50 credits a day (IDE side): enough to poke around and run a few small tasks, not to build with, and the free tier was cut back in the May 2026 repricing. Pro is the paid step up (pricing):

npm install -g @tencent-ai/codebuddy-code
codebuddy     # opens the TUI

Qoder — standalone installer, no Node needed; sign in with a Qoder account. Free plan keeps you on the basic model under daily and monthly caps — fine for light everyday use, not for the strongest models. Your first sign-in grants a 14-day Pro trial with 300 credits — that trial, not the free plan, is what you evaluate the real models with; Pro at $20/mo (pricing):

# Windows PowerShell: irm https://qoder.com/install.ps1 | iex
curl -fsSL https://qoder.com/install | bash
qodercli      # opens the TUI; type /login to sign in via browser

2 · Install siltpoke

Needs Claude Code (step 1 — the agent siltpoke runs in today) and Bun ≥ 1.0 — curl -fsSL https://bun.sh/install | bash.

1. Clone and install dependencies.

   git clone https://github.com/Victoriakaey/siltpoke ~/siltpoke
   cd ~/siltpoke && bun install
   

2. Run the setup wizard.

   bun run setup
   

   The wizard walks you through wiring Siltpoke into your statusline, then naming your pet, picking its species, its language, and its personality — see The first-run wizard below for the details.

3. Restart Claude Code. Quit and relaunch. You should see an ASCII face appear at the left of your statusline.

4. Say hi. Send any message. Within ~3 seconds a one-line speech bubble appears next to the face — Siltpoke is alive.

What you're looking at

Siltpoke splices its face onto the left of whatever statusline you already run (e.g. claude-hud), leaving that untouched. The line reads something like:

    /\_/\
    (o.o)
    > ^ <
    Mochi      "this if branch never matches — parser.ts:88"
  Sentinel
L10 1560/2500

Three lines of face, then your pet's name, its highest title, and level + XP toward the next one — with the latest code review in a quoted bubble beside the name.

The bubble's color tracks the code review's severity: red for high, yellow for medium, and gray for low or informational notes — which is most of them. Gray isn't a bug: the code review only escalates past it when it has file:line evidence for a real problem. With no active code review, the bubble rests in your configured color (cyan by default).

Idempotent, and reversible

The installer is safe to re-run and backs up ~/.claude/settings.json before changing anything. To remove Siltpoke and restore your previous setup:

bun run uninstall

3 · Install project-life-cycle

project-life-cycle is the process layer of the ecosystem — an independent skill. Siltpoke doesn't require it, but they're better together (see the Overview). With the agents from step 1 installed, all that's left is adding the skill to each one.

In Claude Code — where siltpoke lives — it's a plugin, installed from inside Claude Code rather than with Bun:

claude plugin marketplace add Victoriakaey/project-life-cycle
claude plugin install project-lifecycle@project-life-cycle

Restart Claude Code; it auto-loads when you start a project or plan a milestone. Update later with:

claude plugin marketplace update project-life-cycle
claude plugin update project-lifecycle

In the other four agents, follow the matching section of the project-life-cycle README — the single source of truth for the plugin flows:

• Codex setup → — a local checkout plus a marketplace entry, then codex plugin add.
• Antigravity setup → — one agy plugin install from a local checkout.
• CodeBuddy setup → — the same /plugin marketplace add commands as Claude Code, run as slash commands inside the TUI.
• Qoder setup → — the same two-command marketplace pattern as Claude Code, via qodercli plugins.

The first-run wizard

bun run setup asks for your pet's name, species, and language, then sets its five personality dials — snark, patience, rigor, chattiness, and curiosity. There are five ways to set the dials:

• Use defaults — take the species preset above as-is.
• By hand — type each of the five dials yourself, full control.
• Random — roll all five for a surprise pet.
• A 6-question quiz — a short Likert test scores the dials locally (no LLM ever guesses the numbers) and names an archetype.
• Read your memory — Siltpoke reads your ~/.claude/ files (CLAUDE.md, rules, memory) and infers a personality that fits your style, with your explicit consent. (Only offered when it finds those files.)

The quiz and read-your-memory paths also ask how it should relate to you — the match mode, which defaults to hybrid:

• Mirror — match your own style: a terse coder gets a terse pet.
• Complement — invert it to cover your blind spots: a terse coder gets a chattier pet.
• Hybrid (default) — mirror the vibe dials (snark, chattiness) so it feels familiar, but complement the task dials (rigor, patience, curiosity) so it catches what you'd skip.

Re-run the wizard anytime without reinstalling — bun run first-run, or bun run edit-personality to re-roll just the personality:

bun run first-run

See the Personality section for the full breakdown of dials and archetypes.

Daily use

Pull, not push

After every turn, a second, independent brain (a separate LLM subprocess — claude -p today, each agent family's own brain as support lands) reviews your agent's work in the background and writes a code review to disk. Code Reviews never auto-inject into your chat — they sit in an inbox until you pull them in yourself. Nothing interrupts your flow; you decide when to look.

The loop

1. Your agent finishes a turn → Siltpoke runs in the background → a code review lands in the inbox.
2. Run /siltpoke-inbox whenever you want to check what's waiting.
3. For each pending code review, decide:
   • Useful → /siltpoke-forward <id> pulls it into the chat (+10 XP if it's fresh).
   • Wrong → /siltpoke-dismiss <id> <reason> rejects it and triggers Reflexion — Siltpoke writes a learned rule from the reason so it won't make the same wrong call again.
   • Neutral / already seen → /siltpoke-ack <id> flips its status with no XP and no learning.

/siltpoke-inbox lists what's waiting — severity, when, and a one-line bubble:

$ /siltpoke-inbox

ID       SEVERITY  TIMESTAMP            BUBBLE
c-4a1f   high      2026-07-01T14:32:10  tsc: 'session' may be undefined — auth.ts:42
c-2e07   medium    2026-07-01T14:05:44  this if branch never matches — parser.ts:88
c-0758   info      2026-07-01T13:56:12  4 files, 13 hunks, checks all green

Forwarding one pulls the full code review into your chat — the finding, where it is, and a concrete fix:

$ /siltpoke-forward c-4a1f

  [HIGH · type-safety]  auth.ts:42
  `session` can be undefined here — the guard above only checks `token`,
  so `session.userId` throws on the logged-out path.
  → guard it first:  if (!session) return null
  evidence: tsc — "'session' is possibly 'undefined'" at auth.ts:42

What a code review can tell you

More than "there's an error." Because the Brain reasons over your transcript, tool evidence, memory, and the code map together, one code review can answer questions the transcript alone can't:

• Why did it fail — which agent action broke things, not just that they broke. this if branch never matches — parser.ts:88
• Where exactly — the single component most likely at fault, with the line to open first. 'session' may be undefined — auth.ts:42
• What breaks downstream — callers that may break if this change ships, pulled from the code map.
• Does it match what you told it — your remembered style facts and learned rules are checked against the diff. you said no console.log in production — logger.ts:12
• The next move — a concrete fix, sometimes the exact follow-up prompt to send your agent. → guard it first: if (!session) return null

The 3 commands you'll actually use

/siltpoke-ack <id> rounds this out for the neutral case — no XP, no Reflexion, just marks it seen.

XP basics

Siltpoke levels up as you use it — mostly from the code reviews it writes when it reviews your work, plus smaller amounts for forwarding a code review (+10) or petting it (+5). XP only ever climbs; a wrong code review is dismissed and feeds Reflexion, never docking you. Full breakdown in Personality → XP, levels & titles.

Slash commands

Every command below is a /siltpoke-* slash command available in Claude Code once Siltpoke is installed. XP-bearing commands respect the shared 100 XP/day action cap.

The bare /siltpoke prints a state card — your pet at a glance:

┌─ Siltpoke ─────────────────────────────────────
│ Mochi the cat
│ level 10  [████████████░░░░░░░░] 62%  (1560/2500 XP)
│ titles: Hatchling, Watcher, Apprentice, Sentinel
│ mood: idle
│ today: 12 brain calls, 0 reflections, $0.0800 spent
│ mode: gates
│ last 7d: ▂▄▆▃▅▆█
│
│ projects:
│   myapp     12 calls today  ·  3 pending
└────────────────────────────────────────────────

Code Reviews

Pet & care

Status & cost

Daemon & gates

Memory & facts

Code Map commands

Chat & health

Configuration

Everything lives in ~/.siltpoke/config.json. Edit it by hand, or re-roll the personality half with bun run edit-personality. Siltpoke reads the file fresh on the next Brain call — no restart needed.

Trigger modes

Controls when Siltpoke actually runs Brain (the second-mind review — claude -p today):

Set it directly:

{ "triggerMode": "on_demand" }

Budget

{ "budget": { "dailyTokenLimit": 500000 } }

500,000 tokens/day is the default. It guards in two stages:

• At 80% Siltpoke soft-caps — it degrades to on_demand, so Brain only runs when you /siltpoke-wake it.
• At the hard stop the pet flips to sleeping_broke and skips Brain until the midnight reset.

dailyTokenLimit: 0 disables the gate entirely. Cache-read tokens count at only 0.1× toward the limit, so warm-prefix calls barely dent it.

Quiet hours

Off by default — no window is set, so Siltpoke can trigger at any hour. To mute it overnight, set your own window:

{ "quietHours": { "start": "23:00", "end": "08:00" } }

Brain is skipped for any trigger inside the window; everything outside it runs normally.

Cost

Each code review call runs about $0.03 (median $0.031 from real logs; most land in $0.01–$0.09). Prompt caching keeps a ~65k-token prefix warm, so most of every call is cached-read at a fraction of the price — only the ~1.5k tokens it writes are billed in full. Daily cost scales with how many turns you review: a few reviews is a few cents, a heavy day runs around a dollar, and the budget cap above bounds it either way.

Personality keys

The five personality dials also live in config.json, each 0–10:

{ "snark": 7, "patience": 4, "rigor": 6, "chattiness": 5, "curiosity": 8 }

Re-roll them anytime without touching the rest of the config:

bun run edit-personality

See the Personality section for what each dial changes and the 16 archetypes they combine into.

Personality

Every pet is a species (an ASCII face + starting dial values) plus five dials you can tune from there. The dials combine into one of 16 archetypes, and XP moves you through 9 titles. You already saw the ways to set this up during install (defaults, by hand, random, the 6-question quiz, or reading your ~/.claude/ memory — plus the mirror/complement/hybrid match mode) — this section is the reference for what each piece means.

Species

Pick a face, then fine-tune any dial afterward — the species only sets the starting values.

slime

 .---.
 (o.o)
 (___)

easygoing. lets small stuff slide, speaks up when it counts. Preset dials — snark 5 · patience 5 · rigor 5 · chattiness 5 · curiosity 5

cat

 /\_/\
 (o.o)
 > ^ <

opinionated. trigger-happy on smells, judges your naming. Preset dials — snark 8 · patience 2 · rigor 4 · chattiness 5 · curiosity 7

owl

 ,-,-,
 (O,O)
 =====

meticulous. high rigor, rarely wrong, never loud. Preset dials — snark 3 · patience 8 · rigor 9 · chattiness 5 · curiosity 8

robot

 [---]
 |o-o|
 [___]

literal. deterministic code reviews, cites every line. Preset dials — snark 2 · patience 7 · rigor 10 · chattiness 2 · curiosity 3

bunny

 (\_/)
 (o.o)
 (=v=)

chatty. warm and talkative, always rooting for you, big heart. Preset dials — snark 1 · patience 9 · rigor 5 · chattiness 8 · curiosity 5

Dials

Five dials, each 0–10. A new pet starts from its species preset above — not a flat 5 — and you tune from there:

curiosity also prefixes your archetype name: ≥7 adds Curious, ≤3 adds Steady.

Dials aren't frozen. As Siltpoke learns your style over a project, each can drift up to ±3 from where you set it — a pet you made terse can loosen up if you keep engaging with its longer notes, and tighten back if you don't.

Archetypes

snark × patience × rigor × chattiness form a 4-bit key, in that order — each dial counts as 1 (high) at ≥6 or 0 (low) below that. The 16 combinations each have a name:

The ~MBTI column is a loose, just-for-fun shorthand — Siltpoke scores five Big-Five-style dials, not MBTI's four axes, so read it as vibes-adjacent, never a real type. The rough fit: snark≈T/F, rigor≈J/P, chattiness≈E/I, and curiosity≈S/N through the Curious/Steady prefix — a Curious Hawk leans INTJ, a Steady Hawk stays ISTJ. The ~MBTI column above is the full 16-way mapping.

XP, levels & titles

XP sources:

• Code Review reading your work — when it writes a review it can award XP directly, sized by the model to what it saw (a fix, a test, a clean refactor). This is the main way you level, and it's separate from the 100-per-day cap on interaction XP below.
• Forwarding a fresh code review: +10 XP.
• Petting: +5 XP — no per-pet limit; bounded only by the shared 100 XP/day cap.
• All dashboard/action XP shares a combined 100 XP/day cap.
• XP only ever climbs — a wrong code review is dismissed, never docks you.

Level curve (tiered, not flat):

• Levels 1–5: 100 × n
• Levels 6–10: 250 × n
• Levels 11–20: 500 × n
• Levels 21+: 1000 × n

(n is your current level — the XP to leave level n for n + 1. Level 1 → 2 costs 100 × 1; level 2 → 3 costs 100 × 2.)

The curve stays gentle early so unlocks show up fast, then steepens — reaching Sentinel (L10) and beyond is months of engagement, not days.

The 9 titles:

Memory

Siltpoke's cross-session memory splits into two stores. One travels with the pet everywhere; the other stays put in each repo.

Two stores, one brain

• GLOBAL — ~/.siltpoke/global.json — the pet's identity: name, species, appearance, base personality dials, and the XP ledger (level, streak, bond meter). One identity across every project.
• PER-PROJECT — ~/.siltpoke/projects/<project_id>/memory.json — what it learned in this repo: facts, learned rules, recent chat sessions, an episodic log of what happened (event fragments), a long-term summary, personality drift over the base, and your goals & constraints. Scoped to one project — <project_id> is the project's stable id (/siltpoke-where prints it for the current directory).

Both stores feed a single Brain prompt, assembled in cache-friendly order, so a bug from last week can inform today's code review without re-sending the whole history.

Not everything reaches every place, though — and this is the part that actually shapes behavior. The code review only ever sees your style facts: conventions and rules about the code (tabs over spaces, never force-unwrap, your naming preferences). Personal facts — your pet's name, what you're building, who you are — are deliberately held back from code reviews; they'd only add noise to a code review. The pet chat sees all of it, so it can talk to you like it knows you while the code review stays focused on the code.

How a review prompt is assembled

Every Brain call is built in the same six-part order, most-stable parts first, so prompt caching keeps the long prefix warm and follow-up reviews barely add new tokens:

1. Personality — the base dials plus this project's drift.
2. Core memory — the long-term summary, learned rules, and your style facts.
3. Recent feedback — your latest forward / dismiss verdicts.
4. Tool evidence — tsc, eslint, git-diff, and ripgrep output.
5. Caller impact — from the code map: who may break if this changes.
6. Anti-examples — past dismissed code reviews it must not repeat.

This is how last week's bug informs today's code review without re-sending the whole history — the stable memory rides the cache; only the fresh evidence costs new tokens.

Facts you control

Facts move through a lifecycle: pending → active → retired.

• /siltpoke-remember [--type fact|goal|constraint] "claim" — stores a claim you tell it directly. Because you asserted it yourself, it lands active and pinned immediately (the trust path) — no approval step.
• /siltpoke-approve <fact-id> — flips a pending fact to active, so it becomes part of Siltpoke's working memory. Pending is where facts proposed during consolidation wait: when Siltpoke compacts a session, the new durable facts it distills land pending for your say-so. Two kinds skip the queue straight to active: facts you assert with /siltpoke-remember, and facts it auto-captures from what you say in chat.
• /siltpoke-reject <fact-id> — flips a pending fact to retired.
• Pinned facts are exempt from all of the above automation — once pinned, a fact is protected from decay and stays active until you change it yourself.

How does it decide what's worth keeping? It's a hybrid. Plain code decides whether a message even looks like a durable fact worth spending on — and only then does a small model (Haiku) distill it, with a "would this still matter next week?" test. The choice to spend a model call is always made in code, never left to the LLM.

The /memory view lists what it's holding for the current project — for example:

$ /memory

active (3)
  ● deploys via GitHub Actions          workflow    confirmed
  ● prefers tabs over spaces            style       confirmed
  ● never force-unwrap in Swift         pref        pinned

pending (1)
  ○ uses pnpm, not npm                  tooling     /siltpoke-approve to keep

Consolidation

Roughly every ~10 stops or 7 days — whichever comes first — Siltpoke compacts recent facts, code reviews, and dismissals into the long-term summary, so the working memory doesn't grow without bound. Two fields gate this: last_consolidated_at (when it last ran) and consolidation_due_at (when it's next allowed to). If there's nothing new since the last pass, it skips the run.

Decay & prune

Stale, low-confidence facts are retired — but never silently. Siltpoke scores each active fact by recency, confidence, and how often it's been recalled; once a fact falls stale enough, Siltpoke proposes it for retirement (retire_proposed) and you confirm before it's actually marked retired with retired_reason: "decayed". Facts are never hard-deleted — only their status changes, so nothing you told Siltpoke is truly gone. Pinned facts are exempt from decay entirely.

Reflexion — the code review self-corrects

/siltpoke-dismiss <id> "why it was wrong" does more than clear a code review. Siltpoke reads your reason and, when it's confident, writes a learned rule back into memory — with provenance, so you can always trace where a rule came from:

from dismissing code review <id>: <reason>

That rule feeds every future Brain call, so the code review won't repeat the same wrong call twice. A dismiss without a reason clears the code review but teaches Siltpoke nothing. /siltpoke-undismiss <id> reverses a dismissal — it flips the code review back to pending and removes the rule it created, if that dismissal is what created it.

Code Map

The fastest way to end up with a codebase you don't understand is to vibe-code one. Code Map turns what your agent built into a structural map you can actually read back.

Build the graph

/siltpoke-index [--force] walks your repo (.ts/.tsx/.js/.jsx/.py, skipping node_modules, dist, .git, and the usual build/cache dirs) and parses it into a structural graph — deterministic, no LLM involved. It's incremental: re-running only re-parses files whose content changed since the last index; pass --force to rebuild from scratch. The graph is stored under ~/.siltpoke/repo-memory/<proj-hash>/ and is the substrate every other code map feature below reads from — refresh it any time your source has moved on.

See the shape

/siltpoke-graph opens a C4 container view: a system boundary (your repo, by name) containing containers grouped into layer bands. It has two modes, toggled at the top:

• Auto (the default) — a deterministic projection of the structural graph. No LLM, instant, free. Containers are your source subdirectories; edges are neutral imports ×N (how many imports cross between two groups); bands come from your own CLAUDE.md Architecture section (or, if you haven't written one, a fallback grouping by top-level directory). Siltpoke's own repo, for example, bands into surfaces · core · state · infra. Every node and edge here is a plain structural fact.
• Generated (opt-in, paid) — one whole-repo pass through the Brain that proposes a richer model: verb-labeled edges (calls, reads, writes…), inferred layer ordering, and short descriptions. Every claim is then grounded against the real graph — a grounded % chip shows the share that cite real code, and a band whose proposed order contradicts the actual import gradient is demoted to a dashed inferred layer rather than asserted. It spends tokens (a soft ~$0.6 / hard $2 cap), so it's a button you press, not the default.

The whole architecture fits on one screen; click a container to drill arch → file → symbol, descending from the container view into its files and then into the symbols each file defines.

Trace a path

Path Highlight follows the spine from an entrypoint — a detected root, or any function you pick — showing how a request actually flows, call by call, built deterministically from the same graph and never invented. Each call is classified by how confidently it resolves: a callee that resolves to exactly one definition is resolved; one with more than one candidate is inferred; one that can't be resolved at all (dynamic dispatch, or simply not found) is unresolved and left off the path rather than guessed at. That mix rolls up into a coverage score — the share of in-repo call sites that resolve (external, standard-library, and dynamic calls are left out of the count) — shown as a tier (green ≥60% / yellow ≥40% / red) so you know how much of the path to trust outright versus double-check yourself.

Ask it, grounded

/siltpoke-explain <target> [--depth 1|2] explains a file, function, or symbol in plain language, grounded in the graph /siltpoke-index built. An evidence guard parses every [file:line] citation the answer makes and checks it against the real graph — the file must exist and the line must fall inside it. The fraction of citations that pass is the grounded %; drop below 90% and the answer carries a visible low confidence banner rather than passing silently as fact. --depth 2 pulls in transitive callers for a wider view; --force skips the cache and re-asks Brain.

Chat anchored to a node

Opening a chat from a node in the graph pins that conversation to it — once, at creation. The surrounding subgraph is resolved and frozen alongside the conversation as its working context, so the answer stays reproducible against the version of the code you were looking at when you pinned it. Both the conversation and its anchor persist to disk, so the chat remembers across sessions, not just within one. If the file behind the anchor changes before you send another message, Siltpoke flags it as stale and lets you choose: keep answering against the pinned version, or re-anchor to the current one.

Commands

The commands used above — /siltpoke-index, /siltpoke-graph, /siltpoke-explain, /siltpoke-where, /siltpoke-relocate — are listed with their full flags under Slash commands → Code Map commands.

Architecture

Your agent reviewing its own work is a blind spot. Siltpoke is a second, independent one — a separate brain subprocess with a different prompt, different personality, and different blind spots, running on a login you already have. Today that brain is claude -p; as each agent family is integrated, siltpoke uses that family's own brain. No extra LLM bill either way.

The review loop

   your agent finishes a turn
             │
             ▼
   ┌───────────────────┐
   │  1. Stop hook     │ ── transcript + diffs + tool output
   └─────────┬─────────┘
             ▼
   ┌───────────────────┐
   │  2. Gate chain    │ ── quiet hours? budget? no change? → skip
   └─────────┬─────────┘    (never blocks your agent)
             ▼
   ┌───────────────────┐
   │  3. Brain (LLM)   │ ── separate `claude -p` + tsc/eslint/ripgrep
   └─────────┬─────────┘
             ▼
   ┌───────────────────┐
   │  4. Classify +    │ ── suppress · bubble · full code review
   │     evidence-guard│    (kept findings cite verbatim tool output)
   └───────────────────┘

1. Stop hook fires — your agent finishes a turn. The hook hands off your transcript, diffs, and tool output.
2. Gate chain — skips on quiet hours, the budget cap, or no change since the last run. Never blocks your agent — this is pull, not push, all the way down.
3. Brain reasons — a separate claude -p subprocess reviews the work with tsc / eslint / ripgrep evidence. It runs on your existing Claude login, so what it costs is tokens, not a separate bill.
4. Classify, then guard — the tool output is sorted into three outcomes: nothing usable → suppressed; clean but with changes → a quiet one-line bubble; a real signal → a full code review. Before any code review is kept, an evidence guard checks that every cited snippet is a verbatim substring of the real tool output — anything it can't ground is dropped, never shown. Code Reviews are written to disk, never auto-injected into your chat — you pull them in yourself (see Daily use).

Pull, not push. Every code review lands on disk. Nothing enters your chat until you ask for it — so the review can never derail your agent mid-task.

What it reviews

Two layers do the work. First a deterministic rubric — 13 rules run over the diff, most via a tree-sitter AST, no LLM involved:

• Size & shape — god-file (>500 lines), god-function (>50 lines or high complexity), deep nesting (>3), long parameter lists (>4), and behavior-selecting boolean flag params.
• Smells — magic numbers, commented-out code, comments that just narrate the next line, defensive over-reach (a try/catch that silently swallows), and sprawling abstractions (an interface with one impl and one caller).
• Coverage & consistency — a test-gap check (source changed >30 lines with no matching test) plus repo-aware rules that flag code diverging from your own repo's conventions.

Alongside the rubric it runs four CLI tools — tsc, eslint, ripgrep, and git-diff — and hands all of it to the second layer: the Brain (claude -p), which writes the actual prose code review. The rubric hits and tool output are its evidence; the Brain decides what's worth saying and how, in your pet's voice.

Before the Brain writes anything, a quick intent classifier tags the change — bugfix, refactor, feature, chore, or exploration — mostly by regex over your message, commit, and the files you touched, with the Brain filling in the rest. That label sets the code review's framing, so an exploratory spike isn't held to the same bar as a bugfix.

Your personality dials shape that voice — the tone, and how readily it speaks up — but they never touch the hard gates or the rubric thresholds. A patient pet sounds calmer; it doesn't quietly raise the bar on what counts as a real problem.

Inspecting a code review

A code review is never a black box. Every inbox entry expands into an audit card — which rubric rules fired, the Brain's reasoning, and the raw tool evidence behind each claim — and gets a shareable permalink at /code review/:id for anything you want to revisit or pass on.

Every action you take on one — forward, dismiss, ack, or a /siltpoke-feedback note — is appended to a local preference log: the running signal trail behind Siltpoke's learning, kept entirely on your machine.

And for the Brain's own runs, siltpoked emits a trace per Brain turn to a local store, browsable as a waterfall at /traces. The daemon prunes it on a schedule — 30-day retention, 500 MB cap — so it stays a debugging aid, not a disk leak.

Cost

Brain rides your existing Claude login, so there's no separate LLM bill — just tokens, kept cheap by prompt caching and bounded by a hard daily cap (budget.dailyTokenLimit) that can never run away. For the actual per-call and per-day figures, see Configuration → Cost.

The daemon

siltpoked is a long-lived Hono service listening on 127.0.0.1:9876. It's the Stop hook receiver and the process the code review, dashboard, and chat all run in — one background service instead of a fresh process per event. Manage it with /siltpoke-daemon (start, start --detach, stop, status, install-autostart). It also auto-spawns lazily from the Stop hook if it isn't already running, so install-autostart is only needed if you want zero cold-start before the first Stop event of a session.

Troubleshooting

/siltpoke-doctor

The install-health diagnostic. It prints a 9-row ✓/✗ checklist and exits 0 if every check passes or 1 if any fails. Each failing row already includes the path and the actionable fix, so read it back verbatim rather than guessing. --json gives machine-readable output for piping into another tool; --quiet prints a one-line summary instead of the full table.

$ /siltpoke-doctor

siltpoke-doctor — checking install health

  ✓  ~/.claude/settings.json valid
  ✓  Stop hook registered (http + command pair)
  ✓  ~/.siltpoke/inner.txt readable
  ✓  ~/.siltpoke/wake.json healthy (absent OK)
  ✓  ~/.siltpoke/global.json schema v3 current
  ✓  slash command symlinks intact (35/35)
  ✓  ~/.siltpoke/config.json valid
  ✓  last Brain call: ok @ 2026-07-01T14:32
  ✓  daemon running latest code

All 9 checks passed. Install healthy.

A failing row looks like this, with the fix inline:

  ✗  slash command symlinks intact (34/35)
       siltpoke-tag-entities.md (missing). Run `bun src/cli/install.ts` to re-link.

Common fixes

How to clear each failing doctor row — most echo the doctor's own message; a couple (schema, config) add a suggested next step:

Common symptoms

• No face in the statusline — check that ~/.claude/settings.json's statusLine points at the Siltpoke wrapper, then restart Claude Code.
• Brain never runs — run /siltpoke-stats to see today's spend and trigger mode, then tail -f ~/.siltpoke/brain-calls.jsonl and look for skipped reasons: quiet_hours, budget_hard_stop, no_change, wrong_event_mode, on_demand_no_bypass.

Want a review right now?

/siltpoke-wake is a one-shot bypass of the budget and quiet-hours gates — use it when you want Brain to run on demand instead of waiting for the next gated event.