@llblab/pi-kit 0.38.2 → 0.38.4

package/node_modules/@llblab/pi-state-flow/docs/semantic-handoff-contract.md

@@ -2,11 +2,11 @@
 
 ## Status and authority
 
-**M1 semantic contract — locally implemented names and guidance, not a live-model quality claim.** Runtime fields, tools, ownership and callbacks now use `intents`, `strategy`, and `tactics`. Declared legacy `contract`/`working` data is translated under the [migration contract](semantic-compatibility-decision.md). Configurable scopes, flattening and module decisions remain in the [evolution backlog](../BACKLOG.md), which alone owns remaining tasks. The original M0 preservation evidence below remains bound to its old-name baseline.
+**Current semantic contract, shipped in 0.27.0; no live-model quality claim.** Runtime fields, tools, ownership and callbacks use `intents`, `strategy`, and `tactics`. Declared legacy `contract`/`working` data translates under the [migration contract](semantic-compatibility-decision.md). Scope selection and flat tools are delivered under their [scope](scope-selection-contract.md) and [model-interface](single-scope-interface-contract.md) contracts; internal/public modules have their own indexed boundaries. [BACKLOG.md](../BACKLOG.md) owns only outstanding work. The original M0 preservation evidence below remains bound to its old-name baseline.
 
-This contract makes the semantic handoff reviewable before implementation. It distinguishes model responsibilities from deterministic acceptance. It does not claim that any unconstrained model already follows these rules, or that new names improve task performance.
+This contract defines the semantic handoff responsibilities. It distinguishes model responsibilities from deterministic acceptance. It does not claim that any unconstrained model already follows these rules, or that new names improve task performance.
 
-Baseline for the evidence below: package 0.26.5, source commit `4494fee9da8258cdf5f02c42672a0eb9866a512a`, repository-local matching Pi SDK 1.0.0. No source or test changes were needed for this slice.
+Historical M0 baseline for the source-bound evidence below: package 0.26.5, source commit `4494fee9da8258cdf5f02c42672a0eb9866a512a`, repository-local matching Pi SDK 1.0.0. No source or test changes were needed for this slice.
 
 ## Purpose and reconstruction boundary
 
@@ -104,7 +104,7 @@ This does not confer dependency, hydration, existence, execution, completion, or
 - Lazy content can itself be temporary; no semantic plane is an automatic safe haven from ownership cleanup.
 - Consequential survivors can be saved at an unowned appropriate path in the same atomic patch. This is model-authored reconciliation, not runtime promotion, archiving, or movement between scopes.
 
-The current reference grammar is explicitly scoped. Single-scope normalization is M3 work, not permission for M0 to change how unscoped stored references acquire ownership.
+Canonical stored ownership references remain explicitly scoped. With exactly one wanted owner, the implemented [model boundary](single-scope-interface-contract.md) anchors eligible relative structured references to that captured owner before ownership/cascade processing, and projects them relatively on output. This translation grants no acquisition or publication authority.
 
 ## Patch, mode, and trust constraints
 
@@ -115,13 +115,13 @@ This contract inherits [model-tool semantics](architecture.md#model-tools); it d
 - No materialized semantic nulls, model-authored response/config/provenance, or empty acknowledgement-only scope patches.
 - One atomic cohort produces explicit accepted changes. No-op repeats produce no new semantic transition. An Active patch remains an inference barrier; Passive does not gain a new barrier by implication.
 - Active preserves necessary handoff memory before completed prior trajectory leaves normal projection. Passive can use the same semantic distinctions on demand without mandatory consolidation or a State Flow iteration reset. Off exposes no State Flow model context or tools.
-- Global, CWD, and Session can all carry the three core semantic functions. Later overlay precedence is composition, never evidence of greater truth or instruction authority. Configurable participation is not implemented by this contract.
+- Global, CWD, and Session can all carry the three core semantic functions. Later overlay precedence is composition, never evidence of greater truth or instruction authority. The [scope contract](scope-selection-contract.md) owns configurable participation, independently of these semantic meanings.
 - References and state values are data. Package-reviewed trusted protocol may explain the planes, but ordinary memory, artifact compilations, or lazy values cannot alter system instructions.
 - Runtime publication, source provenance, response capture, native lifecycle ownership, and frozen-head reconciliation retain their established independent owners. The semantic relationship is not a module callback or hidden event network.
 
 ## Acceptance map
 
-The IDs below name contracts/oracles, not new runtime record types. Existing tests witness the old-name preservation mechanism. New-name native and model-behavior acceptance belongs to later milestones; this table is not a claim those tests already exist.
+The IDs below name contracts/oracles, not new runtime record types. The table retains the original M0 evidence plan: its milestone/future references describe that checkpoint, not pending implementation. Current deterministic renamed/native witnesses are recorded in the [migration](semantic-compatibility-decision.md#source-bound-m1-validation), [scope](scope-selection-contract.md#m2-functional-acceptance-boundary) and [model-interface](single-scope-interface-contract.md#deterministic-m3-checkpoint) contracts. Live-model semantic acceptance remains unrun.
 
 | ID | Obligation and falsification scenario | Evidence owner |
 | --- | --- | --- |
@@ -133,9 +133,128 @@ The IDs below name contracts/oracles, not new runtime record types. Existing tes
 | SH-6 | Preserve sparse state, no-stored-null rules, detachment, explicit accepted cascade deletions, and exact retained replay. Fails if staging changes inputs, creates stored empty defaults, or replay needs to derive ownership again. | `tests/state.test.ts`, `tests/transition.test.ts`, `tests/temporal.test.ts`; future M1 codec/migration oracle. |
 | SH-7 | Preserve the frozen-prefix, trust, scope, response, and provenance boundaries while using the new semantic guidance. Fails if a memory patch changes system rules, relocates source ownership, or introduces a finalization inference. | Current `tests/protocol.test.ts`, `tests/context.test.ts`, response/Skill/native test families; M1–M4 integration checkpoints. |
 
+### Offline-bundle patch corpus
+
+The following are **M1 model-patch examples**, using the implemented target dialect and explicit Session ownership with the default three-owner selection. A sole-owner selection instead uses the flat interface described in the [model-interface contract](single-scope-interface-contract.md). Field names inside planes are illustrative domain data, not a required schema. The scenario is a release bundle that must remain usable offline; no external release is executed by these examples.
+
+**1. Open a chosen outcome linked to its temporary operational context.**
+
+```json
+{
+  "session": {
+    "intents": {
+      "release": {
+        "outcome": "Prepare an offline-verifiable release bundle",
+        "context": { "$ref": "session.tactics.release" }
+      }
+    },
+    "tactics": {
+      "release": { "progress": "Bundle prepared; offline validation pending" }
+    }
+  }
+}
+```
+
+**2. Preserve a hierarchical accepted strategy, including binding requirements and rejected alternatives.**
+
+```json
+{
+  "session": {
+    "strategy": {
+      "release": {
+        "acceptance": "Accepted approach for this release",
+        "requirement": "User requires offline verification without credentials",
+        "phases": {
+          "prepare": { "approach": "Bundle dependencies and a verifier" },
+          "validate": {
+            "after": "prepare",
+            "approach": "Run the bundled verifier in network isolation"
+          }
+        },
+        "decision": "Use bundled verifier v1",
+        "rationale": "It is already packaged and expected to be self-contained",
+        "rejected": {
+          "online_only": "Cannot satisfy the offline requirement"
+        },
+        "assumption": "Verifier v1 never requires network access",
+        "reconsider_if": "A network-isolated validation attempts a connection"
+      }
+    }
+  }
+}
+```
+
+**3. Record actual progress and validation evidence, not a transcript.**
+
+```json
+{
+  "session": {
+    "tactics": {
+      "release": {
+        "progress": "Preparation complete; validation blocked",
+        "validation": {
+          "check": "Network-isolated bundle verification",
+          "result": "Failed",
+          "evidence": "Verifier v1 attempted to fetch its trust index"
+        },
+        "uncertainty": "Whether an embedded trust index is sufficient",
+        "next": "Inspect the verifier's offline-index interface"
+      }
+    }
+  }
+}
+```
+
+**4. After inspection establishes the supported alternative, revise strategy with reasons.** The failure invalidates the assumption, not the user's offline requirement. Updating the existing `rejected` object merges rather than discarding `online_only`.
+
+```json
+{
+  "session": {
+    "strategy": {
+      "release": {
+        "decision": "Bundle an embedded trust index with verifier v1",
+        "rationale": "The supported local-index option removes the observed fetch",
+        "rejected": {
+          "default_v1": "Network-isolated validation proved its default index is remote"
+        },
+        "assumption": "The bundled index covers every bundle dependency",
+        "reconsider_if": "An index-coverage or network-isolation check fails",
+        "phases": {
+          "prepare": { "approach": "Bundle dependencies, verifier, and trust index" }
+        }
+      }
+    },
+    "tactics": {
+      "release": {
+        "observation": "Exact-source inspection confirmed a supported local-index option",
+        "uncertainty": null,
+        "next": "Rebuild the bundle; rerun coverage and isolation checks"
+      }
+    }
+  }
+}
+```
+
+**5. Only after both checks pass, close the intent and retain the durable conclusion.** In this example the intent owns only `session.tactics.release`, not `session.strategy.release`: acceptance records the tactical deletion while the unowned strategy fields receive an ordinary merge and survive. If the intent also owned strategy.release, cleanup would clear it first and the patch would need to explicitly rewrite every consequence that must remain. Empty `intents`/`tactics` planes disappear if they have no other entries.
+
+```json
+{
+  "session": {
+    "strategy": {
+      "release": {
+        "conclusion": "Coverage and isolation checks passed with the embedded index"
+      }
+    },
+    "intents": { "release": null }
+  }
+}
+```
+
+These conclusions survive intent closure in the same canonical owner; that does not make Session memory cross-session Global knowledge. A proven change of applicability still needs an explicit verified move, never an automatic promotion.
+
 ### Five-example review exercise and answer key
 
-The five JSON patches in [BACKLOG §5.2](../BACKLOG.md#52-coherent-target-examples) form one sequential example, not five unrelated snapshots. A reviewer should be able to reconstruct the following without the original design conversation:
+The five JSON patches in the [offline-bundle corpus above](#offline-bundle-patch-corpus), relocated from the published v0.27.1 backlog, form one sequential example, not five unrelated snapshots. A reviewer should be able to reconstruct the following without the original design conversation:
 
 1. **Open outcome:** Prepare an offline-verifiable release bundle. The intent owns `session.tactics.release` through a structured reference. No claim of final validation success exists.
 2. **Accepted strategy:** Offline verification without credentials remains the user's binding requirement. Preparation precedes network-isolated validation. Bundled verifier v1 is the accepted approach; its self-containment is an assumption. Online-only verification was rejected because it cannot satisfy the requirement.
@@ -149,7 +268,7 @@ The fifth precondition is a semantic claim supplied by the scenario. A determini
 
 M0.1 checked the example against existing mechanisms without implementing the rename:
 
-- Extracted the five JSON patches from the linked backlog section.
+- Extracted the five JSON patches from the then-current backlog section (the corpus is now retained above).
 - Mapped only the scope-root plane names `strategy → contract`, `tactics → working`, and corresponding scoped structured-reference plane segments. Did not rewrite arbitrary prose/domain keys, change source files, or persist a converter.
 - Staged and committed each mapped patch entirely in memory with `stageAtomicScopePatches` / `commitScopedTransition`, no acquired sources and no run finalization; replayed the actual accepted records with `advanceTemporalState`.
 - Asserted staging detachment, unchanged Global/CWD, binding-requirement retention, both rejection reasons, surviving phase dependency, retained failed-check evidence after revision, deletion of only resolved uncertainty, and absence of authored response.
@@ -162,13 +281,12 @@ Historical focused-source command (not validation of the current cascade contrac
 node --experimental-strip-types --test tests/state.test.ts tests/ownership.test.ts tests/transition.test.ts tests/temporal.test.ts tests/protocol.test.ts
 ```
 
-Result for the source identity above: **76 passed, 0 failed**. These tests cover current old-name semantics; they neither certify an unimplemented rename nor substitute for M0.4 real-model baseline evidence. The in-memory example probe did not exercise disk CAS, migration, provider schemas, new selection policy, or flat-reference conversion.
+Result for the source identity above: **76 passed, 0 failed**. These tests covered the then-current old-name semantics; that historical result neither certified the later rename nor substitutes for M0.4 real-model baseline evidence. The in-memory example probe did not exercise disk CAS, migration, provider schemas, new selection policy, or flat-reference conversion.
+
+## Historical handoff and current limits
 
-## Remaining boundaries
+The original M0.1 handoff required M0.2 compatibility decisions and M0.3 selection/private/response/fork decisions before their dependent implementation. Those obligations were subsequently met under the linked migration and scope contracts; flat paths and internal/public modules also shipped in 0.27.0. They are not unresolved prerequisites.
 
-The semantic meanings and preservation obligations above are the M0.1 handoff. The [canonical backlog](../BACKLOG.md#12-ordered-implementation-backlog) owns outstanding work:
+Real-model evaluation remains separate and unrun; the [evaluation contract](semantic-memory-evaluation.md) owns its corpus, rubric and execution gate, while [BACKLOG.md](../BACKLOG.md) owns remaining action. Dynamic loading, background scheduling and new cognitive planes were not delivered by these milestones.
 
-- M0.2 must settle the historical representation, collision/dialect fence, and public-API compatibility contract before M1 changes codecs.
-- M0.3 must settle selection metadata, disabled-stream authority, response-without-Session, and fork policy before M2.
-- M0.4 must obtain source/model-bound behavioral observations; no such evaluation was performed in this slice.
-- Schema adaptation, flat paths, module loading/hooks, and later milestone implementation remain excluded from M0.1. Nothing in this document enables them implicitly.
+The superseded development roadmap is preserved at [the published v0.27.1 source](https://github.com/llblab/pi-state-flow/blob/f9128d9eaa2b94133d992f51f80f16aec0d43653/BACKLOG.md). Its baseline observations, execution instructions and review statuses are historical evidence, not current normative policy. The corpus above and the indexed owning contracts retain the useful semantic rationale and acceptance counterexamples without keeping completed queues active.

package/node_modules/@llblab/pi-state-flow/docs/semantic-memory-evaluation.md

@@ -2,11 +2,11 @@
 
 ## Status and evidence boundary
 
-**Deferred post-implementation comparison — no live baseline executed.** Following the owner's 2026-10-24 implementation-first direction, this trial no longer gates M1–M5 implementation. Preserve the baseline source and fixed corpus for later comparison, disclose any model/provider drift, and never relabel calibration as model behavior. This run sheet specifies one small reproducible linked-task trial and its oracles. The opt-in [runner](../benchmarks/semantic-memory.mjs) now implements the isolated fixture/measurement mechanics and offline scripted calibration; it is not a live model result or evidence that the proposed semantic names improve quality. [BACKLOG.md](../BACKLOG.md#13-evaluation-and-acceptance-strategy) owns remaining execution and acceptance work.
+**Deferred post-implementation comparison — no live baseline executed.** Following the owner's 2026-10-24 implementation-first direction, this trial no longer gates M1–M5 implementation. Preserve the baseline source and fixed corpus for later comparison, disclose any model/provider drift, and never relabel calibration as model behavior. This run sheet specifies one small reproducible linked-task trial and its oracles. The opt-in [runner](../benchmarks/semantic-memory.mjs) now implements the isolated fixture/measurement mechanics and offline scripted calibration; it is not a live model result or evidence that the proposed semantic names improve quality. [BACKLOG.md](../BACKLOG.md#external-validation-and-evaluation) owns remaining execution and acceptance work.
 
 The existing [performance workloads](performance.md) and [benchmark guide](../benchmarks/README.md) are synthetic transport/performance evidence. The current [semantic handoff evidence](semantic-handoff-contract.md#source-bound-validation-evidence) is an old-name in-memory preservation probe. Neither is a replacement for the model observations defined here.
 
-### Local preflight result
+### Historical M0 local preflight result
 
 The preparation inspected only SDK/tool metadata and repository source, without live canonical-store access:
 
@@ -37,7 +37,7 @@ This is 12 user inputs, not necessarily 12 model requests: normal tool turns and
 
 Use the same pinned physical model/provider and reasoning level for all three conditions. Do not silently switch providers when one fails. A provider alias is not an immutable model snapshot: report any actual snapshot identity the provider exposes, or record that it is unavailable. Do not fabricate immutable version provenance from the catalogue name.
 
-The preserved M0 baseline source uses old semantic names with all three scopes. The current runner/calibration now follows the unreleased M1 Strategy/Tactics API; that does not retroactively produce an old-version live baseline. Later comparisons must bind each condition to its actual source/schema digest. Configurable scopes, flat references and module protocols remain future conditions until implemented.
+The preserved M0 baseline source uses old semantic names with all three scopes. The current runner/calibration follows the Strategy/Tactics API released in 0.27.0; that does not retroactively produce an old-version live baseline. Later comparisons must bind each condition to its actual source/schema digest. Seven-selection and flat-interface mechanics are implemented, but their real-model comparison is unrun. The runner's initial all-three conditions are not a substitute for that separate comparison.
 
 ## Isolation and native host setup
 
@@ -137,7 +137,7 @@ Score each applicable semantic obligation as **met / violated / not exercised /
 - **Closure and survivors:** An actually completed commitment closes; durable conclusions survive. Record actual ownership usage separately from its correctness.
 - **Rediscovery/churn:** Repeated reads, repeated tests, no-op patches, needless full-plan replacement, and semantic growth are observations. A necessary revalidation after artifact change is not needless repetition.
 
-Flattened one-scope operation and disabled-owner writes cannot be scored against the preserved4494fee/0.26.5 baseline as if implemented there; their installed target mechanics are covered by the later M2/M3 checkpoints, not by this historical baseline. Reserve those cases for M3's comparison, with actual schemas and excluded-owner byte hashes. M4 adds only a protocol-composition comparison once M1–M3 are stable.
+Flattened one-scope operation and disabled-owner writes cannot be scored against the preserved4494fee/0.26.5 baseline as if implemented there; their installed target mechanics are covered by the later M2/M3 checkpoints, not by this historical baseline. Reserve those cases for M3's comparison, with actual schemas and excluded-owner byte hashes. The historical roadmap also proposed a protocol-composition comparison. M4 ultimately retained existing renderers without changing protocol output, so that decision creates no new experimental treatment or requirement to invent one. Any later cognitive-benefit claim needs separately authorized comparable conditions.
 
 ## Compact report shape and interpretation
 
@@ -163,4 +163,4 @@ Calibration on the M0 source/SDK stack exercised four native user runs per condi
 
 These observations validate harness mechanics only. They are not behavioral rubric scores, live token charges, physical network-isolation proof, or provider cache measurements. The raw public usage fields in faux reports must not be interpreted as live-provider cost evidence.
 
-After functional implementation and deterministic validation, M0.4b requires the authorized credential-capable route and bounded execution settings stated above. Execute comparable baseline/target real-model conditions where reproducible, review the semantic rubric, and retain the compact source-bound report. The canonical backlog retains this deferred remainder; missing model observations do not block changing runtime names or prompts. Do not treat calibration or missing baseline observations as completed model evidence or an agent-quality improvement.
+After functional implementation and deterministic validation, M0.4b requires the authorized credential-capable route and bounded execution settings stated above. Execute comparable baseline/target real-model conditions where reproducible, review the semantic rubric, and retain the compact source-bound report. The canonical backlog retains this deferred remainder separately from 0.27.2 release-local cleanup; missing model observations do not reopen completed runtime implementation. Do not treat calibration or missing baseline observations as completed model evidence or an agent-quality improvement.

package/node_modules/@llblab/pi-state-flow/docs/semantic-module-contract.md

@@ -2,9 +2,9 @@
 
 ## Status and boundary
 
-The internal implementation has supported-Node validation and bounded independent acceptance. The contract and executors are implemented in `lib/semantic-module.ts`; the existing six planes use static bindings in `lib/planes.ts`. This delivered boundary is package-owned composition, not a public plugin ABI, discovery mechanism or external loader. No new native option, stored root, storage version, `immutable/content` disk envelope or tool grammar was introduced by this cohort. The earlier [M4](protocol-composition-decision.md) and [M5](semantic-extensibility-decision.md) retain/defer decisions describe their original evidence. The user's subsequent public-registration request is separate open work in [BACKLOG](../BACKLOG.md#12-ordered-implementation-backlog), not functionality supplied by this internal contract.
+The internal contract and executors in `lib/semantic-module.ts`, with six static plane bindings in `lib/planes.ts`, shipped in **0.27.0**. This boundary is package-owned composition, not a discovery mechanism or external loader. Its original cohort introduced no stored root, storage version, `immutable/content` disk envelope or tool grammar. The earlier [M4](protocol-composition-decision.md) and [M5](semantic-extensibility-decision.md) retain/defer decisions remain historical evidence. Subsequent explicitly authorized work also shipped the [public module registration boundary](public-module-contract.md), including metadata v4 external roots, using the same evaluators and acceptance engine rather than a second semantic engine.
 
-A module participates in context construction. Its identity is not permission to acquire memory, register a stored plane or publish state. The generic contract is not restricted to the six existing names; the current storage/tool binding deliberately is. [BACKLOG](../BACKLOG.md#12-ordered-implementation-backlog) alone owns unfinished public-registration work.
+A module participates in context construction. Its identity is not permission to acquire memory, register a stored plane or publish state. The internal generic contract is not restricted to the six existing names; `lib/planes.ts` binds only the six built-ins. External root admission, native-host registration and retained descriptors belong to the public contract, not these static bindings.
 
 ## The five-member contract
 
@@ -48,7 +48,7 @@ Selection is not authority to replace arbitrary context. The host still owns adm
 
 `produceModuleContent(module, content, input, signal, checkCurrent)` captures inputs, awaits the producer and admits a detached candidate. The host's original-currency assertion and cancellation run before work and after completion/validation. `checkCurrent` is a throwing revalidator (`() => void`), not a boolean predicate; the host must throw when its original basis is obsolete. Cancellation returns without waiting for a producer that ignores its signal; late completion cannot escape as an accepted result. Returned data cannot alias the original input, producer result or the validator's retained argument. This is data isolation, not a JavaScript effects sandbox.
 
-The function never installs state, increments revisions, grants a scope or calls a publisher. A future host adapter must bind its captured conversation/content/model/owner/selection basis to the existing synchronous acceptance check. Starting a fresh transaction and borrowing its current token does not make an old candidate current. Reject/recompute policy must be explicit.
+The function never installs state, increments revisions, grants a scope or calls a publisher. A host adapter must bind its captured conversation/content/model/owner/selection basis to the existing synchronous acceptance check; the public integration does so under its own contract. Starting a fresh transaction and borrowing its current token does not make an old candidate current. Reject/recompute policy must be explicit.
 
 Inference, source acquisition and asynchronous production stay outside canonical exclusion. Constructor-injected inference is enough for the contract; no model client, credentials, agent loop, scheduler or actual background inference is added here. A readonly signature cannot prevent ambient JavaScript effects in trusted package code.
 
@@ -75,10 +75,10 @@ The local dependency direction is `state/context/model-interface/transition -> p
 
 The contract witnesses exercise a stateless exact recent-window module and an immutable archive producer with constructor-injected fake inference. They prove mode-aware contribution transport, preserved source identities, asynchronous candidate isolation, cancellation and obsolete-completion rejection. They are not dummy production planes and are not described as a working archive.
 
-Not implemented by this boundary: new stored planes/codecs, archive node retention/version history, a selected-model inference adapter, background jobs, automatic raw-context replacement, public loading/registration or a stored envelope migration. Those require their actual storage/lifecycle/authority decisions rather than adding unused hooks now. A future module can use the contract without acquiring those permissions by identity alone.
+The internal boundary itself does not register external roots or define codecs; the separately delivered public contract owns those responsibilities. Production archives, a selected-model inference adapter, background jobs, dynamic loading and stored envelope migration remain unimplemented. Native conversation selection is admitted only under the public host contract, not by an arbitrary callback's identity.
 
 ## Verification
 
 `tests/semantic-module.test.ts` owns contract/input/contribution/producer properties; `tests/planes.test.ts` owns real bindings, immutability and navigation/projection. `tests/context.test.ts` owns user-data transport and exact native-message/tool-identity materialization. Existing state/context/model-interface/transition and native SDK tests retain the prior semantic, publication and lifecycle witnesses.
 
-A finite before/after certificate captures all seven selections' Active/bootstrap/Passive protocols, representative sparse/hot/model/context values and intent-cascade output. Equality is useful default-output evidence, not exhaustive AST/runtime equivalence or model-quality proof. Full supported-Node validation, generated-build parity, package inventory, DAG/context checks and independent post-implementation review are separate acceptance evidence; current results belong in canonical remaining work until actually complete.
+A finite before/after certificate captures all seven selections' Active/bootstrap/Passive protocols, representative sparse/hot/model/context values and intent-cascade output. Equality is useful default-output evidence, not exhaustive AST/runtime equivalence or model-quality proof. Supported-Node validation, generated-build parity, package inventory, DAG/context checks and bounded independent internal-contract review were recorded during 0.27.0 development. Those records retain their original scope; later public activation was audited inline, not independently approved. Release CI does not establish live-model quality or installed-client compatibility; see [compatibility](compatibility.md).

package/node_modules/@llblab/pi-state-flow/docs/single-scope-interface-contract.md

@@ -2,9 +2,9 @@
 
 ## Status and boundary
 
-M2 participation/control is complete within the [functional scope boundary](scope-selection-contract.md#m2-functional-acceptance-boundary). M3.1's installed-SDK/local-provider serialization decision is independently **VERIFIED / APPROVE** within the mechanical boundary below. **Native patch roots now follow captured wanted arity:** five flat planes for one owner, explicit owner dictionaries for multiple owners. Both real tools consume the accepted translator only after M2 admission. Native mutation binding and the [deterministic FUNCTIONAL M3 checkpoint](#deterministic-m3-checkpoint) are independently **VERIFIED / APPROVE** within their stated evidence boundaries, not live-model quality. The SDK capability probes themselves publish no memory and confer no private acquisition. The native-read slice below is independently **VERIFIED / APPROVE** within its bounded evidence; neither that historical slice nor accepted mutation binding alone is whole-M3 model-surface acceptance. [BACKLOG.md](../BACKLOG.md#12-ordered-implementation-backlog) alone owns deferred real-model evidence and subsequent M4/M5 decisions.
+M2 participation/control is complete within the [functional scope boundary](scope-selection-contract.md#m2-functional-acceptance-boundary). M3.1's installed-SDK/local-provider serialization decision is independently **VERIFIED / APPROVE** within the mechanical boundary below. **Native patch roots follow captured wanted arity:** five built-in writable planes plus compatible registered mutable external roots, flat for one owner or in explicit owner dictionaries for multiple owners. Public external-root admission is owned by the [public module contract](public-module-contract.md). Both real tools consume the accepted translator only after M2 admission. Native mutation binding and the [deterministic FUNCTIONAL M3 checkpoint](#deterministic-m3-checkpoint) are independently **VERIFIED / APPROVE** within their stated evidence boundaries, not live-model quality. The SDK capability probes themselves publish no memory and confer no private acquisition. The native-read slice below is independently **VERIFIED / APPROVE** within its bounded evidence; neither that historical slice nor accepted mutation binding alone is whole-M3 model-surface acceptance. M4/M5's historical decisions and later internal/public module work also shipped in 0.27.0; [BACKLOG.md](../BACKLOG.md) owns only outstanding work, including separately gated real-model evidence.
 
-The task is to remove mandatory scope knowledge from ordinary single-owner model operations without losing canonical ownership, history, cancellation or multi-owner atomicity. Mode, owner participation and model presentation remain separate. A flat declaration is not an authoring grant.
+The task is to remove mandatory scope knowledge from ordinary single-owner model operations without losing canonical ownership, history, cancellation or multi-owner atomicity. Mode, owner participation and model presentation remain separate. A flat declaration is not an authoring grant. The implementation-slice sections below retain their original then-current gates, counts and verdicts; statements about later M3 slices being pending describe those historical checkpoints, not the current released interface.
 
 ## Schema decision
 

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

@@ -27,7 +27,7 @@ One session-owned `mode` selects these behaviors; there are no separate passive-
 - an extra model turn;
 - a special finalization tool.
 
-Each `patch_state` is an inference barrier, not automatically the end of an iteration. The runtime separately persists the accepted ordinary answer as Session `response` and completes the run.
+In Active mode, `patch_state` is an inference barrier, not automatically the end of an iteration; Passive has no such barrier. The runtime separately completes the run and captures the accepted ordinary answer only in Active participating Session. With Session excluded, completion is lifecycle-only unless another semantic change is accepted; no answer is backfilled or relocated.
 
 **Two meanings of “bootstrap”:**
 
@@ -51,31 +51,39 @@ Active, Passive and Off select the session's workflow and model-facing access, n
 
 All three mode commands accept optional exact owner tokens, in any order: `/state-flow-active session`, `/state-flow-passive cwd global`, `/state-flow-off cwd session`. Any nonempty unique subset of `global cwd session` is valid; autocomplete offers only unused matching tokens and replaces the full argument prefix. Blank/whitespace-only arguments preserve the captured choice. Unknown/duplicate names, flags and comma-separated forms fail before policy or mode changes. Commands never edit global defaults. Off scope changes record native policy only, without reading or initializing canonical memory. Active explicitly owns acquisition where independently permitted; Passive observation alone cannot acquire missing Session or borrow pending fork permission.
 
-Selection is not materialization: all three scopes are selected by default, but a pre-runtime Passive session can have no private Session cohort yet. Read-only observation exposes existing shared owners without inventing empty Session state. An explicit read of a selected owner missing from that read view reports `selected, unavailable`, not `excluded`; an actually excluded owner is rejected by the selection guard. A legitimate first Session patch on an eligible non-fork branch can acquire private memory through normal atomic acceptance. Do not send an empty patch just to initialize it or bypass pending-fork authority.
+All seven nonempty owner sets are supported: `global`, `cwd`, `session`, `global cwd`, `global session`, `cwd session`, and `global cwd session`. Omission of global `scopes` defaults to all three; changing a current selection never moves or migrates data between owners.
+
+Selection is not materialization:
+
+- **Wanted:** The owner is selected by captured policy; wanted arity chooses flat versus explicit-owner grammar.
+- **Available:** A validated read view exists for that owner. A pre-runtime Passive session can observe shared owners while wanted Session remains unacquired.
+- **Excluded:** The owner is outside the wanted policy. Model reads/writes reject it rather than widening selection.
+
+In the 0.27.1 diagnostic, an explicit read of wanted but unavailable Session reports `State Flow session: selected, unavailable`, not exclusion. Reads never invent or acquire private memory, and a mixed available/unavailable batch returns no partial values. A legitimate first Session patch on an eligible non-fork branch can acquire private memory through normal atomic acceptance. Do not send an empty patch to initialize it or bypass pending-fork authority.
 
 How each lifecycle event behaves:
 
-- **New session:** Adopts the global `mode`, defaulting to Off.
-  - An inactive default is recorded once in Pi as `{mode:"off"}` or `{mode:"passive"}`, without creating semantic storage.
-  - An Active default initializes a distinct empty Session layer over global/CWD memory, never another session's private continuation.
+- **New session:** Captures global `mode` and `scopes`, defaulting to Off and all three owners.
+  - An inactive default is recorded once in an owner-bound native v2 policy record containing `{mode, scopes}`, without creating semantic storage.
+  - An Active default accepts the selected owners; if Session participates it initializes a distinct private layer, never another session's continuation. Shared-only choices create no hidden Session semantics.
 - **Resume:** Keeps the selected session's mode; later global default changes do not override it.
   - Passive/Active attach the current same-session memory and its retained history.
   - Off attaches native policy only, without probing semantic files or emitting recovery warnings.
-- **Tree navigation:** Restores the selected branch's mode, but never rewinds memory: State Flow does not depend on the Pi step. Passive/Active keep the current JSON state of every scope, which changes only through accepted patches. Off defers acquisition until a mode is explicitly selected.
-- **Fork:** The child copies its parent's current memory into its own session layer, independent of the step it forked from.
+- **Tree navigation:** Restores the selected branch's mode, but never rewinds memory: State Flow does not depend on the Pi step. Passive/Active acquire the current JSON state of the selected owners under their existing authority, never an old semantic revision. Off defers acquisition until a mode is explicitly selected.
+- **Fork:** The child inherits its parent's captured policy. With Session selected, admitted acquisition copies parent-current private memory into a fresh child owner, independent of the native step. Off or Session-excluded forks defer private copying; later admitted Session acquisition copies the parent's then-current state once.
 - **Abort inference:** Stops generation or an outstanding response-publication wait. Already accepted patches stay durable, so work and corrected direction can continue in the same session.
   - Cancellation before response acceptance keeps the previous response and the unfinished run.
   - Cancellation after acceptance never rolls it back.
   - Abort does not require immediate remote replication.
 - **Native boundary continuation:** A companion may continue through Pi's `turn_end` or `agent_before_settle` boundary without a new user prompt. State Flow keeps projecting current memory and the accepted response across those requests and later patches. It does not restore the completed specification or request another turn itself.
 - **Passive:** `/state-flow-passive` enables both memory tools and projection.
-  - A proven pre-runtime branch records only `{mode}` in Pi and loads shared memory read-only.
+  - A proven pre-runtime branch records native v2 `{mode, scopes}` policy in Pi and observes only selected existing shared memory read-only.
   - Accepted runtimes persist Passive and adopt unrelated shared drift without semantic/provenance writes or revision/step changes.
   - Pending repeats share one acceptance.
 - **Off:** `/state-flow-off` removes memory tools and context, and immediately clears semantic caches.
   - It cancels owned restoration/fork, activation, preparation, response, patch and Passive-persistence waits.
   - It saves only native policy and continuation/fork bookmarks. Existing canonical bytes, including the old stored runtime mode, stay untouched even when malformed or busy.
-  - Repeated Off is inert. Already accepted data is preserved, and a later explicit Passive/Active reacquires memory.
+  - Repeated mode-only Off with the same captured choice is inert; explicit different scopes change native policy only. Already accepted data is preserved, and a later explicit Passive/Active reacquires memory.
   - Global defaults and other sessions remain unchanged.
 - **If Passive cannot persist:** Off itself never attempts canonical persistence; this fallback concerns Passive.
   - The selected Passive policy stays applied. Accepted memory and the native conversation stay intact.
@@ -107,10 +115,11 @@ State Flow does not undo tool effects. After an interruption or a return to an o
 
 ### Fork support and limits
 
-**What a fork copies.** Memory-enabled native fork replacement copies the parent's **current** session checkpoint, retained patch tail and matching provenance into the new session's own storage, independent of the Pi step it forked from.
+**What a fork copies.** When Session participates and private acquisition is admitted, native fork replacement copies the parent's **current** Session stream and matching provenance into the child's own storage, independent of the Pi step it forked from.
 
-- Off records only a child-owned pending-fork policy. Header/store reads and copying wait until an explicit Passive/Active, including after a cold reload.
-- Global/CWD values and provenance stay current. Applying a smaller `historyLimit` may fold shared tails under CAS.
+- Off records only child-owned native pending-fork policy; parent-header/store reads and copying wait for admitted Passive/Active acquisition, including after cold reload.
+- With Session excluded, enabled modes accept selected shared owners plus child lifecycle metadata without reading/copying parent-private memory. Later explicit Session acquisition requires that child's deferred-copy proof and an absent private target; an acquired child never recopies.
+- Selected Global/CWD values and provenance stay current. Applying a smaller `historyLimit` may fold selected shared tails under CAS; excluded semantic files stay unchanged.
 - Parent-private data and history stay intact. The selected mode is kept, so an inactive source does not become Active automatically.
 
 **The child's own history.** The child starts at step zero with a new temporal origin.
@@ -119,12 +128,12 @@ State Flow does not undo tool effects. After an interruption or a return to an o
 - The child's own transitions build its hot window, and owned checkpoints support normal reload/resume.
 - Parent Stop projection is not inherited, including after a child reload.
 
-**Requirements for the initial copy:** a native fork start event, a regular canonical direct-parent session file, matching CWD/identity, a readable temporal source and an unused child namespace. Missing or unsafe evidence or a CAS conflict leaves the copy unavailable rather than importing unrelated private state. Explicit Start can retry an unaccepted copy in the same loaded fork once the cause is corrected.
+**Requirements for the initial copy:** a native fork start event, a regular canonical direct-parent session file, matching CWD/identity, a readable current temporal source and an unoccupied child semantic target. A lifecycle-only child must additionally prove its own deferred-copy authority before private acquisition. Missing or unsafe evidence or a CAS conflict leaves the copy unavailable rather than importing unrelated private state. Explicit Start can retry an unaccepted copy in the same loaded fork once the cause is corrected.
 
 **Limits:**
 
 - Selecting a copied parent step through the child's `/tree` keeps current child-owned memory; it neither rewinds nor recopies parent data.
-- Cold recovery before the first child checkpoint requires an Off-deferred pending-fork marker. Otherwise, it and startup paths lacking the fork event remain unsupported.
+- Cold recovery before first private acceptance requires child-owned pending-fork authority; an accepted shared-only child also retains its matching deferred lifecycle proof. Missing files alone and startup paths without valid fork authority cannot authorize copying.
 - In-memory parent locators and cross-CWD imports remain unsupported.
 - File-only copying requires an exact still-available source cohort.
 
@@ -137,6 +146,7 @@ An optional global `config.json` lives at the root of the State Flow repository,
 ```json
 {
   "mode": "off",
+  "scopes": ["global", "cwd", "session"],
   "logging": false,
   "showSuccessfulPatches": true,
   "historyLimit": 7
@@ -226,9 +236,9 @@ When `pi-telegram` is available, its main-menu section shows `State Flow: active
 - The submenu heading shows the current value in monospace.
 - The bold Mode heading uses a long dash, a description ending in a colon, and a blank line before its settings-style list. Each line has a monospaced minus and lowercase monospaced mode value, then a plain colon and description.
 - The descriptions progress from regular chat with no memory (Off, the new-session default), to ordinary chat with memory tools and an available combined memory view (Passive), to the same memory access with completed answers followed by memory-first continuation (Active). They do not claim a new physical Pi session or disabled native compaction.
-- A Participating scopes line shows the captured current choice, initially from global defaults; later default edits do not replace an existing session choice. Mode/help text describes only that set and states when excluded Session means new answers are delivered without storage.
+- The captured participating owners are named by the Inspect participating memory list below, not a separate line; later default edits do not replace an existing session choice. Mode/help text describes only that set.
 - The bold Inspect participating memory heading follows the same long-dash, description, colon and blank-line pattern. Only selected owners get a monospaced description and direct button; this is not a scope chooser.
-- With one selected owner, its state is also effective and no separate Effective button appears. With two or three, Effective shows the validated available overlay of those selected owners only, in Global→CWD→Session order. Excluded owners do not contribute or gain an inspection action.
+- With one selected owner there is no separate effective state: the agent reads that owner directly, so neither an Effective line nor button appears. With two or three, Effective shows the validated available overlay of those selected owners only, in Global→CWD→Session order. Excluded owners do not contribute or gain an inspection action. The Effective description is a fixed sentence, not an owner enumeration: the list above already names the selected owners.
 
 **Memory inspection:**
 
@@ -273,9 +283,9 @@ See the [storage contract](architecture.md#storage-and-identity) for the exact l
 **Missing fields are fine.** Missing documented fields inside a valid checkpoint or patch are supported.
 
 - Current and historical semantic views include only known fields present in the selected scope or overlay; absent fields and empty responses are omitted. Higher scopes contribute only present values.
-- Unknown top-level fields are ignored when reading checkpoints/patches and are not emitted on later writes; nested data within known planes stays intact.
+- Built-in fields and metadata v4-declared external roots are known semantic content. Declared external values/history survive missing or incompatible definitions; unrelated unknown roots remain outside the supported semantic view. Retired target-format roots explicitly reject rather than being silently ignored. Nested data within admitted planes stays intact.
 - An explicit `read_state` value query for an absent documented top-level field returns `null`, including an empty or absent `session.response`.
-- Reading and Start do not normalize files, advance revisions or require a migration.
+- Read-only inspection never normalizes or converts files. Start does not fill missing planes or create a semantic revision merely for normalization; independently authorized acceptance may perform the supported backed-up format conversion described below.
 - An empty semantic object is different from a missing file or missing ownership metadata.
 
 **Wholly absent shared files.** A checkpoint and its tail are one semantic pair. If both live files of a global or CWD scope disappear, State Flow treats that complete absence as current empty shared reality. An authored `patch_state` applies to that empty basis under exclusion, and normal file-cohort CAS creates the accepted pair without resurrecting cold values or orphaned compilation evidence. Raw precomputed replay still refuses a removed selected target rather than replaying stale normalized changes.
@@ -342,11 +352,11 @@ Commit or push failure is diagnostic-only; repeated push failures warn once per
 **Supported formats.** State Flow accepts only canonical checkpoint/tail files, temporal metadata and the separate session config/runtime contract.
 
 - Scope metadata versions 1/2 remain readable through explicit `contract → strategy`, `working → tactics` translation before field filtering. Current/historical tools expose only the target dialect; retired root writes reject rather than becoming aliases. Legacy missing revisions credit only retained tail records.
-- New writes use scope metadata version 3. On an owned semantic acceptance, legacy cohorts convert with unchanged semantic revisions/causal identities, under the existing lock/CAS and rollback checks. Ordinary inspection and runtime-only mode persistence do not convert files. Upgrade/quiesce all writers before enabling the new code: already-deployed low-level readers cannot be universally fenced by a format number.
+- Core-only writes use scope metadata v3; retained external-module descriptors select v4. Both use Strategy/Tactics. On owned semantic acceptance, supported legacy/descriptor upgrades use the same backup, lock/CAS and rollback checks without advancing revisions/causal identities for representation alone. Ordinary inspection and runtime-only mode persistence do not convert files. Upgrade/quiesce all writers before enabling the new code: already-deployed low-level readers cannot be universally fenced by a format number.
 - Unsupported checkpoint envelopes, combined session metadata, `state.json`, hashed layouts and semantic Pi checkpoint envelopes fail as unsupported, without rewriting existing bytes.
 - Canonical semantic objects lacking optional fields, such as `intents` or `lazy`, are valid sparse state and do not cross this boundary.
-- Before any v1/v2-to-v3 canonical publication, the storage owner writes and verifies an exact-byte JSON backup at `<parent-of-store>/<store-name>-migration-backups/<sha256>.json` (created with directory mode 0700, file mode 0600 on the verified platform; existing non-private paths reject). It lists converted scopes and updated paths alongside the transaction's owned file basis, relative paths, identities, Base64 originals and explicit missing entries, including required Session config/runtime. It never discovers unrelated projects/sessions or source bodies. The returned publication exposes `migrationBackup`; completed backups survive rollback and exact retries reuse them. Backup failure blocks canonical writes.
-- This backup is recovery evidence outside canonical authority, not a Git commit, journal, automatic fallback or power-loss guarantee. Quiesce writers and request a reviewed complete-cohort recovery before downgrade/restoration; do not overwrite intervening foreign data or restore just one file. Retain backups privately. State Flow 0.x retains legacy conversion and retired-root reservations; the temporary support window ends at State Flow 1.0.0, with unsupported versions still explicitly rejected. The prepared0.27.0 candidate keeps its converter/reservations unchanged; no automatic removal, release or working-store migration follows. See the [settled support policy](semantic-compatibility-decision.md#implementation-direction-and-reserved-names).
+- Before a supported legacy or explicit metadata upgrade is canonically published, the storage owner writes and verifies an exact-byte JSON backup at `<parent-of-store>/<store-name>-migration-backups/<sha256>.json` (created with directory mode 0700, file mode 0600 on the verified platform; existing non-private paths reject). It lists converted scopes and updated paths alongside the transaction's owned file basis, relative paths, identities, Base64 originals and explicit missing entries, including required Session config/runtime. It never discovers unrelated projects/sessions or source bodies. The returned publication exposes `migrationBackup`; completed backups survive rollback and exact retries reuse them. Backup failure blocks canonical writes.
+- This backup is recovery evidence outside canonical authority, not a Git commit, journal, automatic fallback or power-loss guarantee. Quiesce writers and request a reviewed complete-cohort recovery before downgrade/restoration; do not overwrite intervening foreign data or restore just one file. Retain backups privately. State Flow 0.x retains legacy conversion and retired-root reservations; the temporary support window ends at State Flow 1.0.0, with unsupported versions still explicitly rejected. Released 0.27.0/0.27.1 retain their converter/reservations, and 0.27.2 preserves that policy; no automatic removal, release or working-store operation follows from consolidation. See the [settled support policy](semantic-compatibility-decision.md#implementation-direction-and-reserved-names).
 
 ### Conflicts and interrupted publication
 
@@ -359,7 +369,7 @@ Commit or push failure is diagnostic-only; repeated push failures warn once per
 
 Do not repeat external actions while memory publication waits.
 
-**Final answers.** Final-answer reconciliation also waits cancelably, then saves the response and the completed-run lifecycle together over current shared memory. Stop, session/tree changes, shutdown and a superseding answer cancel obsolete waits without modifying newer work. A failed or canceled publication leaves the prior response and unfinished run intact; it never requests a repair inference.
+**Final answers.** Active final-answer reconciliation waits cancelably, then completes the run over current selected memory and saves the response only when Session participates. Session-excluded completion does not write a hidden private/shared answer. Stop, session/tree changes, shutdown and a superseding answer cancel obsolete waits without modifying newer work. A failed or canceled publication leaves the prior response and unfinished run intact; it never requests a repair inference.
 
 **Run preparation.** Run preparation and missing-artifact maintenance wait cancelably before the first enabled inference, accepting current shared memory and lifecycle together. If preparation fails, State Flow aborts that native operation rather than sending a rejected or stale draft to the provider; previously accepted memory stays available. Cancellation can leave the new request without a specification checkpoint, so its native conversation is conservatively preserved through idle Stop/reload. Boundary continuation never replays a completed specification.
 
@@ -420,7 +430,7 @@ The agent should use sufficient materialized knowledge before rereading files. I
 
 **Artifact maintenance:**
 
-- It inspects only exact paths already registered in global, CWD or session state, using `size + mtimeNs`, without directory traversal or generic content hashing.
+- It inspects only exact registered paths owned by selected scopes, using `size + mtimeNs`, without directory traversal or generic content hashing. Excluded owners receive no automatic source maintenance or relocation.
 - Proven-missing paths are pruned from their exact owning scopes. Unavailable, relative, directory and symlink paths are preserved.
 - Changed sources keep their artifact value and receive a runtime-only model `hint` until a stable read and same-path compilation update the hidden provenance.
 - Model patches cannot author or delete runtime provenance or hints.

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

@@ -243,16 +243,12 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 			owner: ctx.sessionManager.getSessionId(), mode: snapshot.config.mode, scopes: nativeScopeSelection(ctx), ...value }));
 	}
 
-	function assertNativeMemoryScopes(scopes: readonly StateScope[]): void {
-		captureScopeSelection(scopes);
-	}
-
 	function branchPolicy(ctx: ExtensionContext, reason?: unknown, memoryRequired = true) {
 		const branch = ctx.sessionManager.getBranch();
 		const policy = prepareSelectedBranchPolicy(branch, { owner: ctx.sessionManager.getSessionId(), markerEntryType: PASSIVE_STOP_ENTRY_TYPE,
 			defaults: { mode: isNewSession(reason, branch) ? config.mode : config.inactiveMode, scopes: config.scopes },
 			inactiveMode: config.inactiveMode, fork: reason === "fork" });
-		if (memoryRequired) assertNativeMemoryScopes(policy.scopes);
+		if (memoryRequired) captureScopeSelection(policy.scopes);
 		return policy;
 	}
 
@@ -577,7 +573,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 			// Freeze admitted policy before accepting any selected memory.
 			// Policy-only capture grants no acquisition or semantic-boundary authority.
 			if (nativePolicy.requiresCapture) pi.appendEntry(PASSIVE_STOP_ENTRY_TYPE, nativePolicy.capture);
-			if (nativePolicy.mode !== "off") assertNativeMemoryScopes(nativePolicy.scopes);
+			if (nativePolicy.mode !== "off") captureScopeSelection(nativePolicy.scopes);
 		} catch (error) {
 			runtime = undefined;
 			branchStartsWithoutRuntime = false;
@@ -1245,7 +1241,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 			return { ok: false, message: active ? "State Flow activation was superseded" : "State Flow mode change was superseded", signal: pending.signal };
 		};
 		try {
-			assertNativeMemoryScopes(wanted);
+			captureScopeSelection(wanted);
 			const activation = createRuntime(ctx);
 			const deferred = deferredBranch;
 			if (deferred) {

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

@@ -8,7 +8,6 @@ import type { AtomicScopePatches, StateScope } from "./state.ts";
 
 import { MODEL_PLANE_NAMES } from "./planes.ts";
 
-const PATCH_PLANES = MODEL_PLANE_NAMES;
 const SEMANTIC_ROOT = /^(?:intents|strategy|tactics|artifacts|response|lazy|x_[a-z][a-z0-9_]*)(?=\.|\[|$)/;
 const PATCH_PATH = /^(?:effective|global|cwd|session)\.patches(?:\[\d+\])?$/;
 
@@ -57,7 +56,7 @@ function admitKeys(value: JsonObject, selected: ScopeSelection, external: readon
 	const keys = Object.keys(value);
 	if (!keys.length) throw new Error("Model patch requires at least one supplied branch");
 	if (selected.length === 1) {
-		if (keys.some(key => !PATCH_PLANES.includes(key) && !external.includes(key))) throw new Error("Single-owner model patches require flat semantic planes");
+		if (keys.some(key => !MODEL_PLANE_NAMES.includes(key) && !external.includes(key))) throw new Error("Single-owner model patches require flat semantic planes");
 	} else for (const key of keys) {
 		if (!selected.includes(key as StateScope)) throw new Error(`Multi-owner model patches require participating explicit owners; does not accept field ${key}`);
 	}
@@ -66,7 +65,7 @@ function admitKeys(value: JsonObject, selected: ScopeSelection, external: readon
 function planePatch(value: unknown, external: readonly string[]): asserts value is JsonObject {
 	if (!isObject(value) || !Object.keys(value).length) throw new Error("Model scope patch must be a nonempty object");
 	for (const key of Object.keys(value)) {
-		if (!PATCH_PLANES.includes(key) && !external.includes(key)) throw new Error(`Model patch does not accept semantic plane ${key}`);
+		if (!MODEL_PLANE_NAMES.includes(key) && !external.includes(key)) throw new Error(`Model patch does not accept semantic plane ${key}`);
 		if (!isObject(value[key])) throw new Error(`Model patch plane ${key} must be a JSON object`);
 	}
 }

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

@@ -40,7 +40,7 @@ export interface StateFlowModuleInput<Input extends JsonValue = JsonValue> {
 	assertCurrent(): void;
 }
 
-/** Candidate public v1 contract; durable activation requires matching retained metadata. */
+/** Published public v1 contract; retained descriptors govern durable compatibility. */
 export interface StateFlowModule<Content extends JsonObject = JsonObject, Input extends JsonValue = JsonValue> {
 	readonly immutable: boolean;
 	readonly id: string;

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

@@ -179,7 +179,6 @@ export function buildStateFlowSectionView(
 		if (index % 2 === 0) inspectionRows.push([]);
 		inspectionRows.at(-1)!.push({ text: STATE_FLOW_SCOPE_LABELS[scope], callback_data: callbackData("inspect", scope) });
 	}
-	const named = scopes.map(scope => `<code>${scope}</code>`).join(" → ");
 	const modes: StateFlowTelegramButton[] = STATE_FLOW_MODES.map((mode) => ({
 		text: `${mode === snapshot.mode ? STATE_FLOW_SELECTED_MARKERS[mode] : "⚫️"} ${STATE_FLOW_MODE_LABELS[mode]}`,
 		callback_data: callbackData(mode),
@@ -198,15 +197,12 @@ export function buildStateFlowSectionView(
 			`<code>-</code> <code>passive</code>: regular chat with memory tools; available memory from the selected ${scopes.length === 1 ? "scope" : "scopes"} enters the agent's context.`,
 			"<code>-</code> <code>active</code>: same memory access; each completed answer closes a cycle, and the next request starts from saved state, not the full chat.",
 			"",
-			`<b>Participating scopes:</b> ${named}`,
-			...(!scopes.includes("session") ? ["New answers are delivered, not stored: Session is excluded."] : []),
-			"",
 			"<b>Inspect participating memory</b> — view available stored state even in Off:",
 			"",
 			...scopes.map(scope => `<code>-</code> <code>${scope}</code>: ${STATE_FLOW_SCOPE_DESCRIPTIONS[scope]}`),
 			...(scopes.length > 1
-				? [`<code>-</code> <code>effective</code>: validated available ${named} overlay; excluded scopes do not contribute.`]
-				: ["This single scope is also the agent's effective state; no separate overlay is needed."]),
+				? ["<code>-</code> <code>effective</code>: merged state of the selected scopes in order from the general to the specific."]
+				: []),
 		].join("\n"),
 		parseMode: "html",
 		replyMarkup: { inline_keyboard: [