@llblab/pi-kit 0.20.0 → 0.21.1

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.21.1 - 2026-09-23
+
+- `Queue Transition Reliability`: Advances the exact Telegram pin to `0.51.1`. Busy `/next` now reports the interrupted turn and exact selected queued prompt in order, preserves one reply-header owner through agent start, keeps rapid ordinary messages separate, and lets `/abort` or `/stop` cancel stale notices without allowing notice failures to block dispatch.
+- `Follower Heartbeat Stability`: Uses a dedicated eight-second follower heartbeat response deadline aligned with leader stale-liveness policy, preventing ordinary multi-second Pi/TUI event-loop stalls from destroying a healthy socket, producing leader `EPIPE` noise, or cycling registration status.
+- `Package Cohort`: Keeps every other bundled package at its current exact version. Package membership, resource paths, load order, Pi minimum, and bundled Skill ownership remain unchanged.
+
+## 0.21.0 - 2026-09-23
+
+- `Independent Scope Revisions`: Advances the exact State Flow pin to `0.18.0`. Global, CWD, and Session now persist independent semantic revision counters, Effective displays the truthful `G#/C#/S#` vector, and Session exclusively owns response state while Global and CWD retain only their structural placeholders.
+- `Progressive Backup Replication`: Settled-turn backup attempts asynchronously push the exact current commit to the attached branch's explicitly configured remote/ref without force. Canonical acceptance and response delivery never wait for or roll back on push failure, and a later accepted turn retries the latest backup.
+- `Lifecycle And Status`: Empty ordinary completions now finalize normally and preserve preceding state transitions. Active terminal status uses `state-flow G#/C#/S#`, while Telegram keeps `State Flow: G#/C#/S#`; passive terminal status remains absent and Telegram reports State Flow as off.
+- `Package Cohort`: Keeps every other bundled package at its current exact version. Package membership, resource paths, load order, Pi minimum, and the single bundled `show-me` ownership path remain unchanged.
+
 ## 0.20.0 - 2026-09-23
 
 - `Telegram Workspace Safety`: Advances the exact Telegram pin to `0.51.0`, adding demand-only A–Z slot rotation with dead-owner custody proof, protected inactivity preservation, durable rejection recovery, canonical profile storage paths, and settled leader-election display reconciliation.

package/README.md

@@ -14,15 +14,15 @@ Package links lead to the owning repositories for usage, documentation, issues,
 | [`@llblab/pi-clean-room`](https://github.com/llblab/pi-clean-room) | `0.1.1` | Isolated nested Pi TUI with explicitly selected extensions |
 | [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.10.0` | Compact Codex/Spark subscription-limit and Business credit-usage status |
 | [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.8.1` | Visible continuation scheduling and bounded worker Skills |
-| [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.17.4` | Incremental scoped context/memory compiler with canonical file persistence, optional Git backups, native working context within each run, and targeted historical reads |
-| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.51.0` | Telegram companion with pressure-safe Workspace slot rotation, fenced follower readiness, adaptive Thread continuity, exact queues, files, voice, controls, and bundled Telegram interaction Skills |
+| [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.18.0` | Incremental scoped context/memory compiler with independent scope revisions, canonical file persistence, optional replicated Git backups, native working context within each run, and targeted historical reads |
+| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.51.1` | Telegram companion with stable follower heartbeats, exact queue-transition notices, pressure-safe Workspace rotation, adaptive Thread continuity, files, voice, controls, and bundled Telegram interaction Skills |
 | [`@llblab/skills`](https://github.com/llblab/skills) | `1.15.0` | Portable workflows for engineering, review, design, context maintenance, and other focused tasks |
 
 Versions are exact by design. An upstream release does not change an installed kit until this repository explicitly advances the dependency and publishes a new kit version. Runtime defects and package-specific feature requests belong in the linked repository; package selection and kit installation issues belong here.
 
 ## Install
 
-Requires **Pi 0.87.0+** and **Node.js 22.19.0+**. State Flow 0.17 introduces a breaking storage-format boundary with no in-place predecessor converter. Preserve existing State Flow stores and review the [owning package's storage guidance](https://github.com/llblab/pi-state-flow/blob/v0.17.4/docs/usage.md#moving-a-store-and-the-017-format-boundary) before upgrading from an earlier kit.
+Requires **Pi 0.87.0+** and **Node.js 22.19.0+**. State Flow 0.17 introduces a breaking storage-format boundary with no in-place predecessor converter. Preserve existing State Flow stores and review the [owning package's storage guidance](https://github.com/llblab/pi-state-flow/blob/v0.18.0/docs/usage.md#moving-a-store-and-the-017-format-boundary) before upgrading from an earlier kit.
 
 From npm:
 

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

@@ -3,7 +3,7 @@
 - Keep independent domain modules under `lib/`, mirror every domain with a same-named file under `tests/`, place cross-domain architecture checks in `tests/invariants.test.ts`, and keep `index.ts` as a minimal public-export boundary. Keep `lib/extension.ts` as the Pi lifecycle composition root: it may wire configuration, domain capabilities, handlers, and event subscriptions, but low-level parsing, traversal, formatting, persistence, queue/worker mechanics, and diagnostic I/O belong to their existing owning domains.
 - Keep the extension opt-in and preserve clear attribution to SKILL.state wherever the inherited explicit-state approach is described.
 - Preserve Pi's native tool loop and complete inspectable session trace; project completed-run history only at user-run boundaries. The runtime-context builder owns model projection of the raw scope overlay; callers must not pre-project it. Retain persistent and current-run context-bearing custom messages from other extensions, plus the complete current-run trajectory. Select a unique captured native user timestamp independently of text decoration, including SDK image hints. Observe native user events even while disabled; Start/Stop must retain that observed run anchor. Reset it at native before-agent-start and session-start/tree boundaries, not semantic mode changes. Observation alone never enables state, publishes memory or authorizes compaction. Without a capture, a unique exact specification match may select only model projection. Missing, nonfinite or ambiguous matches retain available context; projection must never assign the lifecycle run anchor. Direct completion persists no private validation feedback.
-- Expose one canonical intent-first materialized state shape across global, CWD, and session scopes with exactly `intents`, `contract`, `working`, `artifacts`, `response`, and `lazy`; the first four and the required `lazy` root are flexible semantic objects, while `response` is the latest complete user-facing answer string where applicable. Only model baseline projection omits lazy bodies. Preserve this plane order in model-facing projection and state presentation. `intents` contains only active commitments to future action, remains hot by default, and must not become a planner, scheduler, task manager, or execution loop.
+- Expose one canonical intent-first materialized state shape across global, CWD, and session scopes with exactly `intents`, `contract`, `working`, `artifacts`, `response`, and `lazy`; the first four and the required `lazy` root are flexible semantic objects, while `response` is the exact latest accepted assistant answer, including the empty string, and is owned only by session state. Global and CWD keep the required key as an empty structural placeholder; effective state inherits the session value. Only model baseline projection omits lazy bodies. Preserve this plane order in model-facing projection and state presentation. `intents` contains only active commitments to future action, remains hot by default, and must not become a planner, scheduler, task manager, or execution loop.
 - Key artifacts directly by their source path. Model-visible artifact entries require only a non-empty `description` plus optional forward-compatible metadata; runtime-owned compilation evidence (`sourceFingerprint`, `sourceHash`, `compilerRevision`, `compiledAt`) belongs in the scope `meta.json` provenance registry. Reserve model-authored `hint`; runtime may add it only to effective/model projection and never to canonical scope state. Retired embedded `hash`/`compiler`/`compiled_at` fields remain readable compatibility evidence and are stripped from model projection. Validate provenance restrictions on every authored artifact entry, not on retained legacy state: individual runtime/legacy provenance fields cannot be set or deleted by model patches in any scope.
 - Inspect only exact artifact source paths already registered in global, CWD, or session state. Never scan directories, discover files, reserve a Knowledge root, interpret file extensions, or read unrelated source bodies. Observe regular non-symlink files through `size + mtimeNs`; proven absence removes the artifact and provenance from each exact owning scope, while relative, symlink, directory, inaccessible, or otherwise unavailable paths are non-destructive evidence.
 - Use `classifyArtifactCompilationNeed` for public acquisition/rehydration and ordinary-artifact Pi invalidations. Compare observed fingerprints with hidden provenance; missing/malformed retained fingerprints, malformed compiler evidence, and compiler changes request compilation without declaring semantic corruption. Fingerprint-only decisions ignore unused legacy hashes, while explicit current hashes retain their checks; never invent hashes in read plans. Accept signed filesystem `mtimeNs`, including pre-epoch sources. Preserve changed-source semantics and add `hint` only to model projection. Effective Skill entries mask lower ordinary entries and retain their separate hash protocol.
@@ -21,16 +21,16 @@
 - Read and write only regular non-symlink State Flow-owned files at those exact paths, publish each file by same-directory atomic rename, preserve arbitrary repository contents, and classify ownership exactly. Retain opaque source bytes for file identity and rollback, not decoded-text reconstructions. Use validated structural JSON equality for in-process semantic comparisons; reserve cryptographic hashes for compact identities that cross persistence/process boundaries. Serialize cooperating canonical-file writers through file-cohort exclusion and CAS. Recheck prepared bases before each replacement/deletion and restore only bytes still matching the publisher's own output. Preserve detected concurrent changes and report unresolved rollback conflicts; do not claim kernel-atomic multi-file CAS against nonparticipating writers. Inspect only exact already-registered artifact paths; do not discover or own a Knowledge directory.
 - At instance initialization resolve the repository, CWD key, and session key; load each scope's anchored canonical checkpoint and tail, materialize at the selected retained boundary, then overlay `global → cwd → session`. Install cached view and file publication basis atomically only after successful restoration/initialization. Revalidate mutable file cohorts; never turn inspection into a long-lived publication-basis cache. Preserve selected retained-boundary evidence across transient restore failure so explicit Start can retry it. A genuinely new session gets an empty session layer and inherits only global/CWD values; it must never reuse another same-CWD session layer. Explicit native fork adoption follows the [session-copy contract](docs/fork-contract.md): copy the proven retained source-session stream and provenance into a distinct fresh canonical origin over current shared streams, without modifying parent-private files. Reject occupied targets and checkpoint the child only after CAS acceptance. Inherited parent pointers never authorize an empty reset; fence parent passive Stop projection across child reload.
 - Bind active Pi checkpoints to retained semantic boundaries in the current canonical lineage. Resume and tree restoration select only retained private session history while global/CWD scopes remain live; every failure resolving a selected boundary fails closed without falling through to older checkpoints, disabled markers, Git revisions, or unrelated newer private state. Passive shared-memory availability does not prove the selected private layer: preserve the recovery failure, reject session reads and all publication until it is resolved, and let explicit Start retry the exact selection. Never checkpoint a passive substitute over failed branch recovery.
-- Every accepted semantic change, including session-only and response-only changes, atomically updates affected canonical checkpoint/tail pairs and temporal metadata without creating a Git commit. After an accepted turn reconciles its response and reaches `agent_before_settle`, one best-effort backup may commit only State Flow-owned already-written files. Acquire the backup mutex before briefly locking canonical storage for bounded root/CWD/session namespace inventory and regular-file byte capture; canonical writers never acquire the backup mutex. Release the canonical lock before every Git command, filter, staging write, ref update, or index synchronization. Stage only the captured snapshot through a private temporary worktree/index, preserve Git ignore/filter policy, and never inventory artifact sources or unrelated directory trees. Keep unrelated staged/index-only content and worktree edits intact; synchronize only exact owned index paths, include HEAD-owned deletions even when already absent from the caller index, and never create an unowned-only initial backup. Backup failure is diagnostic-only and never rolls back state, suppresses an answer, requests continuation, or blocks a later turn. Durable push queues, publication workers, worker leases, and remote retry generations do not exist.
+- Every accepted semantic change, including session-only and response-only changes, atomically updates affected canonical checkpoint/tail pairs and temporal metadata without creating a Git commit. Each materially changed scope advances its own persisted revision exactly once; Global and CWD revisions are shared across their writers, Session is private, and Effective is represented by the `G#/C#/S#` revision vector rather than an invented scalar owner. After an accepted turn reconciles its response and reaches `agent_before_settle`, one best-effort backup may commit only State Flow-owned already-written files. Acquire the backup mutex before briefly locking canonical storage for bounded root/CWD/session namespace inventory and regular-file byte capture; canonical writers never acquire the backup mutex. Release the canonical lock before every Git command, filter, staging write, ref update, or index synchronization. Stage only the captured snapshot through a private temporary worktree/index, preserve Git ignore/filter policy, and never inventory artifact sources or unrelated directory trees. Keep unrelated staged/index-only content and worktree edits intact; synchronize only exact owned index paths, include HEAD-owned deletions even when already absent from the caller index, and never create an unowned-only initial backup. Backup failure is diagnostic-only and never rolls back state, suppresses an answer, requests continuation, or blocks a later turn. After each successful backup attempt, asynchronously push the exact current commit to the attached branch's explicitly configured remote/ref without force. Push failure is visible but has no semantic effect; a later accepted turn retries the latest backup. Durable push queues, publication workers, worker leases, and remote retry generations do not exist.
 - Register `patch_state` as the sole model-authored semantic mutation protocol. Its canonical grammar accepts one or more fixed `global`, `cwd`, and `session` semantic patches; reject unknown fields, empty supplied scopes, material no-ops, and retired finalization or `{scope, patch}` / `unchanged` grammar. Validate every supplied scope against one causal basis and publish it all-or-nothing with one identity, temporal boundary, and durable cohort. Never accept model-authored `response`.
 - Treat every semantic `patch_state` as a strict inference barrier. Give it sequential execution mode; find the matching synchronized assistant through public parent traversal from the selected leaf without constructing a full branch during tool preflight; require exactly one `patch_state` call in that response and block every sibling tool call before execution. The next inference sees rematerialized state. Ordinary accepted answers require no finalization patch or fallback inference.
-- Reconcile `response` only from the actually accepted ordinary assistant answer at `turn_end`; it remains runtime-owned. State Flow has no terminal HTML-comment mutation protocol and does not parse generic service comments. Other extensions retain ownership of their own comments and output handling.
+- Reconcile `response` only from the actually accepted ordinary assistant answer at `turn_end`; it remains runtime-owned, and an accepted empty answer reconciles to `""` rather than causing a finalization failure. State Flow has no terminal HTML-comment mutation protocol and does not parse generic service comments. Other extensions retain ownership of their own comments and output handling.
 - Treat terminal state as a decision-relevant handoff, not narration: retain source-addressed reusable operational knowledge in `artifacts`; compile stable requirements, confirmed decisions, rejected approaches, and interface commitments into `contract`; retain observations, validation, failures, current domain state, unresolved work, interaction consequences, and exact continuation in `working`. Preserve relevant completed prerequisites and verified outcomes while removing obsolete progress narration; reconcile only information affected by the run and relevant existing commitments, not every scope or repository surface.
 - Preserve active constraints, unresolved questions, consequential negative results, and the next discriminating check before compression. Distinguish observations, user requirements, assistant decisions, and hypotheses; do not promote assistant conclusions to user requirements. Treat resource, document, memory, Skill, and agent locators as semantic references wherever context expresses them. Inside ordinary strings and prose, encode a semantic-state path as `$` immediately followed by one valid `read_state` path, for example `$effective.lazy.memory[7]`; the prefix distinguishes a reference from incidental path-like text and leaves room for future parsing. `{"$ref":"cwd.lazy.plan"}` remains the optional structured state-reference form; neither form is a runtime link type. External resource locators retain their native path, URI, Skill, or agent syntax. Resolve references explicitly through the appropriate read/tool when needed and infer no authority, existence, dependency, hydration, execution, or completion merely from their presence. Never scan, audit, or proactively resolve references merely to find broken ones. Only after one requested `read_state` value path is missing may the query domain perform one bounded reverse lookup over current model-patchable semantic planes for exact structured `$ref` and `$path` matches. When durable sources match, return a successful top-level `{value:null, hint:[...]}` diagnostic sentinel: every hint has `type:"dangling-reference"`, an action message, and at most three runtime-verified current owning paths. The null sentinel is never presented without `hint` for this case; keys, patch, and multi-path reads retain ordinary all-or-error semantics. Never scan runtime-owned `response`, and retain the ordinary missing-path error when no durable source matches. A match proves durable semantic provenance, not staleness; no match does not prove invention. The agent may then inspect ownership and patch a proven stale source while preserving surrounding meaning. Effective-state absence does not identify ownership, and unavailable history, inaccessible external resources, or transient read failure do not prove a dangling reference. Retain useful source locators and validity conditions for consequential facts without mandatory per-value metadata. Keep rejection reasons and reconsideration conditions. Reconcile contradictions through evidence or user clarification instead of silently overwriting established constraints or observations; retain unresolved conflicts and decision-relevant hypotheses as uncertain. These are protocol obligations, not deterministic semantic validation gates.
 - Treat `working` as last observations, not a live workspace. Revalidate volatile facts before consequential actions; after interruption or branch navigation inspect relevant external effects before repeating operations. Failed state commits and restored memory do not undo tool effects. Missing evidence proves neither success nor absence of effects: retain uncertainty and the next check. Keep revalidation targeted, without action ledgers or runtime freshness/rollback guarantees.
 - Recognize Skill acquisition only when a successful finalized `read` path exactly matches a registered Pi Skill exposed by the public `getCommands()` resource metadata. Map `sourceInfo.scope` deterministically as user → global, project → CWD, and temporary → session; never infer ownership from path shape. Hash the executed source bytes. Matching current provenance creates no acquisition request. Otherwise append a concise tool-result hint naming the exact target, but keep the read volatile unless the model supplies durable compiler output; pending acquisition never blocks an unrelated semantic patch or ordinary completion. Validate an attempted compilation at the reported scope/path with non-empty `description`, `kind: "skill"`, and flexible non-empty `compilation`, then record runtime-owned `sourceHash` plus `skill-artifact-v1` `compilerRevision` in that scope's provenance. Replace the complete prior Skill artifact and provenance on refresh so obsolete evidence cannot survive. Unregistered `SKILL.md` reads have no acquisition semantics. `contract.compiled_skills` is retired and rejected; never fabricate hashes or bypass explicit source acquisition.
 - Make state stewardship an ordinary model responsibility without a background loop or gratuitous full-state rewrite. Every handoff curates touched and obviously stale or mis-scoped visible branches: place new knowledge at the narrowest valid scope, merge fragmented facts, compress history into conclusions, and delete stale, completed, redundant, or low-value keys while preserving active commitments and evidence. Dedicated cleanup and scope audits require an explicit user request; a feature/release/project boundary may motivate a recommendation, not an automatic audit. For a proven move within one store, inspect both owners, resolve conflicts, apply destination/source changes through one atomic multi-scope patch, and verify both owners plus the effective overlay. External transfers require destination-native acceptance verification before source deletion. Global is only established cross-project/user/environment knowledge, CWD is reusable project truth, and session is branch/run continuation.
-- Accept omitted semantic fields inside each supplied scope patch, but reject empty supplied scopes and require at least one material semantic or provenance change. When no state change is needed, do not call `patch_state`. Always require an accepted non-empty answer, which runtime owns as session `response`. A changed response is a semantic transition; identical complete semantic state finalizes lifecycle without a patch, identity, or temporal step. Semantic usefulness and optimization remain protocol-owned because deterministic validation cannot prove them.
+- Accept omitted semantic fields inside each supplied scope patch, but reject empty supplied scopes and require at least one material semantic or provenance change. When no state change is needed, do not call `patch_state`. Accept the exact ordinary answer, including an empty string, which runtime owns as session `response`. A changed response is a semantic transition; identical complete semantic state finalizes lifecycle without a patch, identity, or temporal step. Semantic usefulness and optimization remain protocol-owned because deterministic validation cannot prove them.
 - Agent-level opt-in `logging` appends local JSONL diagnostics for rejected `patch_state` attempts and response-finalization failures. Every rejected call retains its exact attempted arguments plus the precise error and, when available, tool identity and call id; successful patches and accepted answers are never logged. Preserve exact text blocks only where useful, reduce other blocks to structural identity, never duplicate reasoning bodies, and keep logging outside semantic state, scope metadata, checkpoints, and publication. Logging failure emits at most one warning and never changes enablement or accepted state.
 - Keep `applyPatch` results and staged mutable drafts detached from caller patches and accepted scopes. Detach once at the public patch boundary; private owned-draft COW may share untouched paths only within that isolated basis. Clone incoming replacements, detach inherited objects before preserving their merge behavior, and retain late-response/artifact mutation isolation. Do not trade CAS, publication rollback or public/historical read isolation for cross-boundary sharing.
 - Recursively materialize patches immediately; empty objects preserve, nested object-key `null` deletes, and `null` anywhere in semantic state including arrays is invalid. This prohibition does not apply to runtime envelopes such as an origin's null parent. Persist runtime-normalized replay patches that exactly reproduce accepted state, including complete artifact replacement; runtime-owned provenance is stored in scope `meta.json` and is not part of semantic replay.
@@ -38,13 +38,13 @@
 - Rotate the turn-stable specification on every user-initiated run. Persist the full specification only while that run is unfinished, then remove it atomically with accepted terminal response reconciliation. Enabled provider requests still receive current memory when Pi's actionable turn/settle boundaries continue without another `before_agent_start`; omit an absent specification rather than resurrecting the completed prompt, inventing a user run, or taking over Pi's continuation scheduler. Keep user-controlled specification text at user authority: never interpolate it into the system prompt; repeat it only in synthetic user runtime context. Treat materialized state in that message as fallible assistant-produced data whose transport role does not elevate it into user instructions.
 - When enabled inside an existing session, retain Pi's active context for exactly one complete bootstrap run and require its `patch_state` resolution to compile all future-relevant context.
 - Restore extension state from the active Pi branch's retained-boundary checkpoint and current canonical lineage, not the full entry list, a storage receipt, or Git `HEAD`, on startup and successful tree navigation.
-- Render compact status as accent `state-flow` plus dim `#<step>` in both active and passive modes; every accepted passive patch advances the same counter. `/state-flow-status` must remain observational: show CWD/session keys, step, active temporal head, available hot-history depth, per-scope artifact/tail counts, and already-known invalidations; render only the effective global → CWD → session materialization as semantic JSON; perform no source reads, scans, fingerprinting, or maintenance. When temporal materialization is unavailable, report unknown counts and unavailable state rather than inventing empty projections.
+- Render compact terminal status as accent `state-flow` plus dim `G#/C#/S#` only while active mode is enabled; passive changes still advance the affected scope revisions without exposing an active-status signal. `/state-flow-status` must remain observational: show CWD/session keys, internal step, independent scope revisions, active temporal head, available hot-history depth, per-scope artifact/tail counts, and already-known invalidations; render only the effective global → CWD → session materialization as semantic JSON; perform no source reads, scans, fingerprinting, or maintenance. When temporal materialization is unavailable, report unknown counts and unavailable state rather than inventing empty projections.
 - Explicit `/state-flow-start` creates the canonical file store when missing and returns after local runtime acceptance without initializing or consulting Git. It initializes missing global, CWD, and current-session checkpoint/tail pairs plus session config/runtime metadata through compare-and-swap publication, enables only the current branch, and bootstraps prior conversation when needed. Explicit start on a proven pre-runtime branch establishes an empty session origin rather than importing a later same-session layer; shared streams remain live. Ordinary new sessions remain manual unless repository-global `autoStart` is true; configured new sessions may initialize missing CWD state and receive distinct empty session layers while inheriting global/CWD values. Resumed and tree-selected branches restore their retained canonical lineage regardless of that flag.
 - `/state-flow-stop` returns to the configured passive bootstrap/tool combination. For an accepted runtime, persist only the current session/branch's `config.enabled = false` and necessary runtime provenance, preserving all semantic checkpoints/tails and creating no semantic transition. A proven pre-runtime branch instead appends only the existing `{disabled:true}` Pi checkpoint; a cached passive view never authorizes runtime publication or a retained-boundary checkpoint. Only accepted canonical publication ends that pre-runtime condition. Preserve failed-selection fences, passive access, and later explicit Start/passive patch behavior. Lifecycle-only writes adopt unrelated live shared drift at a fresh origin when needed, without touching semantic/provenance files or counters; same-session races and explicit stale provenance writes still fail closed. Do not opportunistically fold tails or prune evidence during lifecycle persistence, even if another writer loaded a larger history limit. Refresh the host cache after adoption, freeze Stop's handoff from that accepted cache, and inspect newly adopted registered paths before the next enabled inference. Retain a frozen handoff plus the active user-run trajectory (including later tool results), post-stop conversation, and foreign context-bearing custom messages across same-physical-session reload/resume/tree. Exclude completed pre-run conversation only when the active boundary is proven. If a recorded active anchor is missing, nonfinite or ambiguous after native projection/compaction, reuse the active context selector and retain available summaries and tool trajectory; never fall back to the idle cutoff or reconstruct discarded raw entries. Idle Stop still retains only later conversation and foreign custom context. Active restart replaces passive mode but uses that bounded boundary for its one bootstrap run; new and forked physical sessions inherit neither projection. It does not rewrite agent-level `autoStart` or change its policy for future new sessions.
 - After an accepted non-bootstrap run settles with no pending input, State Flow may request native manual compaction under a generation-private marker only when public `getContextUsage()` reports at least 24,000 tokens. Keep the complete latest accepted run from its already captured first-user anchor, including steering and tool results; never substitute the last user message. Require one matching native user timestamp before the final assistant, otherwise skip rather than guessing. Store only retained boundary/step identity in details, and never duplicate state in the summary. Unknown or smaller usage skips compaction; a benign native refusal releases the attempt for later work. Await the native compaction completion/error callback inside the settled handler before returning, so Pi's deferred companion prompt dispatch cannot race an in-flight manual compaction; do not add a timer, queue or continuation owner. Skip prefixes containing foreign custom metadata or native `custom_message` context. Never customize user manual or native threshold/overflow compaction, discard unfinished pre-patch work, create a State Flow origin, or rewrite Pi's append-only JSONL/tree.
 - Keep the injected runtime protocol compact and normative; put rationale and extended explanation in README rather than the model prompt. Contribute initial active/passive protocol through Pi's native `systemPromptOptions.sections.state_flow`, not a returned forced `systemPrompt`; refresh only that owned section at `context_with_system` from current mode so in-flight Stop/Start and boundary continuations do not retain stale instructions. Keep section projection pure in the context domain, preserve unchanged arrays/native deltas and non-system identities, and never invent missing system frames. Preserve companion sections, tool declarations, native trace and explicit foreign forced-prompt precedence. Foreign comment handling remains owned by other extensions.
 - Do not claim strict boundedness for state, the current run trajectory, the turn specification, or the external full trace.
-- Remain extension-agnostic in core semantics, storage, and inference: core modules never import, name, special-case, or encode policy for another extension or transport. One optional leaf presentation adapter (`lib/telegram.ts`) may import public `pi-telegram` membranes to mirror the live patch counter on exactly one main-menu section button, expose the same start/stop affordances already owned by `state-flow-start` and `state-flow-stop`, and read global/CWD/session/effective snapshots in active or passive mode. Telegram observation may lazily load existing shared canonical state even when passive model tools are disabled, but never initializes or mutates it; it must fail open when the transport is absent or its registry is unready and must never alter core behavior.
+- Remain extension-agnostic in core semantics, storage, and inference: core modules never import, name, special-case, or encode policy for another extension or transport. One optional leaf presentation adapter (`lib/telegram.ts`) may import public `pi-telegram` membranes to show the live `G#/C#/S#` effective revision vector on exactly one main-menu section button only while active mode is enabled, expose the same start/stop affordances already owned by `state-flow-start` and `state-flow-stop`, and read global/CWD/session/effective snapshots in active or passive mode. Passive main-menu identity renders `State Flow: off`; requested owner-scope Rich snapshots show `#revision`, while Effective shows the vector. Inspection may refresh live shared streams in memory but never publishes or advances a revision. Telegram observation may lazily load existing shared canonical state even when passive model tools are disabled, but never initializes or mutates it; it must fail open when the transport is absent or its registry is unready and must never alter core behavior.
 - Activate State Flow model tools while an episode is enabled or passive tools are configured; preserve every unrelated active tool when toggling them. Passive reads never initialize storage, while an explicit passive patch may initialize absent canonical storage without enabling an episode, continuation, or compaction. Unsupported predecessor storage is never converted. Keep mutation confined to `patch_state` and historical observation read-only.
 - Keep `.github/workflows/release.yml` as the sole version-tag release owner: it validates immutable tag identity, publishes through npm Trusted Publisher with provenance, verifies the public package, and only then creates the GitHub Release. Keep package, lockfile, tag, and changelog versions aligned; never add a long-lived npm token fallback.
 - Keep opt-in performance executables and workers in top-level `benchmarks/`; their correctness regressions stay in `tests/`. Benchmark workloads may reuse synthetic test fixtures, remain excluded from runtime packaging, and retain source-bound measurement identities across relocations.

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

@@ -2,6 +2,15 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
+## 0.18.0: Independent Revisions and Replicated Backups
+
+- `Independent scope revisions`: Persists independent Global, CWD and Session semantic counters. Each materially changed scope advances once per atomic cohort; no-ops advance none, Session owns response changes, folding preserves counts, and pre-revision 0.17 stores start from retained-tail evidence. Effective uses the truthful `G#/C#/S#` vector rather than a scalar observer count. Metadata v2 keeps v1 readable and fences older writers after a revision-aware scope write.
+- `Passive status semantics`: Active terminal status renders `state-flow G#/C#/S#`, while Telegram retains its `State Flow: G#/C#/S#` label format; passive terminal status is absent and Telegram shows `State Flow: off`. Owner Rich snapshots show `#revision`, Effective shows the vector, and read-only inspection may refresh foreign Global/CWD revisions in memory without publication.
+- `Response ownership`: Documents response as runtime-owned Session state. Global/CWD retain only the empty structural slot required by the uniform canonical shape and omit it from Telegram Rich views; Effective inherits the Session response.
+- `Revision status freshness`: Refreshes terminal status immediately after automatic missing-artifact reconciliation, so an independently advanced Global/CWD revision is visible before any later `patch_state` call rather than appearing to have been caused by that call.
+- `Progressive backup replication`: After each successful settled-turn backup attempt, asynchronously pushes the exact current commit without force to the attached branch's explicitly configured remote/ref. Push failure remains visible but cannot affect canonical acceptance or the answer; a later accepted turn retries the latest backup. No durable queue, worker, lease, retry generation, remote policy metadata or semantic Git authority returns.
+- `Empty response finalization`: Accepts an ordinary completion with no text as a valid lifecycle boundary, stores the Session response as `""`, and preserves any preceding `patch_state` transition instead of emitting a blocking recovery error.
+
 ## 0.17.4: scoped Skill acquisition and passive observability hotfix
 
 - `Passive observability`: Keeps the `state-flow #N` counter visible in terminal and Telegram surfaces while active mode is off, with accepted passive patches advancing the same counter. Telegram scope controls now explicitly retain global/CWD/session/effective inspection in either mode and can lazily read existing shared canonical state when passive model tools are disabled, without initializing or mutating storage.

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

@@ -56,7 +56,7 @@ Starting in an existing conversation retains its context for one complete bootst
 - `/state-flow-status`: Inspect effective state, retained history and known recovery issues without scanning sources or changing state.
 - `/state-flow-stop`: End active episode semantics without deleting memory; an interrupted run retains its frozen handoff and available trajectory.
 
-Active mode is **opt-in**. Passive memory projection and the memory tools are enabled by default: existing state can be read or explicitly patched without an active episode or State Flow compaction. Passive patches advance the same `#N` transition counter. When `pi-telegram` is present, global, CWD, session and effective state remain inspectable from its State Flow section in either mode. Stop returns to the configured passive behavior. `autoStart` can enable active mode for genuinely new sessions; resumed branches restore their own enablement. See [configuration](docs/usage.md#configuration).
+Active mode is **opt-in**. Passive memory projection and the memory tools are enabled by default: existing state can be read or explicitly patched without an active episode or State Flow compaction. Every materially changed owner advances its independent scope revision even in passive mode, without displaying an active-mode status. When active, terminal and Telegram status render the Effective revision vector as `G15/C8/S31`; passive Telegram shows `State Flow: off`. Requested Global, CWD and Session snapshots show their own `#revision`, while Effective shows the vector. Inspection can refresh live shared revisions from other instances without publishing state or advancing a counter. Stop returns to the configured passive behavior. `autoStart` can enable active mode for genuinely new sessions; resumed branches restore their own enablement. See [configuration](docs/usage.md#configuration).
 
 ## State model
 
@@ -80,10 +80,10 @@ Every scope uses the same shape:
 - `contract`: Requirements, decisions, constraints and interface commitments.
 - `working`: Observations, results, uncertainties and current continuation.
 - `artifacts`: Source-addressed descriptions and compiled knowledge.
-- `response`: The latest complete answer, captured by the runtime.
+- `response`: The exact latest accepted answer, including an empty string, captured by the runtime only in Session. Global and CWD retain an empty structural slot; Effective inherits the Session value.
 - `lazy`: Supporting memory available through explicit reads, with its body omitted from baseline model context.
 
-These planes organize ordinary JSON rather than imposing a project-specific schema. The model updates the semantic planes except `response`, which is runtime-owned. Memory remains fallible: storing an observation does not make it current or correct.
+These planes organize ordinary JSON rather than imposing a project-specific schema. The model updates the semantic planes except `response`, which is runtime-owned. Global and CWD revisions are shared by their canonical stores, Session has its own revision, and Effective has no scalar owner: its identity is the `G#/C#/S#` vector. One atomic patch advances each materially changed scope once. Memory remains fallible: storing an observation does not make it current or correct.
 
 Registered Pi Skills may be compiled into source-addressed artifacts when durable guidance is useful. Pi's resource provenance determines ownership: user Skills map to global, project Skills to CWD and temporary Skills to session. A matching source hash needs no update; an uncompiled read remains ordinary volatile context and does not block unrelated patches.
 
@@ -124,7 +124,7 @@ Array ranges, structural `keys` reads and path-intersected `patch` projections s
 
 The default store is `~/.pi/agent/state-flow/`, independent of registered source files. Canonical `checkpoint.json`, `patches.jsonl` and `meta.json` files hold each scope's state, retained changes and metadata; session configuration and runtime identity are stored separately.
 
-**Git backups are optional.** When the store is a configured Git repository, accepted active turns may create versioned backups of State Flow-owned files. Backup needs a Git commit identity; accepting and persisting state does not. A backup failure produces a warning without rejecting or rolling back accepted memory. Git history can be inspected separately, but it is not the authority for `read_state` or automatic restoration of expired semantic boundaries.
+**Git backups are optional.** When the store is a configured Git repository, accepted active turns may create versioned backups of State Flow-owned files. If the attached branch has an explicitly configured remote, State Flow then pushes the exact current backup commit there asynchronously and without force. Commit or push failure produces a warning without rejecting or rolling back accepted memory; a later accepted turn tries the latest backup again. Backup needs a Git commit identity, but accepting and persisting state does not. Git history can be inspected separately, but it is not the authority for `read_state` or automatic restoration of expired semantic boundaries.
 
 Resume and tree navigation restore the selected retained session boundary over current shared global/CWD memory. A new session gets its own session layer. Supported native forks copy selected session state into a new owner without changing the parent's private data. Expired, incomplete or contradictory boundaries fail closed rather than silently substituting newer state. See [fork support](docs/usage.md#fork-support-and-limits) and [storage recovery](docs/usage.md#storage-and-recovery).
 

package/node_modules/@llblab/pi-state-flow/dist/index.d.ts

@@ -3,7 +3,7 @@ export { classifyArtifactCompilationNeed, compileArtifact, hashArtifactSource, i
 export { buildContinuationCandidates, discoverNativeSessionHeaders, inspectStateFlowContinuationProvenance, readNativeSessionHeader, recommendContinuationFromProvenance, resolveContinuationStartup, type ContinuationCandidateProvenance, type ContinuationCandidateSummary, type ContinuationHostContext, type ContinuationHostIntent, type ContinuationProjectIdentity, type ContinuationRecommendation, type ContinuationRecommender, type ContinuationSessionCandidate, type ContinuationStartupDecision, type ContinuationTransport, type NativeSessionHeader } from "./lib/continuation.ts";
 export { captureTemporalFileBases, cwdScopeKey, getDurableRepositoryRoot, isStateFlowOwnedPath, loadScopeStream, parseScopeProvenance, parseScopeStream, serializeScopeProvenance, serializeScopeStream, sessionRuntimePaths, sessionScopeKey, sessionStorageKey, temporalScopePaths, temporalStateFileUpdates, type ScopeStreamSources, type TemporalScopePaths } from "./lib/durable.ts";
 export { default, PATCH_STATE_TOOL_NAME, READ_STATE_TOOL_NAME, type StateFlowExtensionOptions } from "./lib/extension.ts";
-export { backupCurrentStateFlowFiles } from "./lib/git.ts";
+export { backupCurrentStateFlowFiles, pushCurrentStateFlowBackup } from "./lib/git.ts";
 export { createAcceptedTransition, DEFAULT_HISTORY_LIMIT, MAX_HISTORY_LIMIT, projectRecentTransitionsWithLimit, validateRecentTransition, type AcceptedTransition, type RecentScopePatch, type RecentTransition, type RecentTransitionWindow } from "./lib/history.ts";
 export { applyPatch, canonicalJson, hashJson, isObject, validatePatch } from "./lib/json.ts";
 export type { JsonObject, JsonValue } from "./lib/json.ts";
@@ -14,5 +14,5 @@ export { TemporalRuntime } from "./lib/runtime.ts";
 export { hasCompiledSkillArtifact, hashSkillSource, SKILL_ARTIFACT_COMPILER, type SuccessfulSkillRead } from "./lib/skills.ts";
 export { emptyState, isMaterializedState, isStateDocument, overlayStates, projectStateForModel, updateMaterializedArtifacts, type AtomicScopePatches, type MaterializedState, type ScopedPatch, type ScopedStates, type ScopePatch, type SemanticTransition, type StateDocument, type StatePatch, type StateScope, type TerminalTransition } from "./lib/state.ts";
 export { buildStateFlowSectionView, createStateFlowTelegramAdapter, formatStateFlowSectionLabel, loadStateFlowTelegramModules, STATE_FLOW_TELEGRAM_ID, type StateFlowTelegramAdapter, type StateFlowTelegramButton, type StateFlowTelegramCallbackContext, type StateFlowTelegramControlResult, type StateFlowTelegramLoader, type StateFlowTelegramModules, type StateFlowTelegramPort, type StateFlowTelegramSectionContext, type StateFlowTelegramSectionModule, type StateFlowTelegramSnapshot, type StateFlowTelegramView } from "./lib/telegram.ts";
-export { advanceTemporalState, readTemporalState, type TemporalState } from "./lib/temporal.ts";
+export { advanceTemporalState, readTemporalState, temporalScopeRevisions, type ScopeRevisions, type TemporalState } from "./lib/temporal.ts";
 export { parseStateReadPath, readStatePath, type StateReadQuery, type StateReadResult } from "./lib/query.ts";

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

@@ -3,7 +3,7 @@ export { classifyArtifactCompilationNeed, compileArtifact, hashArtifactSource, i
 export { buildContinuationCandidates, discoverNativeSessionHeaders, inspectStateFlowContinuationProvenance, readNativeSessionHeader, recommendContinuationFromProvenance, resolveContinuationStartup } from "./lib/continuation.js";
 export { captureTemporalFileBases, cwdScopeKey, getDurableRepositoryRoot, isStateFlowOwnedPath, loadScopeStream, parseScopeProvenance, parseScopeStream, serializeScopeProvenance, serializeScopeStream, sessionRuntimePaths, sessionScopeKey, sessionStorageKey, temporalScopePaths, temporalStateFileUpdates } from "./lib/durable.js";
 export { default, PATCH_STATE_TOOL_NAME, READ_STATE_TOOL_NAME } from "./lib/extension.js";
-export { backupCurrentStateFlowFiles } from "./lib/git.js";
+export { backupCurrentStateFlowFiles, pushCurrentStateFlowBackup } from "./lib/git.js";
 export { createAcceptedTransition, DEFAULT_HISTORY_LIMIT, MAX_HISTORY_LIMIT, projectRecentTransitionsWithLimit, validateRecentTransition } from "./lib/history.js";
 export { applyPatch, canonicalJson, hashJson, isObject, validatePatch } from "./lib/json.js";
 export { appendStateFlowDiagnostic, projectDiagnosticContent, stateFlowLogPath } from "./lib/logging.js";
@@ -13,5 +13,5 @@ export { TemporalRuntime } from "./lib/runtime.js";
 export { hasCompiledSkillArtifact, hashSkillSource, SKILL_ARTIFACT_COMPILER } from "./lib/skills.js";
 export { emptyState, isMaterializedState, isStateDocument, overlayStates, projectStateForModel, updateMaterializedArtifacts } from "./lib/state.js";
 export { buildStateFlowSectionView, createStateFlowTelegramAdapter, formatStateFlowSectionLabel, loadStateFlowTelegramModules, STATE_FLOW_TELEGRAM_ID } from "./lib/telegram.js";
-export { advanceTemporalState, readTemporalState } from "./lib/temporal.js";
+export { advanceTemporalState, readTemporalState, temporalScopeRevisions } from "./lib/temporal.js";
 export { parseStateReadPath, readStatePath } from "./lib/query.js";

package/node_modules/@llblab/pi-state-flow/dist/lib/durable.d.ts

@@ -10,6 +10,7 @@ export interface ScopeStreamSources {
 /** Read-only activation eligibility for one canonical CWD scope. */
 export declare function hasCwdMaterialization(cwd: string, repositoryRoot: string): boolean;
 export interface ScopeTemporalMetadata {
+    revision: number;
     checkpoint: ScopeStream["checkpoint"]["through"];
     patches: ScopeStream["patches"][number]["transition"][];
 }

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

@@ -36,6 +36,7 @@ export function serializeScopeStream(stream, scope, cwdIdentity) {
         checkpoint: `${canonicalJson(stream.checkpoint.state)}\n`,
         patches: stream.patches.map((record) => `${canonicalJson(record.patch)}\n`).join(""),
         temporal: {
+            revision: stream.revision,
             checkpoint: structuredClone(stream.checkpoint.through),
             patches: stream.patches.map((record) => structuredClone(record.transition)),
         },
@@ -92,6 +93,9 @@ export function classifyScopeStream(checkpointSource, patchesSource, scope, expe
     if (boundaries.length !== patches.length)
         throw new Error(`State Flow ${scope} temporal metadata does not match its semantic tail`);
     const stream = {
+        // 0.17.4 and earlier did not persist scope revisions. Credit only their still-retained
+        // semantic tail; discarded ancestry cannot be reconstructed without inventing history.
+        revision: temporal.revision === undefined ? patches.length : temporal.revision,
         checkpoint: { through: temporal.checkpoint, state: checkpoint },
         patches: patches.map((patch, index) => ({ transition: boundaries[index], patch })),
     };
@@ -159,7 +163,7 @@ export function serializeScopeMetadata(registry, stream, scope, cwdIdentity, exi
     const sources = serializeScopeStream(stream, scope, cwdIdentity);
     const value = {
         ...existing,
-        version: 1,
+        version: 2,
         ...(registry === undefined ? {} : { artifacts: serializeArtifactProvenanceRegistry(registry) }),
         temporal: sources.temporal,
         ...(scope === "cwd" ? { owner: { cwd: resolve(cwdIdentity) } } : {}),
@@ -168,7 +172,7 @@ export function serializeScopeMetadata(registry, stream, scope, cwdIdentity, exi
 }
 /** Compatibility serializer retained for metadata-only callers. */
 export function serializeScopeProvenance(registry) {
-    return `${canonicalJson({ version: 1, artifacts: serializeArtifactProvenanceRegistry(registry) })}\n`;
+    return `${canonicalJson({ version: 2, artifacts: serializeArtifactProvenanceRegistry(registry) })}\n`;
 }
 function parseMetadataDocument(source, label) {
     if (source === undefined)
@@ -189,7 +193,7 @@ export function parseScopeProvenance(source, path) {
     const value = parseMetadataDocument(source, `State Flow provenance file: ${path}`);
     if (Object.keys(value).length === 0)
         return {};
-    if (value.version !== 1)
+    if (value.version !== 1 && value.version !== 2)
         throw new Error(`Invalid State Flow provenance document: ${path}`);
     if (!Object.hasOwn(value, "artifacts"))
         return {};

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

@@ -12,7 +12,7 @@ import { createPassiveContinuation, currentRunTrajectory, lazyNavigationHint, pa
 import { readNativeSessionHeader } from "./continuation.js";
 import { cwdScopeKey, resolveSessionAddress, sessionScopeKey, } from "./durable.js";
 import { completeRun, prepareRun, resumeEpisode, startEpisode, stopEpisode } from "./episode.js";
-import { backupCurrentStateFlowFiles } from "./git.js";
+import { backupCurrentStateFlowFiles, pushCurrentStateFlowBackup } from "./git.js";
 import { projectRecentTransitionsWithLimit } from "./history.js";
 import { isObject, presentationJson, sameJson } from "./json.js";
 import { StateFlowDiagnosticWriter, stateFlowLogPath } from "./logging.js";
@@ -26,6 +26,7 @@ import { emptySnapshot, migrationFailure } from "./snapshot.js";
 import { emptyState, overlayStates, projectStateForModel } from "./state.js";
 import { compactStatus, detailedStatus, STATUS_KEY } from "./status.js";
 import { createStateFlowTelegramAdapter } from "./telegram.js";
+import { temporalScopeRevisions } from "./temporal.js";
 import { commitScopedTransition, stageAtomicScopePatches, stageScopedTransition } from "./transition.js";
 export { formatPatchStateArguments };
 export const PATCH_STATE_TOOL_NAME = "patch_state";
@@ -59,7 +60,7 @@ export default function stateFlowExtension(pi, options = {}) {
     let activeContext;
     let rehydrationPhase;
     const repositoryRoot = resolve(options.repositoryRoot ?? config.directory);
-    const diagnosticWriter = new StateFlowDiagnosticWriter(config.logging, stateFlowLogPath(agentDir), repositoryRoot, (message) => activeContext?.ui.notify(message, "warning"));
+    const diagnosticWriter = new StateFlowDiagnosticWriter(config.logging, stateFlowLogPath(agentDir), repositoryRoot, (message) => notifyActiveContext(message));
     let backupPending = false;
     const skillReads = new SkillReadTracker(hashSkillSource, (path) => activeContext
         ? registeredSkillResolver(activeContext.cwd, pi.getCommands())(path)
@@ -72,6 +73,14 @@ export default function stateFlowExtension(pi, options = {}) {
     function sessionAddress(ctx) {
         return resolveSessionAddress(ctx.sessionManager.getSessionFile(), ctx.sessionManager.getSessionId(), ctx.sessionManager.getHeader()?.timestamp);
     }
+    function notifyActiveContext(message) {
+        try {
+            activeContext?.ui.notify(message, "warning");
+        }
+        catch {
+            // An asynchronous push attempt can outlive the Pi context that launched it.
+        }
+    }
     function createRuntime(ctx) {
         return new TemporalRuntime(ctx.cwd, sessionAddress(ctx), repositoryRoot, undefined, config.historyLimit);
     }
@@ -106,8 +115,13 @@ export default function stateFlowExtension(pi, options = {}) {
         if ("boundary" in checkpoint)
             branchStartsWithoutRuntime = false;
     }
+    function scopeRevisions() {
+        return runtime?.view
+            ? temporalScopeRevisions(runtime.view)
+            : { global: 0, cwd: 0, session: 0 };
+    }
     function updateUi(ctx) {
-        ctx.ui.setStatus(STATUS_KEY, compactStatus(snapshot, (color, text) => ctx.ui.theme.fg(color, text)));
+        ctx.ui.setStatus(STATUS_KEY, compactStatus(snapshot, scopeRevisions(), (color, text) => ctx.ui.theme.fg(color, text)));
     }
     function clearRunTransient() {
         responseAwaitingReconciliation = false;
@@ -179,6 +193,7 @@ export default function stateFlowExtension(pi, options = {}) {
         if (Object.keys(removals).length > 0) {
             const stage = stageAtomicScopePatches(scopeStates, removals, [], runtime.causalBasis());
             commitStage(stage, ctx, false);
+            updateUi(ctx);
         }
         refreshArtifactHints();
     }
@@ -191,12 +206,15 @@ export default function stateFlowExtension(pi, options = {}) {
     function refreshTelegramStateView(scope) {
         if (scope === "session" || scope === "effective")
             assertSelectedBranchAvailable();
-        if (runtime?.view)
-            return;
-        if (!activeContext)
-            throw new Error("State Flow is not attached to an active session yet");
-        runtime ??= createRuntime(activeContext);
-        runtime.loadPassive();
+        if (!runtime?.view) {
+            if (!activeContext)
+                throw new Error("State Flow is not attached to an active session yet");
+            runtime ??= createRuntime(activeContext);
+            runtime.loadPassive();
+        }
+        else if (scope !== "session") {
+            runtime.refreshShared();
+        }
         installScopeStates();
     }
     function syncStateFlowTools() {
@@ -288,6 +306,7 @@ export default function stateFlowExtension(pi, options = {}) {
                     head: structuredClone(view.lineage.at(-1)),
                     historyDepth: view.lineage.length - 1,
                     tailCounts: { global: view.scopes.global.patches.length, cwd: view.scopes.cwd.patches.length, session: view.scopes.session.patches.length },
+                    revisions: temporalScopeRevisions(view),
                 } }),
             staleArtifacts,
             ...(durableStateError === undefined ? {} : { durableStateError }),
@@ -689,6 +708,7 @@ export default function stateFlowExtension(pi, options = {}) {
             snapshot: () => ({
                 enabled: snapshot.config.enabled,
                 step: snapshot.meta.step,
+                revisions: scopeRevisions(),
                 bootstrap: snapshot.meta.bootstrap === true,
                 startPending: telegramStartPending,
             }),
@@ -699,6 +719,7 @@ export default function stateFlowExtension(pi, options = {}) {
                     : scopeStates[scope];
                 return { ...projectModelState(selected), lazy: structuredClone(selected.lazy) };
             },
+            revisions: () => scopeRevisions(),
             canStartNow: () => activeContext === undefined || activeContext.isIdle(),
             start: () => {
                 if (!activeContext)
@@ -907,8 +928,16 @@ export default function stateFlowExtension(pi, options = {}) {
             return;
         backupPending = false;
         try {
-            if (existsSync(join(repositoryRoot, ".git")))
+            if (existsSync(join(repositoryRoot, ".git"))) {
                 backupCurrentStateFlowFiles(repositoryRoot);
+                const pushSessionId = sessionAddress(ctx).id;
+                const pushCwd = ctx.cwd;
+                void pushCurrentStateFlowBackup(repositoryRoot).catch((error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    diagnosticWriter.record(pushSessionId, pushCwd, message, "publication-conflict");
+                    notifyActiveContext(`State Flow accepted canonical state; Git backup push failed: ${message}`);
+                });
+            }
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -951,10 +980,11 @@ export default function stateFlowExtension(pi, options = {}) {
         runAnchorTimestamp = undefined;
         restoreActiveBranch(ctx);
     });
-    pi.on("session_shutdown", (_event, ctx) => {
+    pi.on("session_shutdown", (_event, _ctx) => {
         telegramStartPending = false;
         compactionStopped = true;
         completedRunAccepted = false;
+        activeContext = undefined;
         telegram.dispose();
     });
 }

package/node_modules/@llblab/pi-state-flow/dist/lib/git.d.ts

@@ -1,2 +1,8 @@
 /** Commit only current State Flow-owned files; never changes canonical acceptance. */
 export declare function backupCurrentStateFlowFiles(repositoryRoot: string): string | undefined;
+/** Push the current backup commit to its explicitly configured branch remote without blocking settlement. */
+export declare function pushCurrentStateFlowBackup(repositoryRoot: string): Promise<{
+    commit: string;
+    remote: string;
+    ref: string;
+} | undefined>;

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

@@ -2,11 +2,16 @@
 import { closeSync, constants, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, relative, resolve, sep } from "node:path";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { captureOwnedFileBases, isStateFlowOwnedPath } from "./durable.js";
 import { acquirePublicationLock, withStoragePublicationLock } from "./storage.js";
 const GIT_TIMEOUT_MS = 15_000;
 const STATE_FLOW_COMMIT_TRAILER = "State-Flow-Durable: v1";
+function redactGitDiagnostic(value) {
+    return value
+        .replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1***@")
+        .replace(/([?&](?:access_token|auth|password|token)=)[^&\s]+/gi, "$1***");
+}
 function git(repositoryRoot, args, options = {}) {
     const result = spawnSync("git", ["-C", repositoryRoot, ...args], {
         encoding: "utf8",
@@ -124,6 +129,25 @@ function currentBranchRef(repositoryRoot) {
         throw new Error("State Flow backup requires an attached Git branch");
     return result.stdout.trim();
 }
+function configuredPushDestination(repositoryRoot) {
+    const branchRef = currentBranchRef(repositoryRoot);
+    const branch = branchRef.slice("refs/heads/".length);
+    const configuredRemote = git(repositoryRoot, ["config", "--get", `branch.${branch}.remote`], { allowFailure: true });
+    if (configuredRemote.status > 1)
+        throw new Error(configuredRemote.stderr || "Cannot inspect State Flow backup remote configuration");
+    if (configuredRemote.status !== 0 || configuredRemote.stdout.trim().length === 0)
+        return undefined;
+    const remote = configuredRemote.stdout.trim();
+    if (remote === ".")
+        throw new Error("State Flow backup replication requires a non-local Git remote");
+    const configuredMerge = git(repositoryRoot, ["config", "--get", `branch.${branch}.merge`], { allowFailure: true });
+    if (configuredMerge.status > 1)
+        throw new Error(configuredMerge.stderr || "Cannot inspect State Flow backup branch configuration");
+    const ref = configuredMerge.status === 0 && configuredMerge.stdout.trim().length > 0
+        ? configuredMerge.stdout.trim()
+        : branchRef;
+    return { remote, ref };
+}
 function commitCurrentOwnedFiles(repositoryRoot, expectedHead) {
     const branchRef = currentBranchRef(repositoryRoot);
     if (currentHead(repositoryRoot) !== expectedHead)
@@ -181,3 +205,72 @@ function commitCurrentOwnedFiles(repositoryRoot, expectedHead) {
 export function backupCurrentStateFlowFiles(repositoryRoot) {
     return withBackupLock(repositoryRoot, (root) => commitCurrentOwnedFiles(root, currentHead(root)));
 }
+/** Push the current backup commit to its explicitly configured branch remote without blocking settlement. */
+export function pushCurrentStateFlowBackup(repositoryRoot) {
+    return new Promise((resolvePush, rejectPush) => {
+        let root;
+        let commit;
+        let destination;
+        try {
+            root = assertRepositoryRoot(repositoryRoot);
+            commit = currentHead(root);
+            destination = configuredPushDestination(root);
+        }
+        catch (error) {
+            rejectPush(error);
+            return;
+        }
+        if (commit === undefined || destination === undefined) {
+            resolvePush(undefined);
+            return;
+        }
+        const child = spawn("git", ["-C", root, "push", "--porcelain", "--", destination.remote, `${commit}:${destination.ref}`], {
+            detached: process.platform !== "win32",
+            stdio: ["ignore", "ignore", "pipe"],
+            windowsHide: true,
+            env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never" },
+        });
+        let stderr = "";
+        let failure;
+        let settled = false;
+        function terminate(error) {
+            failure ??= error;
+            if (child.exitCode !== null || child.signalCode !== null) {
+                child.stderr?.destroy();
+                return;
+            }
+            if (!child.pid)
+                return;
+            try {
+                if (process.platform === "win32")
+                    child.kill("SIGKILL");
+                else
+                    process.kill(-child.pid, "SIGKILL");
+            }
+            catch {
+                // Keep waiting for close: signalling failure is not proof that the process ended.
+            }
+        }
+        const timeout = setTimeout(() => terminate(new Error(`Git backup push timed out after ${GIT_TIMEOUT_MS}ms`)), GIT_TIMEOUT_MS);
+        function finish(error) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (error)
+                rejectPush(error);
+            else
+                resolvePush({ commit: commit, ...destination });
+        }
+        child.stderr?.on("data", (chunk) => { stderr = (stderr + chunk.toString("utf8")).slice(-1000); });
+        child.on("error", (error) => {
+            failure ??= error;
+            if (!child.pid)
+                finish(error);
+        });
+        child.once("exit", () => { if (failure)
+            child.stderr?.destroy(); });
+        child.once("close", (code, endedBy) => finish(failure ?? (code === 0 ? undefined
+            : new Error(`Git backup push failed (${endedBy ?? code}): ${redactGitDiagnostic(stderr.trim()) || "no diagnostic output"}`))));
+    });
+}

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

@@ -47,7 +47,7 @@ READ: Use read_state for concrete scope/history gaps. lazy_navigation lists boun
 
 WRITE: patch_state is the sole model-authored semantic mutation mechanism. Supply global/cwd/session patches in any combination; all supplied scopes are validated and durably accepted as one atomic transition. Call it alone in an assistant response, then continue only after its acknowledgement.
 
-RESPONSE: Ordinary assistant completion needs no finalization patch. Runtime reconciles the accepted non-empty answer into response at turn_end without another inference.
+RESPONSE: Ordinary assistant completion needs no finalization patch. At turn_end, runtime stores the exact accepted answer; empty becomes response "".
 
 INTENTS: Keep chosen actions; detail may stay lazy. State refs use {"$ref":"cwd.lazy.plan"} or \`$cwd.lazy.plan\` in text. Resolve only when needed; infer no authority, hydration, execution, or completion. If that resolution proves a dangling state ref, fix/drop it in owning text; never scan for broken refs.
 
@@ -78,11 +78,8 @@ export function finalizedAssistantResponse(message) {
     if (message.content.some((block) => block.type === "toolCall")) {
         throw new Error("Accepted State Flow response cannot contain a tool call");
     }
-    const response = message.content
+    return message.content
         .filter((block) => block.type === "text")
         .map((block) => block.text)
         .join("");
-    if (response.trim().length === 0)
-        throw new Error("Finalized State Flow response must contain non-empty text");
-    return response;
 }

package/node_modules/@llblab/pi-state-flow/dist/lib/runtime.d.ts

@@ -74,6 +74,8 @@ export declare class TemporalRuntime {
      * session or runtime files also fails closed under the existing race rule.
      */
     private reconcileSharedDrift;
+    /** Refresh live shared scopes in memory without publishing or advancing private semantic history. */
+    refreshShared(): boolean;
     /** Canonically accept a prepared retained-boundary origin before lifecycle-only persistence. */
     acceptRestoredOrigin(snapshot: Snapshot): RuntimePublication;
     publish(snapshot: Snapshot, semantic?: boolean, accepted?: AcceptedTransition, options?: {

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

@@ -402,6 +402,17 @@ export class TemporalRuntime {
             throw targetScopeConflict(targets);
         return { view: reconciledView(), base: captured, provenance };
     }
+    /** Refresh live shared scopes in memory without publishing or advancing private semantic history. */
+    refreshShared() {
+        if (!this.view || !this.base)
+            throw new Error("State Flow shared refresh requires a selected temporal runtime");
+        const before = this.view;
+        const reconciled = this.reconcileSharedDrift(new Set());
+        this.view = reconciled.view;
+        this.base = reconciled.base;
+        this.provenanceByScope = reconciled.provenance;
+        return before !== this.view;
+    }
     /** Canonically accept a prepared retained-boundary origin before lifecycle-only persistence. */
     acceptRestoredOrigin(snapshot) {
         if (!this.restoredOriginPending)