@llblab/pi-kit 0.38.2 → 0.38.3

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

@@ -4,34 +4,34 @@
 
 ## Contract
 
-A physical Pi fork creates a fresh child session from its direct parent's **current** canonical session memory. State Flow does not depend on the Pi step the fork starts from:
+A physical Pi fork creates a fresh child identity and inherits the source branch's captured mode and scopes. When Session participates and private acquisition is admitted, it copies its direct parent's **current** canonical Session memory. Off or Session-excluded forks defer private acquisition. State Flow does not depend on the Pi step the fork starts from:
 
 ```text
-child.global  = current live global
-child.cwd     = current live CWD
-child.session = parent session current head
+selected child.global/cwd = current live selected shared owners
+admitted child.session   = direct-parent Session current head
+excluded child.session   = no hidden private semantic stream
 ```
 
-The adapter reads Pi's persisted direct-parent header, requires matching CWD and session identity, reads the parent's current memory and uses its head as the copied boundary. It never consults Git, a storage receipt or an older checkpoint revision.
+At private acquisition, the adapter reads Pi's persisted direct-parent header, requires matching CWD and session identity, and admits the parent's current private stream. A Session-excluded child instead accepts selected shared access and child-owned deferred lifecycle proof without reading the parent header/private store. It never consults Git, a storage receipt or an older checkpoint revision.
 
 The child receives:
 
 - its own UUID, native session key, runtime metadata, and fresh lineage origin;
-- the parent's current session materialization and matching artifact provenance;
-- current live global/CWD values and provenance without rewinding them;
-- selected `mode` and bootstrap lifecycle state, with step reset to zero and no inherited unfinished specification or validation diagnostic.
+- the parent's current Session materialization, matching artifact provenance and retained module descriptors when private copying is admitted;
+- current live selected Global/CWD values and provenance without rewinding them;
+- captured `mode` and `scopes`, with fresh step-zero/bootstrap lifecycle and no inherited unfinished specification or validation diagnostic. A later deferred private copy preserves the child's already accepted lifecycle fields.
 
 **What stays unchanged:**
 
 - The parent's private files and native trace remain unchanged. Later child session writes cannot modify the parent's private layer.
-- Applying a smaller configured `historyLimit` may fold excess shared tails during child acceptance under file-cohort CAS, without changing current shared materialization or provenance. Without retention reduction, the shared files remain unchanged too.
+- Applying a smaller configured `historyLimit` may fold excess selected shared tails during child acceptance under file-cohort CAS, without changing current shared materialization or provenance. Without retention reduction, the shared files remain unchanged too.
 - Forking semantic memory does not clone or roll back project files or tool effects.
 
 **Artifact evidence is current-only, not a historical registry.** Because the child copies the parent's current head, current artifact semantics and their current provenance stay together; shared provenance remains live.
 
 ## Lifecycle and failure
 
-**Copying and acceptance.** `TemporalRuntime.withForkTransaction(source, lifecycle, action, signal?)`:
+**All-owner library copying and acceptance.** The supported `TemporalRuntime.withForkTransaction(source, lifecycle, action, signal?)` contract remains:
 
 1. Pins source identity and the parent's current head boundary before waiting.
 2. Selects exact parent authority plus an unoccupied child under one awaited exclusion.
@@ -43,10 +43,10 @@ Cancellation or rejection cannot initialize an empty child. Failure after accept
 **Forking while Off:**
 
 - Parent-header acquisition and canonical copying are deferred. Only a child-owned pending-fork marker is appended to the native trace; it carries no semantic authority.
-- The marker survives cold extension reload and permits later explicit Passive/Active acquisition, which copies the parent's then-current memory subject to the same identity and occupied-child checks.
+- The marker survives cold extension reload and permits later admitted Session acquisition under explicit Passive/Active policy, copying the parent's then-current private memory subject to the same identity and occupied-target checks. Shared-only enablement retains deferral rather than consuming private-copy authority.
 - Accepted initialization resets the marker.
 
-Memory-enabled native fork adoption and Start's fork retry use this transaction inside the extension's owned restoration lifetime. It publishes the fresh child origin before any runtime-only lifecycle write. Native evidence holds a publisher across fork adoption; it does not certify idle native Abort.
+The native adapter composes the selected-scope ports below inside its owned restoration lifetime, rather than routing every fork through the all-owner library transaction. Fresh shared-only deferral publishes child lifecycle plus selected shared access without private copying; eager/deferred private acceptance validates its corresponding source and target before installing memory. Neither route grants idle native Abort a signal the host does not supply.
 
 **Retry and cancellation:**
 
@@ -64,7 +64,7 @@ Memory-enabled native fork adoption and Start's fork retry use this transaction
 - Navigating to an inherited parent step keeps current child-owned memory; it neither rewinds nor recopies parent data.
 - Child-owned checkpoints use ordinary current-memory reload/resume without rereading the parent header.
 
-**Before the first child-owned checkpoint:** cold recovery requires the explicit Off-deferred pending marker. Missing child files alone never authorize a parent recopy.
+**Before private acquisition:** cold recovery requires child-owned pending-fork authority; an accepted shared-only child additionally retains its validated deferred lifecycle proof. Missing child files alone never authorize a parent copy or recopy.
 
 **Mode and projection:**
 
@@ -75,13 +75,15 @@ Memory-enabled native fork adoption and Start's fork retry use this transaction
 
 ## Internal selected-scope copy boundary
 
-The [selected-scope contract](scope-selection-contract.md#selected-parent-current-private-copy) now implements shared-only child deferral and eager/deferred private copy over selected streams. The native adapter must validate persisted direct-parent identity before exclusion and recheck current in-memory child/parent/policy ownership after waiting. The storage owner verifies only parent-current private files/lineage/provenance plus selected live shared inputs, never recursive ancestry or unrelated disabled owners. Parent bytes stay read-only; occupied, malformed, lost-acquired or already-acquired child evidence cannot become empty memory or authorize recopy.
+The native [selected-scope contract](scope-selection-contract.md#selected-parent-current-private-copy), shipped in 0.27.0, implements shared-only child deferral and eager/deferred private copy over selected streams. The native adapter must validate persisted direct-parent identity before exclusion and recheck current in-memory child/parent/policy ownership after waiting. The storage owner verifies only parent-current private files/lineage/provenance plus selected live shared inputs, never recursive ancestry or unrelated disabled owners. Parent bytes stay read-only; occupied, malformed, lost-acquired or already-acquired child evidence cannot become empty memory or authorize recopy.
 
-These internal APIs return file receipts/sticky authority facts and install the [accepted selected cache](scope-selection-contract.md#accepted-selected-runtime-cache-and-reads) after durable acceptance. They do not yet replace the native all-owner `withForkTransaction` route described above, expose scope settings, or implement native pending-marker/selection-epoch attachment. Isolated selected-copy fixtures are local backend proof, not completed native selected-fork delivery.
+Native `withSelectedDeferredForkTransaction` and `withSelectedForkCopyTransaction` compose the existing origin/current acceptance owner. They return file receipts/sticky authority facts and install the [accepted selected cache](scope-selection-contract.md#accepted-selected-runtime-cache-and-reads) only after durable acceptance; child classification precedes any parent lookup. Public mode-command scope overrides and native pending-marker/selection-lifetime attachment are implemented. The [M2 functional boundary](scope-selection-contract.md#m2-functional-acceptance-boundary) records actual native seven-selection/fork delivery separately from lower backend fixtures.
+
+Copying uses the parent-current materialization and starts one fresh child aligned origin. Retained per-owner tail records may still be copied subject to `historyLimit`; they do not create earlier aligned child materializations. Current-only copying is not a claim that every historical patch byte is absent from child storage.
 
 ## Support boundary
 
-Supported copying requires a persisted regular parent session file, matching header UUID/CWD, current canonical scope/runtime files, and an available retained boundary. Arbitrary session search, UUID aliases, cross-CWD imports, in-memory-only parent locators, conversion of unsupported storage formats, unlimited history, and Git recovery are unsupported.
+Private copying requires a persisted regular direct-parent session file, matching header UUID/CWD, current canonical private/runtime evidence, and an unoccupied child semantic target. A deferred lifecycle-only child must prove its own admitted pending authority; an acquired child uses child-current memory and never recopies. Arbitrary session search, UUID aliases, cross-CWD imports, in-memory-only parent locators, conversion of unsupported storage formats, unlimited history, and Git recovery are unsupported.
 
 ## Evidence
 

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

@@ -4,9 +4,9 @@ This document describes the implemented lazy-state contract. [BACKLOG.md](../BAC
 
 ## Thesis
 
-State Flow provides `lazy` as an object-root semantic plane in every scope's runtime view.
+State Flow supports the optional object-root `lazy` plane in every participating scope.
 
-- It may be absent from stored state. Reads then use `{}` or values inherited through the effective overlay, without rewriting storage.
+- It may be absent from stored state. Exact reads preserve that absence; an absent top-level lazy value returns `null`, while effective reads can inherit a selected broader owner's value. Only default-bearing internal/library compatibility views supply `{}`; no read rewrites storage.
 - Nested lazy values are ordinary JSON. They are durable and versioned with the same causal lineage as hot state, but excluded from ordinary baseline hydration.
 
 The model-facing surface remains small:
@@ -37,7 +37,7 @@ The model-facing surface remains small:
 
 ## Semantic model
 
-Runtime views select present documented semantic planes in intent-first order, omitting absent fields, empty responses and unknown fields:
+Runtime views select present built-in planes in intent-first order, plus metadata v4-declared external roots under the [public module contract](public-module-contract.md), omitting absent fields and empty responses. The built-ins are:
 
 ```text
 global | CWD | session
@@ -45,14 +45,14 @@ global | CWD | session
 ├── strategy
 ├── tactics
 ├── artifacts
-├── response (session-owned; empty structural slot in Global/CWD)
+├── response (new answers are Session-owned; optional on disk)
 └── lazy
 ```
 
 Hot planes:
 
-- `intents`, `strategy`, `tactics` and `artifacts` stay hot in every scope.
-- Session-owned `response` is also hot. New Global and CWD states use an empty structural slot, and stored scopes may omit it. Effective uses the highest-priority present response, and each newly accepted answer is written only in Session.
+- Present `intents`, `strategy`, `tactics` and `artifacts` contribute hot memory from selected available owners.
+- Active projects the highest-priority present nonempty `response`; Passive omits it automatically. New answers are written only in Active participating Session. No stored structural slot is required, and readable legacy Global/CWD answers do not grant new shared authorship.
 - `intents` may keep compact active direction while referring to large supporting detail in `lazy`.
 
 `lazy` differs only in projection policy:
@@ -138,7 +138,7 @@ Ownership evaluates canonical references after model anchoring. A sole-CWD model
 - missing targets;
 - keys outside the `read_state` key grammar `[A-Za-z_$][A-Za-z0-9_$-]*`, for example keys with spaces, dots or non-Latin letters.
 
-**Receipt.** `state_updates.cascaded` lists all owner-scoped targets cleared in the intermediate ownership phase, even if later authored writes recreate them, for example `["session.lazy.plans.x", "session.tactics.draft"]`. Paths only, never lazy bodies or deleted values. The list is deterministic (Global, CWD, Session, then each scope's cascade order), absent when no target cascaded, and never omitted as a predictable write. Nested lazy deletions are reported even when the top-level `lazy_navigation` catalog is unchanged.
+**Receipt.** `state_updates.cascaded` lists targets cleared in the intermediate ownership phase, even if later authored writes recreate them. With multiple wanted owners paths stay scoped, for example `["session.lazy.plans.x", "session.tactics.draft"]`; with exactly one wanted owner they are relative, for example `["lazy.plans.x", "tactics.draft"]`. Canonical ownership and result details remain scoped. Paths only, never lazy bodies or deleted values. The list is deterministic (Global, CWD, Session, then each scope's cascade order), absent when no target cascaded, and never omitted as a predictable write. Nested lazy deletions are reported even when the top-level `lazy_navigation` catalog is unchanged.
 
 **Edge cases:**
 
@@ -151,7 +151,7 @@ Ownership evaluates canonical references after model anchoring. A sole-CWD model
 
 The explicit `effective.lazy` path recursively overlays `global.lazy → cwd.lazy → session.lazy` using the existing scope precedence and conflict semantics. It is read-only as an effective view and is not inserted into ordinary hot baseline state.
 
-Explicit paths such as `global.lazy`, `cwd.lazy`, and `session.lazy` preserve direct ownership access. Deleting a key from an upper scope reveals a lower-scope value exactly as ordinary scope-local deletion does. Hiding an inherited value without changing its owner is not a separate lazy feature.
+Explicit paths such as `global.lazy`, `cwd.lazy`, and `session.lazy` preserve direct ownership access only for wanted, available owners; excluded-owner access rejects without widening selection. Deleting a key from an upper scope reveals a lower-scope value exactly as ordinary scope-local deletion does. Hiding an inherited value without changing its owner is not a separate lazy feature.
 
 Active obligations, current constraints, unresolved next actions, and facts required for the next correct action remain hot.
 
@@ -295,8 +295,7 @@ A multi-path value response is positional:
 {
   "meta": {
     "type": "object",
-    "size": 3,
-    "sources": ["global", "cwd"]
+    "size": 3
   },
   "keys": {
     "memory": "array",
@@ -306,7 +305,7 @@ A multi-path value response is positional:
 }
 ```
 
-For an explicitly scoped object, redundant ownership is omitted:
+An explicitly scoped object uses the same structural-only metadata shape:
 
 ```json
 {
@@ -359,7 +358,6 @@ The read-level `meta` object is intentionally narrow and unrelated to persisted
 - `type` always.
 - `size` for objects, meaning immediate named-key count.
 - `length` for arrays and strings.
-- `sources` only when an effective view actually combines or resolves scope ownership.
 
 It never exposes temporal boundaries, runtime identity, revisions, publication state, provenance registries, timestamps, encoded sizes, cache/index details, diagnostics, or arbitrary copied fields from `meta.json`. Adding a metadata field requires evidence that it changes the agent's next read decision; diagnostic convenience alone is insufficient.
 
@@ -520,7 +518,7 @@ Lazy mutations inherit existing guarantees:
 - One lock/CAS publication cohort.
 - Atomic hot-plus-lazy multi-scope changes.
 - Scope-local deletion and effective revelation semantics.
-- Exact retained-boundary selection on restore and branch navigation.
+- Exact retained boundaries for explicit historical reads; reload/resume/tree attach current same-session memory rather than rewinding it.
 - Read-only discovery with no commit, timestamp update, or transition.
 
 Lazy trees are co-located in canonical scope checkpoints/tails and use the same bounded lineage as hot state. The [performance guide](performance.md) owns current synthetic workloads and measurement limits. No separate lazy index or sharded authority exists; any future layout change requires measured need and must preserve canonical semantics, ownership, and one causal lineage.
@@ -536,7 +534,7 @@ Lazy trees are co-located in canonical scope checkpoints/tails and use the same
 
 ## Normative invariants
 
-1. **Object root, ordinary JSON children**: Every runtime scope view has a lazy object, defaulting to `{}` when absent from stored semantics. Its nested values contain domain semantics, never mandatory State Flow record wrappers.
+1. **Object root, ordinary JSON children**: Present lazy content is an object with ordinary domain JSON children, never mandatory State Flow record wrappers. Sparse semantic/read views preserve absence; `{}` defaults belong only to internal/library compatibility views.
 2. **Semantic snapshots**: `value` contains only the selected state snapshot and `patch` only the selected semantic patch; `keys` alone adds closed structural `meta` before `keys`.
 3. **Exact success**: A successful read returns everything requested; it never truncates or paginates silently.
 4. **Runtime-owned concurrency**: Revisions, locks, and CAS remain internal unless explicitly needed for diagnostics.
@@ -566,7 +564,7 @@ Before release, implementation evidence must prove:
 - `effective.lazy` follows global → CWD → session overlay while explicit scope paths preserve ownership.
 - Reads create no semantic transition, Git commit, publication, freshness update, or future activation.
 - Whole-array replacement and indexed scalar, array, object, nested, multi-index, and stale-basis patches remain atomic.
-- Restore and fork select lazy state from the same retained canonical boundary as the rest of the owning session scope.
+- Reload/resume/tree attach current lazy state with the rest of the owning scope; a supported fork copies parent-current lazy content only when private acquisition is admitted. Historical reads select the same retained causal boundary as other planes.
 - Malformed canonical lazy data fails closed without rewriting the store; rejected queries and patches preserve accepted hot state.
 - Unsupported store formats and `read_state` inputs fail actionably without rewriting retained bytes.
 

package/node_modules/@llblab/pi-state-flow/docs/protocol-composition-decision.md

@@ -2,9 +2,9 @@
 
 ## Scope and accepted decision
 
-The subsequent explicit request for a general internal module API is implemented separately in the [internal semantic-module contract](semantic-module-contract.md). It supersedes this checkpoint's no-extraction disposition only for that bounded internal contract. The historical review/evidence below is not retroactively upgraded, and protocol trust/order and public-loader deferral remain applicable.
+The subsequent explicit request for a general internal module API is implemented separately in the [internal semantic-module contract](semantic-module-contract.md). Together with the later [public registration contract](public-module-contract.md), shipped in 0.27.0, it supersedes this checkpoint's no-extraction disposition only within those bounded module responsibilities. The historical review/evidence below is not retroactively upgraded; protocol trust/order and dynamic-loader deferral remain applicable. All M4 milestone statuses and validation counts below describe that historical checkpoint, not current implementation prerequisites.
 
-M4 is an earned-composition investigation, not a requirement to ship descriptors. **Retain the existing plain render functions and shared trusted snippets; do not extract another semantic module layer now.** No source, public API, emitted protocol, storage format, schema, runtime hook or lifecycle change is proposed. The complete actual terminal follow-up review is **APPROVE — R1 verified; retain implementation/defer further extraction**. [BACKLOG](../BACKLOG.md#12-ordered-implementation-backlog) alone owns subsequent work; M5 and gated quality evidence are not approved by this decision.
+M4 is an earned-composition investigation, not a requirement to ship descriptors. **Retain the existing plain render functions and shared trusted snippets; do not extract another semantic module layer now.** No source, public API, emitted protocol, storage format, schema, runtime hook or lifecycle change is proposed. The complete actual terminal follow-up review is **APPROVE — R1 verified; retain implementation/defer further extraction**. [BACKLOG](../BACKLOG.md) alone owns subsequent work; M5 and gated quality evidence are not approved by this decision.
 
 The question is whether a further Core/Intents/Strategy/Tactics decomposition solves observed duplication, conflicting ownership or maintenance friction. It is not whether all code can be represented as a descriptor array. The accepted [M3 functional checkpoint](single-scope-interface-contract.md#deterministic-m3-checkpoint) already supplies actual scope-free required arguments and typed outputs; M4 must not reopen its admission/source/private contracts or infer model quality from a different source layout.
 

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

@@ -2,13 +2,15 @@
 
 ## Status
 
-Candidate public API v1. Native-host registration and retirement have local supported-Node validation and bounded independent acceptance; **Metadata4 codec/opaque retention has bounded independent acceptance. The local candidate now binds registered mutable external roots to the existing read/patch tools and atomic descriptor admission; this new activation slice is not independently accepted. Public input/context execution is now implemented in the local candidate; Active asynchronous producers now propose complete replacements through that same selected publisher. Local end-to-end acceptance is complete: the ordinary public-only consumer also proves current-only forks and opaque current/history retention through folding, incompatible or absent definitions, reload and re-registration, in SOURCE and the built SDK/package entry. Per the later user instruction, activation implementation and final audit were performed inline without actors; no new independent activation approval or real-model quality result is claimed.** [BACKLOG](../BACKLOG.md#12-ordered-implementation-backlog) alone owns unfinished implementation and acceptance. This is an unpublished local candidate, not a released compatibility promise.
+Public API v1 is published through `@llblab/pi-state-flow/modules` since **0.27.0** and remains supported in **0.27.1**. It includes native-host registration/disposal, metadata v4 descriptors and opaque retention, external-root read/patch tools, captured Active/Passive context, and cohort-atomic Active producer replacements. The package export and source types in `api/modules.ts` and `lib/semantic-module.ts` define the executable surface; this document owns its integration and trust contract.
+
+Registration and codec/retention received bounded independent acceptance during development. Later activation implementation and final audit were performed inline under the owner's instruction; publication does not retroactively grant independent approval to those subphases. Scripted native-SDK and built-package consumer checks are deterministic integration evidence, not live-model quality or installed-client certification. See [compatibility](compatibility.md) for evidence limits and [BACKLOG](../BACKLOG.md) for outstanding work.
 
 Pi loads ordinary companion extensions. StateFlow provides a thin public registration membrane; it does not discover or load plugin code. The [internal evaluators](semantic-module-contract.md) remain separate from native/source admission and atomic publication.
 
 ## Public entry and lifecycle
 
-Import `registerStateFlowModule` and its types from `@llblab/pi-state-flow/modules`. Local source consumers may import `api/modules.ts`; compiled consumers use `dist/api/modules.js`. These membranes do not import the extension composition root.
+Import the runtime function `registerStateFlowModule` from `@llblab/pi-state-flow/modules`. The same entry exports types `StateFlowModule`, `StateFlowModuleSource`, `StateFlowModuleFrame`, `StateFlowModuleInput`, `ModuleContextContribution`, `JsonObject` and `JsonValue`; there is no exported loader or publisher. Local source consumers may import `api/modules.ts`; compiled consumers use `dist/api/modules.js`. These membranes do not import the extension composition root.
 
 Register synchronously in the consumer's `session_start` handler, with StateFlow loaded first. Pass `ctx.sessionManager` only as the native-host identity key, not raw runtime context. Host absence, competing ownership of the same manager, duplicate IDs and incompatible API versions fail explicitly. Two different SDK managers in one process have independent catalogs. A retained native identity check also fences manager reuse for another session/address.
 
@@ -40,7 +42,7 @@ export default function (pi: ExtensionAPI) {
 }
 ```
 
-With this companion registered, a sole participating owner can persist `{"x_acme_notes":{"entries":["accepted"]}}` through `patch_state` and read `x_acme_notes` through `read_state`. Multiple participating owners retain explicit scope wrappers. The context callback now executes on admitted Active/Passive provider contexts; its data is transported as fallible user-level data, not system instructions. Pi 1.0.0 uses `session_shutdown`, not `shutdown`.
+With this companion registered, a sole participating owner can persist `{"x_acme_notes":{"entries":["accepted"]}}` through `patch_state` and read `x_acme_notes` through `read_state`. Multiple participating owners retain explicit scope wrappers. The context callback executes on admitted Active/Passive provider contexts; its data is transported as fallible user-level data, not system instructions. Pi 1.0.0 uses `session_shutdown`, not `shutdown`.
 
 Registration returns an idempotent disposer for that exact instance. It cannot revoke a later equal-ID registration or another host generation. Catalog changes abort old catalog signals; host retirement removes only its own binding before signaling cancellation. Snapshots capture immutable policy, callback identities and definition order. Constructor-injected services remain bound to their original instance. Trusted callbacks are not an effects sandbox, and a catalog snapshot alone is not publication authority.
 
@@ -50,7 +52,9 @@ The public `StateFlowModule<Content, Input>` has the internal identity/immutabil
 
 - **`apiVersion: 1`:** Version of callback/frame assumptions, independently of the runtime package resolved by an older companion's import.
 - **`schemaVersion`:** Positive safe integer for one exact persisted content/policy contract; not the package or host metadata version.
-- **`captureInput?`:** Acquire module-specific JSON input and return `{ value, assertCurrent }`. The synchronous assertion throws if that captured source is obsolete; it does not reacquire data or perform asynchronous work under exclusion.
+- **`captureInput?(source, signal)`:** Optional synchronous or asynchronous acquisition of module-specific JSON input, returning `{ value, assertCurrent }`. It runs outside exclusion; the synchronous receipt throws if that captured source is obsolete and never reacquires data or performs asynchronous work under exclusion.
+- **`context(content, frame)`:** Synchronous contribution computation; an asynchronous return is not admitted. Contributions are user-level data or admitted native conversation indices, never arbitrary system-prompt text.
+- **`produce?(content, frame, signal)`:** Optional synchronous or asynchronous complete-replacement proposal, invoked only by an owned Active preparation. It is not a publisher or independent scheduler. Abort/currentness fences abandon stale asynchronous work even if the callback ignores its signal; trusted synchronous JavaScript is not preempted or sandboxed.
 
 External durable content is initially a JSON object. Validators admit complete resulting values, not recursive partial patches. `immutable` denies main-agent writes, not authorized producer proposals. `produce?` returns a complete replacement object or `undefined`; it never publishes itself. Constructor-injected narrow services avoid a generic capability registry or raw `ctx`.
 
@@ -58,14 +62,20 @@ Activation must pass a detached `StateFlowModuleFrame` to both context and produ
 
 Context proposals are data or exact source-message indices, not system instructions or arbitrary context mutation. Session conversation contains only the completed native segment before a uniquely anchored current user run; ambiguity withholds that segment. Shared frames carry no dialogue/prompt and cannot propose conversation replacement. At most one Session module may select completed conversation; competing selectors fail closed. A selection must preserve whole native tool-call/result units and original identities/order. The host preserves current-run and foreign frames, removes duplicate completed messages, and only alters provider context, never the native journal. Data-only contributions do not themselves remove history. Scope order then captured module order determines data placement before native conversation, after the owned core head. Off invokes none of these callbacks; metadata registration itself neither acquires nor writes memory.
 
+## Historical local acceptance
+
+Before 0.27.0 publication, ordinary public-only SDK consumers exercised mutable/immutable current-only forks from older native points, unchanged parent semantic-file bytes, retained descriptors, a fresh child aligned origin and child reload. Pre-origin materialized reads reject; this does not claim that retained per-owner tail bytes are absent from child storage. Global/CWD/Session/all-three fixtures at history limits 0/1/7 crossed actual folding, retained every still-available current/historical opaque value through missing or incompatible definitions, refused incompatible callbacks/writes and resumed after cold re-registration.
+
+That local checkpoint recorded **1695/1695 on Node 22/24**, **145 package files**, the same two final compiled SDK properties, earlier 16 public and seven codec properties; sets overlap and are not summed. Registration/lifetime and codec retention had their separately bounded independent approvals; activation and final audit were inline. The earlier global **REQUESTCHANGES** verdict was not retroactively upgraded by scoped remediation or publication. The [exact pre-release record](https://github.com/llblab/pi-state-flow/blob/f9128d9eaa2b94133d992f51f80f16aec0d43653/BACKLOG.md#12-ordered-implementation-backlog) retains original counts, review boundaries and superseded execution instructions. These are historical results, not fresh 0.27.2 tests, installed-client certification or model-quality evidence.
+
 ## Recorded compatibility decision
 
-The external-plane path will use owner metadata **version 4**, retaining the same checkpoint, patch-tail and metadata files. This decision preceded codec implementation. The local candidate now admits descriptors and opaque external values through the existing codec/replay/publication path; absent stream descriptors retain legacy three-key streams and v3 output. Integrated SOURCE/build/package and complete compiled-property checks pass on both supported Nodes; independent retention and acceptance reviews approved this storage slice with disclosed coverage limits. The new manual tool path adds a descriptor only with the first nonempty accepted content transition through the same selected publisher; registration, empty proposals and context-only observation cannot mint a slot. Validators receive a detached complete result, not a partial patch, and must be pure synchronous content guards (no acquisition/inference). Definition/schema/policy mismatches reject model writes before validators. Exact reads and patch history use retained descriptors without calling definitions. Current catalog revocation fences queued old calls, including equal-ID re-registration. Input and context callbacks are activated as described above; Active producer publication is now activated through the same engine. Results are complete JSON-object replacements, never recursive merges; `undefined` is no proposal and `{}` clears content without removing its descriptor or fabricating a new slot. Main-agent immutable restrictions remain intact. All applicable producer jobs compute outside exclusion using narrow constructor-injected services, not ambient runtime/storage/model tools. Before publication, the host rechecks original input, content/descriptor, captured source-scope stream, registration generation, native owner/model/selection and cancellation; model or thinking-level changes revoke the original request even after A→B→A. A fresh transaction cannot launder stale work. One invalid/stale result rejects the proposed cohort. After its own accepted publication, context receives the accepted content using the original input receipt and a lease pinned to that exact acceptance. Late cancellation/context/checkpoint failure never rolls accepted memory back.
+The external-plane path uses owner metadata **version 4**, retaining the same checkpoint, patch-tail and metadata files. The recorded decision preceded codec implementation; that implementation shipped in 0.27.0. Descriptors and opaque external values use the existing codec/replay/publication path; absent stream descriptors retain legacy three-key streams and v3 output. Historical integrated SOURCE/build/package and compiled-property checks passed on both supported Nodes; independent retention and acceptance reviews approved that storage slice with disclosed coverage limits. The new manual tool path adds a descriptor only with the first nonempty accepted content transition through the same selected publisher; registration, empty proposals and context-only observation cannot mint a slot. Validators receive a detached complete result, not a partial patch, and must be pure synchronous content guards (no acquisition/inference). Definition/schema/policy mismatches reject model writes before validators. Exact reads and patch history use retained descriptors without calling definitions. Current catalog revocation fences queued old calls, including equal-ID re-registration. Input and context callbacks are activated as described above; Active producer publication is now activated through the same engine. Results are complete JSON-object replacements, never recursive merges; `undefined` is no proposal and `{}` clears content without removing its descriptor or fabricating a new slot. Main-agent immutable restrictions remain intact. All applicable producer jobs compute outside exclusion using narrow constructor-injected services, not ambient runtime/storage/model tools. Before publication, the host rechecks original input, content/descriptor, captured source-scope stream, registration generation, native owner/model/selection and cancellation; model or thinking-level changes revoke the original request even after A→B→A. A fresh transaction cannot launder stale work. One invalid/stale result rejects the proposed cohort. After its own accepted publication, context receives the accepted content using the original input receipt and a lease pinned to that exact acceptance. Late cancellation/context/checkpoint failure never rolls accepted memory back.
 
 - **Identity:** External roots match `x_[a-z][a-z0-9_]*`; use package-derived names. IDs do not authenticate package ownership. Existing built-ins and retired-root reservations remain distinct.
 - **Retained descriptors:** Owner metadata maps each written external root to `{ schemaVersion, immutable }`. Persist the descriptor in the same accepted cohort as its first write and retain it through deletion, folding and fork. Do not recycle a root for unrelated semantics.
 - **No new content envelope:** External objects remain semantic roots, not `{ immutable, content }` wrappers. Policy/version data remains outside model-patchable state. No mixed schema epochs or automatic module-schema conversion is introduced initially.
-- **Available:** Execute a registered definition only when its exact schema version and authoring policy match the retained descriptor. Validate complete candidate content before publication.
+- **Available:** A registered new root without a retained descriptor can receive absent content and propose its first accepted value. Once a descriptor exists, execute only when schema version and authoring policy match it exactly. Registration/observation alone never mint a descriptor; complete candidate content must validate before publication.
 - **Unavailable:** Missing, disposed or incompatible definitions leave opaque retained data. Exact current/history reads may return raw data; automatic context and model writes are unavailable. Unrelated writes, pruning, folding, reload and fork must preserve current values and every still-retained historical boundary without invoking missing callbacks.
 - **Legacy:** Preserve declared v1/v2/v3 meanings and detect raw external-namespace collisions before conversion; formerly ignored roots cannot be silently adopted. Only admitted semantic acceptance may convert complete cohorts through existing backup/byte-CAS safeguards. Inspection and runtime-only policy persistence cannot migrate.
 - **Writer limit:** Version refusal is evidence for inspected old writers, not universal deployed-writer protection. Existing quiescence and unsupported-writer requirements remain. No working-store migration, live reload or release is authorized by this decision.