0xray 4.0.36 → 4.0.38

package/dist/session/session-state-manager.js

@@ -13,9 +13,14 @@ export class SessionStateManager {
     dependencies = new Map();
     sessionGroups = new Map();
     failoverConfigs = new Map();
+    /** Stable store records. A field write patches one key instead of cloning the map. */
+    dependencyRecord = {};
+    groupRecord = {};
+    failoverRecord = {};
     constructor(stateManager, sessionCoordinator) {
         this.stateManager = stateManager;
         this.sessionCoordinator = sessionCoordinator;
+        this.loadPersistedRecords();
     }
     /**
      * Share state between sessions
@@ -86,10 +91,12 @@ export class SessionStateManager {
                     metadata: {},
                 };
                 this.dependencies.set(depId, dep);
+                this.trackDependency(depId);
             }
             dep.dependedBy.push(sessionId);
         }
         this.dependencies.set(sessionId, dependency);
+        this.trackDependency(sessionId);
         this.persistDependencies();
         frameworkLogger.log("session-state-manager", "dependency-registered", "info", { sessionId, dependsOn });
     }
@@ -138,6 +145,7 @@ export class SessionStateManager {
             createdAt: Date.now(),
         };
         this.sessionGroups.set(groupId, group);
+        this.trackGroup(groupId);
         this.persistSessionGroups();
         for (const sessionId of sessionIds) {
             this.sessionCoordinator.shareContext(sessionId, `group:${groupId}:membership`, {
@@ -357,6 +365,7 @@ export class SessionStateManager {
                                     coordinatorId: plan.targetCoordinator,
                                 };
                                 this.sessionGroups.set(groupId, updatedGroup);
+                                this.trackGroup(groupId);
                                 this.persistSessionGroups();
                                 break;
                             }
@@ -400,6 +409,7 @@ export class SessionStateManager {
             autoFailover,
         };
         this.failoverConfigs.set(sessionId, config);
+        this.trackFailover(sessionId);
         this.persistFailoverConfigs();
         frameworkLogger.log("session-state-manager", "failover-configured", "info", { sessionId, backupCount: backupCoordinators.length });
     }
@@ -435,11 +445,21 @@ export class SessionStateManager {
      * Get coordination statistics
      */
     getCoordinationStats() {
+        let activeDependencies = 0;
+        for (const dependency of this.dependencies.values()) {
+            if (dependency.state === "active")
+                activeDependencies += 1;
+        }
+        let activeGroups = 0;
+        for (const group of this.sessionGroups.values()) {
+            if (group.state === "active")
+                activeGroups += 1;
+        }
         return {
             totalDependencies: this.dependencies.size,
-            activeDependencies: Array.from(this.dependencies.values()).filter((d) => d.state === "active").length,
+            activeDependencies,
             totalGroups: this.sessionGroups.size,
-            activeGroups: Array.from(this.sessionGroups.values()).filter((g) => g.state === "active").length,
+            activeGroups,
             failoverConfigs: this.failoverConfigs.size,
         };
     }
@@ -478,10 +498,12 @@ export class SessionStateManager {
                         }
                         if (backup.dependencies) {
                             this.dependencies.set(plan.sessionId, backup.dependencies);
+                            this.trackDependency(plan.sessionId);
                             this.persistDependencies();
                         }
                         if (backup.group) {
                             this.sessionGroups.set(backup.group.groupId, backup.group);
+                            this.trackGroup(backup.group.groupId);
                             this.persistSessionGroups();
                         }
                         break;
@@ -500,17 +522,77 @@ export class SessionStateManager {
             await frameworkLogger.log("session-state-manager", "-rolling-back-step-step-", "info", { message: `  ← Rolling back step: ${step}` });
         }
     }
+    trackDependency(sessionId) {
+        const dependency = this.dependencies.get(sessionId);
+        if (dependency)
+            this.dependencyRecord[sessionId] = dependency;
+        else
+            delete this.dependencyRecord[sessionId];
+    }
+    trackGroup(groupId) {
+        const group = this.sessionGroups.get(groupId);
+        if (group)
+            this.groupRecord[groupId] = group;
+        else
+            delete this.groupRecord[groupId];
+    }
+    trackFailover(sessionId) {
+        const config = this.failoverConfigs.get(sessionId);
+        if (config)
+            this.failoverRecord[sessionId] = config;
+        else
+            delete this.failoverRecord[sessionId];
+    }
     persistDependencies() {
-        const deps = Object.fromEntries(this.dependencies);
-        this.stateManager.set("state_manager:dependencies", deps);
+        this.dependencyRecord = this.adoptStoreRecord("state_manager:dependencies", this.dependencyRecord);
+        this.stateManager.set("state_manager:dependencies", this.dependencyRecord);
     }
     persistSessionGroups() {
-        const groups = Object.fromEntries(this.sessionGroups);
-        this.stateManager.set("state_manager:groups", groups);
+        this.groupRecord = this.adoptStoreRecord("state_manager:groups", this.groupRecord);
+        this.stateManager.set("state_manager:groups", this.groupRecord);
     }
     persistFailoverConfigs() {
-        const configs = Object.fromEntries(this.failoverConfigs);
-        this.stateManager.set("state_manager:failover", configs);
+        this.failoverRecord = this.adoptStoreRecord("state_manager:failover", this.failoverRecord);
+        this.stateManager.set("state_manager:failover", this.failoverRecord);
+    }
+    loadPersistedRecords() {
+        const dependencies = this.readStoreRecord("state_manager:dependencies");
+        if (dependencies) {
+            this.dependencyRecord = dependencies;
+            for (const [sessionId, dependency] of Object.entries(dependencies)) {
+                this.dependencies.set(sessionId, dependency);
+            }
+        }
+        const groups = this.readStoreRecord("state_manager:groups");
+        if (groups) {
+            this.groupRecord = groups;
+            for (const [groupId, group] of Object.entries(groups)) {
+                this.sessionGroups.set(groupId, group);
+            }
+        }
+        const failover = this.readStoreRecord("state_manager:failover");
+        if (failover) {
+            this.failoverRecord = failover;
+            for (const [sessionId, config] of Object.entries(failover)) {
+                this.failoverConfigs.set(sessionId, config);
+            }
+        }
+    }
+    readStoreRecord(key) {
+        const existing = this.stateManager.get(key);
+        if (!existing || typeof existing !== "object" || Array.isArray(existing))
+            return undefined;
+        return existing;
+    }
+    /** Patch the stored object so a pre-seeded key survives the first write. */
+    adoptStoreRecord(key, record) {
+        const existing = this.readStoreRecord(key);
+        if (!existing || existing === record)
+            return record;
+        for (const [id, value] of Object.entries(record)) {
+            existing[id] = value;
+        }
+        return existing;
     }
     shutdown() {
         frameworkLogger.log("session-state-manager", "shutdown-complete", "info");

package/docs-site/docs/plates/activity-log.md

@@ -0,0 +1,38 @@
+---
+title: Activity log
+sidebar_label: Activity log
+---
+
+# Activity log
+
+A tool hook appends one JSON line, and reporting, pulse, and monitor read that same file back.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌──────────────┐ ┌────────────┐ ┌─────────┐ ┌────────┐ │
+│   │ pipeline hook│ │ grok hook  │ │ hermes  │ │ logger │ │
+│   └──────┬───────┘ └─────┬──────┘ └────┬────┘ └───┬────┘ │
+│          └───────────────┴─────────────┴─────┬────┘      │
+└──────────────────────────────────────────────┼───────────┘
+                                               v
+┌──────────────────────────────────────────────┼───────────┐
+│ PROCESSING LAYER                             v           │
+│   ┌────────────────────────────────────────────────────┐ │
+│   │ append one JSON line                               │ │
+│   └──────────────────────────┬─────────────────────────┘ │
+└──────────────────────────────┼───────────────────────────┘
+                               v
+┌──────────────────────────────┼───────────────────────────┐
+│ OUTPUT LAYER                 v                           │
+│   ┌──────────────────────────────────────────────────┐  │
+│   │ .xray/logs/activity.log                          │  │
+│   └──────────────────────────────────────────────────┘  │
+└──────────────────────────────────────────────────────────┘
+```
+
+Today those writers append `logs/framework/activity.log`. The features default still says `.opencode/logs`. The file they share after the rewire is `.xray/logs/activity.log`.
+
+When: on the tool hook, on framework logger flush, and on boot when file logging is on. Why: the report and the pulse read one tail, not a pile of copies.
+
+stamped · 0xray 4.0.36

package/docs-site/docs/plates/cursor-compact.md

@@ -0,0 +1,35 @@
+---
+title: Cursor compact
+sidebar_label: Cursor compact
+---
+
+# Cursor compact
+
+Cursor preCompact writes the station card and cannot block the compact.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the host fires preCompact                          │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+             v
+┌────────────┼───────────────────────────────────────────────┐
+│ PROCESSING LAYER                                            │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ write the station card                             │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+                               v
+┌──────────────────────────────┼─────────────────────────────┐
+│ OUTPUT LAYER                 v                             │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the compact continues                              │   │
+│   └────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+```
+
+The file is `src/integrations/cursor/hooks/pre-compact.js`. The message tells the seat to read STATION.md. The plates that belong here are payload-heat and station-heat.
+
+stamped · 0xray 4.0.36

package/docs-site/docs/plates/grok-compact.md

@@ -0,0 +1,35 @@
+---
+title: Grok compact
+sidebar_label: Grok compact
+---
+
+# Grok compact
+
+Grok PreCompact runs session-start.js with the pre_compact event.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ a compact is about to happen                       │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+             v
+┌────────────┼───────────────────────────────────────────────┐
+│ PROCESSING LAYER                                            │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ build the session payload                          │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+                               v
+┌──────────────────────────────┼─────────────────────────────┐
+│ OUTPUT LAYER                 v                             │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the station card is written                        │   │
+│   └────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+```
+
+The hook is `session-start.js --hook-event=pre_compact`. It calls `buildSessionBootPayload`, writes the station card, and prints nothing. It does not match the conversation. Grok ignores hook stdout. The plates that belong here are payload-heat, cursor-compact, and work-fresh.
+
+stamped · 0xray 4.0.36

package/docs-site/docs/plates/index.md

@@ -21,10 +21,32 @@ Plates have a type. A domain model plate shows how named parts fit. A state flow
 
 ## State flow
 
-[House](./house.md)
+[House](./house.md) · [Review](./review.md)
 
 ## Pipeline
 
-[Routing](./routing.md) · [Governance](./governance.md) · [Boot](./boot.md) · [Orchestration](./orchestration.md) · [Processor](./processor.md) · [Reporting](./reporting.md) · [Memory recall](./memory-recall.md)
+[Routing](./routing.md) · [Governance](./governance.md) · [Boot](./boot.md) · [Orchestration](./orchestration.md) · [Processor](./processor.md) · [Reporting](./reporting.md) · [Memory recall](./memory-recall.md) · [Stamp plate](./stamp-plate.md)
 
-These seven are the lens planes. Each drawing is an input layer, a processing layer, and an output layer. Ground has no plate file.
+Each of these is a lens plane. Each drawing is an input layer, a processing layer, and an output layer. Ground has no plate file.
+
+## Write home
+
+[Record map](./record-map.md) · [Write home](./write-home.md) · [Activity log](./activity-log.md) · [Session capture](./session-capture.md) · [Suit wear](./suit-wear.md) · [Suit organs](./suit-organs.md)
+
+These six are the file ref. Each one is a search lens. The pipeline drawings above stay the lens planes for those machines.
+
+## Hands
+
+[Station card](./station-card.md) · [Notes page](./notes-page.md) · [Reflection page](./reflection-page.md) · [Site manual](./site-manual.md) · [Package face](./package-face.md) · [Suit settings](./suit-settings.md) · [Trail state](./trail-state.md) · [Inference files](./inference-files.md)
+
+These eight are the pages the file ref names. Each one is a search lens. Each lens lists one skill and the plates that belong with it.
+
+## Compact path
+
+[Grok compact](./grok-compact.md) · [Payload heat](./payload-heat.md) · [Station heat](./station-heat.md) · [Pickup stamp](./pickup-stamp.md) · [Cursor compact](./cursor-compact.md)
+
+## Fresh line and the gate
+
+[Work fresh](./work-fresh.md) · [Kept line](./kept-line.md) · [Lens gate](./lens-gate.md) · [Pre tool](./pre-tool.md) · [Lens page](./lens-page.md)
+
+These five are the compact path that was opened. Each one is a search lens. Each lens lists one skill and the plates that belong with it.

package/docs-site/docs/plates/inference-files.md

@@ -0,0 +1,35 @@
+---
+title: Inference files
+sidebar_label: Inference files
+---
+
+# Inference files
+
+Inference cycle state already lives under .xray/inference.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ a cycle closes                                     │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+             v
+┌────────────┼───────────────────────────────────────────────┐
+│ PROCESSING LAYER                                            │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ write the cycle beside the sessions                │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+                               v
+┌──────────────────────────────┼─────────────────────────────┐
+│ OUTPUT LAYER                 v                             │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ files under .xray/inference                        │   │
+│   └────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+```
+
+Cycle state, history, graded ids, and governance state are already there. Session files still fall back to `docs/inference` until the writers move.
+
+stamped · 0xray 4.0.36

package/docs-site/docs/plates/kept-line.md

@@ -0,0 +1,35 @@
+---
+title: Kept line
+sidebar_label: Kept line
+---
+
+# Kept line
+
+A station rewrite keeps one Fresh line and drops the copies.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the card already on disk                              │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+             v
+┌────────────┼───────────────────────────────────────────────┐
+│ PROCESSING LAYER                                            │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ keep the latest Fresh line                            │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+                               v
+┌──────────────────────────────┼─────────────────────────────┐
+│ OUTPUT LAYER                 v                             │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ one Fresh line in the stock card                      │   │
+│   └────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+```
+
+mergeStationMarkdown in src/integrations/hooks/station-hook-runtime.cjs treats a Fresh line as stock. Copies are not preserved. When the new card has no Fresh line, the latest one is kept. The plates that belong here are station-card and work-fresh.
+
+stamped · 0xray 4.0.36

package/docs-site/docs/plates/lens-gate.md

@@ -0,0 +1,35 @@
+---
+title: Lens gate
+sidebar_label: Lens gate
+---
+
+# Lens gate
+
+A search names one plane or it stops.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the tool name and the spoken text                     │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+             v
+┌────────────┼───────────────────────────────────────────────┐
+│ PROCESSING LAYER                                            │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ count card-plane names                                │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+                               v
+┌──────────────────────────────┼─────────────────────────────┐
+│ OUTPUT LAYER                 v                             │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ allow on one name, otherwise stop                     │   │
+│   └────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+```
+
+lensBeforeResearch in src/integrations/hooks/goggles-pipeline.mjs returns null when the call is not research, and when the spoken text names exactly one card plane. Zero names, or more than one, deny with Name one plane. A shell that reads a project source file is research. The first open of a source file that no lens lists is allowed and remembered. The next search stops until that file is on a lens and the plate is on disk. The hook does not author the plate. The plate that belongs here is pre-tool.
+
+stamped · 0xray 4.0.36

package/docs-site/docs/plates/lens-page.md

@@ -0,0 +1,35 @@
+---
+title: Lens page
+sidebar_label: Lens page
+---
+
+# Lens page
+
+The lens page is the card for one plane.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ one plane name                                     │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+             v
+┌────────────┼───────────────────────────────────────────────┐
+│ PROCESSING LAYER                                            │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ draw the card                                      │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+                               v
+┌──────────────────────────────┼─────────────────────────────┐
+│ OUTPUT LAYER                 v                             │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the skill and the plates on that card              │   │
+│   └────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+```
+
+`formatCardPane` in `src/integrations/hooks/goggles-pipeline.mjs` draws the card. Read the card instead of searching the tree. The plates that belong here are record-map and lens-gate.
+
+stamped · 0xray 4.0.36

package/docs-site/docs/plates/notes-page.md

@@ -0,0 +1,35 @@
+---
+title: Notes page
+sidebar_label: Notes page
+---
+
+# Notes page
+
+Notes are the body the station card cannot hold.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the pickup line                                    │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+             v
+┌────────────┼───────────────────────────────────────────────┐
+│ PROCESSING LAYER                                            │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ write the working notes at full depth              │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+                               v
+┌──────────────────────────────┼─────────────────────────────┐
+│ OUTPUT LAYER                 v                             │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the next seat continues                            │   │
+│   └────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+```
+
+The page is `.xray/state/NOTES.md`. The pickup line equals the station intent. The default depth is the working notes: the point, the coverage, the library, the open pull requests, the rituals, and the next cut. A pickup line alone does not survive a compact. PreCompact calls `stampNotesPickup`, which updates only that line and leaves the body alone. The hook does not check the body. The seat writes it before the compact. Do not commit this file. Do not feed it to Repertoire.
+
+stamped · 0xray 4.0.36

package/docs-site/docs/plates/package-face.md

@@ -0,0 +1,35 @@
+---
+title: Package face
+sidebar_label: Package face
+---
+
+# Package face
+
+A release writes the package face, and the agent reads it.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ a release runs                                     │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+             v
+┌────────────┼───────────────────────────────────────────────┐
+│ PROCESSING LAYER                                            │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the release script writes the face                 │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+                               v
+┌──────────────────────────────┼─────────────────────────────┐
+│ OUTPUT LAYER                 v                             │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the published package                              │   │
+│   └────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+```
+
+The face is `README.md`, `package.json`, `AGENTS.md`, `llms.txt`, `CHANGELOG.md`, and `SKILLS.md`. Do not hand-bump the version.
+
+stamped · 0xray 4.0.36

package/docs-site/docs/plates/payload-heat.md

@@ -0,0 +1,35 @@
+---
+title: Payload heat
+sidebar_label: Payload heat
+---
+
+# Payload heat
+
+buildSessionBootPayload calls applyStationHeat and writes the station card.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the compact event                                  │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+             v
+┌────────────┼───────────────────────────────────────────────┐
+│ PROCESSING LAYER                                            │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ apply station heat                                 │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+                               v
+┌──────────────────────────────┼─────────────────────────────┐
+│ OUTPUT LAYER                 v                             │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ STATION.md is on disk                              │   │
+│   └────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+```
+
+The function is in `src/integrations/grok/hooks/grok-hook-utils.js`. The plates that belong here are station-heat and pickup-stamp.
+
+stamped · 0xray 4.0.36

package/docs-site/docs/plates/pickup-stamp.md

@@ -0,0 +1,35 @@
+---
+title: Pickup stamp
+sidebar_label: Pickup stamp
+---
+
+# Pickup stamp
+
+stampNotesPickup writes one pickup line and leaves the rest of NOTES.md alone.
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ INPUT LAYER                                                │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the intent line                                    │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+             v
+┌────────────┼───────────────────────────────────────────────┐
+│ PROCESSING LAYER                                            │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ replace the pickup line                            │   │
+│   └──────────────────────────┬─────────────────────────┘   │
+└──────────────────────────────┼─────────────────────────────┘
+                               v
+┌──────────────────────────────┼─────────────────────────────┐
+│ OUTPUT LAYER                 v                             │
+│   ┌────────────────────────────────────────────────────┐   │
+│   │ the body is untouched                              │   │
+│   └────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+```
+
+The comment on the function is one pickup line. There is no check that the working notes are present. The plate that belongs here is notes-page.
+
+stamped · 0xray 4.0.36