pi-model-fallback 0.5.2 → 0.5.6

package/CHANGELOG.md

@@ -1,6 +1,40 @@
 # Changelog
 
-## Unreleased
+## [0.5.6] - 2026-10-19
+
+### Fixed
+
+- Restore automatic releases on a `package.json` version bump pushed to `main`; the manual **Auto Release** dispatch stays available with `release_authorized` checked.
+
+## [0.5.5] - 2026-10-19
+
+### Fixed
+
+- Serialize cooldown read-modify-write transactions across sessions and processes, publish state atomically, and coordinate reset and expiry pruning so cached snapshots cannot discard or resurrect other sessions' entries. Retry transient Windows sharing violations during atomic replacement.
+
+### Changed
+
+- Run CI on Windows as well as Ubuntu, and accept CRLF markdown when checking release docs.
+
+## [0.5.4] - 2026-10-16
+
+### Changed
+
+- Pin Pi SDK development dependencies to 1.2.0 and verify the extension against the actual Pi host runtime.
+
+## [0.5.3] - 2026-10-12
+
+### Changed
+
+- Require Pi 1.1 for the continuation boundary API and align Pi development dependencies with that release line.
+
+### Fixed
+
+- Continue failed requests after Pi's own retries without replaying the user prompt or dropping image inputs and completed tool results.
+- Keep fallback-chain visitation across continuation loops, respect interruption and aborted settlement, and persist cooldowns only after successful target activation.
+- Retain observed HTTP status and retry headers for the matching request when provider error text omits a status.
+- Keep fallback active for the rest of the run after a config save mid-run; superseding pending fallback work no longer disables fallback until the next user prompt.
+- Recognize Anthropic SDK status-plus-JSON and streaming errors so configured rate-limit and outage rules are evaluated. Treat interrupted Anthropic streams as `502` and supported connection failures as `503`, without changing rule defaults or matching cancellation.
 
 ## [0.5.2] - 2026-10-07
 

package/README.md

@@ -26,6 +26,8 @@ When a failure matches, the extension also stores persistent fallback state so f
 
 ## Install
 
+Requires Pi 1.1 or later for the continuation boundary API.
+
 Install from npm:
 
 ```bash
@@ -97,7 +99,7 @@ Rule fields:
 Top-level fields:
 
 - `enabled`: toggle the extension without deleting rules
-- `autoRetry`: when a fallback fires from a failed turn, automatically re-queue the failed user prompt so the turn retries on the fallback model (defaults to `true`; set to `false` to only switch models). The failed prompt is queued once per fallback transition, so a fallback chain may replay it more than once.
+- `autoRetry`: after Pi exhausts its own retries, continue the existing conversation on the fallback model without re-queueing the user prompt (defaults to `true`; set to `false` to only switch models). Completed tool results and image inputs remain in context; only the failed assistant entry is excluded.
 
 Rules use first-match order: the first rule whose provider/model and status match wins. Put specific `matchModels` rules before broad `matchProviders` rules when they should take priority. `model_fallback_config validate`, `save`, `read`, and `status` report warning-only diagnostics when a later rule or model entry is completely shadowed by an earlier rule; `/model-fallback:status` also includes a concise warning summary for the current config. Warning-bearing config remains valid and can still be saved.
 
@@ -119,12 +121,17 @@ The extension stores:
 
 If the package is installed project-locally and the current project references it from `.pi/settings.json`, those files live under the project `.pi/` directory. Otherwise they live under the user agent directory.
 
+Cooldown updates re-read and merge the current state under a shared `proper-lockfile` lock, including across Pi processes. Reset uses the same lock. State is published by atomic replacement, so readers never see a partially written document; expired entries are ignored on read and removed during the next mutation. Lock acquisition is bounded (about two seconds of retries); a lock or write error is reported rather than overwriting state without the lock. A reset clears entries committed before it; a new failure committed afterward can create a new cooldown.
+
 ## Behavior notes
 
 - Successful responses do nothing.
-- Matching failures from `after_provider_response` can trigger fallback immediately.
-- Assistant error messages parsed at `turn_end` can also persist fallback state for SDK/provider failures that do not emit the normal response hook. Status extraction looks for HTTP-style tokens (for example `status 429`, `HTTP 503`, or `rate limit`) rather than any bare 3-digit number in the message. A status in parentheses is only recognized when an error wrapper keyword precedes it, as in `omni API error (503): ...`; a parenthesized number with no such wrapper, such as `(503) items processed`, stays unmatched.
-- With the default `autoRetry: true`, the failed prompt is automatically queued once per fallback transition on the fallback model. A fallback chain may therefore replay the prompt more than once. Set `autoRetry: false` to switch models without replaying it.
+- Failed HTTP responses are recorded by `after_provider_response`; model switching waits until Pi's retry/recovery paths finish at `agent_before_settle`.
+- Assistant error messages parsed at `turn_end` identify SDK/provider failures that do not emit the normal response hook. When friendly error text omits a status, the extension uses the observed HTTP status and headers from the same model request. Status extraction looks for HTTP-style tokens (for example `status 429`, `HTTP 503`, or `rate limit`) rather than any bare 3-digit number in the message. A status in parentheses is only recognized when an error wrapper keyword precedes it, as in `omni API error (503): ...`; a parenthesized number with no such wrapper, such as `(503) items processed`, stays unmatched.
+- Anthropic SDK errors with a bare status followed by JSON (for example `429 {"type":"error",...}`) are recognized. Status-free Anthropic streaming errors map `rate_limit_error` to `429`, `overloaded_error` to `529`, and `api_error` to `500`; an interrupted stream maps to `502`. Add `529` to a rule's `statuses` if it should cover Anthropic overloads. Supported connection failures without an HTTP response map to `503`; cancellation, refusals, and ordinary numeric prose stay unmatched, and explicit HTTP statuses take precedence.
+- With the default `autoRetry: true`, the existing run continues on the fallback model without a second user request. Set `autoRetry: false` to switch models without continuing.
+- Interrupting a pending fallback prevents continuation. An in-flight model change is not atomic with cancellation: the selected model may change, but the extension will not request another inference after the interrupt.
+- Switching providers sends the existing model context to the target provider. Preserving completed tool results prevents extension-level replay, not a model independently choosing to repeat an action.
 
 Rules never fall back to the failing model itself; a rule whose fallback target equals the failing model is skipped so the next matching rule (or no rule) applies.
 

package/docs/pi-sdk-compatibility.md

@@ -0,0 +1,25 @@
+# Pi SDK 1.2.0 compatibility
+
+This package is verified with the frozen development/test versions:
+
+- `@earendil-works/pi-agent-core`: `1.2.0`
+- `@earendil-works/pi-ai`: `1.2.0`
+- `@earendil-works/pi-coding-agent`: `1.2.0`
+- `@earendil-works/pi-tui`: `1.2.0`
+
+These exact versions are dev/test pins. Public peer dependency ranges are
+unchanged; the package continues to require Pi 1.1 or later.
+
+The upstream [Pi SDK compatibility notes](https://github.com/eiei114/pi-extension-template/blob/main/docs/pi-sdk-compatibility.md)
+record the 1.2.0 `before_agent_start` message-type union and startup busy-state
+changes. This extension does not read user-only event fields, so no production
+API migration was needed. Tests now construct the current `messageType: "user"`
+event and account for sessions being busy while startup handlers run.
+
+From a repository checkout, run `npm run smoke:pi` to exercise the installed
+local Pi CLI and RPC host with this extension. The deterministic offline provider
+returns a source 429 and a successful fallback response; the harness also checks
+a handled invalid config, a second-process reload and feature response, clean
+shutdown, and the native host shell. It uses an isolated agent directory and
+makes no paid inference. `npm run ci` runs the smoke as well as typecheck, tests,
+and pack dry-run.

package/docs/usage.md

@@ -1,12 +1,14 @@
 # Usage
 
-Install:
+Requires Pi 1.1 or later. Install:
 
 ```bash
 pi install npm:pi-model-fallback
 ```
 
-Default behavior: when a `zai/*` model receives `429`, `500`, `502`, `503`, or `504`, Pi switches to `deepseek/deepseek-v4-flash` for the next prompt. The failed prompt is automatically queued once per fallback transition on the fallback model, so a fallback chain may replay it more than once; set `"autoRetry": false` in `model-fallback/config.json` to switch models without retrying it.
+Default behavior: when a `zai/*` model fails with `429`, `500`, `502`, `503`, or `504`, Pi finishes its own retries, switches to `deepseek/deepseek-v4-flash`, and continues the existing conversation without replaying the user prompt. Completed tool results and images remain in context. Set `"autoRetry": false` in `model-fallback/config.json` to switch models without continuing.
+
+The selected session model changes; subsequent requests use that model directly. Interrupting a pending fallback prevents continuation, although a model change already in progress may remain. A chain never revisits a model within the same user run.
 
 Commands:
 
@@ -26,4 +28,6 @@ Cooldown defaults when a rule omits `cooldownMs`:
 
 `Retry-After` and `x-ratelimit-reset*` response headers override `cooldownMs` and those defaults.
 
-If `autoRetry` is disabled, the failed request is not automatically replayed.
+If `autoRetry` is disabled, the existing run is not automatically continued.
+
+Shared cooldown state uses a cross-process lock and atomic file replacement. Concurrent failures merge against the latest file, not a session's cached snapshot. Reset takes the same lock and can repair a malformed state file; it clears earlier commits, not failures committed afterward. Expired entries are ignored when selecting a model and cleaned up during the next state mutation. Lock/write failures are reported instead of performing an unlocked overwrite.

package/docs/verification/pi-sdk-smoke.json

@@ -0,0 +1,103 @@
+{
+  "schema_version": 1,
+  "verification_contract": "pi-sdk-behavior-v2",
+  "sdk_versions": {
+    "@earendil-works/pi-agent-core": "1.2.0",
+    "@earendil-works/pi-ai": "1.2.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
+    "@earendil-works/pi-tui": "1.2.0"
+  },
+  "platform": "win32",
+  "model_inference": "No paid inference; actual pinned Pi CLI/RPC, extension loader, lifecycle and fallback model runtime use a deterministic offline faux provider.",
+  "unhandled_errors": 0,
+  "extension_load_errors": 0,
+  "cases": [
+    {
+      "name": "extension_load",
+      "command": "npm run smoke:pi",
+      "exit_code": 0,
+      "passed": true,
+      "evidence": "{\"exit_code\":0,\"signal\":null,\"timed_out\":false,\"duration_ms\":1013,\"rpc_records\":[{\"type\":\"extension_ui_request\",\"id\":\"150821d3-944b-44d0-99e2-92a72920ec36\",\"method\":\"notify\",\"message\":\"Model fallback: enabled\\nAuto retry: enabled\\nConfig: <isolated-agent-dir>\\\\model-fallback\\\\config.json\\nState: <isolated-agent-dir>\\\\model-fallback\\\\state.json\\nRules: 1\\nConfig warnings: none\\nPersistent entries: 0\\nActive fallback: none\\nOriginal model: none\\nReason: none\",\"notifyType\":\"info\"},{\"id\":\"extension-load\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"handled\"}}],\"stderr\":\"\",\"error\":null}",
+      "assertions": [
+        {
+          "id": "extension_registered",
+          "expected": "The actual Pi host handles the package's registered status command",
+          "observed": "{\"response\":{\"id\":\"extension-load\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"handled\"}},\"notification\":{\"type\":\"extension_ui_request\",\"id\":\"150821d3-944b-44d0-99e2-92a72920ec36\",\"method\":\"notify\",\"message\":\"Model fallback: enabled\\nAuto retry: enabled\\nConfig: <isolated-agent-dir>\\\\model-fallback\\\\config.json\\nState: <isolated-agent-dir>\\\\model-fallback\\\\state.json\\nRules: 1\\nConfig warnings: none\\nPersistent entries: 0\\nActive fallback: none\\nOriginal model: none\\nReason: none\",\"notifyType\":\"info\"},\"exit_code\":0}",
+          "passed": true
+        }
+      ]
+    },
+    {
+      "name": "happy_path",
+      "command": "npm run smoke:pi",
+      "exit_code": 0,
+      "passed": true,
+      "evidence": "{\"exit_code\":0,\"signal\":null,\"timed_out\":false,\"duration_ms\":1014,\"rpc_records\":[{\"type\":\"extension_ui_request\",\"id\":\"f2cfe8b5-18e7-4054-8649-707c1224832e\",\"method\":\"setStatus\",\"statusKey\":\"model-fallback\"},{\"id\":\"happy-path\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"started\"}},{\"type\":\"message_end\",\"message\":{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Exercise the deterministic fallback response.\"}],\"timestamp\":1792131439674}},{\"type\":\"message_end\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"\"}],\"api\":\"pi-sdk-smoke-faux\",\"provider\":\"pi-sdk-smoke-source\",\"model\":\"source\",\"usage\":{\"input\":563,\"output\":0,\"cacheRead\":0,\"cacheWrite\":563,\"totalTokens\":1126,\"cost\":{\"input\":0,\"output\":0,\"cacheRead\":0,\"cacheWrite\":0,\"total\":0}},\"stopReason\":\"error\",\"errorMessage\":\"Error: 429 deterministic smoke failure\",\"timestamp\":1792131439650,\"thinkingLevel\":\"off\"}},{\"type\":\"turn_end\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"\"}],\"api\":\"pi-sdk-smoke-faux\",\"provider\":\"pi-sdk-smoke-source\",\"model\":\"source\",\"usage\":{\"input\":563,\"output\":0,\"cacheRead\":0,\"cacheWrite\":563,\"totalTokens\":1126,\"cost\":{\"input\":0,\"output\":0,\"cacheRead\":0,\"cacheWrite\":0,\"total\":0}},\"stopReason\":\"error\",\"errorMessage\":\"Error: 429 deterministic smoke failure\",\"timestamp\":1792131439650,\"thinkingLevel\":\"off\"},\"toolResults\":[]},{\"type\":\"extension_ui_request\",\"id\":\"8a3bc896-7b4d-4b0a-bcc2-83193ca06029\",\"method\":\"setStatus\",\"statusKey\":\"model-fallback\",\"statusText\":\"fallback:pi-sdk-smoke-target/target\"},{\"type\":\"extension_ui_request\",\"id\":\"919dd5a4-0993-4101-83c8-d29ecc31f3d5\",\"method\":\"notify\",\"message\":\"Model fallback: pi-sdk-smoke-source/source → pi-sdk-smoke-target/target (429). Future sessions preselect fallback until 2026-10-16T06:18:19.680Z.\",\"notifyType\":\"warning\"},{\"type\":\"message_end\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"pi-model-fallback-smoke-ok\"}],\"api\":\"pi-sdk-smoke-faux\",\"provider\":\"pi-sdk-smoke-target\",\"model\":\"target\",\"usage\":{\"input\":563,\"output\":7,\"cacheRead\":0,\"cacheWrite\":563,\"totalTokens\":1133,\"cost\":{\"input\":0,\"output\":0,\"cacheRead\":0,\"cacheWrite\":0,\"total\":0}},\"stopReason\":\"stop\",\"timestamp\":1792131439650,\"thinkingLevel\":\"off\"}},{\"type\":\"turn_end\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"pi-model-fallback-smoke-ok\"}],\"api\":\"pi-sdk-smoke-faux\",\"provider\":\"pi-sdk-smoke-target\",\"model\":\"target\",\"usage\":{\"input\":563,\"output\":7,\"cacheRead\":0,\"cacheWrite\":563,\"totalTokens\":1133,\"cost\":{\"input\":0,\"output\":0,\"cacheRead\":0,\"cacheWrite\":0,\"total\":0}},\"stopReason\":\"stop\",\"timestamp\":1792131439650,\"thinkingLevel\":\"off\"},\"toolResults\":[]},{\"type\":\"agent_settled\",\"aborted\":false}],\"stderr\":\"\",\"error\":null}",
+      "assertions": [
+        {
+          "id": "feature_response",
+          "expected": "The real Pi run handles a 429, persists the configured fallback, and returns the target response",
+          "observed": "{\"response\":{\"id\":\"happy-path\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"started\"}},\"source_error\":{\"type\":\"message_end\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"\"}],\"api\":\"pi-sdk-smoke-faux\",\"provider\":\"pi-sdk-smoke-source\",\"model\":\"source\",\"usage\":{\"input\":563,\"output\":0,\"cacheRead\":0,\"cacheWrite\":563,\"totalTokens\":1126,\"cost\":{\"input\":0,\"output\":0,\"cacheRead\":0,\"cacheWrite\":0,\"total\":0}},\"stopReason\":\"error\",\"errorMessage\":\"Error: 429 deterministic smoke failure\",\"timestamp\":1792131439650,\"thinkingLevel\":\"off\"}},\"fallback_response\":{\"type\":\"message_end\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"pi-model-fallback-smoke-ok\"}],\"api\":\"pi-sdk-smoke-faux\",\"provider\":\"pi-sdk-smoke-target\",\"model\":\"target\",\"usage\":{\"input\":563,\"output\":7,\"cacheRead\":0,\"cacheWrite\":563,\"totalTokens\":1133,\"cost\":{\"input\":0,\"output\":0,\"cacheRead\":0,\"cacheWrite\":0,\"total\":0}},\"stopReason\":\"stop\",\"timestamp\":1792131439650,\"thinkingLevel\":\"off\"}},\"fallback_notification\":{\"type\":\"extension_ui_request\",\"id\":\"919dd5a4-0993-4101-83c8-d29ecc31f3d5\",\"method\":\"notify\",\"message\":\"Model fallback: pi-sdk-smoke-source/source → pi-sdk-smoke-target/target (429). Future sessions preselect fallback until 2026-10-16T06:18:19.680Z.\",\"notifyType\":\"warning\"},\"agent_settled\":{\"type\":\"agent_settled\",\"aborted\":false},\"user_message_count\":1,\"persisted_state\":{\"source\":{\"provider\":\"pi-sdk-smoke-source\",\"model\":\"source\"},\"fallback\":{\"provider\":\"pi-sdk-smoke-target\",\"model\":\"target\"},\"status\":429,\"until\":\"2026-10-16T06:18:19.680Z\",\"createdAt\":\"2026-10-16T06:17:19.680Z\"},\"exit_code\":0}",
+          "passed": true
+        }
+      ]
+    },
+    {
+      "name": "error_path",
+      "command": "npm run smoke:pi",
+      "exit_code": 0,
+      "passed": true,
+      "evidence": "{\"exit_code\":0,\"signal\":null,\"timed_out\":false,\"duration_ms\":963,\"rpc_records\":[{\"type\":\"extension_ui_request\",\"id\":\"8ed2cb69-da08-4c3b-b9aa-3b2e042617c8\",\"method\":\"notify\",\"message\":\"Model fallback config error: Unsupported config version: 2.\",\"notifyType\":\"warning\"},{\"type\":\"extension_ui_request\",\"id\":\"739c37cd-366e-46fa-b25a-49c957448732\",\"method\":\"notify\",\"message\":\"Model fallback: enabled\\nAuto retry: enabled\\nConfig: <isolated-agent-dir>\\\\model-fallback\\\\config.json\\nState: <isolated-agent-dir>\\\\model-fallback\\\\state.json\\nRules: 1\\nConfig warnings: none\\nPersistent entries: 0\\nActive fallback: none\\nOriginal model: none\\nReason: none\",\"notifyType\":\"info\"},{\"id\":\"error-path\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"handled\"}}],\"stderr\":\"\",\"error\":null}",
+      "assertions": [
+        {
+          "id": "handled_error",
+          "expected": "The actual extension reports a malformed config as a handled warning without crashing Pi",
+          "observed": "{\"response\":{\"id\":\"error-path\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"handled\"}},\"warning\":{\"type\":\"extension_ui_request\",\"id\":\"8ed2cb69-da08-4c3b-b9aa-3b2e042617c8\",\"method\":\"notify\",\"message\":\"Model fallback config error: Unsupported config version: 2.\",\"notifyType\":\"warning\"},\"exit_code\":0}",
+          "passed": true
+        }
+      ]
+    },
+    {
+      "name": "reload_cleanup",
+      "command": "npm run smoke:pi",
+      "exit_code": 0,
+      "passed": true,
+      "evidence": "{\"exit_code\":0,\"signal\":null,\"timed_out\":false,\"duration_ms\":977,\"rpc_records\":[{\"type\":\"extension_ui_request\",\"id\":\"7eebdc06-9361-463d-8702-59b1fcf47520\",\"method\":\"notify\",\"message\":\"Model fallback: enabled\\nAuto retry: enabled\\nConfig: <isolated-agent-dir>\\\\model-fallback\\\\config.json\\nState: <isolated-agent-dir>\\\\model-fallback\\\\state.json\\nRules: 1\\nConfig warnings: none\\nPersistent entries: 0\\nActive fallback: none\\nOriginal model: none\\nReason: none\",\"notifyType\":\"info\"},{\"id\":\"reload-first\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"handled\"}}],\"stderr\":\"\",\"error\":null}\n--- next Pi process ---\n{\"exit_code\":0,\"signal\":null,\"timed_out\":false,\"duration_ms\":943,\"rpc_records\":[{\"type\":\"extension_ui_request\",\"id\":\"c14e9202-6c27-45c0-ba9e-08befeff728a\",\"method\":\"notify\",\"message\":\"Model fallback: enabled\\nAuto retry: enabled\\nConfig: <isolated-agent-dir>\\\\model-fallback\\\\config.json\\nState: <isolated-agent-dir>\\\\model-fallback\\\\state.json\\nRules: 1\\nConfig warnings: none\\nPersistent entries: 0\\nActive fallback: none\\nOriginal model: none\\nReason: none\",\"notifyType\":\"info\"},{\"id\":\"reload-status\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"handled\"}},{\"type\":\"extension_ui_request\",\"id\":\"f68c1ead-b99e-4ddd-a43b-e0eb798cbb35\",\"method\":\"notify\",\"message\":\"Model fallback: persistent state cleared; no remembered original model.\",\"notifyType\":\"info\"},{\"type\":\"extension_ui_request\",\"id\":\"f6e7f463-ffb9-4ac8-8cba-68a94653e32b\",\"method\":\"setStatus\",\"statusKey\":\"model-fallback\"},{\"id\":\"reload-feature\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"handled\"}}],\"stderr\":\"\",\"error\":null}",
+      "assertions": [
+        {
+          "id": "reloaded_extension_registered",
+          "expected": "A second real Pi process reloads the extension and handles its registered status command",
+          "observed": "{\"response\":{\"id\":\"reload-status\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"handled\"}},\"notification\":{\"type\":\"extension_ui_request\",\"id\":\"c14e9202-6c27-45c0-ba9e-08befeff728a\",\"method\":\"notify\",\"message\":\"Model fallback: enabled\\nAuto retry: enabled\\nConfig: <isolated-agent-dir>\\\\model-fallback\\\\config.json\\nState: <isolated-agent-dir>\\\\model-fallback\\\\state.json\\nRules: 1\\nConfig warnings: none\\nPersistent entries: 0\\nActive fallback: none\\nOriginal model: none\\nReason: none\",\"notifyType\":\"info\"},\"second_exit_code\":0}",
+          "passed": true
+        },
+        {
+          "id": "reloaded_feature_response",
+          "expected": "The reloaded second process executes reset and returns its package-specific handled response",
+          "observed": "{\"response\":{\"id\":\"reload-feature\",\"type\":\"response\",\"command\":\"prompt\",\"success\":true,\"data\":{\"disposition\":\"handled\"}},\"notification\":{\"type\":\"extension_ui_request\",\"id\":\"f68c1ead-b99e-4ddd-a43b-e0eb798cbb35\",\"method\":\"notify\",\"message\":\"Model fallback: persistent state cleared; no remembered original model.\",\"notifyType\":\"info\"}}",
+          "passed": true
+        },
+        {
+          "id": "clean_shutdown",
+          "expected": "Both actual Pi processes exit cleanly without unhandled, extension-load, or shutdown errors",
+          "observed": "{\"first_exit_code\":0,\"second_exit_code\":0,\"first_timed_out\":false,\"second_timed_out\":false,\"first_unhandled_error\":false,\"second_unhandled_error\":false,\"first_extension_load_error\":false,\"second_extension_load_error\":false}",
+          "passed": true
+        }
+      ]
+    },
+    {
+      "name": "host_shell",
+      "command": "npm run smoke:pi",
+      "exit_code": 0,
+      "passed": true,
+      "evidence": "{\"exit_code\":0,\"signal\":null,\"timed_out\":false,\"rpc_records\":[],\"stderr\":\"\",\"error\":null}",
+      "assertions": [
+        {
+          "id": "native_shell_boundary",
+          "expected": "The native host shell launches the locally pinned Pi CLI and returns exactly 1.2.0",
+          "observed": "{\"exit_code\":0,\"output\":\"1.2.0\",\"expected_version\":\"1.2.0\",\"stderr\":\"\",\"error\":null}",
+          "passed": true
+        }
+      ]
+    }
+  ]
+}

package/extensions/index.ts

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getKeybindings } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import {
   analyzeRuleWarnings,
@@ -16,7 +16,7 @@ import {
   type RuleWarning,
 } from "../lib/config.js";
 import { parseReasonFromErrorMessage, parseStatusFromErrorMessage } from "../lib/error-status.js";
-import { emptyState, findActiveStateEntry, pruneExpiredState, readState, upsertStateEntry, validateStateShape, writeState, type FallbackState } from "../lib/state.js";
+import { findActiveStateEntry, readState, updateState, upsertStateEntry, writeState, type FallbackState } from "../lib/state.js";
 import { isRecord } from "../lib/internal.ts";
 import { modelFallbackPaths, readConfig, writeConfig, type ModelFallbackPaths } from "../lib/storage.js";
 
@@ -37,6 +37,45 @@ export default function modelFallback(pi: ExtensionAPI) {
   // target a model never visited, which makes chains (free → kimi → glm) safe while
   // preventing A→B→A ping-pong with circular rules.
   let visitedFallbackKeys = new Set<string>();
+  let cancelled = false;
+  let generation = 0;
+  let switching = false;
+  let uiPromptOpen = false;
+  let removeTerminalListener: (() => void) | undefined;
+  let responseFailure: { modelKey: string; status: number; headers: Record<string, string> } | undefined;
+  let pendingFailure: { source: ModelRef; status: number; reason?: string; entryId: string; headers: Record<string, string> } | undefined;
+
+  function cancelFallback(): void {
+    cancelled = true;
+    invalidatePending();
+  }
+
+  // Drop fallback work computed from superseded state without disabling fallback
+  // for the rest of the run (unlike cancelFallback).
+  function invalidatePending(): void {
+    generation += 1;
+    pendingFailure = undefined;
+  }
+
+  pi.on("session_start", (_event, ctx) => {
+    removeTerminalListener?.();
+    if (ctx.mode === "tui") {
+      removeTerminalListener = ctx.ui.onTerminalInput((data) => {
+        if ((pendingFailure || switching) && !uiPromptOpen && getKeybindings().matches(data, "app.interrupt")) cancelFallback();
+        // Observe cancellation without consuming autocomplete, overlay, or editor input.
+        return undefined;
+      });
+    }
+  });
+  pi.on("ui_prompt_start", () => { uiPromptOpen = true; });
+  pi.on("ui_prompt_end", () => { uiPromptOpen = false; });
+  pi.on("session_shutdown", () => {
+    cancelFallback();
+    removeTerminalListener?.();
+    removeTerminalListener = undefined;
+  });
+  pi.on("session_before_switch", cancelFallback);
+  pi.on("session_before_tree", cancelFallback);
 
   function syncPaths(ctx: ExtensionContext): void {
     if (pathsResolvedForCwd === ctx.cwd) return;
@@ -58,18 +97,9 @@ export default function modelFallback(pi: ExtensionAPI) {
   async function loadState(ctx: ExtensionContext): Promise<FallbackState | undefined> {
     try {
       syncPaths(ctx);
-      const statePath = paths.state;
-      if (!existsSync(statePath)) {
-        state = emptyState();
-        return state;
-      }
-
-      const before = validateStateShape(JSON.parse(await readFile(statePath, "utf8")));
-      const after = pruneExpiredState(before);
-      state = after;
-      if (JSON.stringify(before) !== JSON.stringify(after)) {
-        await writeState(statePath, after);
-      }
+      // Prune the snapshot for selection, but never write a stale read back over another session.
+      // Mutating transactions prune the current on-disk state while holding the state lock.
+      state = await readState(paths.state);
       return state;
     } catch (error) {
       ctx.ui.notify(`Model fallback state error: ${errorMessage(error)}`, "warning");
@@ -103,7 +133,13 @@ export default function modelFallback(pi: ExtensionAPI) {
     visitedFallbackKeys = new Set([originalModelKey, activeFallbackKey]);
     lastFallbackReason = `persistent ${active.status} from ${originalModelKey} until ${active.until}`;
     updateStatus(ctx);
-    const ok = await pi.setModel(fallbackModel);
+    let ok = false;
+    switching = true;
+    try {
+      ok = await pi.setModel(fallbackModel);
+    } finally {
+      switching = false;
+    }
     if (!ok) {
       ctx.ui.notify(`Model fallback auth unavailable: ${modelRefKey(active.fallback)}`, "warning");
       originalModelKey = undefined;
@@ -117,7 +153,7 @@ export default function modelFallback(pi: ExtensionAPI) {
     ctx.ui.notify(`Model fallback preselected: ${originalModelKey} → ${activeFallbackKey} until ${active.until}.`, "warning");
   }
 
-  async function persistFailure(source: ModelRef, status: number, headers: Record<string, string>, ctx: ExtensionContext, reason?: string): Promise<boolean> {
+  async function persistFailure(source: ModelRef, status: number, headers: Record<string, string>, ctx: ExtensionContext, isCancelled: () => boolean, reason?: string): Promise<boolean> {
     const loaded = config ?? (await loadConfig(ctx));
     if (!loaded) return false;
     const match = findFallback(loaded, { provider: source.provider, id: source.model }, status, reason);
@@ -129,30 +165,12 @@ export default function modelFallback(pi: ExtensionAPI) {
       return false;
     }
 
-    // Loop guard: never fall back to a model already visited this run (the original or an
-    // earlier fallback). This both blocks circular rules from ping-ponging and stops the
-    // current fallback from re-selecting itself, while still allowing onward cascades
-    // (free → kimi → glm) when a different rule matches the fallback's own failure.
-    // Exception: when the failing model is the remembered original and the candidate is the
-    // already-preselected fallback, re-applying the same hop is idempotent and stays allowed
-    // (turn attribution can lag behind the preselection).
     const fallbackKey = modelRefKey(match.fallback);
     const sourceKey = modelRefKey(source);
-    const idempotentReapply = fallbackKey === activeFallbackKey && sourceKey === originalModelKey;
-    if (visitedFallbackKeys.has(fallbackKey) && !idempotentReapply) return false;
+    if (visitedFallbackKeys.has(fallbackKey) || isCancelled()) return false;
 
     const now = new Date();
     const until = new Date(now.getTime() + cooldownMsFor(match.rule.cooldownMs, status, headers)).toISOString();
-    const loadedState = state ?? (await loadState(ctx)) ?? { version: 1 as const, entries: [] };
-    state = upsertStateEntry(loadedState, {
-      source,
-      fallback: match.fallback,
-      status,
-      until,
-      createdAt: now.toISOString(),
-      ruleName: match.rule.name,
-    });
-    await writeState(paths.state, state);
 
     const prevOriginal = originalModelKey;
     const prevActive = activeFallbackKey;
@@ -167,30 +185,50 @@ export default function modelFallback(pi: ExtensionAPI) {
     lastFallbackReason = `${status} from ${sourceKey}${reason ? ` (${reason})` : ""}; persistent until ${until}`;
     updateStatus(ctx);
 
-    const ok = await pi.setModel(fallbackModel);
-    if (!ok) {
+    let ok = false;
+    try {
+      ok = await pi.setModel(fallbackModel);
+    } catch (error) {
+      ctx.ui.notify(`Model fallback switch failed: ${errorMessage(error)}`, "warning");
+    }
+    if (!ok || isCancelled()) {
       originalModelKey = prevOriginal;
       activeFallbackKey = prevActive;
       lastFallbackReason = prevReason;
       visitedFallbackKeys = prevVisited;
       updateStatus(ctx);
-      ctx.ui.notify(`Model fallback auth unavailable: ${modelRefKey(match.fallback)}`, "warning");
+      if (!ok) ctx.ui.notify(`Model fallback auth unavailable: ${modelRefKey(match.fallback)}`, "warning");
       return false;
     }
-    ctx.ui.notify(`Model fallback: ${originalModelKey} → ${activeFallbackKey} (${status}). Future sessions preselect fallback until ${until}.`, "warning");
+    if (isCancelled()) return false;
+    state = await updateState(paths.state, (current) => isCancelled() ? current : upsertStateEntry(current, {
+      source, fallback: match.fallback, status, until, createdAt: now.toISOString(), ruleName: match.rule.name,
+    }));
+    if (isCancelled()) return false;
+    ctx.ui.notify(`Model fallback: ${sourceKey} → ${activeFallbackKey} (${status}). Future sessions preselect fallback until ${until}.`, "warning");
     return true;
   }
 
-  pi.on("agent_start", async (_event, ctx) => {
+  pi.on("before_agent_start", async (_event, ctx) => {
+    cancelled = false;
+    generation += 1;
+    pendingFailure = undefined;
+    responseFailure = undefined;
     await loadConfig(ctx);
     await loadState(ctx);
-    visitedFallbackKeys = new Set();
+    visitedFallbackKeys = new Set(ctx.model ? [modelKey(ctx.model)] : []);
     await applyPersistentFallback(ctx);
     updateStatus(ctx);
   });
 
+  pi.on("agent_start", (_event, ctx) => {
+    // Preselection happens before a run exists; abort once its controller is active.
+    if (cancelled) ctx.abort();
+  });
+
   pi.on("model_select", async (event, ctx) => {
-    if (activeFallbackKey && modelKey(event.model) !== activeFallbackKey) {
+    if (modelKey(event.model) !== activeFallbackKey) {
+      cancelFallback();
       activeFallbackKey = undefined;
       originalModelKey = undefined;
       lastFallbackReason = undefined;
@@ -199,34 +237,53 @@ export default function modelFallback(pi: ExtensionAPI) {
     }
   });
 
-  pi.on("after_provider_response", async (event, ctx) => {
-    const current = ctx.model;
-    const loaded = config ?? (await loadConfig(ctx));
-    if (!current || !loaded) return;
-    if (event.status >= 200 && event.status < 300) return;
+  pi.on("before_provider_request", () => { responseFailure = undefined; });
+  pi.on("after_provider_response", (event, ctx) => {
+    responseFailure = event.status >= 400 && ctx.model
+      ? { modelKey: modelKey(ctx.model), status: event.status, headers: event.headers }
+      : undefined;
+  });
 
-    await persistFailure(modelToRef(current), event.status, event.headers, ctx);
+  pi.on("turn_end", (event) => {
+    const response = responseFailure;
+    responseFailure = undefined;
+    pendingFailure = undefined;
+    const message = event.message;
+    if (message.role !== "assistant" || message.stopReason !== "error") return;
+    const source = { provider: message.provider, model: message.model };
+    const observed = response?.modelKey === modelRefKey(source) ? response : undefined;
+    const errorText = message.errorMessage ?? "";
+    const status = parseStatusFromErrorMessage(errorText) ?? observed?.status;
+    if (status !== undefined) {
+      pendingFailure = { source, status, reason: parseReasonFromErrorMessage(errorText),
+        entryId: event.messageEntryId, headers: observed?.headers ?? {} };
+    }
+  });
+
+  pi.on("agent_before_settle", async (event, ctx) => {
+    const failure = pendingFailure;
+    if (event.outcome !== "error" || cancelled || !failure || !ctx.model || modelKey(ctx.model) !== modelRefKey(failure.source)) return;
+    const visibleFailure = event.context.contextEntries.some((entry) => entry.sourceEntry.id === failure.entryId && entry.messages.some((message) => message.role === "assistant" && message.stopReason === "error"));
+    if (!visibleFailure && !event.context.canContinue) return;
+    pendingFailure = undefined;
+    const currentGeneration = generation;
+    const isCancelled = () => cancelled || generation !== currentGeneration;
+    switching = true;
+    try {
+      const switched = await persistFailure(failure.source, failure.status, failure.headers, ctx, isCancelled, failure.reason);
+      if (!switched || isCancelled() || config?.autoRetry === false) return;
+      return {
+        entries: visibleFailure ? [...event.entries, { type: "context_edit" as const, targetId: failure.entryId, replacement: null }] : event.entries,
+        continue: true,
+      };
+    } finally {
+      switching = false;
+    }
   });
 
-  pi.on("turn_end", async (event, ctx) => {
-    const message = event.message as unknown;
-    if (!isRecord(message) || message.role !== "assistant") return;
-    const errorMessage = typeof message.errorMessage === "string" ? message.errorMessage : undefined;
-    if (!errorMessage) return;
-    const status = parseStatusFromErrorMessage(errorMessage);
-    if (status === undefined) return;
-    const reason = parseReasonFromErrorMessage(errorMessage);
-    const provider = typeof message.provider === "string" ? message.provider : ctx.model?.provider;
-    const model = typeof message.model === "string" ? message.model : ctx.model?.id;
-    if (!provider || !model) return;
-    const switched = await persistFailure({ provider, model }, status, {}, ctx, reason);
-    if (!switched) return;
-    const loaded = config;
-    if (!loaded || loaded.autoRetry === false) return;
-    const prompt = lastUserPromptText(ctx);
-    if (!prompt) return;
-    ctx.ui.notify(`Model fallback: retrying failed prompt on ${activeFallbackKey}.`, "info");
-    await pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+  pi.on("agent_settled", () => {
+    pendingFailure = undefined;
+    responseFailure = undefined;
   });
 
   pi.registerCommand("model-fallback:status", {
@@ -241,6 +298,7 @@ export default function modelFallback(pi: ExtensionAPI) {
   pi.registerCommand("model-fallback:reset", {
     description: "Return from fallback model to the pre-fallback model when remembered and clear persistent state",
     handler: async (_args, ctx) => {
+      cancelFallback();
       syncPaths(ctx);
       state = { version: 1, entries: [] };
       await writeState(paths.state, state);
@@ -305,6 +363,7 @@ export default function modelFallback(pi: ExtensionAPI) {
       if (!ctx.hasUI) return textResult("Config not saved: confirmation UI is unavailable.", { configPath: paths.config, ...warningDetails(warnings) });
       const ok = await ctx.ui.confirm("Save model fallback config?", summarizeConfig(nextConfig, warnings));
       if (!ok) return textResult("Config not saved.", { configPath: paths.config, ...warningDetails(warnings) });
+      invalidatePending();
       await writeConfig(paths.config, nextConfig);
       config = nextConfig;
       return textResult(configResultText("Config saved.", warnings), { configPath: paths.config, ...warningDetails(warnings) });
@@ -316,29 +375,6 @@ function autoRetryEnabled(config: ModelFallbackConfig): boolean {
   return config.autoRetry !== false;
 }
 
-function lastUserPromptText(ctx: ExtensionContext): string | undefined {
-  const entries = ctx.sessionManager.getEntries() as unknown[];
-  for (let index = entries.length - 1; index >= 0; index -= 1) {
-    const entry = entries[index];
-    if (!isRecord(entry) || !isRecord(entry.message)) continue;
-    const message = entry.message;
-    if (message.role !== "user") continue;
-    return userMessageText(message.content);
-  }
-  return undefined;
-}
-
-function userMessageText(content: unknown): string | undefined {
-  if (typeof content === "string") return content.trim() || undefined;
-  if (!Array.isArray(content)) return undefined;
-  const parts: string[] = [];
-  for (const block of content) {
-    if (isRecord(block) && block.type === "text" && typeof block.text === "string") parts.push(block.text);
-  }
-  const text = parts.join("\n").trim();
-  return text || undefined;
-}
-
 function shouldUseProjectLocalState(ctx: ExtensionContext): boolean {
   const projectSettingsPath = join(ctx.cwd, ".pi", "settings.json");
   return existsSync(projectSettingsPath) && projectSettingsIncludesThisPackage(projectSettingsPath);

package/lib/config.ts

@@ -24,7 +24,7 @@ export interface FallbackRule {
 export interface ModelFallbackConfig {
   version: 1;
   enabled: boolean;
-  /** Re-queue the failed user prompt after switching to the fallback model so the turn retries automatically. Defaults to true. */
+  /** Continue the existing conversation after switching without replaying the user prompt. Defaults to true. */
   autoRetry?: boolean;
   rules: FallbackRule[];
 }

package/lib/error-status.ts

@@ -1,3 +1,5 @@
+import { isRecord } from "./internal.ts";
+
 const REASON_TEXT_PATTERNS: Array<[RegExp, string]> = [
   [/exceeds\s+(?:this|the)\s+model'?s?\s+context\s+length/i, "context_length_exceeded"],
   [/context[\s_-]*length[\s_-]*exceeded/i, "context_length_exceeded"],
@@ -27,9 +29,24 @@ const EMPTY_PROVIDER_RESPONSE_PATTERNS: RegExp[] = [
   /response (has|with) no body/i,
   /stream ended without a terminal event/i,
   /stream ended without finish_reason/i,
+  /^Anthropic stream ended before message_stop$/,
 ];
 
 export function parseStatusFromErrorMessage(message: string): number | undefined {
+  if (message.trimStart().startsWith("{")) {
+    try {
+      const payload: unknown = JSON.parse(message);
+      if (isRecord(payload) && payload.type === "error" && isRecord(payload.error)) {
+        switch (payload.error.type) {
+          case "overloaded_error": return 529;
+          case "rate_limit_error": return 429;
+          case "api_error": return 500;
+        }
+      }
+    } catch {
+      // Non-JSON error text still uses the status patterns below.
+    }
+  }
   for (const pattern of EMPTY_PROVIDER_RESPONSE_PATTERNS) {
     if (pattern.test(message)) {
       // Synthesize 502 so status-based fallback rules fire instead of the
@@ -40,9 +57,8 @@ export function parseStatusFromErrorMessage(message: string): number | undefined
     }
   }
   const patterns: RegExp[] = [
-    // Leading bare status code, optionally prefixed with "Error:", e.g. "401: {\"type\":\"CreditsError\"...}"
-    // or "Error: 401: {\"type\":\"CreditsError\"...}" (OpenCode Go, OpenRouter relays)
-    /^\s*(?:error\s*:?\s*)?([1-5][0-9]{2})\s*:/i,
+    // SDKs use either "429: ..." or "429 {JSON}"; keep ordinary numeric prose unmatched.
+    /^\s*(?:error\s*:?\s*)?([1-5][0-9]{2})(?:\s*:|\s+(?=\{))/i,
     // Anchored "Error: <status> <prose>", e.g. "Error: 429 quota exceeded"
     // (GitHub Copilot). The pattern above needs a colon AFTER the status and the
     // "error <status>" pattern below needs whitespace directly after "error", so
@@ -71,5 +87,8 @@ export function parseStatusFromErrorMessage(message: string): number | undefined
     if (Number.isInteger(status) && status >= 100 && status <= 599) return status;
   }
 
+  // Connection failures have no HTTP response; use the existing unavailable-service rules.
+  if (/^\s*(?:error:\s*)?(?:connection error|request timed out|fetch failed)[.!]?\s*$/i.test(message) ||
+      /\b(?:ECONNRESET|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ETIMEDOUT)\b/.test(message)) return 503;
   return undefined;
 }

package/lib/state.ts

@@ -1,9 +1,14 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, open, realpath, rename, rm } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import lockfile from "proper-lockfile";
 import { modelRefKey, type ModelRef } from "./config.ts";
-import { isRecord, readJsonIfExists, readModelRef, readNonEmptyString } from "./internal.ts";
+import { isNodeError, isRecord, readJsonIfExists, readModelRef, readNonEmptyString } from "./internal.ts";
 
 export const STATE_VERSION = 1;
+const WINDOWS_RENAME_RETRY_MS = 1000;
+const WINDOWS_RENAME_RETRY_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
 
 export interface FallbackStateEntry {
   source: ModelRef;
@@ -30,8 +35,75 @@ export async function readState(path: string, now = new Date()): Promise<Fallbac
 }
 
 export async function writeState(path: string, state: FallbackState): Promise<void> {
+  const next = validateStateShape(state);
+  // Explicit replacement (notably reset) must also be able to repair a corrupt old file.
+  await withStateLock(path, (target, checkLock) => publishState(target, next, checkLock));
+}
+
+/** Serialize the entire read/modify/publish transaction, including across Pi processes. */
+export async function updateState(path: string, update: (current: FallbackState) => FallbackState): Promise<FallbackState> {
+  return withStateLock(path, async (target, checkLock) => {
+    const next = validateStateShape(update(await readState(target)));
+    checkLock();
+    await publishState(target, next, checkLock);
+    return next;
+  });
+}
+
+async function withStateLock<T>(path: string, operation: (target: string, checkLock: () => void) => Promise<T>): Promise<T> {
   await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(validateStateShape(state), null, 2)}\n`, "utf8");
+  // Aliases of the same agent directory must share a lock (the state file may not exist yet).
+  const target = join(await realpath(dirname(path)), basename(path));
+  let compromised: Error | undefined;
+  const release = await lockfile.lock(target, {
+    realpath: false,
+    retries: { retries: 100, factor: 1, minTimeout: 20, maxTimeout: 20, randomize: false },
+    onCompromised: (error) => { compromised = error; },
+  });
+  const checkLock = () => { if (compromised) throw compromised; };
+  try {
+    checkLock();
+    return await operation(target, checkLock);
+  } finally {
+    await release();
+  }
+}
+
+async function publishState(path: string, state: FallbackState, checkLock: () => void): Promise<void> {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  let created = false;
+  try {
+    const file = await open(temporary, "wx", 0o600);
+    created = true;
+    try {
+      await file.writeFile(`${JSON.stringify(state, null, 2)}\n`, "utf8");
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    // Readers see either the old complete document or the new one, never a partial write.
+    checkLock();
+    await replaceStateFile(temporary, path, checkLock);
+  } finally {
+    if (created) await rm(temporary, { force: true });
+  }
+}
+
+async function replaceStateFile(source: string, target: string, checkLock: () => void): Promise<void> {
+  // Windows can reject replacement while an unlocked reader briefly has the target open.
+  const deadline = Date.now() + WINDOWS_RENAME_RETRY_MS;
+  let retryDelayMs = 10;
+  for (;;) {
+    try {
+      await rename(source, target);
+      return;
+    } catch (error) {
+      if (process.platform !== "win32" || !isNodeError(error) || !WINDOWS_RENAME_RETRY_CODES.has(error.code ?? "") || Date.now() >= deadline) throw error;
+      await delay(retryDelayMs);
+      checkLock();
+      retryDelayMs = Math.min(retryDelayMs + 10, 100);
+    }
+  }
 }
 
 export function upsertStateEntry(state: FallbackState, entry: FallbackStateEntry): FallbackState {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-model-fallback",
-  "version": "0.5.2",
+  "version": "0.5.6",
   "description": "Pi extension that switches to a fallback model after provider failures such as 429 rate limits.",
   "type": "module",
   "license": "MIT",
@@ -31,7 +31,8 @@
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "node --test tests/*.test.mjs",
-    "ci": "npm run typecheck && npm test && npm run pack:check",
+    "smoke:pi": "node scripts/pi-sdk-smoke.mjs",
+    "ci": "npm run typecheck && npm test && npm run smoke:pi && npm run pack:check",
     "pack:check": "npm pack --dry-run"
   },
   "pi": {
@@ -45,18 +46,22 @@
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-coding-agent": ">=1.1.0",
     "@earendil-works/pi-tui": "*",
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "^1.0.4",
-    "@earendil-works/pi-ai": "^1.0.4",
-    "@earendil-works/pi-coding-agent": "^1.0.4",
-    "@earendil-works/pi-tui": "^1.0.4",
+    "@earendil-works/pi-agent-core": "1.2.0",
+    "@earendil-works/pi-ai": "1.2.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
+    "@earendil-works/pi-tui": "1.2.0",
     "@types/node": "^26.6.3",
+    "@types/proper-lockfile": "4.1.4",
     "jiti": "^2.7.0",
     "typebox": "latest",
     "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "proper-lockfile": "4.1.2"
   }
 }