@code-yeongyu/senpi 2026.10.26-1 → 2026.10.27-1

package/dist/modes/rpc/compact-spool-storage.js

@@ -0,0 +1,195 @@
+import { join } from "node:path";
+import { CompactReadError } from "./compact-read-lease.js";
+import { createSpoolDir, removeSpoolDir } from "./compact-spool-dir.js";
+import { CompactStorageReadError, describeCause, } from "./compact-storage-io.js";
+/**
+ * The spool file path of compact current-state storage (senpi#4272, R3.C6.4): one serial
+ * asynchronous job chain, the private epoch directory, spool file writes, reads and reclamation,
+ * and the failure ledger. `CompactContentStore` adds leaf ownership and spilling on top.
+ */
+export const RECLAIM_WORK_ALLOWANCE_BYTES = 1024 * 1024;
+const RECLAIM_RETRY_DELAYS_MS = [100, 400, 1_600, 6_400, 25_600];
+const FAILURE_HISTORY = 32;
+export class CompactSpoolStorage {
+    assertReadable() {
+        if (this.retired)
+            throw new CompactReadError("retired");
+    }
+    beginRead() {
+        this.assertReadable();
+        this.reads++;
+        this.reading ??= Promise.withResolvers();
+        let done = false;
+        return () => {
+            if (done)
+                return;
+            done = true;
+            if (--this.reads === 0) {
+                this.reading?.resolve();
+                this.reading = undefined;
+            }
+        };
+    }
+    constructor(dir, io) {
+        this.failures = [];
+        this.nextFile = 1;
+        this.chain = Promise.resolve();
+        this.queued = 0;
+        this.spillQueued = false;
+        this.halted = false;
+        this.retired = false;
+        this.pendingIoCopyBytes = 0;
+        this.spillBytesWritten = 0;
+        this.reclaimDebtBytes = 0;
+        this.reads = 0;
+        this.dir = dir;
+        this.io = io;
+    }
+    /** Resolves once every queued storage job, including the ones they queued, has completed. */
+    async idle() {
+        while (this.queued > 0)
+            await this.chain;
+    }
+    /**
+     * Invalidates spilling, joins owned I/O, then removes the epoch directory only when this store
+     * created it and it still passes the ownership checks; otherwise rejects with `CompactSpoolRefusedError`.
+     */
+    async retire() {
+        this.retired = true;
+        await this.reading?.promise;
+        await this.idle();
+        const token = this.spoolToken;
+        this.spoolToken = undefined;
+        if (token !== undefined)
+            await removeSpoolDir(this.dir, token);
+    }
+    /** Reads a committed file and rejects a missing, unreadable or short one. */
+    async readFile(path, bytes, operation) {
+        const done = this.beginRead();
+        try {
+            const result = await this.readCommittedFile(path, bytes, operation);
+            this.assertReadable();
+            return result;
+        }
+        finally {
+            done();
+        }
+    }
+    async readCommittedFile(path, bytes, operation) {
+        let data;
+        try {
+            data = await this.io.readFile(path);
+        }
+        catch (cause) {
+            throw this.readFailure(operation, path, cause);
+        }
+        if (data.byteLength !== bytes) {
+            throw this.readFailure(operation, path, new Error(`expected ${bytes} bytes, found ${data.byteLength}`));
+        }
+        return data;
+    }
+    /** Writes one new spool file; undefined means the write failed and was reported (a spill write also halts spilling). */
+    async writeFile(data, operation, retainedInMemoryBytes) {
+        const path = await this.ensureDir(retainedInMemoryBytes);
+        if (path === undefined)
+            return undefined;
+        const file = join(path, `${operation === "spill_write" ? "leaf" : "page"}-${this.nextFile++}.bin`);
+        this.pendingIoCopyBytes += data.byteLength;
+        try {
+            await this.io.writeFile(file, data);
+            this.spillBytesWritten += data.byteLength;
+            return file;
+        }
+        catch (cause) {
+            try {
+                this.fail(operation, file, cause, retainedInMemoryBytes);
+            }
+            finally {
+                this.discard(file, data.byteLength);
+            }
+            return undefined;
+        }
+        finally {
+            this.pendingIoCopyBytes -= data.byteLength;
+        }
+    }
+    /**
+     * An unreferenced (or partially written) spool file: reclamation debt until its unlink completes or
+     * finds it gone. Files dropped after retirement started belong to the directory retirement removes.
+     */
+    discard(path, bytes) {
+        if (this.retired)
+            return;
+        this.reclaimDebtBytes += bytes;
+        this.enqueue("reclaim", () => this.reclaim(path, bytes, 0));
+    }
+    /** A failed unlink keeps its debt and is retried with bounded backoff outside the job chain. */
+    async reclaim(path, bytes, attempt) {
+        try {
+            await this.io.unlink(path);
+        }
+        catch (cause) {
+            if (cause.code !== "ENOENT") {
+                this.fail("reclaim", path, cause, 0);
+                const delay = RECLAIM_RETRY_DELAYS_MS[attempt];
+                if (delay !== undefined) {
+                    setTimeout(() => {
+                        if (this.retired)
+                            this.reclaimDebtBytes -= bytes;
+                        else
+                            this.enqueue("reclaim", () => this.reclaim(path, bytes, attempt + 1));
+                    }, delay).unref?.();
+                }
+                return;
+            }
+        }
+        this.reclaimDebtBytes -= bytes;
+        this.scheduleSpill();
+    }
+    get spillAllowed() {
+        return !this.halted && !this.retired;
+    }
+    /** True while a storage failure or unreclaimed debt above the work allowance holds spilling back. */
+    get spillStopped() {
+        return this.halted || this.reclaimDebtBytes > RECLAIM_WORK_ALLOWANCE_BYTES;
+    }
+    enqueue(operation, job) {
+        this.queued++;
+        this.chain = this.chain
+            .then(job)
+            .catch((cause) => {
+            if (operation === "spill_write")
+                this.spillQueued = false;
+            this.fail(operation, this.dir, cause, 0);
+        })
+            .finally(() => {
+            this.queued--;
+        });
+    }
+    /** Creates the private epoch directory once; a refusal or failure halts spilling and is reported. */
+    ensureDir(retained) {
+        this.dirReady ??= createSpoolDir(this.dir).then((token) => {
+            this.spoolToken = token;
+            return this.dir;
+        }, (cause) => {
+            this.fail("spool_create", this.dir, cause, retained);
+            return undefined;
+        });
+        return this.dirReady;
+    }
+    readFailure(operation, path, cause) {
+        this.fail(operation, path, cause, 0);
+        return new CompactStorageReadError(operation, path, cause);
+    }
+    fail(operation, path, cause, retained) {
+        if (operation === "spill_write" || operation === "spool_create")
+            this.halted = true;
+        this.record({ operation, path, cause: describeCause(cause), retainedInMemoryBytes: retained });
+    }
+    record(failure) {
+        this.failures.push(failure);
+        if (this.failures.length > FAILURE_HISTORY)
+            this.failures.shift();
+    }
+}
+//# sourceMappingURL=compact-spool-storage.js.map

package/dist/modes/rpc/compact-storage-io.d.ts

@@ -2,7 +2,7 @@
  * The asynchronous file seam of compact current-state storage (senpi#4272) and the failures it
  * reports. Every spool access goes through `CompactStorageIo`; nothing here blocks the host loop.
  */
-export type CompactStorageOperation = "spool_create" | "spill_write" | "leaf_read" | "reclaim";
+export type CompactStorageOperation = "spool_create" | "spill_write" | "page_write" | "leaf_read" | "page_read" | "reclaim";
 export interface CompactStorageFailure {
     readonly operation: CompactStorageOperation;
     readonly path: string;
@@ -17,6 +17,7 @@ export interface CompactStorageIo {
     unlink(path: string): Promise<void>;
 }
 export declare const nodeCompactStorageIo: CompactStorageIo;
+/** Never throws: a host-supplied cause that cannot be described must not abort the failure report. */
 export declare function describeCause(cause: unknown): string;
 /** Committed storage that can no longer be read: a real error, never empty content. */
 export declare class CompactStorageReadError extends Error {

package/dist/modes/rpc/compact-storage-io.js

@@ -4,8 +4,14 @@ export const nodeCompactStorageIo = {
     readFile: (path) => readFile(path),
     unlink: (path) => unlink(path),
 };
+/** Never throws: a host-supplied cause that cannot be described must not abort the failure report. */
 export function describeCause(cause) {
-    return cause instanceof Error ? cause.message : String(cause);
+    try {
+        return cause instanceof Error ? cause.message : String(cause);
+    }
+    catch {
+        return "unprintable failure cause";
+    }
 }
 /** Committed storage that can no longer be read: a real error, never empty content. */
 export class CompactStorageReadError extends Error {

package/dist/modes/rpc/compact-text-roots.d.ts

@@ -0,0 +1,22 @@
+import { type CompactContentStore, type LeafId } from "./compact-content-store.ts";
+/** Persistent append tree: positive refs are leaves, negative refs are nodes, zero is empty. */
+export declare class CompactTextRoots {
+    private readonly nodes;
+    private readonly pending;
+    private readonly store;
+    private next;
+    constructor(store: CompactContentStore);
+    get residentNodes(): number;
+    units(id: LeafId): number;
+    isCommitted(id: LeafId): boolean;
+    /** Transfers one live root and one newly owned bounded leaf into the new root. */
+    append(root: LeafId, text: string): LeafId;
+    adjust(id: LeafId, live: number, pins: number): void;
+    /** Bounded UTF-16 result and bounded leaf/tail count, checked before any I/O. */
+    read(root: LeafId, tail: string, offset: number, units: number, maxLeaves?: number, valid?: () => void): Promise<string>;
+    private node;
+    private appendLeaf;
+    private height;
+    private join;
+}
+//# sourceMappingURL=compact-text-roots.d.ts.map

package/dist/modes/rpc/compact-text-roots.js

@@ -0,0 +1,138 @@
+import { CompactCommitDependencies } from "./compact-commit-dependencies.js";
+import { COMPACT_LEAF_CODE_UNITS } from "./compact-content-store.js";
+import { CompactReadError } from "./compact-read-lease.js";
+/** Persistent append tree: positive refs are leaves, negative refs are nodes, zero is empty. */
+export class CompactTextRoots {
+    constructor(store) {
+        this.nodes = new Map();
+        this.next = -1;
+        this.store = store;
+        this.pending = new CompactCommitDependencies(store, (id) => store.committed(id));
+    }
+    get residentNodes() {
+        return this.nodes.size;
+    }
+    units(id) {
+        return id === 0 ? 0 : id > 0 ? this.store.leafUnits(id) : this.node(id).units;
+    }
+    isCommitted(id) {
+        return this.nodes.has(id) && !this.pending.has(id);
+    }
+    /** Transfers one live root and one newly owned bounded leaf into the new root. */
+    append(root, text) {
+        this.units(root);
+        const leaf = this.store.createLeaf(text);
+        if (root === 0)
+            return leaf;
+        const result = this.appendLeaf(root, leaf);
+        this.store.adjust(root, -1, 0);
+        this.store.adjust(leaf, -1, 0);
+        return result;
+    }
+    adjust(id, live, pins) {
+        const node = this.node(id);
+        const beforeLive = Number(node.live > 0);
+        const beforePin = Number(node.live === 0 && node.pins > 0);
+        if (node.live + live < 0 || node.pins + pins < 0)
+            throw new CompactReadError("ownership");
+        node.live += live;
+        node.pins += pins;
+        const liveChange = Number(node.live > 0) - beforeLive;
+        const pinChange = Number(node.live === 0 && node.pins > 0) - beforePin;
+        // Extra cuts on a live subtree do not visit children. Only category transitions propagate.
+        if (liveChange || pinChange) {
+            this.store.adjust(node.left, liveChange, pinChange);
+            this.store.adjust(node.right, liveChange, pinChange);
+        }
+        if (node.live === 0 && node.pins === 0) {
+            this.pending.delete(id);
+            this.nodes.delete(id);
+        }
+    }
+    /** Bounded UTF-16 result and bounded leaf/tail count, checked before any I/O. */
+    async read(root, tail, offset, units, maxLeaves = 2, valid = () => this.store.assertReadable()) {
+        this.store.assertReadable();
+        valid();
+        const length = this.units(root);
+        if (!Number.isSafeInteger(offset) ||
+            !Number.isSafeInteger(units) ||
+            offset < 0 ||
+            units < 0 ||
+            offset + units > length + tail.length)
+            throw new CompactReadError("range");
+        if (units > COMPACT_LEAF_CODE_UNITS)
+            throw new CompactReadError("size_limit");
+        if (!Number.isSafeInteger(maxLeaves) || maxLeaves < 1 || maxLeaves > 2)
+            throw new CompactReadError("count_limit");
+        const selected = [];
+        const visit = (id, start, end) => {
+            if (start >= end || id === 0)
+                return;
+            if (id > 0) {
+                if (selected.length === maxLeaves)
+                    throw new CompactReadError("count_limit");
+                selected.push({ id, offset: start, units: end - start });
+            }
+            else {
+                const node = this.node(id);
+                const leftUnits = this.units(node.left);
+                visit(node.left, start, Math.min(end, leftUnits));
+                visit(node.right, Math.max(0, start - leftUnits), end - leftUnits);
+            }
+        };
+        visit(root, offset, Math.min(length, offset + units));
+        const tailUnits = units === 0 ? 0 : Math.max(0, offset + units - Math.max(offset, length));
+        if (selected.length + Number(tailUnits > 0) > maxLeaves)
+            throw new CompactReadError("count_limit");
+        this.store.adjust(root, 0, 1);
+        const done = this.store.beginRead();
+        try {
+            let result = "";
+            for (const part of selected) {
+                const text = await this.store.readLeaf(part.id);
+                valid();
+                result += text.slice(part.offset, part.offset + part.units);
+            }
+            valid();
+            return result + tail.slice(Math.max(0, offset - length), Math.max(0, offset - length) + tailUnits);
+        }
+        finally {
+            this.store.adjust(root, 0, -1);
+            done();
+        }
+    }
+    node(id) {
+        const node = this.nodes.get(id);
+        if (!node)
+            throw new CompactReadError("ownership");
+        return node;
+    }
+    appendLeaf(root, leaf) {
+        const node = this.nodes.get(root);
+        if (!node || this.height(node.left) === this.height(node.right))
+            return this.join(root, leaf);
+        const right = this.appendLeaf(node.right, leaf);
+        const result = this.join(node.left, right);
+        this.store.adjust(right, -1, 0);
+        return result;
+    }
+    height(id) {
+        return id > 0 ? 0 : this.node(id).height;
+    }
+    join(left, right) {
+        const id = this.next--;
+        this.nodes.set(id, {
+            left,
+            right,
+            units: this.units(left) + this.units(right),
+            height: 1 + Math.max(this.height(left), this.height(right)),
+            live: 1,
+            pins: 0,
+        });
+        this.store.adjust(left, 1, 0);
+        this.store.adjust(right, 1, 0);
+        this.pending.set(id, [left, right]);
+        return id;
+    }
+}
+//# sourceMappingURL=compact-text-roots.js.map

package/dist/modes/rpc/compact-text-view.d.ts

@@ -0,0 +1,22 @@
+import { type LeafId } from "./compact-content-store.ts";
+import type { CompactTextRoots } from "./compact-text-roots.ts";
+import type { CompactBlockKind, CompactPersistence } from "./compact-transition.ts";
+export interface FrozenBlock {
+    readonly contentIndex: number;
+    readonly kind: CompactBlockKind;
+    readonly root: LeafId;
+    /** A cut shares the immutable tail (under one leaf), not a new leaf for each freeze. */
+    readonly tail: string;
+}
+export interface CompactMessageView {
+    readonly messageId: string;
+    readonly persistence: CompactPersistence | undefined;
+    readonly blocks: readonly {
+        readonly contentIndex: number;
+        readonly kind: CompactBlockKind;
+        readonly text: string;
+    }[];
+}
+/** Compatibility assembly only; each underlying range is bounded, the resulting legacy view is not. */
+export declare function readCompactBlocks(texts: CompactTextRoots, blocks: readonly FrozenBlock[], valid: () => void): Promise<CompactMessageView["blocks"]>;
+//# sourceMappingURL=compact-text-view.d.ts.map

package/dist/modes/rpc/compact-text-view.js

@@ -0,0 +1,16 @@
+import { COMPACT_LEAF_CODE_UNITS } from "./compact-content-store.js";
+/** Compatibility assembly only; each underlying range is bounded, the resulting legacy view is not. */
+export async function readCompactBlocks(texts, blocks, valid) {
+    const result = [];
+    for (const { contentIndex, kind, root, tail } of blocks) {
+        valid();
+        const length = texts.units(root) + tail.length;
+        let text = "";
+        for (let offset = 0; offset < length; offset += COMPACT_LEAF_CODE_UNITS) {
+            text += await texts.read(root, tail, offset, Math.min(COMPACT_LEAF_CODE_UNITS, length - offset), 2, valid);
+        }
+        result.push({ contentIndex, kind, text });
+    }
+    return result;
+}
+//# sourceMappingURL=compact-text-view.js.map

package/dist/modes/rpc/compact-transition.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The typed transitions compact current state accepts (senpi#4272, R3.C6.4) and the typed
+ * rejection `CompactSessionState.accept` throws when one fails validation.
+ */
+export type CompactBlockKind = "text" | "thinking" | "tool_arguments";
+export type CompactPersistence = "pending" | "appended" | "failed";
+export interface BlockAddress {
+    readonly messageId: string;
+    readonly contentIndex: number;
+}
+export type CompactTransition = (BlockAddress & {
+    readonly type: "block_start";
+    readonly kind: CompactBlockKind;
+    readonly seed: string;
+    /**
+     * The whole seed when later deltas replay it from offset 0, or 0 when they continue after it. Partial
+     * coverage is refused: the uncovered seed tail would make every later delta overlap or leave a gap.
+     */
+    readonly coveredCodeUnits: number;
+}) | (BlockAddress & {
+    readonly type: "block_delta";
+    readonly offset: number;
+    readonly text: string;
+}) | (BlockAddress & {
+    readonly type: "block_replace";
+    readonly text: string;
+}) | {
+    readonly type: "message_status";
+    readonly messageId: string;
+    readonly persistence: CompactPersistence;
+} | {
+    readonly type: "message_remove";
+    readonly messageId: string;
+};
+type CompactRejection = "unknown_block" | "duplicate_block" | "invalid_coverage" | "non_contiguous" | "conflicting_overlap" | "unknown_message";
+export declare class CompactTransitionError extends Error {
+    readonly reason: CompactRejection;
+    constructor(reason: CompactRejection, detail: string);
+}
+export {};
+//# sourceMappingURL=compact-transition.d.ts.map

package/dist/modes/rpc/compact-transition.js

@@ -0,0 +1,12 @@
+/**
+ * The typed transitions compact current state accepts (senpi#4272, R3.C6.4) and the typed
+ * rejection `CompactSessionState.accept` throws when one fails validation.
+ */
+export class CompactTransitionError extends Error {
+    constructor(reason, detail) {
+        super(`compact transition rejected (${reason}): ${detail}`);
+        this.name = "CompactTransitionError";
+        this.reason = reason;
+    }
+}
+//# sourceMappingURL=compact-transition.js.map

package/dist/modes/rpc/connection-handler.d.ts

@@ -50,6 +50,8 @@ export interface RpcConnectionSink {
     writeRaw(chunk: string): void;
     /** Shared bindings accept correlated records synchronously, before JSONL buffering. */
     writeRecord?(record: object): void;
+    /** The internal structured lane (senpi#4272): seeded records and block controls, never a legacy destination. */
+    writeStructured?(record: object): void;
     waitForBackpressure(): Promise<void>;
     /** Tears the transport down once its event queue can no longer deliver (overflow, write failure). */
     close?(): void;

package/dist/modes/rpc/connection-handler.js

@@ -47,7 +47,7 @@ import { runAbort, runGetEffectStatus, runQueuedInputChange, runSetModel, runSet
 import { EffectLedger } from "./effect-ledger.js";
 import { EFFECT_LEDGER_CAPABILITY } from "./effect-record.js";
 import { createRpcEventOutputBuffer } from "./event-output-buffer.js";
-import { settleExtensionUiResponse } from "./extension-ui-response.js";
+import { answeredUiRequestId, settleExtensionUiResponse } from "./extension-ui-response.js";
 import { answerGetEntries } from "./get-entries-command.js";
 import { runHoldInput } from "./held-input-commands.js";
 import { HostSessionControl } from "./host-session-control.js";
@@ -64,6 +64,7 @@ import { runPauseForRun, runResumeForRun } from "./run-hold-commands.js";
 import { availableModelsData, interruptRunningTurn } from "./session-control-actions-data.js";
 import { SessionExtensionUiRequests, sessionDialogRequests } from "./session-extension-ui-requests.js";
 import { subscribeSessionRecords } from "./session-record-stream.js";
+import { subscribeStructuredSessionRecords } from "./structured-session-records.js";
 import { RpcSessionRelocation } from "./session-relocation.js";
 import { answerHostResponse, isHostResponse, relocationChannel, } from "./session-relocation-channel.js";
 export { buildRpcSessionState } from "./rpc-session-state.js";
@@ -190,6 +191,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     // Set by the first command that asks this session for a turn; `set_retry_fallback` is refused after it.
     let turnRequested = false;
     let unsubscribe;
+    let unsubscribeStructured;
     let unsubscribeBackpressure;
     let unsubscribeLoadedSurfaces;
     let unsubscribeExtensionEvents;
@@ -762,6 +764,10 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             unsubscribe = subscribeSessionRecords(session, outputEvent, (abortSource) => {
                 lastAbortSource = abortSource;
             });
+            unsubscribeStructured?.();
+            unsubscribeStructured = sink.writeStructured
+                ? subscribeStructuredSessionRecords(session, (record) => sink.writeStructured?.(tagSessionRecord(record)))
+                : undefined;
             unsubscribeBackpressure = session.agent.subscribe(async () => {
                 await waitForRpcBackpressure();
             });
@@ -1704,15 +1710,13 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             parsed !== null &&
             "type" in parsed &&
             parsed.type === "extension_ui_response") {
-            if (!options.workerSecurityBridge &&
-                "id" in parsed &&
-                typeof parsed.id === "string" &&
-                grantRequests.has(parsed.id)) {
+            const requestId = answeredUiRequestId(parsed);
+            if (!options.workerSecurityBridge && requestId !== undefined && grantRequests.has(requestId)) {
                 const sender = options.clientInfo?.connectionId();
                 const capable = sender === undefined
                     ? clientCapabilities?.includes("grant_select") === true
                     : options.clientInfo?.hasCapability?.(sender, "grant_select") === true;
-                if (grantRequests.get(parsed.id) !== sender || !capable)
+                if (grantRequests.get(requestId) !== sender || !capable)
                     return;
             }
             const reply = settleExtensionUiResponse(parsed, {
@@ -1767,10 +1771,12 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         pendingExtensionRequests.close();
         unsubscribeProviderAccountEvents();
         unsubscribe?.();
+        unsubscribeStructured?.();
         unsubscribeBackpressure?.();
         unsubscribeLoadedSurfaces?.();
         unsubscribeExtensionEvents?.();
         unsubscribe = undefined;
+        unsubscribeStructured = undefined;
         unsubscribeBackpressure = undefined;
         unsubscribeLoadedSurfaces = undefined;
         unsubscribeExtensionEvents = undefined;

package/dist/modes/rpc/host-ensure-start.js

@@ -16,7 +16,7 @@ import { keepOwnerPipe, OWNER_WATCH_FD } from "./host-lifecycle-launch.js";
 import { pollProtocolInfo } from "./host-readiness.js";
 import { initialHostEnvironment } from "./host-spawn-environment.js";
 import { hostLaunchProfile } from "./protocol-identity.js";
-import { createSocketSecret, socketSecretPath } from "./socket-transport.js";
+import { ensureSocketSecret, socketSecretPath } from "./socket-transport.js";
 import { relayPresenterBootstrap } from "./mcp-presenter-bootstrap.js";
 export const DEFAULT_READINESS_TIMEOUT_MS = 10_000;
 export { DEFAULT_STOP_TIMEOUT_MS };
@@ -38,9 +38,11 @@ export async function startHost(paths, socket, options, generation = 0) {
         reason,
     });
     // The settings file must exist before the supervisor reads it at boot, so it
-    // records the policy before the spawn instead of beside the pidfile.
+    // records the policy before the spawn instead of beside the pidfile. A valid public
+    // secret belongs to the endpoint, not to this start: clients that already read it
+    // derive the pipe name from it, so a start reuses it and never rotates it.
     if (process.platform === "win32")
-        await createSocketSecret(socketSecretPath(socket));
+        await ensureSocketSecret(socketSecretPath(socket));
     await writeHostSettings(paths, {
         socket,
         capabilities: PINNED_HOST_CLIENT_CAPABILITIES,

package/dist/modes/rpc/security-presentations.js

@@ -109,7 +109,8 @@ export class RpcSecurityPresentations {
         if (pending.connection !== connection ||
             (connection !== undefined && !this.fanout.connectionHas(connection, "grant_select")))
             return false;
-        state?.grants.delete(requestId);
+        // The entry stays until the worker reports the grant settled (settleGrant): a frame the worker
+        // refuses leaves the grant pending, and it must stay answerable only by its recipient.
         return true;
     }
     settleGrant(sessionId, requestId) {

package/dist/modes/rpc/session-binding.js

@@ -1,6 +1,7 @@
 import { bindToProviderScope, runWithProviderScope } from "@earendil-works/pi-ai/node/provider-scope";
 import { createRpcConnectionHandler, } from "./connection-handler.js";
 import { createToolAttributionSpans } from "./session-attribution.js";
+import { structuredLaneEnabled } from "./structured-session-records.js";
 /**
  * Creates the extension UI bridge and subscriptions within the entry's provider
  * scope. The classic handler remains the single source of command semantics.
@@ -54,8 +55,17 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
                 return dropAfterClose();
             writeInScope(record);
         };
+        const writeStructuredInScope = bindToProviderScope((record) => writer.structuredLanes.accept(sessionId, record));
         const taggedSink = {
             writeRecord,
+            ...(structuredLaneEnabled()
+                ? {
+                    writeStructured: (record) => {
+                        if (entry.scope.state !== "closed")
+                            writeStructuredInScope(record);
+                    },
+                }
+                : {}),
             // A late raw reply after the scope closed is dropped like any record (senpi#2871); while the scope is
             // open, records arrive only through writeRecord, so a raw write is a wiring bug.
             writeRaw: () => {

package/dist/modes/rpc/session-event-writer.d.ts

@@ -2,6 +2,7 @@ import type { ExtensionUIContext, SessionKind } from "../../core/extensions/type
 import { type McpFormBinding } from "../../core/mcp-form-types.ts";
 import { McpPresenterAuthority, type McpPresenterConnection } from "./mcp-presenter-authority.ts";
 import type { SecurityNoticeSnapshot, SecurityNoticeState } from "../../core/security-notices.ts";
+import { SessionStructuredLanes } from "./session-structured-lanes.ts";
 import { type MediaPersister } from "./media-placeholders.ts";
 import type { RpcHostLifecycleEvent, RpcOpenQueuedEvent, RpcSessionClosedEvent, RpcSessionClosedReason, RpcSessionParkedEvent } from "./rpc-types.ts";
 import { type SessionEventWriterConnection } from "./session-event-fanout.ts";
@@ -23,6 +24,7 @@ export declare const MAX_SHARED_STDIO_QUEUE_RECORDS = 4096;
  * scheduling boundary and violate D9.
  */
 export declare class SessionEventWriter {
+    readonly structuredLanes: SessionStructuredLanes;
     private presenterAuthority?;
     private readonly presenterConnections;
     private readonly presenterBindings;

package/dist/modes/rpc/session-event-writer.js

@@ -3,6 +3,7 @@ import { bindPrivateMcpForms } from "../../core/mcp-form-types.js";
 import { McpPresenterAuthority } from "./mcp-presenter-authority.js";
 import { MEDIA_PLACEHOLDERS_CAPABILITY } from "./custom-capability.js";
 import { normalizeJsonValue } from "./json-normal-value.js";
+import { SessionStructuredLanes } from "./session-structured-lanes.js";
 import { serializeJsonLine } from "./jsonl.js";
 import { omitNormalInlineMedia } from "./media-placeholders.js";
 import { RpcSecurityPresentations } from "./security-presentations.js";
@@ -141,6 +142,7 @@ export class SessionEventWriter {
         return this.reservedCloseBytes;
     }
     constructor(writeRaw, waitOrSchedule, scheduleFlush) {
+        this.structuredLanes = new SessionStructuredLanes();
         this.presenterConnections = new Map();
         this.presenterBindings = new Map();
         this.records = new SessionRecordAccounting();