@llblab/pi-kit 0.27.4 → 0.27.5

package/BACKLOG.md

@@ -1,9 +1,10 @@
 # Backlog
 
-The 0.27.4 composition is recorded in [CHANGELOG.md](./CHANGELOG.md). Package pins, resource order and bundled runtime ownership remain authoritative in `package.json`.
+The 0.27.5 composition is recorded in [CHANGELOG.md](./CHANGELOG.md). Package pins, resource order and bundled runtime ownership remain authoritative in `package.json`.
 
 ## Carried checks
 
+- **Installed 0.27.5 cleanup smoke (operator-owned):** After separately authorized installation/reload, confirm State Flow missing-deletion hints, recursive empty-object cleanup, inherited fallback and preserved array slots in disposable storage. Packed validation does not certify installed clients.
 - **Installed 0.27.4 inspection smoke (operator-owned):** After separately authorized installation/reload, inspect a large nested State Flow field in disposable storage. Confirm readable JSON layout, separate truncation notices and intact genuine string escapes. Packed validation does not certify installed Telegram clients.
 - **Installed 0.27.3 single patch display smoke (operator-owned):** After separately authorized installation/reload, confirm one argument block followed by changed/no-op acknowledgements, compact configuration and visible rejected arguments/errors in disposable State Flow storage.
 - **Installed 0.27.2 cascade receipt smoke (operator-owned):** After separately authorized installation/reload, close an intent owning a nested lazy key in disposable State Flow storage and confirm the receipt lists its owner path under `cascaded`, without the body. Packed validation does not certify installed clients.

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.27.5: State Flow Cleanup and Deletion Hints
+
+- `Cleanup and Deletion Hints`: Advances the exact State Flow pin to `0.25.4`. Accepted scopes recursively drop empty object fields without shifting array slots; cleanup may reveal inherited values. Missing authored deletions report their target and first unavailable component without blocking useful writes or creating revisions. Exact history and untouched scopes stay unchanged. Other pins, resources and load order are unchanged.
+
 ## 0.27.4: Readable State Flow Inspection
 
 - `Readable Inspection`: Advances the exact State Flow pin to published `0.25.3`. Large Telegram inspection fields now show pretty-printed JSON prefixes directly, with separate truncation notices instead of escaped `preview` strings. Genuine JSON string escapes and storage semantics are preserved. Other pins, resources and load order are unchanged.

package/README.md

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

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

@@ -8,7 +8,7 @@ The [relocation ledger](docs/agent-contract-relocation.md) maps every pre-compac
 - Keep `index.ts` minimal, independent domains in `lib/` with same-named tests, architecture checks in `tests/invariants.test.ts`, and Pi lifecycle composition in `lib/extension.ts`; delegate low-level mechanics to their owners. See [composition](docs/architecture.md#composition).
 - Keep Off the genuinely new-session default, with Passive and Active opt-in; Off removes State Flow model tools/context without deleting memory. Modes belong to the current session; global mode is only a new-session default. Passive declares both tools even without memory, but contributes protocol/projected state only with a validated view. See [mode behavior](docs/usage.md#active-passive-and-configured-off) and [configuration](docs/usage.md#configuration).
 - Preserve Pi's native tool loop, trace and foreign context; the context domain alone projects the raw scope overlay. Freeze/rebase the head only at specified boundaries, retain current-run trajectory and stable-position tail notices, and never give projection IDs or guessed user anchors publication/compaction authority. See [Pi lifecycle](docs/architecture.md#pi-lifecycle) and [projection evidence](docs/performance.md#context-projection-and-trajectory-selection).
-- Store only present known `intents`, `contract`, `working`, `artifacts`, `response`, `lazy` fields; preserve nested data and retained causal identities. Missing planes and empty response do not become fabricated stored defaults; malformed evidence fails closed. Keep lazy bodies out of automatic projection and Session as the sole author of new responses. See [semantic state](docs/architecture.md#semantic-state) and [temporal model](docs/architecture.md#temporal-model).
+- Store only present known `intents`, `contract`, `working`, `artifacts`, `response`, `lazy` fields; preserve nonempty nested data and retained causal identities. Normalize empty object fields/planes only in supplied scopes and response-owned Session, before ownership and after cascades/compilation; preserve array slots and exact current/historical reads. Model projection may omit legacy empty branches. Missing planes and empty response do not become fabricated stored defaults; malformed evidence fails closed. Keep lazy bodies out of automatic projection and Session as the sole author of new responses. See [semantic state](docs/architecture.md#semantic-state) and [temporal model](docs/architecture.md#temporal-model).
 - Respect global → CWD → session ownership, scope-local deletion and inherited fallbacks; scope does not confer instruction authority. Registered Skill ownership follows Pi source provenance, not path shape. See [semantic state](docs/architecture.md#semantic-state) and [artifact routing](docs/architecture.md#artifact-routing).
 - Artifacts name exact registered source paths; observe only regular non-symlink files, never discover directories or read unrelated bodies. Preserve hidden per-scope provenance, exact-owner compilation, stable fingerprint checks and separate Skill hashes; unavailable sources are not proof of deletion. See [artifact routing](docs/architecture.md#artifact-routing).
 - Preserve session config/runtime, per-scope metadata, lineage and provenance outside model-patchable state; decode legacy mode evidence read-only, never mix representations or normalize storage eagerly. See [storage and identity](docs/architecture.md#storage-and-identity) and [mode compatibility](docs/compatibility.md#mode-configuration-compatibility).

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

@@ -1,16 +1,17 @@
 # Backlog
 
-The **0.25.3: Readable Telegram Inspection** hotfix is prepared; outcomes belong in [CHANGELOG.md](CHANGELOG.md). This backlog retains installed-client gates and deferred decisions. Cascade semantics, canonical storage, stored patch records and lifecycle behaviour remain unchanged.
+The **0.25.4: Empty-Object Cleanup and Deletion Hints** hotfix outcomes belong in [CHANGELOG.md](CHANGELOG.md). This backlog retains publication, installed-client gates and deferred decisions.
 
 ## Out of scope
 
 - Changing what a cascade deletes, including writes into an owned target made by the closing patch. That stays deleted by design and already appears in the receipt.
-- Nested `lazy_navigation`, warnings, validation or rejection of any kind.
+- Nested `lazy_navigation` and intent-ownership warnings, validation or rejection. Authored missing-deletion hints do not change cascade behavior.
 - Any reduction of lifecycle state; the tagged-union question stays deferred.
 
 ## Carried gates
 
-- **0.25.3 publication.** Validate and publish through the exact-tag workflow; verify GitHub Release and npm commit, then synchronize and release Pi Kit.
+- **0.25.4 publication and kit synchronization.** Verify the exact-tag workflow, GitHub Release and npm commit, then bundle and publish Pi Kit 0.27.5.
+- **Installed 0.25.4 cleanup smoke (operator-owned).** After separately authorized installation/reload, use disposable storage to confirm missing-deletion hints, recursive empty-object cleanup, inherited fallback and preserved array slots. Local validation and publication do not certify installed clients.
 - **Installed 0.25.3 inspection smoke (operator-owned).** After separately authorized installation/reload, inspect a large nested field: real layout newlines/quotes, separate omitted-character notice and intact genuine JSON string escapes. Use disposable storage; local adapter tests do not certify installed Telegram clients.
 - **Installed 0.25.2 smoke (operator-owned).** Disposable store: confirm one patch argument block followed by changed/no-op acknowledgements, compact rows with `showSuccessfulPatches: false`, and visible rejected arguments/errors.
 - **Installed 0.25.1 smoke (operator-owned).** Disposable store: close an intent that owns a nested lazy key and confirm the receipt lists it under `cascaded`. May be combined with the open 0.25.0 smoke.

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

@@ -2,6 +2,13 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
+## Unreleased
+
+## 0.25.4: Empty-Object Cleanup and Deletion Hints
+
+- `Safe missing deletions`: Deletion-only patches through absent ancestors succeed without creating data or blocking other writes. Missing authored targets report their owner-scoped JSON Pointer and first unavailable component; hints remain outside state/history and create no revisions. Mixed new objects process `null` as deletion markers. Stored null and array-index deletion remain rejected; ordinary repeats and intent cascades stay quiet.
+- `Recursive empty-object cleanup`: Accepted supplied scopes and response-owned Session omit empty object fields/planes, before ownership and after cascades/compilation. Explicit `{}` carries no retained value; roots, array slots and empty arrays survive. Model context hides legacy empty branches; untouched scopes and exact historical reads/replay remain unchanged. Cleanup can reveal inherited values and is recorded once as ordinary deletions.
+
 ## 0.25.3: Readable Telegram Inspection
 
 - `Readable inspection`: Telegram memory inspection shows large fields as direct pretty-printed JSON prefixes instead of JSON-encoded `preview` strings with escaped layout and quotes. A separate notice reports omitted characters. Transport-aware budgeting preserves the Rich message ceiling and Unicode boundaries; genuine JSON string escapes, stored state and exact `read_state` results remain unchanged.

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

@@ -145,6 +145,7 @@ Registered Pi Skills may be compiled into source-addressed artifacts when durabl
 - Overlapping assignments follow successful acceptance order. Correct repeats succeed without new semantic revisions.
 - Session remains private.
 - Object patches merge recursively, and `null` deletes an object key instead of being stored.
+- Accepted supplied scopes recursively drop empty object fields and planes, including explicit `{}`; empty ancestors disappear. Array slots and empty arrays stay intact. Cleanup is scope-local and may reveal inherited values. Model context hides legacy empty branches, but reading never rewrites history. See [patch semantics](docs/architecture.md#model-tools).
 
 ```json
 {

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

@@ -43,9 +43,12 @@ function lazyValueKind(value) {
         return "object";
     return typeof value;
 }
+function hasLazyContent(value) {
+    return !isObject(value) || Object.values(value).some(hasLazyContent);
+}
 /** Fixed-budget navigation only: never place lazy bodies or partial key catalogs in baseline context. */
 export function lazyNavigationHint(state) {
-    const entries = isObject(state.lazy) ? Object.entries(state.lazy) : [];
+    const entries = isObject(state.lazy) ? Object.entries(state.lazy).filter(([, value]) => hasLazyContent(value)) : [];
     const base = { available: entries.length > 0, path: LAZY_HINT_PATH };
     if (!base.available)
         return base;
@@ -196,6 +199,8 @@ export class ContextProjection {
             }
         const prefix = (a, b) => a.length <= b.length && a.every((part, index) => part === b[index]);
         updates.effective = updates.effective.filter((entry) => {
+            if ("deleted" in entry && this.view && known(entry.path) === undefined)
+                return false;
             const matches = ({ path }) => path.length === entry.path.length && prefix(path, entry.path);
             const authored = leaves.findLast(matches) ?? objects.findLast(matches);
             if (!authored)

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

@@ -808,9 +808,9 @@ export default function stateFlowExtension(pi, options = {}) {
                         ? `\nState materialized atomically at ${scopes.join("+")} scope${scopes.length === 1 ? "" : "s"}.`
                         : "\nState already current.";
                     return { content: [
-                            { type: "text", text: acknowledgement },
+                            { type: "text", text: acknowledgement + stage.missingDeletions.map(({ path, unavailablePath }) => `\n\nHint: deletion skipped at ${path}; target absent. First unavailable component: ${unavailablePath}. Check the path if you expected an existing value.`).join("") },
                             ...(updates ? [{ type: "text", text: `\n${presentationJson({ state_updates: updates })}` }] : []),
-                        ], details: { scopes, step: snapshot.meta.step, changed } };
+                        ], details: { scopes, step: snapshot.meta.step, changed, missingDeletions: stage.missingDeletions } };
                 }, signal);
             }
             catch (error) {

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

@@ -2,8 +2,16 @@ export type JsonValue = null | boolean | number | string | JsonValue[] | JsonObj
 export interface JsonObject {
     [key: string]: JsonValue;
 }
+export interface MissingDeletion {
+    /** JSON Pointer paths relative to the patched object. */
+    path: string;
+    unavailablePath: string;
+}
+/** Remove empty object fields without removing array slots or mutating the input. */
+export declare function pruneEmptyObjects(value: JsonObject): JsonObject;
+export declare function pruneEmptyObjects(value: JsonValue): JsonValue;
 /** Detach at the mutable public boundary; share untouched paths only inside the owned draft. */
-export declare function applyPatch(state: JsonObject, patch: JsonObject): JsonObject;
+export declare function applyPatch(state: JsonObject, patch: JsonObject, missingDeletions?: MissingDeletion[]): JsonObject;
 export declare function isObject(value: JsonValue | unknown): value is JsonObject;
 export declare function validatePatch(value: unknown): asserts value is JsonObject;
 export declare function canonicalJson(value: JsonValue | unknown): string;

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

@@ -4,17 +4,17 @@ function isIndexedArrayPatch(value) {
     const keys = Object.keys(value);
     return keys.length > 0 && keys.every((key) => ARRAY_INDEX_SELECTOR.test(key));
 }
-function applyOwnedValue(current, value, owned) {
+function applyOwnedValue(current, value, owned, missingDeletions, path, unavailablePath) {
     // Preserve inherited-object merge semantics without borrowing prototype objects.
     if (!owned && current !== null && typeof current === "object")
         current = structuredClone(current);
     return Array.isArray(current) && isObject(value) && isIndexedArrayPatch(value)
-        ? applyOwnedArrayPatch(current, value)
-        : isObject(current) && isObject(value)
-            ? applyOwnedPatch(current, value)
+        ? applyOwnedArrayPatch(current, value, missingDeletions, path, unavailablePath)
+        : isObject(value)
+            ? applyOwnedPatch(isObject(current) ? current : {}, value, missingDeletions, path, unavailablePath ?? (!isObject(current) ? path : undefined))
             : structuredClone(value);
 }
-function applyOwnedArrayPatch(state, patch) {
+function applyOwnedArrayPatch(state, patch, missingDeletions, path, unavailablePath) {
     let next = state;
     for (const [selector, value] of Object.entries(patch)) {
         const index = Number(ARRAY_INDEX_SELECTOR.exec(selector)[1]);
@@ -25,7 +25,7 @@ function applyOwnedArrayPatch(state, patch) {
             throw new Error(`State patch array index ${selector} cannot be deleted; replace the whole array instead`);
         const owns = Object.hasOwn(next, index);
         const current = next[index];
-        const materialized = applyOwnedValue(current, value, owns);
+        const materialized = applyOwnedValue(current, value, owns, missingDeletions, `${path}/${index}`, unavailablePath);
         if (owns && Object.is(current, materialized))
             continue;
         if (next === state)
@@ -34,20 +34,27 @@ function applyOwnedArrayPatch(state, patch) {
     }
     return next;
 }
-function applyOwnedPatch(state, patch) {
+function applyOwnedPatch(state, patch, missingDeletions, path = "", unavailablePath) {
     let next = state;
     for (const [key, value] of Object.entries(patch)) {
         const owns = Object.hasOwn(next, key);
+        const target = missingDeletions ? `${path}/${key.replace(/~/g, "~0").replace(/\//g, "~1")}` : "";
         if (value === null) {
-            if (!owns)
+            if (!owns) {
+                missingDeletions?.push({ path: target, unavailablePath: unavailablePath ?? target });
                 continue;
+            }
             if (next === state)
                 next = { ...state };
             delete next[key];
             continue;
         }
         const current = next[key];
-        const materialized = applyOwnedValue(current, value, owns);
+        const materialized = applyOwnedValue(current, value, owns, missingDeletions, target, unavailablePath ?? (!owns ? target : undefined));
+        // Deletion-only patches must not fabricate absent ancestor objects; explicit {} still writes.
+        if (!owns && current === undefined && isObject(value) && Object.keys(value).length > 0
+            && isObject(materialized) && Object.keys(materialized).length === 0)
+            continue;
         if (owns && Object.is(current, materialized))
             continue;
         if (next === state)
@@ -56,9 +63,43 @@ function applyOwnedPatch(state, patch) {
     }
     return next;
 }
+export function pruneEmptyObjects(value) {
+    if (Array.isArray(value)) {
+        let next = value;
+        for (let index = 0; index < value.length; index++) {
+            const pruned = pruneEmptyObjects(value[index]);
+            if (pruned === value[index])
+                continue;
+            if (next === value)
+                next = value.slice();
+            next[index] = pruned;
+        }
+        return next;
+    }
+    if (!isObject(value))
+        return value;
+    let next = value;
+    for (const [key, child] of Object.entries(value)) {
+        const pruned = pruneEmptyObjects(child);
+        const empty = isObject(pruned) && Object.keys(pruned).length === 0;
+        if (!empty && pruned === child)
+            continue;
+        if (next === value)
+            next = { ...value };
+        if (empty)
+            delete next[key];
+        else
+            Object.defineProperty(next, key, { value: pruned, enumerable: true, configurable: true, writable: true });
+    }
+    return next;
+}
 /** Detach at the mutable public boundary; share untouched paths only inside the owned draft. */
-export function applyPatch(state, patch) {
-    return applyOwnedPatch(structuredClone(state), patch);
+export function applyPatch(state, patch, missingDeletions) {
+    const collected = missingDeletions ? [] : undefined;
+    const next = applyOwnedPatch(structuredClone(state), patch, collected);
+    if (collected)
+        missingDeletions.push(...collected);
+    return next;
 }
 export function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

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

@@ -1,6 +1,6 @@
 import { DEFAULT_HISTORY_LIMIT, MAX_HISTORY_LIMIT } from "./history.js";
 import { isObject, sameJson } from "./json.js";
-import { emptyState, projectSemanticPatch, projectStateForModel } from "./state.js";
+import { emptyState, projectSemanticPatch, projectStateForRead } from "./state.js";
 import { readTemporalView } from "./temporal.js";
 const MAX_REFERENCE_SOURCES = 3;
 const MAX_REFERENCE_SCAN_NODES = 10_000;
@@ -32,7 +32,7 @@ export function readStatePath(view, path, historyLimit = DEFAULT_HISTORY_LIMIT)
         const boundary = view.lineage[view.lineage.length - 1 - query.offset];
         if (!boundary)
             throw new Error("Requested history predates the proven temporal origin");
-        return { path, boundary: structuredClone(boundary), state: projectStateForModel(readTemporalView(view, query.offset, query.scope, historyLimit)) };
+        return { path, boundary: structuredClone(boundary), state: projectStateForRead(readTemporalView(view, query.offset, query.scope, historyLimit)) };
     }
     const record = view.scopes[query.scope].patches.at(-1 - query.offset);
     if (!record)
@@ -271,7 +271,7 @@ export function readProjectedState(view, paths, projection = "value", historyLim
                 throw new Error("Value and keys projections require a state path");
             const readsLazy = selectors[0]?.kind === "key" && selectors[0].key === "lazy";
             const raw = readTemporalView(view, query.offset, query.scope, historyLimit);
-            const state = readsLazy ? raw : projectStateForModel(raw);
+            const state = readsLazy ? raw : projectStateForRead(raw);
             const field = selectors.length === 1 && selectors[0]?.kind === "key" ? selectors[0].key : undefined;
             if (projection === "value" && field !== undefined && Object.hasOwn(emptyState(), field) && !Object.hasOwn(state, field))
                 return { value: null };

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

@@ -83,5 +83,7 @@ export declare function selectSemanticFields(value: JsonObject): JsonObject;
 export declare function projectSemanticState(state: JsonObject): SemanticState;
 /** Preserve deletion meaning in visible history without exposing ignored fields or empty responses. */
 export declare function projectSemanticPatch(patch: JsonObject): JsonObject;
-/** Model-visible projection: lazy bodies and runtime artifact bookkeeping stay out of ordinary context. */
+/** Explicit hot reads filter hidden bodies/bookkeeping without normalizing legacy semantic data. */
+export declare function projectStateForRead(state: SemanticState, artifactHints?: ArtifactModelHints): SemanticState;
+/** Ordinary model context omits empty object fields; exact reads and replay remain observational. */
 export declare function projectStateForModel(state: SemanticState, artifactHints?: ArtifactModelHints): SemanticState;

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

@@ -1,5 +1,5 @@
 import { isArtifactRegistry, projectArtifactsForModel, updateArtifactRegistry, } from "./artifact.js";
-import { applyPatch, isObject } from "./json.js";
+import { applyPatch, isObject, pruneEmptyObjects } from "./json.js";
 export function emptyState() {
     return { intents: {}, contract: {}, working: {}, artifacts: {}, response: "", lazy: {} };
 }
@@ -50,11 +50,15 @@ export function projectSemanticPatch(patch) {
         projected.response = null;
     return projected;
 }
-/** Model-visible projection: lazy bodies and runtime artifact bookkeeping stay out of ordinary context. */
-export function projectStateForModel(state, artifactHints = {}) {
+/** Explicit hot reads filter hidden bodies/bookkeeping without normalizing legacy semantic data. */
+export function projectStateForRead(state, artifactHints = {}) {
     const { lazy: _hidden, ...visible } = state;
     const projected = projectSemanticState(visible);
     if (projected.artifacts)
         projected.artifacts = projectArtifactsForModel(projected.artifacts, artifactHints);
     return projected;
 }
+/** Ordinary model context omits empty object fields; exact reads and replay remain observational. */
+export function projectStateForModel(state, artifactHints = {}) {
+    return pruneEmptyObjects(projectStateForRead(state, artifactHints));
+}

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

@@ -1,12 +1,15 @@
 import { type ArtifactProvenance } from "./artifact.ts";
 import type { SuccessfulArtifactRead } from "./acquisition.ts";
 import { type AcceptedTransition } from "./history.ts";
+import { type MissingDeletion } from "./json.ts";
 import { type OwnedPath } from "./ownership.ts";
 import { type SuccessfulSkillRead } from "./skills.ts";
 import type { Snapshot } from "./snapshot.ts";
 import type { AtomicScopePatches, ScopedSemanticStates, StateScope, TerminalTransition } from "./state.ts";
 export interface StagedScopedTransition {
     nextStates: ScopedSemanticStates;
+    /** Authored no-op deletions; presentation evidence only, never replay input. */
+    missingDeletions: MissingDeletion[];
     /** Scope-local targets removed by the staged intent cascade, not replay input. */
     cascades: Record<StateScope, OwnedPath[]>;
     stateHashes: Record<StateScope, string>;

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

@@ -1,6 +1,6 @@
 import { compileArtifact, ORDINARY_ARTIFACT_COMPILER, validateArtifactMetadata, validateArtifactRegistry, validateModelArtifactPatch, } from "./artifact.js";
 import { createAcceptedTransition } from "./history.js";
-import { applyPatch, containsNull, hashJson, isObject, validatePatch } from "./json.js";
+import { applyPatch, containsNull, hashJson, isObject, pruneEmptyObjects, validatePatch } from "./json.js";
 import { cascadeDeletionPatch, computeIntentCascade } from "./ownership.js";
 import { hasCompiledSkillArtifact, SKILL_ARTIFACT_COMPILER } from "./skills.js";
 import { emptyState } from "./state.js";
@@ -137,27 +137,37 @@ function stageScopedSemanticTransition(currentStates, transition, successfulSkil
     const nextStates = { ...currentStates };
     const provenanceUpdates = { global: {}, cwd: {}, session: {} };
     const cascades = { global: [], cwd: [], session: [] };
+    const missingDeletions = [];
     for (const scope of SCOPES) {
         const authored = patches.get(scope) ?? {};
         const patch = { ...authored, ...(scope === "session" && acceptedResponse !== undefined ? { response: acceptedResponse } : {}) };
-        let materialized = applyPatch({ ...emptyState(), ...currentStates[scope] }, patch);
+        const scopedMissing = [];
+        const normalize = patches.has(scope) || scope === "session" && acceptedResponse !== undefined;
+        const applied = applyPatch(currentStates[scope], patch, scopedMissing);
+        const patched = normalize ? pruneEmptyObjects(applied) : applied;
+        missingDeletions.push(...scopedMissing.map(({ path, unavailablePath }) => ({
+            path: `/${scope}${path}`, unavailablePath: `/${scope}${unavailablePath}`,
+        })));
+        let materialized = { ...emptyState(), ...patched };
         // Authored operations first, then the same-scope intent ownership cascade.
         const cascade = cascades[scope] = computeIntentCascade(scope, currentStates[scope], materialized);
         if (cascade.length > 0)
             materialized = applyPatch(materialized, cascadeDeletionPatch(cascade));
         compileReadArtifacts(materialized, { artifacts: authored.artifacts ?? {} }, artifactReads.filter((read) => (read.scope ?? "global") === scope), provenanceUpdates[scope]);
         compileReadSkills(scope, materialized, { artifacts: authored.artifacts ?? {} }, skillReads.filter((read) => read.scope === scope), provenanceUpdates[scope]);
-        validateMaterializedTransition(materialized, scope);
         const nextState = materialized;
         for (const key of Object.keys(emptyState())) {
-            if (!Object.hasOwn(currentStates[scope], key) && !Object.hasOwn(patch, key)
+            if (!Object.hasOwn(patched, key)
                 && !(key === "artifacts" && Object.keys(provenanceUpdates[scope]).length > 0))
                 delete nextState[key];
         }
-        nextStates[scope] = nextState;
+        const normalized = normalize ? pruneEmptyObjects(nextState) : nextState;
+        validateMaterializedTransition({ ...emptyState(), ...normalized }, scope);
+        nextStates[scope] = normalized;
     }
     return {
         nextStates,
+        missingDeletions,
         cascades,
         provenanceUpdates,
         stateHashes: {

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

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

package/node_modules/@llblab/pi-state-flow/dist/skills/state-flow-guide/SKILL.md

@@ -56,7 +56,7 @@ Call `patch_state` alone per assistant response; await acceptance before depende
 
 The runtime waits cancelably for publication ownership, then applies authored Global/CWD operations to current canonical values. Untouched fields survive; overlapping targets follow successful acceptance order. Correct repeats succeed as `State already current.` without another semantic revision. Do not repeat external actions during a memory wait, or rebuild an entire scope from an older snapshot. Session ownership/history fences remain private, not a universal merge.
 
-When present, semantic planes `intents`, `contract`, `working`, `artifacts`, and `lazy` are objects; nested lazy values may contain ordinary JSON without stored nulls. Stored checkpoints and patches may omit any documented plane. Current and historical views assemble only known fields present in the selected scopes. Absent fields and empty responses are omitted from views. Checkpoint/tail readers ignore unknown top-level fields, and writers emit only known fields. Nested data within known planes remains intact. Explicit value reads of an absent documented top-level field return `null`. Authored `patch_state` keeps its documented field grammar. Objects merge, arrays/scalars replace, omitted fields persist. Nested `null` removes an owned object key; inherited content may reappear. Canonical `"[N]"` keys patch array elements; indexed deletion is forbidden.
+When present, semantic planes `intents`, `contract`, `working`, `artifacts`, and `lazy` are objects; nested lazy values may contain ordinary JSON without stored nulls. Stored checkpoints and patches may omit any documented plane. Current and historical views assemble only known fields present in the selected scopes. Absent fields and empty responses are omitted from views. Checkpoint/tail readers ignore unknown top-level fields, and writers emit only known fields. Nested data within known planes remains intact. Explicit value reads of an absent documented top-level field return `null`. Authored `patch_state` keeps its documented field grammar. Objects merge, arrays/scalars replace, and omitted nonempty fields persist. Accepted supplied scopes recursively omit empty object fields and planes, including explicit `{}`; the scope root remains `{}`. This also cleans legacy empty branches in that scope, which can advance its revision once. Array slots and empty arrays remain; empty object fields inside elements disappear without shifting indices. Model projection hides legacy empty branches, but exact current/historical reads and untouched scopes are not normalized. Nested `null` removes an owned object key; empty ancestors disappear and inherited content may reappear. Canonical `"[N]"` keys patch existing array elements; indexed deletion and out-of-bounds indices are forbidden. Replace the whole array to add/remove elements. Missing authored object-key deletions succeed with a nonfatal hint showing owner-scoped JSON Pointers for the target and first unavailable component. Hints are not state, do not advance revisions and do not prove a typo; check the address only when deletion was expected to change something. Never guess or automatically correct the target.
 
 Work from intents. A structured `{"$ref"}` anywhere inside an intent owns ("delete with me") an existing object key under `working` or `lazy` in the same scope; a textual `$path` mention only uses it. Opening a task:
 

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

@@ -66,7 +66,7 @@ Later scopes win. A scope-local `null` deletion removes only that scope's key an
 - `readTemporalState` and the embedding callback keep default-bearing compatibility views for internal registry consumers. Those defaults never become stored overrides or model context.
 - Passive reads and Start do not fill checkpoint fields or create revisions for normalization; missing shared pairs initialize as empty objects.
 
-**Staging and replay.** Authored staging uses raw scope presence and derives runtime-normalized replay from the writes actually accepted, including complete artifact replacement; replay must reproduce accepted state exactly. Existing empty/no-op tail records keep their proven boundaries, while new no-op writes still create none.
+**Staging and replay.** Authored staging uses raw scope presence and derives runtime-normalized replay from the writes actually accepted, including complete artifact replacement; replay must reproduce accepted state exactly. Each supplied scope (and Session on response reconciliation) recursively omits empty object fields, including explicit `{}` and empty planes, before intent ownership and after cascades/compilation. The scope root remains `{}`; array slots and empty arrays remain, while object fields inside array elements are pruned. Untouched scopes are not normalized. Existing empty branches in a supplied scope become explicit accepted deletions and may advance its revision once; clean repeats create none. Model projection hides legacy empty object fields without changing stored state, exact current/historical reads or replay.
 
 **Validation.** Present documented fields keep usable object/string types, valid artifact entries and the no-stored-null rule; ignored fields may contain arbitrary JSON. Malformed JSON and invalid storage/history authority remain errors.
 
@@ -701,7 +701,9 @@ The package exposes read-only host contracts that:
 **`patch_state` grammar.** It accepts one or more fixed `global`, `cwd` and `session` semantic patches.
 
 - Supplied scopes contain object-valued `artifacts`, `contract`, `working` and `intents`, plus object-valued `lazy` whose nested values are ordinary JSON.
-- Omitted fields keep their values, recursive object merge updates them, arrays/primitives replace, and nested object-key `null` deletes.
+- Recursive object merge updates fields, arrays/primitives replace, and nested object-key `null` deletes, including inside newly created objects. Deletion-only patches through absent ancestors create no empty parents. Accepted supplied scopes recursively omit empty object fields and empty planes: deleting the last child removes its empty ancestors, and explicit `{}` is not a retained value. Nonempty omitted fields persist; an object patch that turns a scalar/array into an empty object removes that field. Cleanup is scope-local and can reveal inherited values; it stops at the scope root and never removes array slots.
+- Against an existing array, a nonempty object containing only canonical `"[N]"` keys recursively patches those existing elements (zero-based). Out-of-bounds indices and indexed `null` deletions are rejected atomically; adding/removing elements requires replacing the whole array. Against objects, those keys remain literal object keys.
+- Missing authored object-key deletions succeed with nonfatal hints in the acknowledgement, for both unchanged and mixed patches. Each hint gives the owner-scoped target and first unavailable component as escaped JSON Pointers; a non-object ancestor is also unavailable. These hints are presentation-only: no state fields, revisions, history records, automatic path correction or cascade warnings.
 - Rejected: materialized null within documented semantic planes, empty supplied scopes, unknown top-level fields, model-authored `response`, and finalization or `{scope, patch}` / `unchanged` grammars. The semantic null rule does not apply to runtime envelopes such as an origin's null parent.
 - Correct repeated results succeed as `State already current.` without another semantic revision or history record; avoid gratuitous acknowledgment patches.
 - Global/CWD overlap follows successful acceptance order, and unmentioned current fields survive. Session ownership is not a shared-memory merge.

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

@@ -44,9 +44,13 @@ function lazyValueKind(value: JsonValue): LazyValueKind {
 	return typeof value as Exclude<LazyValueKind, "array" | "object">;
 }
 
+function hasLazyContent(value: JsonValue): boolean {
+	return !isObject(value) || Object.values(value).some(hasLazyContent);
+}
+
 /** Fixed-budget navigation only: never place lazy bodies or partial key catalogs in baseline context. */
 export function lazyNavigationHint(state: SemanticState): { available: boolean; path: string; keys?: Record<string, LazyValueKind> } {
-	const entries = isObject(state.lazy) ? Object.entries(state.lazy) : [];
+	const entries = isObject(state.lazy) ? Object.entries(state.lazy).filter(([, value]) => hasLazyContent(value)) : [];
 	const base = { available: entries.length > 0, path: LAZY_HINT_PATH };
 	if (!base.available) return base;
 	if (entries.length > LAZY_HINT_MAX_KEYS) return base;
@@ -184,6 +188,7 @@ export class ContextProjection {
 		const prefix = (a: readonly (string | number)[], b: readonly (string | number)[]) =>
 			a.length <= b.length && a.every((part, index) => part === b[index]);
 		updates.effective = updates.effective.filter((entry) => {
+			if ("deleted" in entry && this.view && known(entry.path) === undefined) return false;
 			const matches = ({ path }: typeof leaves[number]) => path.length === entry.path.length && prefix(path, entry.path);
 			const authored = leaves.findLast(matches) ?? objects.findLast(matches);
 			if (!authored) return true;

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

@@ -815,9 +815,10 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 						? `\nState materialized atomically at ${scopes.join("+")} scope${scopes.length === 1 ? "" : "s"}.`
 						: "\nState already current.";
 					return { content: [
-						{ type: "text" as const, text: acknowledgement },
+						{ type: "text" as const, text: acknowledgement + stage.missingDeletions.map(({ path, unavailablePath }) =>
+							`\n\nHint: deletion skipped at ${path}; target absent. First unavailable component: ${unavailablePath}. Check the path if you expected an existing value.`).join("") },
 						...(updates ? [{ type: "text" as const, text: `\n${presentationJson({ state_updates: updates })}` }] : []),
-					], details: { scopes, step: snapshot.meta.step, changed } };
+					], details: { scopes, step: snapshot.meta.step, changed, missingDeletions: stage.missingDeletions } };
 				}, signal);
 			} catch (error) {
 				let attempted: unknown;

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

@@ -3,6 +3,12 @@ import { createHash } from "node:crypto";
 export type JsonValue = null | boolean | number | string | JsonValue[] | JsonObject;
 export interface JsonObject { [key: string]: JsonValue }
 
+export interface MissingDeletion {
+	/** JSON Pointer paths relative to the patched object. */
+	path: string;
+	unavailablePath: string;
+}
+
 const ARRAY_INDEX_SELECTOR = /^\[(0|[1-9]\d*)\]$/;
 
 function isIndexedArrayPatch(value: JsonObject): boolean {
@@ -10,17 +16,22 @@ function isIndexedArrayPatch(value: JsonObject): boolean {
 	return keys.length > 0 && keys.every((key) => ARRAY_INDEX_SELECTOR.test(key));
 }
 
-function applyOwnedValue(current: JsonValue | undefined, value: JsonValue, owned: boolean): JsonValue {
+function applyOwnedValue(
+	current: JsonValue | undefined, value: JsonValue, owned: boolean,
+	missingDeletions: MissingDeletion[] | undefined, path: string, unavailablePath?: string,
+): JsonValue {
 	// Preserve inherited-object merge semantics without borrowing prototype objects.
 	if (!owned && current !== null && typeof current === "object") current = structuredClone(current);
 	return Array.isArray(current) && isObject(value) && isIndexedArrayPatch(value)
-		? applyOwnedArrayPatch(current, value)
-		: isObject(current) && isObject(value)
-			? applyOwnedPatch(current, value)
+		? applyOwnedArrayPatch(current, value, missingDeletions, path, unavailablePath)
+		: isObject(value)
+			? applyOwnedPatch(isObject(current) ? current : {}, value, missingDeletions, path, unavailablePath ?? (!isObject(current) ? path : undefined))
 			: structuredClone(value);
 }
 
-function applyOwnedArrayPatch(state: JsonValue[], patch: JsonObject): JsonValue[] {
+function applyOwnedArrayPatch(
+	state: JsonValue[], patch: JsonObject, missingDeletions: MissingDeletion[] | undefined, path: string, unavailablePath?: string,
+): JsonValue[] {
 	let next = state;
 	for (const [selector, value] of Object.entries(patch)) {
 		const index = Number(ARRAY_INDEX_SELECTOR.exec(selector)![1]);
@@ -30,7 +41,7 @@ function applyOwnedArrayPatch(state: JsonValue[], patch: JsonObject): JsonValue[
 		if (value === null) throw new Error(`State patch array index ${selector} cannot be deleted; replace the whole array instead`);
 		const owns = Object.hasOwn(next, index);
 		const current = next[index];
-		const materialized = applyOwnedValue(current, value, owns);
+		const materialized = applyOwnedValue(current, value, owns, missingDeletions, `${path}/${index}`, unavailablePath);
 		if (owns && Object.is(current, materialized)) continue;
 		if (next === state) next = state.slice();
 		next[index] = materialized;
@@ -38,18 +49,27 @@ function applyOwnedArrayPatch(state: JsonValue[], patch: JsonObject): JsonValue[
 	return next;
 }
 
-function applyOwnedPatch(state: JsonObject, patch: JsonObject): JsonObject {
+function applyOwnedPatch(
+	state: JsonObject, patch: JsonObject, missingDeletions?: MissingDeletion[], path = "", unavailablePath?: string,
+): JsonObject {
 	let next = state;
 	for (const [key, value] of Object.entries(patch)) {
 		const owns = Object.hasOwn(next, key);
+		const target = missingDeletions ? `${path}/${key.replace(/~/g, "~0").replace(/\//g, "~1")}` : "";
 		if (value === null) {
-			if (!owns) continue;
+			if (!owns) {
+				missingDeletions?.push({ path: target, unavailablePath: unavailablePath ?? target });
+				continue;
+			}
 			if (next === state) next = { ...state };
 			delete next[key];
 			continue;
 		}
 		const current = next[key];
-		const materialized = applyOwnedValue(current, value, owns);
+		const materialized = applyOwnedValue(current, value, owns, missingDeletions, target, unavailablePath ?? (!owns ? target : undefined));
+		// Deletion-only patches must not fabricate absent ancestor objects; explicit {} still writes.
+		if (!owns && current === undefined && isObject(value) && Object.keys(value).length > 0
+			&& isObject(materialized) && Object.keys(materialized).length === 0) continue;
 		if (owns && Object.is(current, materialized)) continue;
 		if (next === state) next = { ...state };
 		Object.defineProperty(next, key, { value: materialized, enumerable: true, configurable: true, writable: true });
@@ -57,9 +77,39 @@ function applyOwnedPatch(state: JsonObject, patch: JsonObject): JsonObject {
 	return next;
 }
 
+/** Remove empty object fields without removing array slots or mutating the input. */
+export function pruneEmptyObjects(value: JsonObject): JsonObject;
+export function pruneEmptyObjects(value: JsonValue): JsonValue;
+export function pruneEmptyObjects(value: JsonValue): JsonValue {
+	if (Array.isArray(value)) {
+		let next = value;
+		for (let index = 0; index < value.length; index++) {
+			const pruned = pruneEmptyObjects(value[index]!);
+			if (pruned === value[index]) continue;
+			if (next === value) next = value.slice();
+			next[index] = pruned;
+		}
+		return next;
+	}
+	if (!isObject(value)) return value;
+	let next = value as JsonObject;
+	for (const [key, child] of Object.entries(value)) {
+		const pruned = pruneEmptyObjects(child);
+		const empty = isObject(pruned) && Object.keys(pruned).length === 0;
+		if (!empty && pruned === child) continue;
+		if (next === value) next = { ...value };
+		if (empty) delete next[key];
+		else Object.defineProperty(next, key, { value: pruned, enumerable: true, configurable: true, writable: true });
+	}
+	return next;
+}
+
 /** Detach at the mutable public boundary; share untouched paths only inside the owned draft. */
-export function applyPatch(state: JsonObject, patch: JsonObject): JsonObject {
-	return applyOwnedPatch(structuredClone(state), patch);
+export function applyPatch(state: JsonObject, patch: JsonObject, missingDeletions?: MissingDeletion[]): JsonObject {
+	const collected = missingDeletions ? [] as MissingDeletion[] : undefined;
+	const next = applyOwnedPatch(structuredClone(state), patch, collected);
+	if (collected) missingDeletions!.push(...collected);
+	return next;
 }
 
 export function isObject(value: JsonValue | unknown): value is JsonObject {

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

@@ -1,6 +1,6 @@
 import { DEFAULT_HISTORY_LIMIT, MAX_HISTORY_LIMIT, type RecentScopePatch } from "./history.ts";
 import { isObject, sameJson, type JsonObject, type JsonValue } from "./json.ts";
-import { emptyState, projectSemanticPatch, projectStateForModel, type SemanticState, type StateScope } from "./state.ts";
+import { emptyState, projectSemanticPatch, projectStateForRead, type SemanticState, type StateScope } from "./state.ts";
 import { readTemporalView, type TemporalState, type TransitionBoundary } from "./temporal.ts";
 
 export type StateReadQuery =
@@ -61,7 +61,7 @@ export function readStatePath(view: TemporalState, path: string, historyLimit =
 	if (query.kind === "state") {
 		const boundary = view.lineage[view.lineage.length - 1 - query.offset];
 		if (!boundary) throw new Error("Requested history predates the proven temporal origin");
-		return { path, boundary: structuredClone(boundary), state: projectStateForModel(readTemporalView(view, query.offset, query.scope, historyLimit)) };
+		return { path, boundary: structuredClone(boundary), state: projectStateForRead(readTemporalView(view, query.offset, query.scope, historyLimit)) };
 	}
 	const record = view.scopes[query.scope].patches.at(-1 - query.offset);
 	if (!record) throw new Error(`Requested ${query.scope} patch predates retained hot history`);
@@ -275,7 +275,7 @@ export function readProjectedState(view: TemporalState, paths: readonly string[]
 			if (query.kind !== "state") throw new Error("Value and keys projections require a state path");
 			const readsLazy = selectors[0]?.kind === "key" && selectors[0].key === "lazy";
 			const raw = readTemporalView(view, query.offset, query.scope, historyLimit);
-			const state = readsLazy ? raw : projectStateForModel(raw);
+			const state = readsLazy ? raw : projectStateForRead(raw);
 			const field = selectors.length === 1 && selectors[0]?.kind === "key" ? selectors[0].key : undefined;
 			if (projection === "value" && field !== undefined && Object.hasOwn(emptyState(), field) && !Object.hasOwn(state, field)) return { value: null };
 			return projectValue(selectValue(state, selectors, path), projection);

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

@@ -6,7 +6,7 @@ import {
 	type ArtifactModelHints,
 	type ArtifactRegistry,
 } from "./artifact.ts";
-import { applyPatch, isObject, type JsonObject } from "./json.ts";
+import { applyPatch, isObject, pruneEmptyObjects, type JsonObject } from "./json.ts";
 
 /** Runtime defaults for documented semantic planes; stored objects may omit them or retain other fields. */
 export type MaterializedState = JsonObject & {
@@ -148,10 +148,15 @@ export function projectSemanticPatch(patch: JsonObject): JsonObject {
 	return projected;
 }
 
-/** Model-visible projection: lazy bodies and runtime artifact bookkeeping stay out of ordinary context. */
-export function projectStateForModel(state: SemanticState, artifactHints: ArtifactModelHints = {}): SemanticState {
+/** Explicit hot reads filter hidden bodies/bookkeeping without normalizing legacy semantic data. */
+export function projectStateForRead(state: SemanticState, artifactHints: ArtifactModelHints = {}): SemanticState {
 	const { lazy: _hidden, ...visible } = state;
 	const projected = projectSemanticState(visible);
 	if (projected.artifacts) projected.artifacts = projectArtifactsForModel(projected.artifacts, artifactHints);
 	return projected;
 }
+
+/** Ordinary model context omits empty object fields; exact reads and replay remain observational. */
+export function projectStateForModel(state: SemanticState, artifactHints: ArtifactModelHints = {}): SemanticState {
+	return pruneEmptyObjects(projectStateForRead(state, artifactHints));
+}

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

@@ -9,7 +9,7 @@ import {
 } from "./artifact.ts";
 import type { SuccessfulArtifactRead } from "./acquisition.ts";
 import { createAcceptedTransition, type AcceptedTransition } from "./history.ts";
-import { applyPatch, containsNull, hashJson, isObject, validatePatch, type JsonObject } from "./json.ts";
+import { applyPatch, containsNull, hashJson, isObject, pruneEmptyObjects, validatePatch, type JsonObject, type MissingDeletion } from "./json.ts";
 import { cascadeDeletionPatch, computeIntentCascade, type OwnedPath } from "./ownership.ts";
 import { hasCompiledSkillArtifact, SKILL_ARTIFACT_COMPILER, type SuccessfulSkillRead } from "./skills.ts";
 import type { Snapshot } from "./snapshot.ts";
@@ -29,6 +29,8 @@ import type {
 
 export interface StagedScopedTransition {
 	nextStates: ScopedSemanticStates;
+	/** Authored no-op deletions; presentation evidence only, never replay input. */
+	missingDeletions: MissingDeletion[];
 	/** Scope-local targets removed by the staged intent cascade, not replay input. */
 	cascades: Record<StateScope, OwnedPath[]>;
 	stateHashes: Record<StateScope, string>;
@@ -189,10 +191,18 @@ function stageScopedSemanticTransition(
 	const nextStates = { ...currentStates };
 	const provenanceUpdates: Record<StateScope, Record<string, ArtifactProvenance>> = { global: {}, cwd: {}, session: {} };
 	const cascades: Record<StateScope, OwnedPath[]> = { global: [], cwd: [], session: [] };
+	const missingDeletions: MissingDeletion[] = [];
 	for (const scope of SCOPES) {
 		const authored = patches.get(scope) ?? {};
 		const patch = { ...authored, ...(scope === "session" && acceptedResponse !== undefined ? { response: acceptedResponse } : {}) };
-		let materialized = applyPatch({ ...emptyState(), ...currentStates[scope] }, patch) as StateDocument;
+		const scopedMissing: MissingDeletion[] = [];
+		const normalize = patches.has(scope) || scope === "session" && acceptedResponse !== undefined;
+		const applied = applyPatch(currentStates[scope], patch, scopedMissing);
+		const patched = normalize ? pruneEmptyObjects(applied) : applied;
+		missingDeletions.push(...scopedMissing.map(({ path, unavailablePath }) => ({
+			path: `/${scope}${path}`, unavailablePath: `/${scope}${unavailablePath}`,
+		})));
+		let materialized = { ...emptyState(), ...patched } as StateDocument;
 		// Authored operations first, then the same-scope intent ownership cascade.
 		const cascade = cascades[scope] = computeIntentCascade(scope, currentStates[scope], materialized);
 		if (cascade.length > 0) materialized = applyPatch(materialized, cascadeDeletionPatch(cascade)) as StateDocument;
@@ -203,16 +213,18 @@ function stageScopedSemanticTransition(
 			provenanceUpdates[scope],
 		);
 		compileReadSkills(scope, materialized, { artifacts: authored.artifacts ?? {} }, skillReads.filter((read) => read.scope === scope), provenanceUpdates[scope]);
-		validateMaterializedTransition(materialized, scope);
 		const nextState: SemanticState = materialized;
 		for (const key of Object.keys(emptyState())) {
-			if (!Object.hasOwn(currentStates[scope], key) && !Object.hasOwn(patch, key)
+			if (!Object.hasOwn(patched, key)
 				&& !(key === "artifacts" && Object.keys(provenanceUpdates[scope]).length > 0)) delete nextState[key];
 		}
-		nextStates[scope] = nextState;
+		const normalized = normalize ? pruneEmptyObjects(nextState) : nextState;
+		validateMaterializedTransition({ ...emptyState(), ...normalized }, scope);
+		nextStates[scope] = normalized;
 	}
 	return {
 		nextStates,
+		missingDeletions,
 		cascades,
 		provenanceUpdates,
 		stateHashes: {

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

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

package/node_modules/@llblab/pi-state-flow/skills/state-flow-guide/SKILL.md

@@ -56,7 +56,7 @@ Call `patch_state` alone per assistant response; await acceptance before depende
 
 The runtime waits cancelably for publication ownership, then applies authored Global/CWD operations to current canonical values. Untouched fields survive; overlapping targets follow successful acceptance order. Correct repeats succeed as `State already current.` without another semantic revision. Do not repeat external actions during a memory wait, or rebuild an entire scope from an older snapshot. Session ownership/history fences remain private, not a universal merge.
 
-When present, semantic planes `intents`, `contract`, `working`, `artifacts`, and `lazy` are objects; nested lazy values may contain ordinary JSON without stored nulls. Stored checkpoints and patches may omit any documented plane. Current and historical views assemble only known fields present in the selected scopes. Absent fields and empty responses are omitted from views. Checkpoint/tail readers ignore unknown top-level fields, and writers emit only known fields. Nested data within known planes remains intact. Explicit value reads of an absent documented top-level field return `null`. Authored `patch_state` keeps its documented field grammar. Objects merge, arrays/scalars replace, omitted fields persist. Nested `null` removes an owned object key; inherited content may reappear. Canonical `"[N]"` keys patch array elements; indexed deletion is forbidden.
+When present, semantic planes `intents`, `contract`, `working`, `artifacts`, and `lazy` are objects; nested lazy values may contain ordinary JSON without stored nulls. Stored checkpoints and patches may omit any documented plane. Current and historical views assemble only known fields present in the selected scopes. Absent fields and empty responses are omitted from views. Checkpoint/tail readers ignore unknown top-level fields, and writers emit only known fields. Nested data within known planes remains intact. Explicit value reads of an absent documented top-level field return `null`. Authored `patch_state` keeps its documented field grammar. Objects merge, arrays/scalars replace, and omitted nonempty fields persist. Accepted supplied scopes recursively omit empty object fields and planes, including explicit `{}`; the scope root remains `{}`. This also cleans legacy empty branches in that scope, which can advance its revision once. Array slots and empty arrays remain; empty object fields inside elements disappear without shifting indices. Model projection hides legacy empty branches, but exact current/historical reads and untouched scopes are not normalized. Nested `null` removes an owned object key; empty ancestors disappear and inherited content may reappear. Canonical `"[N]"` keys patch existing array elements; indexed deletion and out-of-bounds indices are forbidden. Replace the whole array to add/remove elements. Missing authored object-key deletions succeed with a nonfatal hint showing owner-scoped JSON Pointers for the target and first unavailable component. Hints are not state, do not advance revisions and do not prove a typo; check the address only when deletion was expected to change something. Never guess or automatically correct the target.
 
 Work from intents. A structured `{"$ref"}` anywhere inside an intent owns ("delete with me") an existing object key under `working` or `lazy` in the same scope; a textual `$path` mention only uses it. Opening a task:
 

package/package.json

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