Infernoflow

🔥 infernoflow

Every new AI session starts cold — the gotchas you found, the decisions you made, don't survive. infernoflow makes them stick.

Persistent memory for AI coding sessions. Captures the gotchas, decisions and dead ends your code can't tell an agent — and replays them into your next Cursor / Claude Code / Copilot chat so the same wrong turn never happens twice.

You spent 90 minutes yesterday teaching Claude that your auth API returns 200 even on errors — check the response body, not the status code. Today you ask the same kind of question and watch it write if (response.ok) { return data } all over again. The AI didn't get worse overnight. It just doesn't have memory.

infernoflow is a local-first CLI + VS Code extension + open protocol (AMP) that gives your AI persistent context across sessions. No SaaS. JSONL on disk. Three rule files your IDE already reads.

Built-in assistant memory remembers *you*. infernoflow remembers the *codebase*: the memory lives in your repo under .ai-memory/, travels through git to your teammates, and works the same in Claude Code, Cursor and Copilot.

What's new in 0.50

• The MCP server tells the agent how to use the memory. Clients that show MCP server instructions, such as Claude Code, now get the memory protocol when they connect: check where you stopped, search before changing a file, save decisions, gotchas and failed attempts without being asked. It works even where no hook or rule file loads it.

What's new in 0.49

• Unsaved decisions come back. If a Claude Code session ends with a decision or finding you stated but nobody saved, the next session starts with a one-time reminder to offer saving it (the quote stays on your machine).
• `setup` shows what is really installed — every part, installed, skipped with the reason, or missing with the command that fixes it.
• `setup` runs init with the CLI you installed, never npx through a shell.

What's new in 0.48

• Codex CLI. setup registers the MCP server in .codex/config.toml (no machine paths, safe to commit) and creates AGENTS.md with the memory block, on machines with Codex.
• Pre-commit note. When a commit touches a file that memory has a gotcha, failed attempt or decision about, git commit shows it first. Never blocks.
• Safer uninstall. It removes only infernoflow's block from your rule files; it used to delete CLAUDE.md whole.

What's new in 0.47

• Committed configs stay clean across the team. .vscode/mcp.json and .cursor/mcp.json no longer hold your machine's paths (infernoflow mcp in ${workspaceFolder}), and the rule files no longer list recent commits or personal memory — so a teammate's pull doesn't leave changed files. Optional AGENTS.md support.
• Save reminders from what you type (Claude Code): "remember this", "we decided…", "turns out…" — in English or Hebrew — remind the agent to save it in its own words. Hebrew frustration phrases are logged too.

What's new in 0.46

• Memory maintenance hints (0.46.5): status, recap and the session start tell you when memory has duplicates, noise or entries about files that changed since, and name the command to fix it. Set "maintenance": "auto" in .ai-memory/amp.json to tidy up once a day, or "off". Also: every command has its own --help that never runs the command.
• Fresh memory every Claude Code session — a SessionStart hook injects current memory (framed as information to verify, not instructions); CLAUDE.md no longer carries a copy that goes stale.
• `infernoflow resume` — "where were we?" in one call. Claude Code also leaves an automatic local resume point when a session ends.
• Stale and resolved entries — entries about a file that changed since are marked *may be stale*; infernoflow resolve retires one from AI context.
• Review what arrives through git (0.46.1) — memory added by teammates is listed until you review it, and the GitHub Action shows memory changes in each PR.
• Safer by default — only read-only MCP tools are pre-approved; the memory-keeper agent is limited to single infernoflow commands; secrets are redacted; MCP is registered per project.
• `infernoflow doctor --e2e` (0.46.3) — an end-to-end self-test in a throw-away sandbox: CLI, the MCP server with every tool called, the prompt and session hooks, git drift, attribution. Also: prompt hooks ignore agent/tool text, memory-mode projects aren't offered contract tools, git drift reports git failures, and every entry names who wrote it.

Full list: CHANGELOG.md.

Session bookmarks

Drop a named resume point mid-session. When the context window fills up or you're about to make a risky change, one command captures the current session's transcript and stores it as a jumpable checkpoint:

infernoflow bookmark "before the SP refactor"

Or just say it in chat — the Cursor beforeSubmitPrompt hook catches phrases like "bookmark this" / "mark this point" / "save this checkpoint" and drops the bookmark itself, no AI cooperation required. Or let the AI do it via the amp_bookmark MCP tool when it notices the session is getting long.

No `--note`? infernoflow reads Claude Code's own on-disk transcript (~/.claude/projects/…/*.jsonl), distills the last 40 turns to markdown, and stores it as the bookmark's context. Fully deterministic — no model call. Recall any time:

infernoflow bookmark list                # ● has context, ○ marker only

infernoflow bookmark show "SP refactor" # jump back — see the whole snapshot

Bookmarks are never auto-pruned, and they surface in infernoflow switch under a ## 🔖 Bookmarks — Resume Points section so the next session opens right where work paused.

🆕 Proactive capture — a Claude skill + a memory-keeper agent

init now installs two things into .claude/ so the loop runs itself on Claude Code:

• `infernoflow-memory` skill (.claude/skills/) — teaches the agent to start warm (resume), then proactively log real gotchas, decisions-with-a-*because*, dead ends, and durable preferences, and drop a bookmark at stopping points or when you say *"bookmark this"*. Capture is balanced — it skips routine steps, anything obvious from the code, secrets, and duplicates.
• `memory-keeper` subagent (.claude/agents/) — a specialist you can delegate to. It sweeps the session, dedupes against what's already stored, logs what's worth keeping, drops bookmarks, and reports back. It never edits code or logs secrets, and a guard limits its shell to single infernoflow read/log commands (blocked if the guard can't run).

Both are installed automatically by infernoflow init (fresh and on re-run of an existing project) and ship in the package — nothing to set up by hand.

The loop

Every new AI session today starts cold. The agent re-reads your code, re-derives the obvious, and re-makes the same wrong move someone else made yesterday. infernoflow closes that loop in four stages:

1. Capture — while you and the agent work, moments worth saving get logged automatically: a gotcha hit, a decision made, an attempted fix that failed, a pattern noticed, a resume point marked. The AI writes them via the amp_write MCP tool. A protocol block injected into the rule files teaches it exactly when. Prompt hooks (Claude Code UserPromptSubmit, Cursor beforeSubmitPrompt) backstop the AI by scanning the text you typed — subagent hand-backs, system reminders, fenced or indented code, quotes and stack traces are skipped — for trouble signals (not working, still broken, same error; !! / retry only in short prompts) and writing the entry deterministically when the AI doesn't (English and Hebrew). In Claude Code the hook also notices when you ask the agent to remember something, state a decision or describe a finding, and reminds the agent to save it in its own words — it stores nothing itself for those. If a session ends with one of those still unsaved, the next session starts with a one-time reminder to offer saving it. The Cursor hook also turns *"bookmark this"* into a bookmark.
2. Link — each captured moment becomes a structured AMP entry (gotcha | decision | attempt | note | detection | pattern | bookmark) with timestamp, file:line, tags, and a stable AMP id.
3. Persist — entries land in .ai-memory/branches/ .jsonl (git-tracked, travels with your branch — teammates inherit it) plus .ai-memory/global.jsonl (personal preferences, gitignored, synced across your machines via any OS-synced folder).
4. Restore — when a new session starts, the agent reads CLAUDE.md / .cursorrules / copilot-instructions.md at boot. The most relevant entries are already there. Warm start; no cold derivation.

And at the last moment before a repeat: when a commit touches a file that memory has a gotcha, failed attempt or decision about, the git pre-commit note prints those entries — to you or to the agent running git commit. It never blocks the commit. (setup / init install it in .git/hooks; turn it off with "preCommit": "off" in .ai-memory/amp.json.)

No service to log into. No SaaS. JSONL on disk, an MCP server, and three rule files your IDE already reads.

Install

npm install -g infernoflow

infernoflow init --yes

Zero runtime dependencies. Works on Node ≥ 18 — macOS, Linux, Windows.

init --yes does the whole setup: creates .ai-memory/, writes rule files for every supported IDE, wires the MCP server for Cursor / VS Code Copilot / Claude Code in one shot, installs the infernoflow-memory skill + memory-keeper agent into .claude/, applies the clean-tree git policy, and drops a visible demo entry so you can confirm the loop is alive with:

infernoflow status

The 5-command core + 4

These cover 95% of usage:

| infernoflow bookmark "..." | 🆕 Drop a named resume point — auto-captures the session transcript as its context. list / show / rm round it out. Surfaces in switch.