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

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

@@ -8,6 +8,7 @@ import { SessionEventWriterRecovery } from "./session-event-writer-recovery.js";
 import { isCorrelatedReply } from "./socket-peer-recovery.js";
 import { materializerLine } from "./compact-materializer-line.js";
 import { declarationReply } from "./compact-negotiation.js";
+import { unvouchedCall } from "./compact-call-identity.js";
 /** A record's legacy line, encoded on first use: a record no legacy destination needs never builds it (RULING-81 X06). */
 export class RecordLine {
     constructor(record, encoded) {
@@ -39,15 +40,16 @@ export class SessionEventWriterDestinations extends SessionEventWriterRecovery {
         const placeholder = new RecordLine(redacted, placeholderLine);
         if (!isTargeted && !this.fanout.acceptance.has(sessionId))
             this.fanout.rememberSnapshot(sessionId, tagged, line.text, placeholderLine);
+        const copies = new Map();
         for (const target of targets) {
             if (target !== undefined && !this.fanout.get(target))
                 continue;
             const registered = target === undefined ? undefined : this.fanout.get(target);
             const wants = placeholderLine !== undefined && this.fanout.connectionHas(target, MEDIA_PLACEHOLDERS_CAPABILITY);
             if (registered && target !== undefined) {
-                const out = this.eventLine(target, sessionId, wants ? redacted : tagged, wants ? placeholder : line);
+                const out = this.eventLine(target, sessionId, wants ? redacted : tagged, wants ? placeholder : line, copies);
                 const keyed = !out.atomic && compactDelta(tagged) !== undefined && tagged.message !== null;
-                registered.actor.enqueue(out.line, keyed ? MESSAGE_KEY : undefined, out.undelivered, keyed ? serializeJsonLine(demoteToDeltaOnly(tagged)) : undefined, isCorrelatedReply(tagged), mirrors.includes(target)
+                registered.actor.enqueue(out.line, keyed ? MESSAGE_KEY : undefined, out.undelivered, keyed ? serializeJsonLine(demoteToDeltaOnly(out.record ?? tagged)) : undefined, isCorrelatedReply(tagged), mirrors.includes(target)
                     ? undefined
                     : this.fanout.attachmentOf(target, sessionId, isTargeted, record.type), current);
             }
@@ -60,9 +62,10 @@ export class SessionEventWriterDestinations extends SessionEventWriterRecovery {
      * 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.
      */
-    eventLine(target, sessionId, record, line) {
+    eventLine(target, sessionId, record, line, copies) {
         const reply = declarationReply(record, this.compactSelection(target));
         if (reply !== undefined && reply !== record)
             return { line: serializeJsonLine(reply) };
@@ -81,17 +84,28 @@ export class SessionEventWriterDestinations extends SessionEventWriterRecovery {
             return { line: line.text };
         if (!this.fanout.connectionHas(target, COMPACT_EVENTS_CAPABILITY))
             return { line: line.text };
-        const materializer = materializerLine(this.fanout, this.required, target, sessionId, record);
+        // RULING-120 (#5331): only this compact peer's copy carries the ids the settled overlay pages for its message;
+        // RULING-123 (#5346): and a live call record's snapshot key, or `callUnknown` when the lane vouched for none.
+        let copy = copies.get(record);
+        if (!copy) {
+            const identity = lane.identities.of(record.type, lane.acceptedSequence) ?? unvouchedCall(record);
+            const stamped = identity ? { ...record, ...identity } : record;
+            copy = { stamped, line: identity ? new RecordLine(stamped) : line };
+            copies.set(record, copy);
+        }
+        const { stamped, line: stampedLine } = copy;
+        const identity = stamped !== record;
+        const materializer = materializerLine(this.fanout, this.required, target, sessionId, stamped);
         if (materializer)
             return materializer;
-        const built = line.built;
-        const size = built === undefined ? jsonSize(record) : { bytes: Buffer.byteLength(built) - 1, units: built.length - 1 };
+        const built = stampedLine.built;
+        const size = built === undefined ? jsonSize(stamped) : { bytes: Buffer.byteLength(built) - 1, units: built.length - 1 };
         if (size.bytes + 1 <= COMPACT_RECORD_MAX_BYTES)
-            return { line: line.text };
+            return { line: stampedLine.text, ...(identity ? { record: stamped } : {}) };
         const at = { sessionEpoch: lane.sessionEpoch, sequence: lane.acceptedSequence };
         const routes = this.ordinaryRoute(target, sessionId)?.routes ?? [];
         const owner = routes[0] ?? admissionId;
-        const minted = events.mint({ socketEpoch, sessionId, admissionId: owner }, at, record, built ?? size);
+        const minted = events.mint({ socketEpoch, sessionId, admissionId: owner }, at, stamped, built ?? size);
         if (minted.ok) {
             const { id } = minted.value;
             const held = events.claim({ socketEpoch, sessionId }, id, owner);
@@ -100,6 +114,7 @@ export class SessionEventWriterDestinations extends SessionEventWriterRecovery {
                     held.value.admissions.add(route);
             return {
                 line: serializeJsonLine({ type: Reflect.get(record, "type"), sessionId, eventLease: minted.value }),
+                ...(identity ? { record: stamped } : {}),
                 // The lease lives only if its envelope is written: every drop path of the socket actor ends it unseen.
                 undelivered: (written) => {
                     if (!written)

package/dist/utils/version-check.js

@@ -22,7 +22,9 @@ export function readAvailableVersion(payload, channel) {
 const DEFAULT_VERSION_CHECK_TIMEOUT_MS = 10000;
 const RELEASE_CHANGELOG_BASE_URL = "https://github.com/code-yeongyu/senpi/blob";
 const RELEASE_CHANGELOG_PATH = "packages/coding-agent/CHANGELOG.md";
-const SENPI_CALVER_PATTERN = /^(\d{4})\.(\d{1,2})\.(\d{1,2})(?:-([2-9]\d*))?$/;
+// Month and day may be zero-padded (`2026.11.02-1` as stamped in package.json) or not (npm's normalized
+// `2026.11.2-1`); a `-1` revision is the same release as the bare date.
+const SENPI_CALVER_PATTERN = /^(\d{4})\.(\d{1,2})\.(\d{1,2})(?:-([1-9]\d*))?$/;
 function parseSenpiCalVer(version) {
     const match = SENPI_CALVER_PATTERN.exec(version);
     if (!match) {
@@ -30,6 +32,10 @@ function parseSenpiCalVer(version) {
     }
     return [Number(match[1]), Number(match[2]), Number(match[3]), Number(match[4] ?? 1)];
 }
+/** Unpadded form semver accepts, used when a CalVer version is compared with a plain semver version. */
+function canonicalCalVer([year, month, day, revision]) {
+    return revision > 1 ? `${year}.${month}.${day}-${revision}` : `${year}.${month}.${day}`;
+}
 /** Include useful errno details hidden behind Node's generic "fetch failed" error. */
 export function formatVersionCheckError(error) {
     const rootMessage = error instanceof Error && error.message ? error.message : String(error);
@@ -58,8 +64,8 @@ export function comparePackageVersions(leftVersion, rightVersion) {
         }
         return 0;
     }
-    const left = valid(leftTrimmed);
-    const right = valid(rightTrimmed);
+    const left = valid(leftCalVer ? canonicalCalVer(leftCalVer) : leftTrimmed);
+    const right = valid(rightCalVer ? canonicalCalVer(rightCalVer) : rightTrimmed);
     if (!left || !right) {
         return undefined;
     }