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

package/dist/bundle/rpc-entry.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import"./chunks/chunk-QQPZQZAV.js";import{main}from"./chunks/chunk-665UPAKG.js";import"./chunks/chunk-2BTB7AWD.js";import"./chunks/chunk-KEJWNCLN.js";import"./chunks/chunk-AMCDEC5A.js";import"./chunks/chunk-5TG7AOLR.js";import"./chunks/chunk-VRKA3LIT.js";import"./chunks/chunk-C5G5PONA.js";import"./chunks/chunk-OG2JODU6.js";import"./chunks/chunk-HECKLNOO.js";import{configureHttpDispatcher}from"./chunks/chunk-FEQDJBDL.js";import"./chunks/chunk-B255QWLT.js";import"./chunks/chunk-ARNSNIED.js";import"./chunks/chunk-L5OFGHDA.js";import"./chunks/chunk-UURGXV5B.js";import"./chunks/chunk-NEOL3GWO.js";import"./chunks/chunk-J2OBN7TI.js";import"./chunks/chunk-Y4MPEIY5.js";import"./chunks/chunk-ZJSGYBBD.js";import"./chunks/chunk-FOMJ73UU.js";import"./chunks/chunk-VICVLJNU.js";import"./chunks/chunk-PIAY636U.js";import"./chunks/chunk-LGO25HPL.js";import"./chunks/chunk-Y3TMJV3J.js";import"./chunks/chunk-ETCYVVVO.js";import"./chunks/chunk-7ICGN62G.js";import"./chunks/chunk-IBV4OVXQ.js";import"./chunks/chunk-VOSHKGXG.js";import"./chunks/chunk-WEOFT5KT.js";import"./chunks/chunk-QMRJYMNH.js";import"./chunks/chunk-7DWTKE4Z.js";import"./chunks/chunk-ZUVGFXCS.js";import"./chunks/chunk-6LDUM5CL.js";import"./chunks/chunk-FNBEICAA.js";import"./chunks/chunk-SGS76663.js";import"./chunks/chunk-H4QOEVS5.js";import"./chunks/chunk-3CKVTGWG.js";import"./chunks/chunk-PE3PNVKT.js";import"./chunks/chunk-5UVTDRIP.js";import"./chunks/chunk-ZNPH5BWS.js";import"./chunks/chunk-6VWIMHMH.js";import"./chunks/chunk-RQDLTDNO.js";import"./chunks/chunk-KLAX467B.js";import"./chunks/chunk-SAZ6E74O.js";import"./chunks/chunk-F7GBSQRV.js";import"./chunks/chunk-GZVCRV7I.js";import"./chunks/chunk-KUPQO7MC.js";import"./chunks/chunk-U3VOXCGP.js";import"./chunks/chunk-SOMFLLPD.js";import"./chunks/chunk-PZSDJIXD.js";import"./chunks/chunk-26UBFF6N.js";import"./chunks/chunk-MTQQ2VQH.js";import"./chunks/chunk-WEGTCUO3.js";import"./chunks/chunk-GDPWQJDQ.js";import"./chunks/chunk-E6UCZ7E5.js";import"./chunks/chunk-UYO5Z35O.js";import"./chunks/chunk-H52J72VA.js";import"./chunks/chunk-HB35RBP4.js";import"./chunks/chunk-7X72IACK.js";import"./chunks/chunk-YWD54RHU.js";import"./chunks/chunk-C5XX36EB.js";import"./chunks/chunk-IYL5E4QQ.js";import"./chunks/chunk-OEFCY46F.js";import"./chunks/chunk-KRNXUTZJ.js";import"./chunks/chunk-AC72EWI5.js";import"./chunks/chunk-RQFD6LG2.js";import"./chunks/chunk-RPAEB2Z5.js";import"./chunks/chunk-D2ROBVZ4.js";import"./chunks/chunk-CLZLV65G.js";import"./chunks/chunk-YU4AYH4C.js";import"./chunks/chunk-N4TSAHRL.js";import"./chunks/chunk-LNAZ7XEU.js";import"./chunks/chunk-DLAY7CIU.js";import"./chunks/chunk-KKVVSE6C.js";import"./chunks/chunk-COH5F7QV.js";import"./chunks/chunk-RFB5CBW7.js";import"./chunks/chunk-Y7QPP7BG.js";import"./chunks/chunk-4WWORAQH.js";import"./chunks/chunk-GVSBCJFI.js";import"./chunks/chunk-QTS2XGPQ.js";import"./chunks/chunk-TG4E7Z7W.js";import"./chunks/chunk-32R442XT.js";import"./chunks/chunk-WHPDEDCC.js";import"./chunks/chunk-7UC4W2T2.js";import"./chunks/chunk-HK46JMSC.js";import"./chunks/chunk-WBTKUCRH.js";import"./chunks/chunk-WDTJ6JKE.js";import"./chunks/chunk-5ROMKDLK.js";import"./chunks/chunk-3W47LTXQ.js";import"./chunks/chunk-3BJFH3CZ.js";import"./chunks/chunk-3SASTB6Y.js";import"./chunks/chunk-5CSZPC55.js";import"./chunks/chunk-PJ34QVL5.js";import"./chunks/chunk-BMX2U22F.js";import"./chunks/chunk-YU2P3CAR.js";import"./chunks/chunk-XZR4J6HM.js";import"./chunks/chunk-D22YF34L.js";import"./chunks/chunk-ZOFZRJSL.js";import"./chunks/chunk-ZFIC2DZV.js";import"./chunks/chunk-6WISUXVI.js";import"./chunks/chunk-XVRRNJQD.js";import"./chunks/chunk-42XRJQM6.js";import"./chunks/chunk-2SOVDETB.js";import"./chunks/chunk-UKSFF47T.js";import"./chunks/chunk-OM7LH7AP.js";import"./chunks/chunk-QEESHRTS.js";import{APP_NAME,scrubBrandFromEnvironment}from"./chunks/chunk-ISZ4EWIS.js";import"./chunks/chunk-ATQFN5HI.js";import"./chunks/chunk-EYSV6A7S.js";import"./chunks/chunk-MIENF2YK.js";import"./chunks/chunk-OXNWERO4.js";import"./chunks/chunk-QN2BHP3M.js";import"./chunks/chunk-AOTHPTMU.js";import"./chunks/chunk-O5RYI3IW.js";import"./chunks/chunk-IKOFCODM.js";process.title=`${APP_NAME}-rpc`;scrubBrandFromEnvironment();process.env.PI_CODING_AGENT="true";process.env.AI_AGENT=APP_NAME;process.emitWarning=(()=>{});configureHttpDispatcher();main(["--mode","rpc",...process.argv.slice(2)]);
+import"./chunks/chunk-QQPZQZAV.js";import{main}from"./chunks/chunk-H3BTMIH5.js";import"./chunks/chunk-2BTB7AWD.js";import"./chunks/chunk-HUSQY3ID.js";import"./chunks/chunk-B2LRAXQU.js";import"./chunks/chunk-5TG7AOLR.js";import"./chunks/chunk-VRKA3LIT.js";import"./chunks/chunk-C5G5PONA.js";import"./chunks/chunk-OG2JODU6.js";import"./chunks/chunk-HECKLNOO.js";import{configureHttpDispatcher}from"./chunks/chunk-FEQDJBDL.js";import"./chunks/chunk-B255QWLT.js";import"./chunks/chunk-ARNSNIED.js";import"./chunks/chunk-L5OFGHDA.js";import"./chunks/chunk-UURGXV5B.js";import"./chunks/chunk-NEOL3GWO.js";import"./chunks/chunk-J2OBN7TI.js";import"./chunks/chunk-Y4MPEIY5.js";import"./chunks/chunk-ZJSGYBBD.js";import"./chunks/chunk-FOMJ73UU.js";import"./chunks/chunk-VICVLJNU.js";import"./chunks/chunk-PIAY636U.js";import"./chunks/chunk-LGO25HPL.js";import"./chunks/chunk-Y3TMJV3J.js";import"./chunks/chunk-ETCYVVVO.js";import"./chunks/chunk-7ICGN62G.js";import"./chunks/chunk-N6OHYIJR.js";import"./chunks/chunk-VOSHKGXG.js";import"./chunks/chunk-WEOFT5KT.js";import"./chunks/chunk-QMRJYMNH.js";import"./chunks/chunk-7DWTKE4Z.js";import"./chunks/chunk-FVYWSBX3.js";import"./chunks/chunk-6LDUM5CL.js";import"./chunks/chunk-FNBEICAA.js";import"./chunks/chunk-SGS76663.js";import"./chunks/chunk-H4QOEVS5.js";import"./chunks/chunk-3CKVTGWG.js";import"./chunks/chunk-PE3PNVKT.js";import"./chunks/chunk-5UVTDRIP.js";import"./chunks/chunk-ZNPH5BWS.js";import"./chunks/chunk-6VWIMHMH.js";import"./chunks/chunk-RQDLTDNO.js";import"./chunks/chunk-KLAX467B.js";import"./chunks/chunk-SAZ6E74O.js";import"./chunks/chunk-F7GBSQRV.js";import"./chunks/chunk-GZVCRV7I.js";import"./chunks/chunk-KUPQO7MC.js";import"./chunks/chunk-U3VOXCGP.js";import"./chunks/chunk-SOMFLLPD.js";import"./chunks/chunk-PZSDJIXD.js";import"./chunks/chunk-26UBFF6N.js";import"./chunks/chunk-MTQQ2VQH.js";import"./chunks/chunk-WEGTCUO3.js";import"./chunks/chunk-GDPWQJDQ.js";import"./chunks/chunk-E6UCZ7E5.js";import"./chunks/chunk-UYO5Z35O.js";import"./chunks/chunk-H52J72VA.js";import"./chunks/chunk-HB35RBP4.js";import"./chunks/chunk-7X72IACK.js";import"./chunks/chunk-YWD54RHU.js";import"./chunks/chunk-C5XX36EB.js";import"./chunks/chunk-IYL5E4QQ.js";import"./chunks/chunk-OEFCY46F.js";import"./chunks/chunk-KRNXUTZJ.js";import"./chunks/chunk-AC72EWI5.js";import"./chunks/chunk-RQFD6LG2.js";import"./chunks/chunk-RPAEB2Z5.js";import"./chunks/chunk-D2ROBVZ4.js";import"./chunks/chunk-CLZLV65G.js";import"./chunks/chunk-YU4AYH4C.js";import"./chunks/chunk-N4TSAHRL.js";import"./chunks/chunk-LNAZ7XEU.js";import"./chunks/chunk-DLAY7CIU.js";import"./chunks/chunk-KKVVSE6C.js";import"./chunks/chunk-COH5F7QV.js";import"./chunks/chunk-RFB5CBW7.js";import"./chunks/chunk-Y7QPP7BG.js";import"./chunks/chunk-4WWORAQH.js";import"./chunks/chunk-GVSBCJFI.js";import"./chunks/chunk-QTS2XGPQ.js";import"./chunks/chunk-TG4E7Z7W.js";import"./chunks/chunk-32R442XT.js";import"./chunks/chunk-WHPDEDCC.js";import"./chunks/chunk-7UC4W2T2.js";import"./chunks/chunk-HK46JMSC.js";import"./chunks/chunk-WBTKUCRH.js";import"./chunks/chunk-WDTJ6JKE.js";import"./chunks/chunk-5ROMKDLK.js";import"./chunks/chunk-3W47LTXQ.js";import"./chunks/chunk-3BJFH3CZ.js";import"./chunks/chunk-3SASTB6Y.js";import"./chunks/chunk-5CSZPC55.js";import"./chunks/chunk-PJ34QVL5.js";import"./chunks/chunk-BMX2U22F.js";import"./chunks/chunk-YU2P3CAR.js";import"./chunks/chunk-PP52OWBB.js";import"./chunks/chunk-CQ3G57HE.js";import"./chunks/chunk-ZOFZRJSL.js";import"./chunks/chunk-ZFIC2DZV.js";import"./chunks/chunk-6WISUXVI.js";import"./chunks/chunk-XVRRNJQD.js";import"./chunks/chunk-42XRJQM6.js";import"./chunks/chunk-2SOVDETB.js";import"./chunks/chunk-UKSFF47T.js";import"./chunks/chunk-OM7LH7AP.js";import"./chunks/chunk-QEESHRTS.js";import{APP_NAME,scrubBrandFromEnvironment}from"./chunks/chunk-ISZ4EWIS.js";import"./chunks/chunk-ATQFN5HI.js";import"./chunks/chunk-EYSV6A7S.js";import"./chunks/chunk-MIENF2YK.js";import"./chunks/chunk-OXNWERO4.js";import"./chunks/chunk-QN2BHP3M.js";import"./chunks/chunk-AOTHPTMU.js";import"./chunks/chunk-O5RYI3IW.js";import"./chunks/chunk-IKOFCODM.js";process.title=`${APP_NAME}-rpc`;scrubBrandFromEnvironment();process.env.PI_CODING_AGENT="true";process.env.AI_AGENT=APP_NAME;process.emitWarning=(()=>{});configureHttpDispatcher();main(["--mode","rpc",...process.argv.slice(2)]);

package/dist/bundle/runtime-manifest.json

@@ -1 +1 @@
-{"buildId":"29c0244c28dfb182","externals":["@earendil-works/chord","@earendil-works/pi-pty","@silvia-odwyer/photon-node","bufferutil","canvas","kerberos","supports-color","utf-8-validate"]}
+{"buildId":"b333b4398db12fde","externals":["@earendil-works/chord","@earendil-works/pi-pty","@silvia-odwyer/photon-node","bufferutil","canvas","kerberos","supports-color","utf-8-validate"]}

package/dist/core/session-recovery-identity.d.ts

@@ -1,4 +1,15 @@
-/** The recovery identity of one session record; never a property on the record, so no byte changes (R3.C1.2). */
+/**
+ * The recovery identity of one session record. It is never a property on the record a session produces, so every
+ * legacy record, and every record with the compact-updates flag off, keeps its bytes (R3.C1.2). One exception
+ * (RULING-120, senpi#5331): with the flag on, the RPC host stamps the copy it sends a `compact_events` peer of a live
+ * `message_end` (`messageId`, `terminalSequence`), `entry_appended` (`owningMessageId`) and `transcript_write_failed`
+ * (`messageId`) with the ids the settled store recorded for that message, so that peer can join the live record to its
+ * settled `message-<terminalSequence>` and `join-<n>` rows across a reconnect or recovery cut. The ids are opaque,
+ * stable for the message's lifetime and never reused in the session; nothing else carries them. The same copy of a live
+ * call record (`toolcall_*` updates, `tool_execution_*`, `tool_hook_status`) carries the `runtimeItemKey` of the call
+ * the host changed with it, or `callUnknown: true` when it changed none (RULING-123, senpi#5346): that key comes from
+ * the calls component (`compact-call-model.ts`), not from this carrier.
+ */
 export interface RecoveryCarrier {
     readonly messageId: string;
     /** Host-issued nonce, internal to the producer/lane handshake; never serialized with a public record. */

package/dist/modes/rpc/compact-call-fold.d.ts

@@ -1,11 +1,13 @@
 import type { ActiveBlock } from "./compact-active-block.ts";
-import type { CallProjection, CallScope } from "./compact-call-model.ts";
+import { type CallIdentity, type CallProjection, type CallScope } from "./compact-call-model.ts";
 import type { CallStep, CompactSessionCalls } from "./compact-session-calls.ts";
 import type { SeededMessage } from "./compact-seeded-messages.ts";
 import type { CompactTransition } from "./compact-transition.ts";
 export interface CallFold {
     readonly changed: boolean;
     readonly projection?: CallProjection;
+    /** An execution or hook record's call (RULING-123): the one it changed, or `callUnknown` when it changed none. */
+    readonly identity?: CallIdentity;
 }
 type SeededBlockTransition = Extract<CompactTransition, {
     type: "seeded_block";

package/dist/modes/rpc/compact-call-fold.js

@@ -1,3 +1,5 @@
+import { CALL_NAMED_RECORDS } from "./compact-call-identity.js";
+import { CALL_UNKNOWN, callIdentity, } from "./compact-call-model.js";
 const field = (record, key) => Reflect.get(record, key);
 const text = (record, key) => String(field(record, key) ?? "");
 const ownedRaw = (block) => block ? { kind: "owned", root: block.root, tailRoot: block.tailRoot } : null;
@@ -47,10 +49,12 @@ export function foldCallRecord(calls, record, scope, sequence) {
     const step = { sequence, scope };
     const before = calls.table.counters.replacements;
     let projection;
-    switch (field(record, "type")) {
+    let call;
+    const type = field(record, "type");
+    switch (type) {
         case "tool_execution_start": {
             const parentToolCallId = field(record, "parentToolCallId");
-            calls.executionStart(step, {
+            call = calls.executionStart(step, {
                 toolCallId: text(record, "toolCallId"),
                 toolName: text(record, "toolName"),
                 args: field(record, "args") ?? null,
@@ -59,13 +63,13 @@ export function foldCallRecord(calls, record, scope, sequence) {
             break;
         }
         case "tool_execution_update":
-            calls.executionUpdate(step, text(record, "toolCallId"), field(record, "args") ?? null, field(record, "partialResult") ?? null);
+            call = calls.executionUpdate(step, text(record, "toolCallId"), field(record, "args") ?? null, field(record, "partialResult") ?? null);
             break;
         case "tool_execution_end":
-            calls.executionEnd(step, text(record, "toolCallId"), field(record, "result") ?? null, field(record, "isError") === true);
+            call = calls.executionEnd(step, text(record, "toolCallId"), field(record, "result") ?? null, field(record, "isError") === true);
             break;
         case "tool_hook_status":
-            calls.hook(step, text(record, "toolCallId"), record);
+            call = calls.hook(step, text(record, "toolCallId"), record);
             break;
         case "turn_end":
             calls.turnEnd(step);
@@ -80,6 +84,13 @@ export function foldCallRecord(calls, record, scope, sequence) {
             break;
         }
     }
-    return { changed: calls.table.counters.replacements !== before, ...(projection ? { projection } : {}) };
+    const named = CALL_NAMED_RECORDS.has(String(type));
+    // C3.4: a call sharing its toolCallId inside its message was picked by order, which a stamp never vouches for.
+    const identity = call && calls.table.sharesIdInMessage(call) ? CALL_UNKNOWN : callIdentity(call);
+    return {
+        changed: calls.table.counters.replacements !== before,
+        ...(projection ? { projection } : {}),
+        ...(named ? { identity } : {}),
+    };
 }
 //# sourceMappingURL=compact-call-fold.js.map

package/dist/modes/rpc/compact-call-identity.d.ts

@@ -0,0 +1,13 @@
+import { type CallIdentity } from "./compact-call-model.ts";
+/** RULING-123 (#5346): the execution and hook records whose compact copy names the call they belong to. */
+export declare const CALL_NAMED_RECORDS: ReadonlySet<string>;
+/** The content index of the block a `toolcall_*` update streams; undefined for every other record. */
+export declare function toolcallIndex(record: object): number | undefined;
+/**
+ * What a compact peer's copy of `record` says when the lane holds no identity for it. A live call record the host
+ * changed no call with (ignored as unknown or late, refused at the protocol depth limit, or arriving while the compact
+ * state is unavailable) says `callUnknown` rather than omitting the key (RULING-123 (7), RULING-122's fail-safe rule);
+ * every other record says nothing.
+ */
+export declare function unvouchedCall(record: object): CallIdentity | undefined;
+//# sourceMappingURL=compact-call-identity.d.ts.map

package/dist/modes/rpc/compact-call-identity.js

@@ -0,0 +1,30 @@
+import { CALL_UNKNOWN } from "./compact-call-model.js";
+/** RULING-123 (#5346): the execution and hook records whose compact copy names the call they belong to. */
+export const CALL_NAMED_RECORDS = new Set([
+    "tool_execution_start",
+    "tool_execution_update",
+    "tool_execution_end",
+    "tool_hook_status",
+]);
+const streamEvent = (record) => Object(Reflect.get(record, "assistantMessageEvent"));
+/** A `toolcall_start`, `toolcall_delta` or `toolcall_end` update: it streams one call's block of its message. */
+function streamsCall(record) {
+    const kind = Reflect.get(streamEvent(record), "type");
+    return Reflect.get(record, "type") === "message_update" && typeof kind === "string" && kind.startsWith("toolcall_");
+}
+/** The content index of the block a `toolcall_*` update streams; undefined for every other record. */
+export function toolcallIndex(record) {
+    const index = Reflect.get(streamEvent(record), "contentIndex");
+    return streamsCall(record) && typeof index === "number" ? index : undefined;
+}
+/**
+ * What a compact peer's copy of `record` says when the lane holds no identity for it. A live call record the host
+ * changed no call with (ignored as unknown or late, refused at the protocol depth limit, or arriving while the compact
+ * state is unavailable) says `callUnknown` rather than omitting the key (RULING-123 (7), RULING-122's fail-safe rule);
+ * every other record says nothing.
+ */
+export function unvouchedCall(record) {
+    const named = CALL_NAMED_RECORDS.has(String(Reflect.get(record, "type")));
+    return named || streamsCall(record) ? CALL_UNKNOWN : undefined;
+}
+//# sourceMappingURL=compact-call-identity.js.map

package/dist/modes/rpc/compact-call-model.d.ts

@@ -110,6 +110,20 @@ export declare const CALL_RECORDS: ReadonlySet<string>;
 /** Records whose only lane effect is a call transition: ignored, they take no sequence (RULING-13 Q9). */
 export declare const CALL_ONLY_RECORDS: ReadonlySet<string>;
 export declare function runtimeItemKey(scope: CallScope, creationSequence: number, k: number): string;
+/**
+ * RULING-123 (#5346): the call a compact peer's copy of a live call record names. `runtimeItemKey` is the key
+ * `runtimeItemKey` above minted when the outstanding call the record changed was created, the key that call's snapshot
+ * `calls` entry and its settled projection carry: opaque, fixed for the call's lifetime, and never reused in the session
+ * (it embeds the epoch and the creation sequence, so it alone is unique, even when providers reuse a `toolCallId`).
+ * `callUnknown`: the host changed no call with this record, so it cannot vouch for one (RULING-122's fail-safe rule).
+ */
+export type CallIdentity = {
+    readonly runtimeItemKey: string;
+} | {
+    readonly callUnknown: true;
+};
+export declare const CALL_UNKNOWN: CallIdentity;
+export declare function callIdentity(call: OutstandingCall | undefined): CallIdentity;
 /** Fixed-width tree ordinal so the root orders calls by creation, independent of the epoch string. */
 export declare function callOrder(creationSequence: number, k: number): string;
 export declare function callLeaves(call: OutstandingCall): readonly LeafId[];

package/dist/modes/rpc/compact-call-model.js

@@ -19,6 +19,10 @@ export const CALL_ONLY_RECORDS = new Set([
 export function runtimeItemKey(scope, creationSequence, k) {
     return `${scope.sessionEpoch}:${creationSequence}.${k}`;
 }
+export const CALL_UNKNOWN = Object.freeze({ callUnknown: true });
+export function callIdentity(call) {
+    return call ? { runtimeItemKey: call.runtimeItemKey } : CALL_UNKNOWN;
+}
 /** Fixed-width tree ordinal so the root orders calls by creation, independent of the epoch string. */
 export function callOrder(creationSequence, k) {
     return `${String(creationSequence).padStart(16, "0")}.${String(k).padStart(4, "0")}`;

package/dist/modes/rpc/compact-call-table.d.ts

@@ -20,6 +20,7 @@ export declare class CompactCallTable {
     private readonly byMessage;
     private readonly byId;
     private readonly children;
+    private readonly shared;
     private slotBytes;
     private headerBytes;
     readonly counters: {
@@ -41,6 +42,12 @@ export declare class CompactCallTable {
      * a call still executing, each execution end closes, and each carrier settles, the call it belongs to.
      */
     oldestById(toolCallId: string, turnId: string | null, open: (call: OutstandingCall) => boolean): OutstandingCall | undefined;
+    /**
+     * RULING-123, C3.4: whether another call of `call`'s own message took the same toolCallId. An execution or hook
+     * record names only the toolCallId, so it cannot say which of those calls it is about. The mark lasts while any call
+     * of that message and id is live, so a later record is not attributed by elimination either.
+     */
+    sharesIdInMessage(call: OutstandingCall): boolean;
     ofTurn(turnId: string): Iterable<OutstandingCall>;
     all(): Iterable<OutstandingCall>;
     childrenOf(parentKey: string): readonly OutstandingCall[];
@@ -64,6 +71,8 @@ export declare class CompactCallTable {
     release(ref: ValueRef | undefined): void;
     entriesOf(ref: ValueRef | undefined, valid: () => void): AsyncGenerator<readonly [string, OutstandingCall], any, any>;
     private index;
+    /** The live calls of one message under one toolCallId. */
+    private inMessage;
     private unindex;
 }
 /** The creation ordinal is fixed by the key (RULING-13 Q1): `epoch:creationSequence.k`. */

package/dist/modes/rpc/compact-call-table.js

@@ -3,6 +3,7 @@ import { CompactComponentRoots } from "./compact-component-roots.js";
 import { CompactValues } from "./compact-values.js";
 const turnKey = (turnId, toolCallId) => `${turnId}\u0000${toolCallId}`;
 const messageKey = (messageId, contentIndex) => `${messageId}#${contentIndex}`;
+const sharedKey = (messageId, toolCallId) => `${messageId}\u0000${toolCallId}`;
 /**
  * The resident side of the calls component (S06 design section 2): the live entries, four indexes, the owned slot
  * values, and the persistent root every change republishes through the shared component roots.
@@ -15,6 +16,7 @@ export class CompactCallTable {
         this.byMessage = new Map();
         this.byId = new Map();
         this.children = new Map();
+        this.shared = new Set();
         this.slotBytes = 0;
         this.headerBytes = 0;
         this.counters = { replacements: 0, progressReplacements: 0, unknown: 0, late: 0, collisions: 0, reused: 0 };
@@ -60,6 +62,15 @@ export class CompactCallTable {
         }
         return oldest?.call;
     }
+    /**
+     * RULING-123, C3.4: whether another call of `call`'s own message took the same toolCallId. An execution or hook
+     * record names only the toolCallId, so it cannot say which of those calls it is about. The mark lasts while any call
+     * of that message and id is live, so a later record is not attributed by elimination either.
+     */
+    sharesIdInMessage(call) {
+        const { owningMessageId, toolCallId } = call;
+        return owningMessageId !== null && toolCallId !== null && this.shared.has(sharedKey(owningMessageId, toolCallId));
+    }
     *ofTurn(turnId) {
         for (const { call } of this.entries.values())
             if (call.turnId === turnId)
@@ -117,6 +128,9 @@ export class CompactCallTable {
             }
         this.headerBytes -= headerBytes(entry.call);
         this.entries.delete(key);
+        const { owningMessageId, toolCallId } = entry.call;
+        if (owningMessageId !== null && toolCallId && !this.inMessage(owningMessageId, toolCallId).length)
+            this.shared.delete(sharedKey(owningMessageId, toolCallId));
         this.root = this.roots.set(this.root, entry.order, undefined);
         this.counters.replacements++;
     }
@@ -165,6 +179,8 @@ export class CompactCallTable {
             const keys = this.byId.get(call.toolCallId) ?? [];
             if (!keys.includes(call.runtimeItemKey))
                 this.byId.set(call.toolCallId, [...keys, call.runtimeItemKey]);
+            if (call.owningMessageId !== null && this.inMessage(call.owningMessageId, call.toolCallId).length > 1)
+                this.shared.add(sharedKey(call.owningMessageId, call.toolCallId));
         }
         if (call.owningMessageId !== null && call.contentIndex !== null)
             this.byMessage.set(messageKey(call.owningMessageId, call.contentIndex), call.runtimeItemKey);
@@ -174,6 +190,10 @@ export class CompactCallTable {
             this.children.set(call.parentKey, siblings);
         }
     }
+    /** The live calls of one message under one toolCallId. */
+    inMessage(messageId, toolCallId) {
+        return (this.byId.get(toolCallId) ?? []).filter((key) => this.get(key)?.owningMessageId === messageId);
+    }
     unindex(call) {
         if (call.toolCallId) {
             const slot = turnKey(call.turnId, call.toolCallId);

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

@@ -2,6 +2,11 @@ import { type CatalogReader } from "./compact-catalog-steps.ts";
 import type { CatalogComponent } from "./compact-recovery-catalog.ts";
 import type { SettledReader } from "./compact-settled-messages.ts";
 import type { FrozenAcceptedRoot } from "./session-acceptance-lane.ts";
+/**
+ * The settled member of the terminal a message ended at: `message-<terminalSequence>`. A compact peer's live
+ * `message_end` carries that `terminalSequence` and the row's `messageId` (RULING-120, #5331).
+ */
+export declare const settledMember: (terminalSequence: number) => import("./compact-recovery-ids.ts").BoundedId;
 /**
  * The settled family (R4.B2, S05, RULING-13 Q2): one `message-<terminal sequence>` member per terminal still pending
  * or failed in the cut, with its status, error, entry join, terminal payload and the call projection it retired, paged

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

@@ -4,6 +4,13 @@ import { textComponent } from "./compact-catalog-transcript.js";
 import { emptyComponent, stepsComponent } from "./compact-catalog-writer.js";
 const SETTLED = familyId("settled");
 const IDENTITY = familyId("identity");
+/**
+ * The settled member of the terminal a message ended at: `message-<terminalSequence>`. A compact peer's live
+ * `message_end` carries that `terminalSequence` and the row's `messageId` (RULING-120, #5331).
+ */
+export const settledMember = (terminalSequence) => memberId("message", terminalSequence);
+/** The identity member of this epoch's n-th entry join: `join-<n>`, whose `messageId` an `entry_appended` names. */
+const joinMember = (ordinal) => memberId("join", ordinal);
 /** A terminal as stored: its row, its payload (terminal record and correlation) spliced in, its paged call walked. */
 function terminalSteps(settled, row, valid) {
     const { kind: _kind, payload, call, ...fields } = row;
@@ -25,7 +32,7 @@ export async function* settledComponents(reader, settled) {
         if (member.kind !== "terminal")
             continue;
         const steps = terminalSteps(settled, member.row, reader.valid);
-        yield* stepsComponent(reader.store, SETTLED, memberId("message", member.row.terminalSequence), steps);
+        yield* stepsComponent(reader.store, SETTLED, settledMember(member.row.terminalSequence), steps);
         count += 1;
     }
     if (count === 0)
@@ -45,7 +52,7 @@ export async function* identityComponents(reader, root, settled) {
         if (member.kind !== "owner")
             continue;
         const join = JSON.stringify({ messageId: member.messageId, entryId: member.entryId });
-        yield* textComponent(reader.store, IDENTITY, memberId("join", member.ordinal), join);
+        yield* textComponent(reader.store, IDENTITY, joinMember(member.ordinal), join);
     }
 }
 //# sourceMappingURL=compact-catalog-settled.js.map

package/dist/modes/rpc/compact-lane-current.d.ts

@@ -40,6 +40,8 @@ export declare class CompactLaneCurrent {
     foldComponent(record: object, sequence: number): void;
     /** An execution, hook or boundary record for the calls component (S06); undefined once the state is unavailable. */
     foldCall(record: object, sequence: number, turnId: string | null): CallFold | undefined;
+    /** The call whose block a `toolcall_*` update streams (RULING-123); undefined once the state is unavailable. */
+    callOwning(messageId: string, contentIndex: number): import("./compact-call-model.ts").OutstandingCall | undefined;
     /**
      * The cold work of one accepted transcript transition: an owned append makes its message appended, and the flow a
      * real producer committed (edit, context-edit removal, compaction, branch) maps through this epoch's settled joins.

package/dist/modes/rpc/compact-lane-current.js

@@ -74,6 +74,10 @@ export class CompactLaneCurrent {
             return undefined;
         }
     }
+    /** The call whose block a `toolcall_*` update streams (RULING-123); undefined once the state is unavailable. */
+    callOwning(messageId, contentIndex) {
+        return this.state?.callOwning(messageId, contentIndex);
+    }
     /**
      * The cold work of one accepted transcript transition: an owned append makes its message appended, and the flow a
      * real producer committed (edit, context-edit removal, compaction, branch) maps through this epoch's settled joins.

package/dist/modes/rpc/compact-message-identity.d.ts

@@ -0,0 +1,74 @@
+import type { TranscriptTransition } from "../../core/session-transcript-journal.ts";
+import type { CallIdentity } from "./compact-call-model.ts";
+/**
+ * An accepted end's settled ids: the message's `messageId` and the end's accepted sequence. A pending or failed terminal
+ * pages them as the `message-<terminalSequence>` member; a joined message writes no terminal row and pages only its
+ * `join-<n>` member's `messageId`.
+ */
+export interface TerminalIdentity {
+    readonly messageId: string;
+    readonly terminalSequence: number;
+}
+/**
+ * RULING-120 (#5331): the ids the settled store records for one message, which a compact peer's own copy of the live
+ * record carries too: an accepted end's terminal ids, a failed write's `messageId`, an entry join's `owningMessageId`
+ * (the `messageId` of its `join-<n>` member). RULING-123 (#5346): a live call record's call, by its snapshot key.
+ */
+export type LiveIdentity = TerminalIdentity | {
+    readonly messageId: string;
+} | {
+    readonly owningMessageId: string;
+} | {
+    readonly ownerUnknown: true;
+} | CallIdentity;
+/** An end the settled store accepted: whether it joined the message to its durable entry, and the ids it recorded. */
+export interface SettledEnd {
+    readonly joined: boolean;
+    readonly identity: TerminalIdentity;
+}
+/**
+ * How many joined entries may wait for their `entry_appended` at once. Each normally arrives within a batch or two of
+ * its append, so this only bounds entries whose `entry_appended` the lane never folds; the oldest is dropped first.
+ */
+export declare const MAX_PENDING_JOINS = 1024;
+/**
+ * RULING-122 (#5337): how many unvouched entry ids the epoch remembers, so their `entry_appended` says `ownerUnknown`
+ * instead of a false not-owned: an owned append whose join was dropped at `MAX_PENDING_JOINS`, or that the settled
+ * store never joined (its transcript unavailable, its join refused). Past this the epoch overflows and can no longer
+ * vouch for any entry it has no join for.
+ */
+export declare const MAX_EVICTED_JOINS = 4096;
+/**
+ * One lane epoch's view of those ids for delivery: each joined entry's owning message, captured when its append is
+ * applied and kept by entry id until that entry's `entry_appended` takes it (RULING-121, #5337), so transcript batches
+ * applied in between cannot drop it; and the ids of the record it accepted last, answered only while that record, at
+ * that sequence, is the one being delivered.
+ */
+export declare class MessageIdentities {
+    private readonly joins;
+    private readonly unvouched;
+    private overflowed;
+    private evictions;
+    private overflows;
+    private held;
+    /** The epoch ended: nothing it joined or held can name a record delivered later. */
+    reset(): void;
+    /** Joins dropped at the bound and evicted ids dropped from the ring, over the lane's life (never reset). */
+    status(): {
+        ownerJoinsEvicted: number;
+        ownerJoinsOverflowed: number;
+    };
+    /**
+     * `owner`: the message the settled store joined this append to, the `messageId` of its `join-<n>` member; undefined
+     * when it recorded no join, which for an owned append (it carries `owningMessageId`) leaves the entry unvouched.
+     */
+    joined(transition: TranscriptTransition, owner: string | undefined): void;
+    private unvouch;
+    /** Every acceptance starts with nothing held, so a record the lane refuses never inherits its predecessor's ids. */
+    clear(): void;
+    /** Holds the ids the settled store recorded for this record, or for an `entry_appended`, its entry's join (taken). */
+    hold(type: string, sequence: number, record: object, recorded: LiveIdentity | undefined): void;
+    of(type: unknown, sequence: number): LiveIdentity | undefined;
+    private takeEntryOwner;
+}
+//# sourceMappingURL=compact-message-identity.d.ts.map

package/dist/modes/rpc/compact-message-identity.js

@@ -0,0 +1,101 @@
+/**
+ * How many joined entries may wait for their `entry_appended` at once. Each normally arrives within a batch or two of
+ * its append, so this only bounds entries whose `entry_appended` the lane never folds; the oldest is dropped first.
+ */
+export const MAX_PENDING_JOINS = 1024;
+/**
+ * RULING-122 (#5337): how many unvouched entry ids the epoch remembers, so their `entry_appended` says `ownerUnknown`
+ * instead of a false not-owned: an owned append whose join was dropped at `MAX_PENDING_JOINS`, or that the settled
+ * store never joined (its transcript unavailable, its join refused). Past this the epoch overflows and can no longer
+ * vouch for any entry it has no join for.
+ */
+export const MAX_EVICTED_JOINS = 4096;
+const OWNER_UNKNOWN = Object.freeze({ ownerUnknown: true });
+/**
+ * One lane epoch's view of those ids for delivery: each joined entry's owning message, captured when its append is
+ * applied and kept by entry id until that entry's `entry_appended` takes it (RULING-121, #5337), so transcript batches
+ * applied in between cannot drop it; and the ids of the record it accepted last, answered only while that record, at
+ * that sequence, is the one being delivered.
+ */
+export class MessageIdentities {
+    constructor() {
+        this.joins = new Map();
+        this.unvouched = new Set();
+        this.overflowed = false;
+        this.evictions = 0;
+        this.overflows = 0;
+    }
+    /** The epoch ended: nothing it joined or held can name a record delivered later. */
+    reset() {
+        this.joins.clear();
+        this.unvouched.clear();
+        this.overflowed = false;
+        this.held = undefined;
+    }
+    /** Joins dropped at the bound and evicted ids dropped from the ring, over the lane's life (never reset). */
+    status() {
+        return { ownerJoinsEvicted: this.evictions, ownerJoinsOverflowed: this.overflows };
+    }
+    /**
+     * `owner`: the message the settled store joined this append to, the `messageId` of its `join-<n>` member; undefined
+     * when it recorded no join, which for an owned append (it carries `owningMessageId`) leaves the entry unvouched.
+     */
+    joined(transition, owner) {
+        if (transition.kind !== "append")
+            return;
+        if (owner === undefined) {
+            if (transition.owningMessageId !== undefined)
+                this.unvouch(transition.id);
+            return;
+        }
+        this.joins.set(transition.id, owner);
+        if (this.joins.size <= MAX_PENDING_JOINS)
+            return;
+        const [oldest] = this.joins.keys();
+        if (oldest === undefined)
+            return;
+        this.joins.delete(oldest);
+        this.evictions += 1;
+        this.unvouch(oldest);
+    }
+    unvouch(entryId) {
+        this.unvouched.add(entryId);
+        if (this.unvouched.size <= MAX_EVICTED_JOINS)
+            return;
+        const [forgotten] = this.unvouched.keys();
+        if (forgotten !== undefined)
+            this.unvouched.delete(forgotten);
+        this.overflows += 1;
+        if (this.overflowed)
+            return;
+        this.overflowed = true;
+        process.stderr.write(`senpi rpc acceptance: unvouched-owner ring overflowed (${MAX_EVICTED_JOINS}; evicted or never-joined owned entries); unmatched entries carry ownerUnknown until the epoch ends\n`);
+    }
+    /** Every acceptance starts with nothing held, so a record the lane refuses never inherits its predecessor's ids. */
+    clear() {
+        this.held = undefined;
+    }
+    /** Holds the ids the settled store recorded for this record, or for an `entry_appended`, its entry's join (taken). */
+    hold(type, sequence, record, recorded) {
+        const identity = recorded ?? (type === "entry_appended" ? this.takeEntryOwner(record) : undefined);
+        if (identity)
+            this.held = { type, sequence, identity };
+    }
+    of(type, sequence) {
+        const held = this.held;
+        return held && held.type === type && held.sequence === sequence ? held.identity : undefined;
+    }
+    takeEntryOwner(record) {
+        const entryId = Reflect.get(Object(Reflect.get(record, "entry")), "id");
+        if (typeof entryId !== "string")
+            return undefined;
+        const owningMessageId = this.joins.get(entryId);
+        this.joins.delete(entryId);
+        if (owningMessageId !== undefined)
+            return { owningMessageId };
+        // RULING-122: an entry whose join may have been dropped is never reported as not message-owned.
+        const unknown = this.unvouched.delete(entryId) || this.overflowed;
+        return unknown ? OWNER_UNKNOWN : undefined;
+    }
+}
+//# sourceMappingURL=compact-message-identity.js.map

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

@@ -40,11 +40,12 @@ export declare class CompactSessionCalls {
     requestedName(step: CallStep, messageId: string, contentIndex: number, name: string): void;
     /** `toolcall_end` and each terminal block: the announcement's final id, name and input; the call owns the raw. */
     announce(step: CallStep, block: AnnouncedBlock, raw: CallRaw | null): void;
-    executionStart(step: CallStep, start: ExecutionStart): void;
-    executionUpdate(step: CallStep, toolCallId: string, args: unknown, partialResult: unknown): void;
-    hook(step: CallStep, toolCallId: string, record: unknown): void;
+    /** Each per-id execution record returns the call it changed (RULING-123), undefined when it changed none. */
+    executionStart(step: CallStep, start: ExecutionStart): OutstandingCall | undefined;
+    executionUpdate(step: CallStep, toolCallId: string, args: unknown, partialResult: unknown): OutstandingCall | undefined;
+    hook(step: CallStep, toolCallId: string, record: unknown): OutstandingCall | undefined;
     /** An end closes the oldest call still open under its id (senpi#4278); with none open it may replace an abandoned one. */
-    executionEnd(step: CallStep, toolCallId: string, result: unknown, isError: boolean): void;
+    executionEnd(step: CallStep, toolCallId: string, result: unknown, isError: boolean): OutstandingCall | undefined;
     /**
      * The carrier settled (RULING-13 Q2): the oldest call under its id still awaiting a carrier, own turn first (the
      * same order the ends closed them in, senpi#4278), leaves with its completed descendants as one projection.