@llblab/pi-kit 0.27.5 → 0.27.6

package/BACKLOG.md

@@ -1,9 +1,14 @@
 # Backlog
 
-The 0.27.5 composition is recorded in [CHANGELOG.md](./CHANGELOG.md). Package pins, resource order and bundled runtime ownership remain authoritative in `package.json`.
+The 0.27.6 composition is recorded in [CHANGELOG.md](./CHANGELOG.md). Package pins, resource order and bundled runtime ownership remain authoritative in `package.json`.
+
+## Release acceptance
+
+- **Publication:** Once State Flow 0.25.5 is verified on npm, install its exact pin, validate the packed kit and run the exact-tag workflow; verify GitHub Release and npm identity.
 
 ## Carried checks
 
+- **Installed 0.27.6 restoration/compaction smoke (operator-owned):** After separately authorized installation/reload, use disposable storage to confirm failed Active restoration blocks provider inference across tree/reload, explicit mode recovery remains available, and native Codemode values/deletions survive completed-history compaction. Packed validation does not certify installed clients.
 - **Installed 0.27.5 cleanup smoke (operator-owned):** After separately authorized installation/reload, confirm State Flow missing-deletion hints, recursive empty-object cleanup, inherited fallback and preserved array slots in disposable storage. Packed validation does not certify installed clients.
 - **Installed 0.27.4 inspection smoke (operator-owned):** After separately authorized installation/reload, inspect a large nested State Flow field in disposable storage. Confirm readable JSON layout, separate truncation notices and intact genuine string escapes. Packed validation does not certify installed Telegram clients.
 - **Installed 0.27.3 single patch display smoke (operator-owned):** After separately authorized installation/reload, confirm one argument block followed by changed/no-op acknowledgements, compact configuration and visible rejected arguments/errors in disposable State Flow storage.

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.27.6: State Flow Restoration Fence and Codemode Compaction
+
+- `Restoration and Compaction`: Advances the exact State Flow pin to `0.25.5`. Failed Active restoration blocks inference before the provider rather than exposing native history; valid selection, accepted Start or explicit Passive/Off permits recovery. Native Codemode metadata no longer blocks completed-history compaction, while values/deletions survive compaction and resume. Unknown metadata and visible custom context stay protected. Other pins, resources and load order are unchanged.
+
 ## 0.27.5: State Flow Cleanup and Deletion Hints
 
 - `Cleanup and Deletion Hints`: Advances the exact State Flow pin to `0.25.4`. Accepted scopes recursively drop empty object fields without shifting array slots; cleanup may reveal inherited values. Missing authored deletions report their target and first unavailable component without blocking useful writes or creating revisions. Exact history and untouched scopes stay unchanged. Other pins, resources and load order are unchanged.

package/README.md

@@ -17,7 +17,7 @@ Package links lead to the owning repositories for usage, documentation, issues,
 | [`@llblab/pi-clean-room`](https://github.com/llblab/pi-clean-room) | `0.3.0` | Isolated nested Pi TUI with named npm extensions and compatible model selection |
 | [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.12.1` | Shared Codex quota/Business credit status and persistent priority Fast toggle, mirrored in Telegram |
 | [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.9.0` | Visible continuation scheduling and bounded worker Skills through compiled, manifest-owned resources |
-| [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.25.4` | Scoped context/memory compiler with intent-owned memory, recursive empty-object cleanup, missing-deletion hints and readable Telegram inspection |
+| [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.25.5` | Scoped context/memory compiler with intent-owned memory, failed Active restoration fencing and Codemode-safe compaction |
 | [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.51.6` | Telegram companion with connection resume, Workspace slot recovery, follower Threads, filterable Skills, files, voice, and controls |
 | [`@llblab/skills`](https://github.com/llblab/skills) | `1.15.0` | Portable workflows for engineering, review, design, context maintenance, and other focused tasks |
 
@@ -25,7 +25,7 @@ Versions are exact by design. An upstream release does not change an installed k
 
 ## Install
 
-Requires **Pi 1.0.0+** and **Node.js 22.19.0+**. State Flow requires its canonical checkpoint/tail storage format and does not convert unsupported stores in place. Preserve existing stores and consult the [owning package's storage guidance](https://github.com/llblab/pi-state-flow/blob/v0.25.4/docs/usage.md#moving-a-store-and-supported-formats) before changing installations.
+Requires **Pi 1.0.0+** and **Node.js 22.19.0+**. State Flow requires its canonical checkpoint/tail storage format and does not convert unsupported stores in place. Preserve existing stores and consult the [owning package's storage guidance](https://github.com/llblab/pi-state-flow/blob/v0.25.5/docs/usage.md#moving-a-store-and-supported-formats) before changing installations.
 
 From npm:
 
@@ -45,7 +45,7 @@ Prefer the kit instead of separately loading the same packages. If you already u
 
 ## Development
 
-The `0.27.5` composition includes State Flow `0.25.4` with recursive empty-object cleanup and missing-deletion hints; all other pins, resources and load order remain unchanged. `npm run validate` checks exact installed pins, declared resources, dependency audit and bundled inventory. It does not certify installed-client rendering; carried checks remain in [Backlog](./BACKLOG.md).
+The `0.27.6` composition includes State Flow `0.25.5` with failed Active restoration fencing and Codemode-safe compaction; all other pins, resources and load order remain unchanged. `npm run validate` checks exact installed pins, declared resources, dependency audit and bundled inventory. It does not certify installed-client rendering; carried checks remain in [Backlog](./BACKLOG.md).
 
 ```bash
 npm install

package/node_modules/@llblab/pi-state-flow/AGENTS.md

@@ -18,7 +18,7 @@ The [relocation ledger](docs/agent-contract-relocation.md) maps every pre-compac
 
 - Treat canonical scope files as semantic authority and Git only as optional backup. Classify complete, wholly absent, partial and malformed cohorts before recovery; absent shared pairs may initialize only under accepted authority, while incomplete/private evidence fails closed. Never repair through ad-hoc writes. See [storage recovery](docs/usage.md#storage-and-recovery) and [transaction rule](docs/filesystem-recovery.md#transaction-rule).
 - Keep exact regular-file, byte-CAS and lock-serialized publication with cancelable waits, single-use callback-scoped capabilities and guarded rollback. Never hold exclusion across inference, source acquisition or Git; do not steal interrupted locks, claim kernel-atomic multi-file publication or promise power-loss durability. See [asynchronous transaction](docs/architecture.md#asynchronous-storage-transaction) and [durability boundary](docs/filesystem-recovery.md#power-loss-durability).
-- Attach Off branches through native policy bookkeeping only, deferring memory acquisition and recovery diagnostics until explicit Passive/Active. Preserve pending Off forks across cold reload with child-owned native markers, without reading the parent header/store until acquisition. When memory is selected, restore private retained boundaries over live shared scopes and copy exact proven source-session history into a fresh fork owner; never substitute current, empty, Git or another branch on expiry/failure. Explicit Start instead validates current same-session authority. Only accepted candidates install cache, checkpoint and mode. See [Pi lifecycle](docs/architecture.md#pi-lifecycle) and [fork contract](docs/fork-contract.md).
+- Attach Off branches through native policy bookkeeping only, deferring memory acquisition and recovery diagnostics until explicit Passive/Active. Preserve pending Off forks across cold reload with child-owned native markers, without reading the parent header/store until acquisition. When memory is selected, restore private retained boundaries over live shared scopes and copy exact proven source-session history into a fresh fork owner; never substitute current, empty, Git or another branch on expiry/failure. Explicit Start instead validates current same-session authority. Only accepted candidates install cache, checkpoint and mode. Failed selected Active restoration fences live inference through public Abort until valid selection, accepted Start or explicit Passive/Off; never silently expose native history as the inactive fallback. See [Pi lifecycle](docs/architecture.md#pi-lifecycle) and [fork contract](docs/fork-contract.md).
 - Persist each material semantic change and its affected revisions exactly once, including accepted Session responses. Optional settled-turn Git backup may capture only already-accepted owned files, leave unrelated index/worktree data intact and push without force or semantic side effects. Defer busy backup when the host provides no settlement operation signal rather than blocking Abort; never move it to `turn_end` or add a durable push queue. Off cancels owned captures/pushes and suppresses late reporting; normal agent-operation completion must not cancel an independently admitted push, and foreign callers' pushes retain ownership. See [optional Git backup](docs/architecture.md#optional-git-backup).
 - Accept one atomic `patch_state` cohort across supplied scopes against current shared memory; reject empty scopes, unknown/retired grammar and model-authored `response`. Correct no-ops create no transition. Enforce the single-call inference barrier before sibling tools execute and retain conservative model-facing reconciliation when a result cannot be predicted. See [model tools](docs/architecture.md#model-tools) and [Pi lifecycle](docs/architecture.md#pi-lifecycle).
 - Reconcile the actual accepted ordinary answer at `turn_end` with response-owned cancellation and one accepted lifecycle publication; do not request private repair inference, ceremonial finalization patches or roll back accepted memory after cancellation. See [Pi lifecycle](docs/architecture.md#pi-lifecycle).

package/node_modules/@llblab/pi-state-flow/BACKLOG.md

@@ -1,6 +1,6 @@
 # Backlog
 
-The **0.25.4: Empty-Object Cleanup and Deletion Hints** hotfix outcomes belong in [CHANGELOG.md](CHANGELOG.md). This backlog retains publication, installed-client gates and deferred decisions.
+The **0.25.5: Active Restoration Fence and Codemode Compaction** hotfix is prepared; outcomes belong in [CHANGELOG.md](CHANGELOG.md). This backlog retains publication, installed-client gates and deferred decisions.
 
 ## Out of scope
 
@@ -8,9 +8,13 @@ The **0.25.4: Empty-Object Cleanup and Deletion Hints** hotfix outcomes belong i
 - Nested `lazy_navigation` and intent-ownership warnings, validation or rejection. Authored missing-deletion hints do not change cascade behavior.
 - Any reduction of lifecycle state; the tagged-union question stays deferred.
 
+## 0.25.5 acceptance
+
+- **Publication.** Run the exact-tag workflow and verify GitHub Release/npm identity, then synchronize and release Pi Kit 0.27.6.
+- **Installed restoration/compaction smoke (operator-owned).** After separately authorized reload, use disposable storage to confirm failed Active restoration blocks provider inference across tree/reload, explicit mode recovery remains available, and native Codemode values/deletions survive completed-history compaction. Local/native tests do not certify the installed client.
+
 ## Carried gates
 
-- **0.25.4 publication and kit synchronization.** Verify the exact-tag workflow, GitHub Release and npm commit, then bundle and publish Pi Kit 0.27.5.
 - **Installed 0.25.4 cleanup smoke (operator-owned).** After separately authorized installation/reload, use disposable storage to confirm missing-deletion hints, recursive empty-object cleanup, inherited fallback and preserved array slots. Local validation and publication do not certify installed clients.
 - **Installed 0.25.3 inspection smoke (operator-owned).** After separately authorized installation/reload, inspect a large nested field: real layout newlines/quotes, separate omitted-character notice and intact genuine JSON string escapes. Use disposable storage; local adapter tests do not certify installed Telegram clients.
 - **Installed 0.25.2 smoke (operator-owned).** Disposable store: confirm one patch argument block followed by changed/no-op acknowledgements, compact rows with `showSuccessfulPatches: false`, and visible rejected arguments/errors.

package/node_modules/@llblab/pi-state-flow/CHANGELOG.md

@@ -2,7 +2,10 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
-## Unreleased
+## 0.25.5: Active Restoration Fence and Codemode Compaction
+
+- `Active restoration fence`: Failed retained Active restoration aborts live inference instead of silently exposing native history under an inactive fallback. Expired tree/reload and contradictory-lineage native tests prove zero provider calls and unchanged memory. Valid selection, accepted Start or explicit Passive/Off releases the fence; historical authority is never substituted.
+- `Codemode-safe compaction`: Exact native `codemode-store` metadata no longer blocks completed-history compaction. Full branch records remain intact; native Codemode reads prove values and deletions survive compaction, reload and resume. Unknown metadata and visible custom context remain protected.
 
 ## 0.25.4: Empty-Object Cleanup and Deletion Hints
 

package/node_modules/@llblab/pi-state-flow/dist/lib/compaction.js

@@ -3,10 +3,11 @@ import { estimateTokens } from "@earendil-works/pi-coding-agent";
 export const STATE_FLOW_COMPACTION_SUMMARY = "State Flow accepted the completed work before this boundary. Current memory is restored from its retained semantic boundary and projected separately; use the retained native entries for subsequent work.";
 /** A modest margin above Pi's default 20k retained suffix absorbs estimation drift. */
 export const STATE_FLOW_COMPACTION_MIN_CONTEXT_TOKENS = 24_000;
-function stateFlowEntry(entry) {
+function contextInvisibleEntry(entry) {
+    // Codemode reconstructs its store from the full native branch, not the compacted model context.
     return entry.type === "custom"
         && typeof entry.customType === "string"
-        && entry.customType.startsWith("state-flow-");
+        && (entry.customType.startsWith("state-flow-") || entry.customType === "codemode-store");
 }
 export function shouldRequestStateFlowCompaction(usage) {
     return typeof usage?.tokens === "number"
@@ -45,7 +46,7 @@ export function planStateFlowCompaction(entries, boundary, step, runAnchorTimest
     const keep = entries.findIndex(isRunAnchor);
     if (keep < 0 || keep > terminal || entries.findLastIndex(isRunAnchor) !== keep)
         return undefined;
-    if (entries.slice(0, keep).some((entry) => entry.type === "custom_message" || (entry.type === "custom" && !stateFlowEntry(entry))))
+    if (entries.slice(0, keep).some((entry) => entry.type === "custom_message" || (entry.type === "custom" && !contextInvisibleEntry(entry))))
         return undefined;
     const firstKeptEntryId = entries[keep]?.id;
     const leafId = entries.at(-1)?.id;

package/node_modules/@llblab/pi-state-flow/dist/lib/extension.js

@@ -42,7 +42,7 @@ export default function stateFlowExtension(pi, options = {}) {
     let scopeStates = { global: emptyState(), cwd: emptyState(), session: emptyState() };
     let effectiveState = {};
     let branchStartsWithoutRuntime = false;
-    let selectedHistoryExpired = false;
+    let selectedBoundaryError;
     let modePersistenceError;
     /** One pending inactive-mode persistence; later inactive choices coalesce until it publishes. */
     const inactivePersistence = new OwnedOperationSlot();
@@ -390,7 +390,7 @@ export default function stateFlowExtension(pi, options = {}) {
                 runtime = undefined;
                 snapshot = emptySnapshot("off");
                 branchStartsWithoutRuntime = withoutRuntime;
-                selectedHistoryExpired = false;
+                selectedBoundaryError = undefined;
                 modePersistenceError = persistenceError;
                 forkInitialization = reason === "fork";
                 installScopeStates();
@@ -408,7 +408,7 @@ export default function stateFlowExtension(pi, options = {}) {
         runtime = createRuntime(ctx);
         installScopeStates();
         branchStartsWithoutRuntime = false;
-        selectedHistoryExpired = false;
+        selectedBoundaryError = undefined;
         forkInitialization = sessionStartReason === "fork";
         let selection = { kind: "settled" };
         let skipped = 0;
@@ -439,6 +439,8 @@ export default function stateFlowExtension(pi, options = {}) {
                                 ? { ...selected.checkpoint, mode: sourceFence.mode ?? config.inactiveMode } : selected.checkpoint };
                     }
                     catch (error) {
+                        selectedBoundaryError = { expired: error instanceof HistoryBoundaryExpiredError,
+                            blockInference: selected.checkpoint.mode === "active" && requestedMode === undefined };
                         snapshot = selectedBoundaryFailure(diagnosticText(error), inactiveSelection(selected.checkpoint.mode));
                     }
                 }
@@ -500,6 +502,13 @@ export default function stateFlowExtension(pi, options = {}) {
                 throw new Error("State Flow branch selection changed while awaiting publication");
         };
         let accepted = false;
+        const failSelection = (error) => {
+            selectedBoundaryError = { expired: error instanceof HistoryBoundaryExpiredError,
+                blockInference: pending.requestedMode === undefined && (selection.kind === "auto-start"
+                    || ((selection.kind === "restore" || selection.kind === "fork") && selection.checkpoint.mode === "active")) };
+            snapshot = selectedBoundaryFailure(diagnosticText(error), inactiveSelection(snapshot.config.mode));
+            installScopeStates();
+        };
         // Install accepted memory before native writes; later ancillary failures cannot revert or replay it.
         const accept = (candidate, next, nativeWrites) => {
             accepted = true;
@@ -583,10 +592,7 @@ export default function stateFlowExtension(pi, options = {}) {
                     }
                     if (!isCurrent())
                         return;
-                    if (error instanceof HistoryBoundaryExpiredError)
-                        selectedHistoryExpired = true;
-                    snapshot = selectedBoundaryFailure(diagnosticText(error), snapshot.config.mode === "active" ? config.inactiveMode : snapshot.config.mode);
-                    installScopeStates();
+                    failSelection(error);
                 }
                 finally {
                     pending.awaitingAcceptance = false;
@@ -612,8 +618,7 @@ export default function stateFlowExtension(pi, options = {}) {
             // Host failures before acceptance leave the selection unavailable, never invented empty memory.
             if (accepted || !isCurrent())
                 return;
-            snapshot = selectedBoundaryFailure(diagnosticText(error), snapshot.config.mode === "active" ? config.inactiveMode : snapshot.config.mode);
-            installScopeStates();
+            failSelection(error);
         }
         finally {
             pending.awaitingAcceptance = false;
@@ -642,7 +647,7 @@ export default function stateFlowExtension(pi, options = {}) {
     function settleSelection(ctx, reason, notifyRecovery, skipped, selectedMemory) {
         const failure = !isActive() && snapshot.meta.validation?.attempt === 0 ? snapshot.meta.validation.error : undefined;
         if (failure !== undefined && notifyRecovery && !modePersistenceError) {
-            if (selectedHistoryExpired)
+            if (selectedBoundaryError?.expired)
                 notifyProblem(ctx, "State Flow history is outside the retained temporal window; /state-flow-active can use current session memory.", "warning");
             else
                 notifyProblem(ctx, `State Flow restore failed: ${failure}`, "error");
@@ -919,14 +924,14 @@ export default function stateFlowExtension(pi, options = {}) {
                     ? findPassiveStopBoundary(ctx.sessionManager.getBranch(), owner, PASSIVE_STOP_ENTRY_TYPE) : undefined;
                 const bootstrap = hasPriorConversation(ctx.sessionManager.getBranch()) || passiveContinuation !== undefined || boundary !== undefined;
                 const activated = current ? resumeEpisode(current, bootstrap) : startEpisode(bootstrap);
-                const recoveredCurrent = selectedHistoryExpired;
+                const recoveredCurrent = selectedBoundaryError?.expired;
                 publish(activated);
                 accepted = true;
                 inactivePersistence.cancel();
                 runtime = selected = activation;
                 snapshot = activated;
                 activeContext = ctx;
-                selectedHistoryExpired = false;
+                selectedBoundaryError = undefined;
                 modePersistenceError = undefined;
                 installScopeStates();
                 const continuation = passiveContinuation ?? bootstrapContinuation ?? (deferred ? selectedContinuation(ctx, deferred.reason) : undefined);
@@ -988,6 +993,8 @@ export default function stateFlowExtension(pi, options = {}) {
     /** Local policy, tools and UI change before any canonical wait. */
     function applyInactiveMode(ctx, mode) {
         snapshot = deactivateEpisode(snapshot, mode);
+        if (selectedBoundaryError)
+            selectedBoundaryError.blockInference = false;
         clearRunTransient();
         syncStateFlowTools();
         updateUi(ctx);
@@ -1074,7 +1081,7 @@ export default function stateFlowExtension(pi, options = {}) {
         acquisition.reset();
         runtime = undefined;
         snapshot = emptySnapshot("off");
-        selectedHistoryExpired = false;
+        selectedBoundaryError = undefined;
         branchStartsWithoutRuntime = preRuntime;
         forkInitialization = pendingFork;
         deferredBranch = { owner: address.key, cwd: ctx.cwd, reason: pendingFork ? "fork" : undefined };
@@ -1307,6 +1314,12 @@ export default function stateFlowExtension(pi, options = {}) {
         return { messages: projection.project(source, view, () => runtimeContextHead(snapshot, view, projectRecentTransitionsWithLimit(config.historyLimit, runtime?.recent() ?? []))) };
     }
     function prepareContext(messages, ctx) {
+        // Pi continues after hook errors; public Abort fences inference instead of exposing the native history fallback.
+        if (selectedBoundaryError?.blockInference && ctx.signal && !shuttingDown) {
+            ctx.abort();
+            notifyProblem(ctx, "State Flow inference blocked: Active memory restoration failed. Select a valid branch or use /state-flow-active for current memory; /state-flow-passive or /state-flow-off explicitly permits native context.", "error");
+            return;
+        }
         const pending = inferencePreparation.current;
         const selected = runtime;
         const operationSignal = ctx.signal;

package/node_modules/@llblab/pi-state-flow/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-state-flow",
-  "version": "0.25.4",
+  "version": "0.25.5",
   "license": "MIT",
   "private": false,
   "description": "Incremental scoped state/context/memory compiler for Pi, inspired by SKILL.state",

package/node_modules/@llblab/pi-state-flow/docs/architecture.md

@@ -328,7 +328,7 @@ The current user specification stays at user authority and appears only in synth
 
 **Why no retain-none boundaries.** State Flow does not use retain-none boundary compactions. Completed canonical state omits the exact user prompt, and foreign custom context can legitimately occur inside the latest retained iteration; hiding both would make the projected semantic state a lossy substitute for native context.
 
-**What prevents the boundary:** unknown or smaller usage, foreign custom metadata or native `custom_message` context in the prefix that would be removed, stale selection, Stop/bootstrap/error/abort, and pending input. User manual and native threshold/overflow compaction stay unmodified; unaccepted work stays under Pi's native compaction contract.
+**What prevents the boundary:** unknown or smaller usage, foreign custom metadata or native `custom_message` context in the prefix that would be removed, stale selection, Stop/bootstrap/error/abort, and pending input. The exact native `custom` type `codemode-store` is exempt alongside State Flow metadata: it carries no model context, and Codemode reconstructs its values/deletions from the full append-only branch even after compaction. Unknown types, similarly named types and visible custom messages are not exempt. User manual and native threshold/overflow compaction stay unmodified; unaccepted work stays under Pi's native compaction contract.
 
 ### Context view and trajectory
 
@@ -510,6 +510,8 @@ Without removals on a complete accepted cohort, publication preserves semantic/p
 3. **Acceptance.** The selected boundary, the exact-source fork, a truly new auto-start origin (`withStartTransaction` with creation authority, rechecking branch evidence after waiting) or failed-Stop read-only recovery then use the awaited runtime API. Bootstrap and policy are derived after waiting and published in that single acceptance.
 4. **Installation.** Only the current lifetime installs memory, checkpoint, continuation, tools and UI before yielding; a later native-write failure only warns.
 
+**Failed Active selection.** An unaccepted Active restoration/fork or automatic Start failure carries an inference fence independently of the inactive fallback mode. The live `context` hook calls public `ctx.abort()` before returning; merely throwing would let Pi continue with native history. Re-selecting/reloading the failed Active boundary reconstructs the fence. Accepted Start or a valid branch releases it; explicit Passive/Off permits native context but grants no missing historical/publication authority. Signal-less inspection does not cancel or clear the fence.
+
 **Interaction with mode choices:**
 
 - A new selection revokes older work; shutdown drains current and superseded restoration operations.

package/node_modules/@llblab/pi-state-flow/docs/compatibility.md

@@ -53,7 +53,7 @@ On the tested SDK, `before_agent_start` precedes the low-level agent's `prompt`;
 2. The active `context` hook supplies the operation signal and awaits preparation/maintenance before provider inference.
 3. If preparation fails, State Flow calls public `ctx.abort()`. Pi catches context-hook errors and may otherwise continue inference, so a thrown error alone is not a fence.
 
-Native tests prove no provider call before coherent acceptance, cancellation while an independent writer remains held, rollback without draft installation and preservation of uncompiled native input.
+Native tests prove no provider call before coherent acceptance, cancellation while an independent writer remains held, rollback without draft installation and preservation of uncompiled native input. Failed retained Active restoration also aborts live inference before the provider; native witnesses cover expired tree selection/reload and contradictory private lineage without changing canonical bytes. Explicit inactive policy releases that inference fence, not the write fence.
 
 **Signals are not universal.** Idle commands and session events can lack them. Do not infer native Abort cancellation from an extension-owned shutdown signal or generalize active-run tests to idle waits.
 
@@ -126,7 +126,7 @@ This optional-backup policy does not apply to required semantic publication or r
 **State Flow-owned compaction:**
 
 - Requires known sufficient context usage and a proven retained run anchor.
-- Preserves the complete accepted run, skips protected foreign context and never requests retain-none shortening.
+- Preserves the complete accepted run, skips protected foreign context and never requests retain-none shortening. Exact native `codemode-store` custom metadata permits shortening; native tests preserve its branch records and verify `load()` values/deletions through the real Codemode extension after compaction/reload/resume.
 - Leaves native manual/threshold/overflow compaction to Pi.
 - Awaits native compaction completion or refusal in the settled handler, so deferred companion prompts do not race it.
 - Skips compaction when usage is unknown or insufficient; a benign refusal permits a later attempt.

package/node_modules/@llblab/pi-state-flow/docs/usage.md

@@ -93,7 +93,7 @@ How each lifecycle event behaves:
   - A missing or ambiguous native anchor skips compaction instead of choosing the last steering message.
   - On resume, native `buildContextEntries()` and TUI rendering omit the older completed prefix.
   - Unknown or smaller usage skips the request, and custom Pi retention settings may still decline it benignly.
-  - These prevent State Flow-owned shortening: foreign custom context in the prefix that would be removed, bootstrap/abort/error, Stop and pending input.
+  - These prevent State Flow-owned shortening: foreign custom context in the prefix that would be removed, bootstrap/abort/error, Stop and pending input. Pi's context-invisible `codemode-store` metadata does not block shortening: it stays on the full native branch, so `load()` and deletions survive compaction and resume. Unknown metadata and all `custom_message` entries remain protected.
   - Obsolete or inactive owned requests are canceled before their hook can fall through to a model summary, and a late completion cannot clear a newer request.
   - Ordinary manual/threshold/overflow compaction stays native and may preserve unfinished work not yet patched into memory.
 
@@ -281,6 +281,7 @@ A missing or expired private retained boundary is unavailable; State Flow does n
 
 **After a selected-boundary failure:**
 
+- If the selected Active boundary cannot be restored, live inference is aborted before the provider instead of silently sending native history under an inactive fallback. Reload/resume retains this fence. Select a valid branch or explicitly Start from current same-session memory; explicit Passive/Off permits native context without repairing historical authority. Signal-less inspection remains observational.
 - Passive may still expose current global/CWD memory, but never the unavailable historical session layer or permission to publish an empty replacement.
 - Historical session reads and every `patch_state` refuse without changing canonical files or appending substitute checkpoints.
 - Passive/Off selection stays available and records the native policy/write fence described above. A later reload may expose validated current memory read-only, not the unavailable selected history.

package/node_modules/@llblab/pi-state-flow/lib/compaction.ts

@@ -26,10 +26,11 @@ type ActiveEntry = {
 	message?: { role?: unknown; stopReason?: unknown; content?: unknown; timestamp?: unknown };
 };
 
-function stateFlowEntry(entry: ActiveEntry): boolean {
+function contextInvisibleEntry(entry: ActiveEntry): boolean {
+	// Codemode reconstructs its store from the full native branch, not the compacted model context.
 	return entry.type === "custom"
 		&& typeof entry.customType === "string"
-		&& entry.customType.startsWith("state-flow-");
+		&& (entry.customType.startsWith("state-flow-") || entry.customType === "codemode-store");
 }
 
 export function shouldRequestStateFlowCompaction(usage: { tokens: number | null } | undefined): boolean {
@@ -70,7 +71,7 @@ export function planStateFlowCompaction(
 	const isRunAnchor = (entry: ActiveEntry) => entry.type === "message" && entry.message?.role === "user" && entry.message.timestamp === runAnchorTimestamp;
 	const keep = entries.findIndex(isRunAnchor);
 	if (keep < 0 || keep > terminal || entries.findLastIndex(isRunAnchor) !== keep) return undefined;
-	if (entries.slice(0, keep).some((entry) => entry.type === "custom_message" || (entry.type === "custom" && !stateFlowEntry(entry)))) return undefined;
+	if (entries.slice(0, keep).some((entry) => entry.type === "custom_message" || (entry.type === "custom" && !contextInvisibleEntry(entry)))) return undefined;
 	const firstKeptEntryId = entries[keep]?.id;
 	const leafId = entries.at(-1)?.id;
 	if (typeof firstKeptEntryId !== "string" || typeof leafId !== "string") return undefined;

package/node_modules/@llblab/pi-state-flow/lib/extension.ts

@@ -93,7 +93,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 	let scopeStates: ScopedStates = { global: emptyState(), cwd: emptyState(), session: emptyState() };
 	let effectiveState: SemanticState = {};
 	let branchStartsWithoutRuntime = false;
-	let selectedHistoryExpired = false;
+	let selectedBoundaryError: { expired: boolean; blockInference: boolean } | undefined;
 	let modePersistenceError: string | undefined;
 	/** One pending inactive-mode persistence; later inactive choices coalesce until it publishes. */
 	const inactivePersistence = new OwnedOperationSlot<InactivePersistence>();
@@ -448,7 +448,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 				runtime = undefined;
 				snapshot = emptySnapshot("off");
 				branchStartsWithoutRuntime = withoutRuntime;
-				selectedHistoryExpired = false;
+				selectedBoundaryError = undefined;
 				modePersistenceError = persistenceError;
 				forkInitialization = reason === "fork";
 				installScopeStates();
@@ -464,7 +464,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 		runtime = createRuntime(ctx);
 		installScopeStates();
 		branchStartsWithoutRuntime = false;
-		selectedHistoryExpired = false;
+		selectedBoundaryError = undefined;
 		forkInitialization = sessionStartReason === "fork";
 		let selection: BranchSelection = { kind: "settled" };
 		let skipped = 0;
@@ -492,6 +492,8 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 						selection = { kind: "fork", source, checkpoint: sourceFence?.persistenceError !== undefined
 							? { ...selected.checkpoint, mode: sourceFence.mode ?? config.inactiveMode } : selected.checkpoint };
 					} catch (error) {
+						selectedBoundaryError = { expired: error instanceof HistoryBoundaryExpiredError,
+							blockInference: selected.checkpoint.mode === "active" && requestedMode === undefined };
 						snapshot = selectedBoundaryFailure(diagnosticText(error), inactiveSelection(selected.checkpoint.mode));
 					}
 				} else if (selected.kind === "boundary") {
@@ -548,6 +550,13 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 			if (!isCurrent()) throw new Error("State Flow branch selection changed while awaiting publication");
 		};
 		let accepted = false;
+		const failSelection = (error: unknown): void => {
+			selectedBoundaryError = { expired: error instanceof HistoryBoundaryExpiredError,
+				blockInference: pending.requestedMode === undefined && (selection.kind === "auto-start"
+					|| ((selection.kind === "restore" || selection.kind === "fork") && selection.checkpoint.mode === "active")) };
+			snapshot = selectedBoundaryFailure(diagnosticText(error), inactiveSelection(snapshot.config.mode));
+			installScopeStates();
+		};
 		// Install accepted memory before native writes; later ancillary failures cannot revert or replay it.
 		const accept = (candidate: TemporalRuntime, next: Snapshot, nativeWrites: () => void): void => {
 			accepted = true;
@@ -616,9 +625,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 						return;
 					}
 					if (!isCurrent()) return;
-					if (error instanceof HistoryBoundaryExpiredError) selectedHistoryExpired = true;
-					snapshot = selectedBoundaryFailure(diagnosticText(error), snapshot.config.mode === "active" ? config.inactiveMode : snapshot.config.mode);
-					installScopeStates();
+					failSelection(error);
 				} finally {
 					pending.awaitingAcceptance = false;
 				}
@@ -637,8 +644,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 		} catch (error) {
 			// Host failures before acceptance leave the selection unavailable, never invented empty memory.
 			if (accepted || !isCurrent()) return;
-			snapshot = selectedBoundaryFailure(diagnosticText(error), snapshot.config.mode === "active" ? config.inactiveMode : snapshot.config.mode);
-			installScopeStates();
+			failSelection(error);
 		} finally {
 			pending.awaitingAcceptance = false;
 			branchRestoration.release(pending);
@@ -668,7 +674,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 	function settleSelection(ctx: ExtensionContext, reason: unknown, notifyRecovery: boolean, skipped: number, selectedMemory: boolean): void {
 		const failure = !isActive() && snapshot.meta.validation?.attempt === 0 ? snapshot.meta.validation.error : undefined;
 		if (failure !== undefined && notifyRecovery && !modePersistenceError) {
-			if (selectedHistoryExpired) notifyProblem(ctx, "State Flow history is outside the retained temporal window; /state-flow-active can use current session memory.", "warning");
+			if (selectedBoundaryError?.expired) notifyProblem(ctx, "State Flow history is outside the retained temporal window; /state-flow-active can use current session memory.", "warning");
 			else notifyProblem(ctx, `State Flow restore failed: ${failure}`, "error");
 		}
 		const continuation = selectedMemory ? selectedContinuation(ctx, reason) : undefined;
@@ -909,14 +915,14 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 					? findPassiveStopBoundary(ctx.sessionManager.getBranch(), owner, PASSIVE_STOP_ENTRY_TYPE) : undefined;
 				const bootstrap = hasPriorConversation(ctx.sessionManager.getBranch()) || passiveContinuation !== undefined || boundary !== undefined;
 				const activated = current ? resumeEpisode(current, bootstrap) : startEpisode(bootstrap);
-				const recoveredCurrent = selectedHistoryExpired;
+				const recoveredCurrent = selectedBoundaryError?.expired;
 				publish(activated);
 				accepted = true;
 				inactivePersistence.cancel();
 				runtime = selected = activation;
 				snapshot = activated;
 				activeContext = ctx;
-				selectedHistoryExpired = false;
+				selectedBoundaryError = undefined;
 				modePersistenceError = undefined;
 				installScopeStates();
 				const continuation = passiveContinuation ?? bootstrapContinuation ?? (deferred ? selectedContinuation(ctx, deferred.reason) : undefined);
@@ -984,6 +990,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 	/** Local policy, tools and UI change before any canonical wait. */
 	function applyInactiveMode(ctx: ExtensionContext, mode: InactiveMode): void {
 		snapshot = deactivateEpisode(snapshot, mode);
+		if (selectedBoundaryError) selectedBoundaryError.blockInference = false;
 		clearRunTransient();
 		syncStateFlowTools();
 		updateUi(ctx);
@@ -1064,7 +1071,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 		acquisition.reset();
 		runtime = undefined;
 		snapshot = emptySnapshot("off");
-		selectedHistoryExpired = false;
+		selectedBoundaryError = undefined;
 		branchStartsWithoutRuntime = preRuntime;
 		forkInitialization = pendingFork;
 		deferredBranch = { owner: address.key, cwd: ctx.cwd, reason: pendingFork ? "fork" : undefined };
@@ -1296,6 +1303,12 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 	}
 
 	function prepareContext(messages: AgentMessage[], ctx: ExtensionContext): ReturnType<typeof projectContext> | Promise<ReturnType<typeof projectContext>> {
+		// Pi continues after hook errors; public Abort fences inference instead of exposing the native history fallback.
+		if (selectedBoundaryError?.blockInference && ctx.signal && !shuttingDown) {
+			ctx.abort();
+			notifyProblem(ctx, "State Flow inference blocked: Active memory restoration failed. Select a valid branch or use /state-flow-active for current memory; /state-flow-passive or /state-flow-off explicitly permits native context.", "error");
+			return;
+		}
 		const pending = inferencePreparation.current;
 		const selected = runtime;
 		const operationSignal = ctx.signal;

package/node_modules/@llblab/pi-state-flow/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-state-flow",
-  "version": "0.25.4",
+  "version": "0.25.5",
   "license": "MIT",
   "private": false,
   "description": "Incremental scoped state/context/memory compiler for Pi, inspired by SKILL.state",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.27.5",
+  "version": "0.27.6",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -46,7 +46,7 @@
     "@llblab/pi-clean-room": "0.3.0",
     "@llblab/pi-codex-usage": "0.12.1",
     "@llblab/pi-grow-loop": "0.9.0",
-    "@llblab/pi-state-flow": "0.25.4",
+    "@llblab/pi-state-flow": "0.25.5",
     "@llblab/pi-telegram": "0.51.6",
     "@llblab/skills": "1.15.0"
   },