@code-yeongyu/senpi 2026.11.2-1 → 2026.11.2-2

package/dist/modes/rpc/compact-session-calls.js

@@ -110,24 +110,23 @@ export class CompactSessionCalls {
             raw: call.raw?.kind === "owned" ? call.raw : raw,
         });
     }
+    /** Each per-id execution record returns the call it changed (RULING-123), undefined when it changed none. */
     executionStart(step, start) {
         const turnId = step.scope.turnId;
         if (turnId === null)
-            return;
+            return undefined;
         const started = {
             startSequence: step.sequence,
             startedAtMs: Date.now(),
             resolvedName: start.toolName,
         };
         const announced = this.table.oldestById(start.toolCallId, turnId, awaitingStart);
-        if (announced) {
-            this.update(step, announced, {
+        if (announced)
+            return this.update(step, announced, {
                 ...started,
                 phase: "executing",
                 input: { ...announced.input, started: start.args },
             });
-            return;
-        }
         const existing = this.table.byTurnId(turnId, start.toolCallId);
         if (existing)
             this.table.counters.reused++;
@@ -142,6 +141,7 @@ export class CompactSessionCalls {
         });
         if (existing)
             this.table.repoint(turnId, start.toolCallId, created.runtimeItemKey);
+        return created;
     }
     executionUpdate(step, toolCallId, args, partialResult) {
         const call = this.resolve(step, toolCallId, executing);
@@ -154,6 +154,7 @@ export class CompactSessionCalls {
         if (call.input.prepared === null)
             this.update(step, progressed, { input: { ...call.input, prepared: args } });
         this.sequence = step.sequence;
+        return progressed;
     }
     hook(step, toolCallId, record) {
         const call = this.resolve(step, toolCallId, stillOpen);
@@ -161,8 +162,9 @@ export class CompactSessionCalls {
             return this.ignore("unknown");
         if (terminal(call))
             return this.ignore("late");
-        this.table.replaceSlot(call, "hook", record);
+        const hooked = this.table.replaceSlot(call, "hook", record);
         this.sequence = step.sequence;
+        return hooked;
     }
     /** An end closes the oldest call still open under its id (senpi#4278); with none open it may replace an abandoned one. */
     executionEnd(step, toolCallId, result, isError) {
@@ -172,7 +174,7 @@ export class CompactSessionCalls {
         if (terminal(call) && call.outcome?.kind !== "abandoned")
             return this.ignore("late");
         const ended = this.table.replaceSlot(call, "result", result);
-        this.update(step, ended, {
+        return this.update(step, ended, {
             phase: TERMINAL_PHASE,
             outcome: { kind: "result", isError, source: "execution_end" },
             join: orphaned(this.table, call) || call.join === "carrierless" ? "carrierless" : "pending",
@@ -226,6 +228,7 @@ export class CompactSessionCalls {
     }
     ignore(kind) {
         this.table.counters[kind]++;
+        return undefined;
     }
     create(step, fields) {
         if (this.mintedAt !== step.sequence) {
@@ -245,8 +248,10 @@ export class CompactSessionCalls {
         return call;
     }
     update(step, call, patch) {
-        this.table.put({ ...call, ...patch }, creationOf(call));
+        const next = { ...call, ...patch };
+        this.table.put(next, creationOf(call));
         this.sequence = step.sequence;
+        return next;
     }
 }
 //# sourceMappingURL=compact-session-calls.js.map

package/dist/modes/rpc/compact-session-state.d.ts

@@ -24,6 +24,8 @@ export declare class CompactSessionState extends CompactActiveMessages {
     accept(t: CompactTransition, sequence?: number, turnId?: string | null): number;
     /** A call record at its lane step; `changed` is false when the record is ignored and takes no sequence (Q9). */
     acceptCall(record: object, sequence: number, turnId: string | null): CallFold;
+    /** The outstanding call whose block this is: the call a `toolcall_*` update streams (RULING-123), by the table's index. */
+    callOwning(messageId: string, contentIndex: number): import("./compact-call-model.ts").OutstandingCall | undefined;
     applyCold(t: CompactColdOperation): Promise<import("./compact-cold-operations.ts").CompactColdOutcome>;
     /** One ordered cold unit per flow: its operations run back to back after acceptance, each with its outcome. */
     applyColdFlow(flow: CompactColdFlow): Promise<readonly import("./compact-cold-operations.ts").CompactColdOutcome[]>;

package/dist/modes/rpc/compact-session-state.js

@@ -182,6 +182,10 @@ export class CompactSessionState extends CompactActiveMessages {
             this.sequence = sequence;
         return fold;
     }
+    /** The outstanding call whose block this is: the call a `toolcall_*` update streams (RULING-123), by the table's index. */
+    callOwning(messageId, contentIndex) {
+        return this.calls.table.byOwner(messageId, contentIndex);
+    }
     applyCold(t) {
         return this.cold.run(t, this.sequence);
     }

package/dist/modes/rpc/compact-settled-messages.d.ts

@@ -1,6 +1,7 @@
 import type { RecoveryCarrier } from "../../core/session-recovery-identity.ts";
 import type { TranscriptTransition } from "../../core/session-transcript-journal.ts";
 import type { CallProjection } from "./compact-call-model.ts";
+import type { SettledEnd } from "./compact-message-identity.ts";
 import { type FrozenIndex } from "./compact-content-index.ts";
 import { CompactContentStore, type CompactContentStoreOptions, type LeafId } from "./compact-content-store.ts";
 import type { CompactValues, ValueRef } from "./compact-values.ts";
@@ -69,17 +70,24 @@ export declare class CompactSettledMessages {
     reader(root: SettledRoot): SettledReader;
     valid(carrier: RecoveryCarrier | undefined): carrier is RecoveryCarrier;
     /**
-     * Returns whether this end joined the message to its durable entry: the only end that settles persistence. `call`:
+     * Returns the accepted end (undefined when refused): whether it joined the message to its durable entry, the only end
+     * that settles persistence, and the message's settled ids (RULING-120): its `messageId` and the end's accepted sequence as
+     * `terminalSequence`, which a pending or failed terminal pages as `message-<terminalSequence>` and a joined message
+     * pages only through its `join-<n>` member's `messageId` (an already-joined end writes no terminal row). `call`:
      * the projection of the outstanding call this toolResult settles, stored with the terminal (Q2). The terminal is
      * serialized from `record`, so a record over the protocol depth limit is refused typed before anything changes
      * (RULING-59 C); the lane runs that check, and counts the refusal, before it calls this.
      */
-    end(record: object, carrier: RecoveryCarrier | undefined, sequence: number, turnId: string | null, call?: CallProjection): boolean;
+    end(record: object, carrier: RecoveryCarrier | undefined, sequence: number, turnId: string | null, call?: CallProjection): SettledEnd | undefined;
     private reject;
-    fail(carrier: RecoveryCarrier | undefined, errorMessage: string): void;
+    /** Marks the message's pending terminal failed; returns the `messageId` that row carries, undefined for none. */
+    fail(carrier: RecoveryCarrier | undefined, errorMessage: string): {
+        readonly messageId: string;
+    } | undefined;
+    /** Joins an owned append to its message; returns that message's id, the `messageId` of the join member it made. */
     append(transition: Extract<TranscriptTransition, {
         kind: "append";
-    }>): void;
+    }>): string | undefined;
     private join;
     /** Ended and joined: its rows stay paged; its end marker folds into its join, its entry stays claimed. */
     private settle;

package/dist/modes/rpc/compact-settled-messages.js

@@ -34,7 +34,10 @@ export class CompactSettledMessages {
         return carrier !== undefined && carrier.epoch === this.epoch;
     }
     /**
-     * Returns whether this end joined the message to its durable entry: the only end that settles persistence. `call`:
+     * Returns the accepted end (undefined when refused): whether it joined the message to its durable entry, the only end
+     * that settles persistence, and the message's settled ids (RULING-120): its `messageId` and the end's accepted sequence as
+     * `terminalSequence`, which a pending or failed terminal pages as `message-<terminalSequence>` and a joined message
+     * pages only through its `join-<n>` member's `messageId` (an already-joined end writes no terminal row). `call`:
      * the projection of the outstanding call this toolResult settles, stored with the terminal (Q2). The terminal is
      * serialized from `record`, so a record over the protocol depth limit is refused typed before anything changes
      * (RULING-59 C); the lane runs that check, and counts the refusal, before it calls this.
@@ -43,7 +46,8 @@ export class CompactSettledMessages {
         assertProtocolDepth(record);
         if (!this.valid(carrier))
             return this.reject("unknown_message");
-        const id = carrier.messageId;
+        const identity = { messageId: carrier.messageId, terminalSequence: sequence };
+        const id = identity.messageId;
         if (this.keys.has(`end:${id}`) || this.keys.has(`settled:${id}`))
             return this.reject("duplicate_end");
         const owned = this.keys.get(`owner:${id}`);
@@ -58,7 +62,7 @@ export class CompactSettledMessages {
         }
         if (this.keys.has(`owner:${id}`)) {
             this.settle(id);
-            return joined;
+            return { joined, identity };
         }
         // The call projection is owned first: a refusal there leaves no payload leaf and no end marker behind.
         const projection = call ? this.rows.values.own(call) : null;
@@ -80,7 +84,7 @@ export class CompactSettledMessages {
             kind: "terminal",
             messageId: id,
             turnId,
-            terminalSequence: sequence,
+            terminalSequence: identity.terminalSequence,
             role,
             runtimeItemKey: call?.runtimeItemKey ?? null,
             entryId: null,
@@ -95,26 +99,30 @@ export class CompactSettledMessages {
             this.store.adjust(projection.owner, -1, 0);
         if (!["user", "assistant", "toolResult", "custom"].includes(role))
             this.diagnose("unsupported_role");
-        return false;
+        return { joined: false, identity };
     }
     reject(reason) {
         this.diagnose(reason);
-        return false;
+        return undefined;
     }
+    /** Marks the message's pending terminal failed; returns the `messageId` that row carries, undefined for none. */
     fail(carrier, errorMessage) {
         if (!this.valid(carrier) || !this.keys.has(`terminal:${carrier.messageId}`))
-            return this.diagnose("unknown_message");
+            return this.reject("unknown_message");
         this.rows.patch(`terminal:${carrier.messageId}`, { status: "failed", error: { errorMessage } });
+        return { messageId: carrier.messageId };
     }
+    /** Joins an owned append to its message; returns that message's id, the `messageId` of the join member it made. */
     append(transition) {
         const id = transition.owningMessageId;
         if (id === undefined)
-            return;
+            return undefined;
         if (transition.recoveryEpoch !== this.epoch)
-            return this.diagnose("retired_owner");
+            return this.reject("retired_owner");
         if (this.keys.has(`owner:${id}`) || this.keys.has(`settled:${id}`) || this.keys.has(`entry:${transition.id}`))
-            return this.diagnose("conflicting_owner");
+            return this.reject("conflicting_owner");
         this.join(id, transition.id);
+        return id;
     }
     join(messageId, entryId) {
         const owner = { kind: "owner", messageId, entryId, ordinal: this.joins++ };

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

@@ -339,7 +339,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     const pendingExtensionRequests = new SessionExtensionUiRequests(uiRequestChanged);
     const grantRequests = new Map();
     sessionDialogRequests.set(session, pendingExtensionRequests);
-    const questions = new ConnectionQuestionBridge(output, uiRequestChanged);
+    const questions = new ConnectionQuestionBridge(output, uiRequestChanged, () => options.clientInfo?.connectionId());
     let secretHandshake = false;
     const secretOwners = new Map();
     const secretCapable = (connection) => connectionRoles.has(connection, INTERACTIVE_USER_CAPABILITY) &&

package/dist/modes/rpc/connection-question-bridge.d.ts

@@ -8,7 +8,8 @@ export declare class ConnectionQuestionBridge {
     private readonly resolved;
     private readonly output;
     private readonly changed;
-    constructor(output: (record: object) => void, changed?: (change?: UiRequestChange) => void);
+    private readonly raiser;
+    constructor(output: (record: object) => void, changed?: (change?: UiRequestChange) => void, raiser?: () => string | undefined);
     pendingQuestions(): RpcQuestionUiRequest[];
     ask(request: QuestionRequest, opts?: Options): Promise<QuestionResponse>;
     respond(response: RpcExtensionUIResponse, beforeAnswer?: () => void): boolean | "question_incomplete" | "question_already_resolved";

package/dist/modes/rpc/connection-question-bridge.js

@@ -1,11 +1,12 @@
 import { settledQuestionStatus, unansweredQuestionIds } from "./extension-ui-response.js";
 export const sessionQuestionBridges = new WeakMap();
 export class ConnectionQuestionBridge {
-    constructor(output, changed) {
+    constructor(output, changed, raiser = () => undefined) {
         this.pending = new Map();
         this.resolved = new Set();
         this.output = output;
         this.changed = changed;
+        this.raiser = raiser;
     }
     pendingQuestions() {
         return [...this.pending.values()].map(({ frame }) => ({
@@ -25,6 +26,7 @@ export class ConnectionQuestionBridge {
             toolCallId: request.requestId,
             waitForAnswer: request.waitForAnswer,
             questions: request.questions,
+            raisedBy: this.raiser() ?? "agent",
             timeout,
             askedAtMs,
             deadlineAtMs: askedAtMs + timeout,

package/dist/modes/rpc/host-lifecycle-proxy.d.ts

@@ -42,6 +42,15 @@ export interface PrepareSocketPathHooks {
     /** Replaces the listener probe, so a test can pin each verdict. */
     readonly listenerState?: (socketPath: string) => Promise<ListenerState>;
 }
+/**
+ * Frees `socketPath` for this process's bind, removing only a dead socket entry and refusing everything else
+ * (#5314). No portable fd-based check exists for a socket entry: `open()` fails on one (ENXIO on Linux,
+ * EOPNOTSUPP on macOS), `O_PATH` is Linux-only, and there is no unlink-by-fd. So every read is `lstat`, which
+ * never follows a link, and `unlink(2)` removes the name, never a link's target. The entry is re-stamped before
+ * the second reachability probe (which must not be steered through a swapped-in link) and again as the last step
+ * before the unlink; reachability is re-checked after the decision because a socket bound earlier can start
+ * listening without changing identity.
+ */
 export declare function prepareSocketPath(socketPath: string, hooks?: PrepareSocketPathHooks): Promise<void>;
 export declare function listen(server: Server, socketPath: string, secret?: Uint8Array): Promise<void>;
 export declare function closeServer(server: Server): Promise<void>;

package/dist/modes/rpc/host-lifecycle-proxy.js

@@ -3,7 +3,7 @@
  * adoption of the public name, and the readiness probes of the private hop. Split out of
  * `host-lifecycle.ts`, which keeps the supervisor's orchestration (senpi#2566).
  */
-import { chmod, mkdir, stat, unlink } from "node:fs/promises";
+import { chmod, lstat, mkdir, unlink } from "node:fs/promises";
 import { createConnection, createServer } from "node:net";
 import { dirname } from "node:path";
 import { proxyWithAdmission } from "./host-admission-proxy.js";
@@ -166,7 +166,7 @@ async function canConnect(socketPath, secret, internalKey, probeMs) {
 }
 async function stampOf(socketPath) {
     try {
-        const entry = await stat(socketPath, { bigint: true });
+        const entry = await lstat(socketPath, { bigint: true });
         return { dev: entry.dev, ino: entry.ino, ctimeNs: entry.ctimeNs, socket: entry.isSocket() };
     }
     catch (cause) {
@@ -176,6 +176,15 @@ async function stampOf(socketPath) {
     }
 }
 const sameStamp = (a, b) => a.dev === b.dev && a.ino === b.ino && a.ctimeNs === b.ctimeNs;
+/**
+ * Frees `socketPath` for this process's bind, removing only a dead socket entry and refusing everything else
+ * (#5314). No portable fd-based check exists for a socket entry: `open()` fails on one (ENXIO on Linux,
+ * EOPNOTSUPP on macOS), `O_PATH` is Linux-only, and there is no unlink-by-fd. So every read is `lstat`, which
+ * never follows a link, and `unlink(2)` removes the name, never a link's target. The entry is re-stamped before
+ * the second reachability probe (which must not be steered through a swapped-in link) and again as the last step
+ * before the unlink; reachability is re-checked after the decision because a socket bound earlier can start
+ * listening without changing identity.
+ */
 export async function prepareSocketPath(socketPath, hooks = {}) {
     if (process.platform === "win32" || socketPath.startsWith("\0"))
         return;
@@ -192,18 +201,31 @@ export async function prepareSocketPath(socketPath, hooks = {}) {
     // Linux refuses a connect to a regular file too; never remove what is not a socket.
     if (!probed.socket)
         throw inUse("the entry is not a socket");
-    const state = await (hooks.listenerState ?? socketEntryListenerState)(socketPath);
+    const probe = hooks.listenerState ?? socketEntryListenerState;
+    const state = await probe(socketPath);
     if (state.verdict === "gone")
         return;
     if (state.verdict === "live")
         throw inUse(state.evidence);
     await hooks.afterStaleProbe?.();
     // Something may have replaced the entry since the probe; unlink only the entry probed dead.
-    const current = await stampOf(socketPath);
-    if (current === undefined)
+    const unchanged = async () => {
+        const current = await stampOf(socketPath);
+        if (current === undefined)
+            return false;
+        if (!sameStamp(probed, current))
+            throw inUse("the entry changed after it was probed");
+        return true;
+    };
+    if (!(await unchanged()))
+        return;
+    const again = await probe(socketPath);
+    if (again.verdict === "gone")
+        return;
+    if (again.verdict === "live")
+        throw inUse(again.evidence);
+    if (!(await unchanged()))
         return;
-    if (!sameStamp(probed, current))
-        throw inUse("the entry changed after it was probed");
     try {
         await unlink(socketPath);
     }

package/dist/modes/rpc/rpc-question-types.d.ts

@@ -23,6 +23,8 @@ export type RpcQuestionUiRequest = {
     toolCallId: string;
     waitForAnswer: boolean;
     questions: RpcQuestionSpec[];
+    /** The connection whose command raised the question, or `"agent"` when no connection's command was dispatching. */
+    raisedBy?: string;
     timeout: number;
     askedAtMs: number;
     deadlineAtMs: number;

package/dist/modes/rpc/session-acceptance-compact.d.ts

@@ -1,8 +1,9 @@
 import type { RecoveryCarrier } from "../../core/session-recovery-identity.ts";
 import type { TranscriptTransition } from "../../core/session-transcript-journal.ts";
-import type { CallProjection } from "./compact-call-model.ts";
+import type { CallFold } from "./compact-call-fold.ts";
 import type { CompactLaneCurrent } from "./compact-lane-current.ts";
 import type { CanonicalUnit } from "./compact-lane-transitions.ts";
+import type { LiveIdentity } from "./compact-message-identity.ts";
 import type { CompactSettledMessages } from "./compact-settled-messages.ts";
 /** The compact components one lane epoch feeds: its settled terminals and its current state. */
 export interface CompactComponents {
@@ -16,14 +17,23 @@ export interface AcceptedRecord {
     readonly canonical: CanonicalUnit | undefined;
     readonly sequence: number;
     readonly turnId: string | null;
-    /** The projection of the outstanding call a toolResult terminal settles (RULING-13 Q2), stored with it. */
-    readonly call?: CallProjection | undefined;
+    /**
+     * The call fold of a call record: the projection of the outstanding call a toolResult terminal settles (RULING-13 Q2),
+     * stored with it, and the call an execution or hook record changed (RULING-123).
+     */
+    readonly call?: CallFold | undefined;
 }
-/** One accepted transcript transition: its owned join, then the cold flow and persistence it carries. */
-export declare function foldCompactTransition({ settled, current }: CompactComponents, transition: TranscriptTransition, transcriptAvailable: boolean, epoch: string): void;
+/**
+ * One accepted transcript transition: its owned join, then the cold flow and persistence it carries. Returns the
+ * message an append joined, the id its `join-<n>` member records.
+ */
+export declare function foldCompactTransition({ settled, current }: CompactComponents, transition: TranscriptTransition, transcriptAvailable: boolean, epoch: string): string | undefined;
 /**
  * The compact side of one accepted record: canonical and component folds, its terminal, its persistence. The call
- * records fold before the lane commits this sequence (RULING-13 Q9), so they are not here.
+ * records fold before the lane commits this sequence (RULING-13 Q9), so they are not here. Returns the identity the
+ * settled store recorded for this record's message (RULING-120), or the call a live call record belongs to: the one its
+ * fold changed, or for a `toolcall_*` update the call owning the streamed block once it folded (RULING-123); undefined
+ * when there is none.
  */
-export declare function foldCompactRecord({ settled, current }: CompactComponents, { record, type, carrier, canonical, sequence, turnId, call }: AcceptedRecord): void;
+export declare function foldCompactRecord({ settled, current }: CompactComponents, { record, type, carrier, canonical, sequence, turnId, call }: AcceptedRecord): LiveIdentity | undefined;
 //# sourceMappingURL=session-acceptance-compact.d.ts.map

package/dist/modes/rpc/session-acceptance-compact.js

@@ -1,25 +1,37 @@
+import { toolcallIndex } from "./compact-call-identity.js";
+import { callIdentity } from "./compact-call-model.js";
 import { COMPONENT_RECORDS } from "./compact-current-components.js";
-/** One accepted transcript transition: its owned join, then the cold flow and persistence it carries. */
+/**
+ * One accepted transcript transition: its owned join, then the cold flow and persistence it carries. Returns the
+ * message an append joined, the id its `join-<n>` member records.
+ */
 export function foldCompactTransition({ settled, current }, transition, transcriptAvailable, epoch) {
-    if (transition.kind === "append" && transcriptAvailable)
-        settled.append(transition);
+    const owner = transition.kind === "append" && transcriptAvailable ? settled.append(transition) : undefined;
     current.transcript(transition, settled, epoch);
+    return owner;
 }
 /**
  * The compact side of one accepted record: canonical and component folds, its terminal, its persistence. The call
- * records fold before the lane commits this sequence (RULING-13 Q9), so they are not here.
+ * records fold before the lane commits this sequence (RULING-13 Q9), so they are not here. Returns the identity the
+ * settled store recorded for this record's message (RULING-120), or the call a live call record belongs to: the one its
+ * fold changed, or for a `toolcall_*` update the call owning the streamed block once it folded (RULING-123); undefined
+ * when there is none.
  */
 export function foldCompactRecord({ settled, current }, { record, type, carrier, canonical, sequence, turnId, call }) {
     if (canonical)
         current.fold(canonical, sequence, turnId);
     if (COMPONENT_RECORDS.has(type))
         current.foldComponent(record, sequence);
-    const joined = type === "message_end" && settled.end(record, carrier, sequence, turnId, call);
-    if (type === "transcript_write_failed")
-        settled.fail(carrier, String(Reflect.get(record, "errorMessage")));
+    const ended = type === "message_end" ? settled.end(record, carrier, sequence, turnId, call?.projection) : undefined;
+    const failed = type === "transcript_write_failed"
+        ? settled.fail(carrier, String(Reflect.get(record, "errorMessage")))
+        : undefined;
     // A failed write, or a terminal whose committed entry the lane accepted, settles its compact persistence too.
-    const status = type === "transcript_write_failed" ? "failed" : joined ? "appended" : undefined;
+    const status = type === "transcript_write_failed" ? "failed" : ended?.joined ? "appended" : undefined;
     if (status && settled.valid(carrier))
         current.status(carrier.messageId, status);
+    const block = toolcallIndex(record);
+    const streamed = block !== undefined && carrier ? callIdentity(current.callOwning(carrier.messageId, block)) : undefined;
+    return ended?.identity ?? failed ?? call?.identity ?? streamed;
 }
 //# sourceMappingURL=session-acceptance-compact.js.map

package/dist/modes/rpc/session-acceptance-lane.d.ts

@@ -2,6 +2,7 @@ import type { RecoveryCarrier } from "../../core/session-recovery-identity.ts";
 import type { TranscriptTransition } from "../../core/session-transcript-journal.ts";
 import { type TranscriptRoot } from "./accepted-transcript.ts";
 import type { CanonicalUnit } from "./compact-lane-transitions.ts";
+import { MessageIdentities } from "./compact-message-identity.ts";
 import { type SettledDiagnostic, type SettledRoot } from "./compact-settled-messages.ts";
 import type { FrozenCompactState } from "./compact-state-view.ts";
 import { type CompactContentStoreOptions } from "./compact-content-store.ts";
@@ -59,6 +60,8 @@ export declare class SessionAcceptanceLane extends AcceptedRootReads {
     private turnId;
     private correlation;
     private refusedCorrelations;
+    /** RULING-120 (#5331): the settled ids of the record being delivered, read at `acceptedSequence`. */
+    readonly identities: MessageIdentities;
     private retiredAs;
     private storageRetired;
     private nonce;
@@ -119,6 +122,8 @@ export declare class SessionAcceptanceLane extends AcceptedRootReads {
         allocatedIndexNodes: number;
         residentPages: number;
         peakResidentPages: number;
+        ownerJoinsEvicted: number;
+        ownerJoinsOverflowed: number;
         residentSettledKeys: number;
         refusedRecords: number;
         transcript: import("./compact-transfer-staging.ts").StagingStatus;

package/dist/modes/rpc/session-acceptance-lane.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { AcceptedTranscript } from "./accepted-transcript.js";
+import { MessageIdentities } from "./compact-message-identity.js";
 import { CompactSettledMessages } from "./compact-settled-messages.js";
 import { CompactContentStore } from "./compact-content-store.js";
 import { TransferStaging } from "./compact-transfer-staging.js";
@@ -26,6 +27,8 @@ export class SessionAcceptanceLane extends AcceptedRootReads {
         this.turnId = null;
         this.correlation = null;
         this.refusedCorrelations = 0;
+        /** RULING-120 (#5331): the settled ids of the record being delivered, read at `acceptedSequence`. */
+        this.identities = new MessageIdentities();
         this.storageRetired = false;
         this.nonce = randomUUID();
         this.cleanup = Promise.resolve();
@@ -67,6 +70,7 @@ export class SessionAcceptanceLane extends AcceptedRootReads {
             return;
         if (this.settled)
             this.retireSettled();
+        this.identities.reset();
         this.nonce = nonce;
         if (input.epochSignal)
             Buffer.from(nonce, "ascii").copy(Buffer.from(input.epochSignal));
@@ -98,7 +102,8 @@ export class SessionAcceptanceLane extends AcceptedRootReads {
         for (const transition of transitions) {
             this.sequence += 1;
             this.transcript.apply(transition);
-            foldCompactTransition(this.compact(), transition, this.transcript.available, this.nonce);
+            const owner = foldCompactTransition(this.compact(), transition, this.transcript.available, this.nonce);
+            this.identities.joined(transition, owner);
         }
     }
     /**
@@ -109,6 +114,7 @@ export class SessionAcceptanceLane extends AcceptedRootReads {
      */
     accept(record, carrier, canonical, canonicalRefused = false) {
         const type = field(record, "type");
+        this.identities.clear();
         if (this.retired || this.epoch === "" || typeof type !== "string" || !SEQUENCED.has(type))
             return undefined;
         this.beforeAccept?.(record);
@@ -132,16 +138,9 @@ export class SessionAcceptanceLane extends AcceptedRootReads {
         const messageId = type.startsWith("message_") && this.settled.valid(carrier) ? carrier.messageId : null;
         if (type === "message_start")
             this.activeMessageId = messageId;
-        if (folds)
-            foldCompactRecord(this.compact(), {
-                record,
-                type,
-                carrier,
-                canonical,
-                sequence: this.sequence,
-                turnId,
-                call: call?.projection,
-            });
+        const unit = { record, type, carrier, canonical, sequence: this.sequence, turnId, call };
+        // An unfolded record is still delivered, so its `entry_appended` takes its entry's join (RULING-122).
+        this.identities.hold(type, this.sequence, record, folds ? foldCompactRecord(this.compact(), unit) : undefined);
         if (type === "message_end" && this.activeMessageId === messageId)
             this.activeMessageId = null;
         return {
@@ -203,6 +202,7 @@ export class SessionAcceptanceLane extends AcceptedRootReads {
         return {
             ...this.settled.storageStatus(),
             refusedRecords: this.current.refusedRecords,
+            ...this.identities.status(),
             transcript: this.staging.status(),
         };
     }
@@ -227,6 +227,7 @@ export class SessionAcceptanceLane extends AcceptedRootReads {
      */
     retire(reason, keep = new Set()) {
         this.retiredAs ??= reason;
+        this.identities.reset();
         this.generations.close();
         this.transcript = new AcceptedTranscript(this.staging);
         for (const root of this.live)

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

@@ -20,7 +20,8 @@ export declare abstract class SessionEventWriterDestinations extends SessionEven
      * holds this lane-owned session, becomes an `eventLease` envelope at the record's accepted sequence, its content
      * staged from the line another destination built or else streamed from the record (never one legacy line); every
      * other destination gets the legacy line. Past the peer's lease bound, or when the record cannot be staged, the peer
-     * gets a typed refusal and its connection closes (fail closed, like a plain peer's overflow).
+     * gets a typed refusal and its connection closes (fail closed, like a plain peer's overflow). A stamped copy is
+     * built once per delivery (`copies`), so every compact peer leases the same staged text.
      */
     private eventLine;
 }