Pimp My IDE / garage dispatch
Back to garage
October 1, 2026 | Pi 1.0 / durable agents / replay policy

Do not weld the queue into the cockpit.

Pi 1.0 keeps the coding agent aimed at one person in a terminal. Pi Durable puts crash recovery, shared steering, and long-running tasks in a separate experimental package. That seam is the release.

Persistence saves state. Durability decides what can repeat, who owns the storage, what a crash interrupts, and which receipt survives.

The split matters more than the feature list.

Earendil released Pi 1.0 on October 1. The coding agent now includes Codemode, Model Context Protocol support, virtual models, deferred tool loading, prompt-cache warming, transcript-aware prompt changes, and a full-screen terminal interface.[1] That is already a wide control panel.

The release does something sharper beside it. Long-running, multi-client work does not get folded into the stable coding agent. It ships as Pi Durable, a separate experimental package. Earendil says the terminal agent remains a tool for one person on one machine. If its process dies, that person inspects the result and continues. Pi Durable handles a different job: many conversations, attached clients, stored work, and restart recovery.[2]

A durable agent is not a terminal session with a database bolted underneath.

This is good product restraint. Interactive work and unattended work have different failure contracts. A person at the keyboard can resolve ambiguity after a crash. A service must decide in advance whether a half-finished tool call may run again, whether a repeated request is the same job, and which process owns the state.

Replay policy is the real firewall.

Pi Durable stores each tool call's intent before execution. After a restart, it reruns the tool only when the tool declares replay: "safe". A call without that declaration returns an interrupted result to the model. The package documentation uses a search call as the safe example and a production deploy as the call that must not repeat.[3]

That small flag carries more weight than a generic "resume" promise. Reading an issue twice is usually harmless. Charging a card, publishing a package, or deploying a release twice is not. Recovery needs a per-effect decision. The model should not invent that decision after the process returns.

Submissions get a separate guard. A caller can attach a requestId. Retrying the same ID returns the existing submission instead of placing another one. This controls duplicate admission. It does not make every downstream tool exactly-once. The input gate and the effect gate remain separate.[2][3]

Storage has a custody label.

The package ships memory, SQLite, and JSONL backends. It also exposes a conformance suite for custom storage. One process owns a storage at a time. The README states that there is no cross-process lock.[3] That limit belongs in every deployment plan. Two workers opening the same state file is not a scale-out strategy.

The SQLite backend uses write-ahead logging with synchronous = NORMAL. The package says commits survive process crashes, while the newest commit may be lost after a power or host failure. JSONL can use fsync before each commit marker.[3] "Stored" needs a named failure boundary. A clean process restart, a dead host, and a lost volume are three different tests.

The same care appears in the live view. Answers and tool output are committed at most every 100 milliseconds. A crash can lose that newest window. Slow watchers eventually receive a fresh snapshot instead of an unlimited backlog.[3] These are useful, concrete limits. They make the interface inspectable.

Use the package boundary as an operating rule.

Keep an agent in the interactive chassis when a person owns the session, can see the process, and can decide what to do after interruption. Move toward a durable harness when work must survive process death, accept commands from more than one client, run several conversations at once, or expose a task graph outside the terminal.

Do not cross that boundary on a feature checkbox alone. Pi Durable is marked experimental. Its API may change without notice. Before adoption, choose one storage owner, classify every effect by replay safety, assign request IDs at the intake edge, and run a crash drill around a real side effect.

The packages are real. The public npm registry reported version 1.0.0 for the coding agent and Durable packages during this inspection. A clean temporary install loaded Pi Durable, opened an in-memory harness, created its root conversation, read the empty committed view, and closed it. That smoke check proves the published package can start on the inspected Node runtime. It does not prove SQLite recovery, tool replay, provider calls, or production fitness.[4]

Interactive makeover / durability firewall

Route the requirement, not the hype.

Traditional purpose replaced: one "persistent mode" toggle. Better version: four native controls show which requirements stay in the interactive chassis and which ones cross into the experimental durable package. The generated ticket keeps the missing proof visible.

Select durable requirements

Leave a switch open when a person at the terminal can own the interruption. Select it only when the application must carry that responsibility.

Requirement relays

Selection recommends an evaluation boundary. It does not prove Pi Durable fits the workload. The package is experimental.

Keep three checks outside the relay

Authority
Durable execution does not add a built-in filesystem, process, network, or credential sandbox.
Effects
Storage cannot make an unsafe deploy, charge, or publish action safe to repeat.
Host loss
The documented SQLite mode may lose the newest commit after power or host failure.
Requirement route

Core / durable split

0 durable needs
Pi 1.0Durable
Pi 1.0Durable
Pi 1.0Durable
Pi 1.0Durable
Each relay moves one requirement. No selection claims implementation evidence.

Keep the work in the interactive chassis.

A person can own the session and interruption. Do not add a service runtime without a durable requirement.

Four contracts before rollout

Durability needs more than saved chat.

01 / ADMISSION

Is this the same request?

Assign a stable request ID before retries reach the harness. Test duplicate delivery.

02 / EFFECT

May this tool run again?

Classify each tool. Read-only is not enough when a read can consume, lease, or acknowledge work.

03 / CUSTODY

Who owns storage?

Name one writer process. Add an external lease before more than one process can contend.

04 / RECOVERY

What does restart prove?

Kill the process during an effect. Compare committed state, external state, and the operator receipt.

Sources read

Source log and evidence boundary
  1. Earendil, "Pi 1.0", published and read October 1, 2026. This is the vendor release post for the stable coding-agent package and the experimental Pi Durable package.
  2. Earendil Engineering, "Pi Durable", published and read October 1, 2026. It describes the intended split between the terminal agent and durable harness, plus task checkpoints, request IDs, attached clients, conversation concurrency, and execution environments.
  3. Pi Durable source and README, inspected October 1, 2026 at commit 86dfceec402ad77e563bf4feab5f26c42d5f5db6. The README marks the package experimental and documents replay rules, storage backends, one-process ownership, SQLite and JSONL durability limits, watcher snapshots, and the 100 millisecond commit cadence. The repository root also states that Pi has no built-in permission system and runs with the launching process's authority unless externally contained.
  4. Published Pi Durable 1.0.0 package, inspected and smoke-tested October 1, 2026. The registry reported MIT license and Node 22.19 or newer. A temporary clean install on Node 22.22.2 imported the package, opened an in-memory harness, created a root conversation, read its empty view, and closed cleanly. No model provider, SQLite backend, tool call, or crash recovery path ran.
  5. Hacker News item 49926069, resolved through the official API on October 1, 2026. It identified the Pi release during a scan that also covered Cloudflare Clef, K2 event streams, Rust compiler work, model routing, and current open-source developer tools. It is a discovery source, not evidence for package behavior.

Evidence boundary. The first three sources come from the project publisher. Their architecture and behavior claims are not independent validation. Pimp My IDE confirmed package publication and a narrow in-memory startup path. It did not reproduce crash recovery, request deduplication, SQLite behavior, concurrent clients, prompt-cache behavior, or tool replay. The firewall creates an evaluation ticket only.