@code-yeongyu/senpi 2026.10.18 → 2026.10.19

package/dist/core/pending-input-session.js

@@ -0,0 +1,220 @@
+import { createHash, randomUUID } from "node:crypto";
+import { SessionPendingInputJournal } from "./pending-input-journal.js";
+import { createSessionQueuedInputPort } from "./pending-input-session-port.js";
+import { PENDING_INPUT_TRANSITION, PendingInputStore } from "./pending-input-store.js";
+export class ClientMessageIdConflictError extends Error {
+    constructor(clientMessageId) {
+        super(`Client message id ${clientMessageId} was already used for a different message.`);
+        this.code = "client_message_id_conflict";
+        this.name = "ClientMessageIdConflictError";
+        this.clientMessageId = clientMessageId;
+    }
+}
+/**
+ * The pending inputs of one AgentSession (senpi#3549): the store, opened on the first identified input, and the
+ * agent queue port over it. Input without a client id never touches the store and keeps the legacy queue path.
+ */
+export class SessionPendingInputs {
+    constructor(options) {
+        this.lifetimeId = randomUUID();
+        this.attempts = 0;
+        /** Bumped synchronously by every clear, so a change can tell a clear it raced from a real divergence. */
+        this.clears = 0;
+        this.options = options;
+        // A session file that already holds pending inputs is recovered now: the agent's first drain must see them.
+        const journaled = options.sessionManager
+            .getEntries()
+            .some((entry) => entry.type === "custom" && entry.customType === PENDING_INPUT_TRANSITION);
+        // Opened eagerly, unawaited: every later use awaits this same opening and surfaces its failure, so the
+        // eager start only must not report it a second time as an unhandled rejection.
+        if (journaled)
+            this.store().catch(() => undefined);
+    }
+    /**
+     * How a restored input (from the RPC admission ledger after a reopen) re-enters the native queue: under the
+     * store's rebound queue id while it is still queued; not at all once the store retired it (delivered, removed,
+     * failed); `undefined` when the store never held it, so the caller restores it as before.
+     */
+    async restoreHandle(clientMessageId) {
+        if (this.storeOpening === undefined)
+            return undefined;
+        const input = (await this.storeOpening).current(clientMessageId);
+        if (input === undefined)
+            return undefined;
+        return input.phase === "queued" ? { queuedId: input.handle.queuedId } : "retired";
+    }
+    /**
+     * Admits an identified input and, only when it is newly admitted, puts its native copy in the agent queue
+     * inside the same gated step, so no drain, edit or removal can run between the two. A repeated submit of the
+     * same input is answered from the record (`replayed`) and enqueues nothing.
+     */
+    async admit(input, enqueue) {
+        const store = await this.store();
+        return store.transaction(async (tx) => {
+            const result = await tx.submit({
+                clientMessageId: input.clientMessageId,
+                fingerprint: admissionFingerprint(input),
+                text: input.text,
+                attachments: (input.images ?? []).map(attachmentFingerprint),
+                requestedMode: input.mode,
+            });
+            if (result?.outcome === "client_message_id_conflict")
+                throw new ClientMessageIdConflictError(input.clientMessageId);
+            const admitted = tx.current(input.clientMessageId);
+            if (result?.outcome === "admitted" && admitted !== undefined)
+                enqueue(admitted.handle.queuedId);
+            return result;
+        });
+    }
+    /**
+     * Edits or removes an identified input: the store transition is journaled first, and only when it answers
+     * `edited`/`removed` does `applyNative` change the native queue, inside the same gated step, so no drain
+     * can see one without the other. Returns undefined when the store never admitted this input.
+     */
+    async change(request, applyNative) {
+        if (this.storeOpening === undefined)
+            return undefined;
+        const clearsAtStart = this.clears;
+        const store = await this.storeOpening;
+        return store.transaction(async (tx) => {
+            const current = tx.current(request.clientMessageId);
+            if (current === undefined)
+                return undefined;
+            const target = {
+                effectId: request.effectId ?? randomUUID(),
+                handle: current.handle,
+                expectedRevision: request.expectedRevision ?? current.revision,
+            };
+            const result = request.text === undefined
+                ? await tx.apply(request.clientMessageId, { type: "remove", ...target })
+                : await tx.apply(request.clientMessageId, {
+                    type: "edit",
+                    ...target,
+                    text: request.text,
+                    attachments: current.attachments,
+                });
+            const outcome = legacyOutcome(result?.outcome);
+            if (outcome !== "edited" && outcome !== "removed")
+                return outcome;
+            const native = applyNative();
+            // A synchronous clear can empty the queue while the change is being journaled; its own record of the
+            // clear is queued behind this step and retires the input, so the change simply found nothing. Any other
+            // missing native copy is a real divergence (review L1, L-c).
+            if (native === "not_found" && this.clears !== clearsAtStart)
+                return "not_found";
+            if (native !== outcome)
+                throw new PendingInputDivergenceError(request.clientMessageId, outcome, native);
+            return outcome;
+        });
+    }
+    /**
+     * Records an explicit clear (Stop, `clear_queue`, unload with clearQueue) of identified inputs that just left the
+     * native queue: each still-queued one is removed by `stop`, so a reopen never queues it again.
+     */
+    async recordCleared(clientMessageIds) {
+        this.clears += 1;
+        if (this.storeOpening === undefined || clientMessageIds.length === 0)
+            return;
+        const store = await this.storeOpening;
+        // One record for the whole clear: it lands or not as a unit, never split around a later entry.
+        await store.transaction(async (tx) => {
+            const queued = clientMessageIds.filter((clientMessageId) => tx.current(clientMessageId)?.phase === "queued");
+            if (queued.length === 0)
+                return;
+            await tx.applyAll(queued.map((clientMessageId) => ({
+                clientMessageId,
+                event: { type: "cancel", cause: "stop", consumerFenced: true },
+            })));
+        });
+    }
+    /**
+     * Pending inputs (queued, sending, failed) and the outcome of each known id, consistent through
+     * `throughCursor`: apply it, then only updates with a later cursor. Absence from `inputs` is never an outcome.
+     */
+    async snapshot(knownClientMessageIds = []) {
+        const store = this.storeOpening === undefined ? undefined : await this.storeOpening;
+        const inputs = (store?.snapshot() ?? []).filter((input) => input.state !== "delivered" && input.state !== "removed");
+        const outcomes = knownClientMessageIds.map((clientMessageId) => {
+            const read = store?.read(clientMessageId);
+            return read?.status === "admitted"
+                ? { clientMessageId, status: "admitted", projection: read.projection }
+                : { clientMessageId, status: "not_admitted" };
+        });
+        return { lifetimeId: this.lifetimeId, throughCursor: store?.throughCursor ?? 0, inputs, outcomes };
+    }
+    /** The agent's queue port. Before the store opens nothing identified is queued, so it drains natively. */
+    queuedInputPort() {
+        return {
+            claim: async (queue, drain) => (await this.openPort())?.claim(queue, drain) ?? drain(),
+            commitConsumption: async (queue, messages) => (await this.openPort())?.commitConsumption(queue, messages),
+            release: async (queue, messages, giveBack) => {
+                const port = await this.openPort();
+                if (port === undefined)
+                    giveBack.restore();
+                else
+                    await port.release(queue, messages, giveBack);
+            },
+        };
+    }
+    store() {
+        this.storeOpening ??= PendingInputStore.open({
+            journal: this.options.journal ?? new SessionPendingInputJournal(this.options.sessionManager),
+            lifetimeId: this.lifetimeId,
+            nextQueuedId: this.options.nextQueuedId,
+            // The agent port commits consumption before any provider sees an input, so an attempt left `sending` by a
+            // crash was never sent and returns to the queue under its id (T28).
+            uncommittedAttemptsAreUnsent: true,
+        }).then((store) => {
+            const onChange = this.options.onChange;
+            if (onChange !== undefined)
+                store.subscribe((projections, cursor) => onChange({ lifetimeId: this.lifetimeId, cursor, changes: projections }));
+            return store;
+        });
+        return this.storeOpening;
+    }
+    async openPort() {
+        if (this.storeOpening === undefined)
+            return undefined;
+        const store = await this.storeOpening;
+        this.port ??= createSessionQueuedInputPort({
+            store,
+            ownerId: `${process.pid}:${this.lifetimeId}`,
+            writerGeneration: 1,
+            nextAttemptId: () => `${this.lifetimeId}:${++this.attempts}`,
+        });
+        return this.port;
+    }
+}
+function admissionFingerprint(input) {
+    const images = (input.images ?? []).map(attachmentFingerprint);
+    return sha256(JSON.stringify([input.mode, input.text, images]));
+}
+function attachmentFingerprint(image) {
+    return `${image.mimeType}:${sha256(image.data)}`;
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+/** The store changed an input that the native queue no longer held: the two views disagree and must not be hidden. */
+export class PendingInputDivergenceError extends Error {
+    constructor(clientMessageId, recorded, native) {
+        super(`Queued input ${clientMessageId} was ${recorded} in its record but ${native} in the queue.`);
+        this.code = "pending_input_divergence";
+        this.name = "PendingInputDivergenceError";
+    }
+}
+/** `sending` keeps the legacy spelling `already_delivered` (the handoff began); the snapshot says `sending`. */
+function legacyOutcome(outcome) {
+    switch (outcome) {
+        case "edited":
+        case "removed":
+        case "conflict":
+        case "already_delivered":
+            return outcome;
+        case "sending":
+            return "already_delivered";
+        default:
+            return "not_found";
+    }
+}
+//# sourceMappingURL=pending-input-session.js.map

package/dist/core/pending-input-store.d.ts

@@ -7,6 +7,8 @@ export interface PendingInputJournalRecord {
     readonly cursor: number;
     readonly input: PendingInput;
     readonly result?: PendingInputOperationResult;
+    /** Further inputs changed in the same step (a consumer's batch), recorded atomically with `input`. */
+    readonly batch?: readonly PendingInput[];
 }
 export interface PendingInputJournal {
     append(record: PendingInputJournalRecord): Promise<void>;
@@ -18,13 +20,27 @@ export interface PendingInputStoreOptions {
     readonly nextQueuedId: () => string;
     readonly dispatch?: (token: DeliveryToken, input: PendingInput) => void;
     readonly restoreToDraft?: (text: string) => void;
+    /** Passed to every reopen rebind; see the `rebind` event (senpi#3549). */
+    readonly uncommittedAttemptsAreUnsent?: boolean;
     /**
      * Receives a listener's throw; an owner should always supply it, since the default rethrow is uncaught. A committed transition is not undone by a failing observer, and its dispatch
      * still runs; by default the error is rethrown on a later microtask so it is never silently lost.
      */
     readonly onListenerError?: (error: unknown) => void;
 }
-export type PendingInputListener = (projection: PendingInputProjection) => void;
+/** Called after each committed transition with its projection and the journal cursor it was written at. */
+export type PendingInputListener = (projections: readonly PendingInputProjection[], cursor: number) => void;
+/** Transitions inside one gated step: each is committed directly, since the caller already holds the gate. */
+export interface PendingInputTransaction {
+    submit(event: Omit<SubmitEvent, "type" | "handle">): Promise<PendingInputOperationResult | undefined>;
+    apply(clientMessageId: string, event: Exclude<PendingInputEvent, SubmitEvent>): Promise<PendingInputOperationResult | undefined>;
+    /** Applies every change in one journal record: all of them land or none does. */
+    applyAll(changes: readonly {
+        readonly clientMessageId: string;
+        readonly event: Exclude<PendingInputEvent, SubmitEvent>;
+    }[]): Promise<(PendingInputOperationResult | undefined)[]>;
+    current(clientMessageId: string): PendingInput | undefined;
+}
 export type PendingInputRead = {
     readonly status: "admitted";
     readonly projection: PendingInputProjection;
@@ -62,11 +78,26 @@ export declare class PendingInputStore {
     apply(clientMessageId: string, event: Exclude<PendingInputEvent, SubmitEvent>): Promise<PendingInputOperationResult | undefined>;
     /** Explicit Stop over the inputs the caller saw: each named revision is removed or reported, never guessed. */
     stop(items: readonly StopItem[], consumerFenced: boolean): Promise<StopReceipt>;
+    /**
+     * Runs `work` under the gate every command shares, so a consumer can change its native buffer and the
+     * journal in one step that no edit, removal or other consumer can interleave with.
+     */
+    transaction<T>(work: (tx: PendingInputTransaction) => Promise<T>): Promise<T>;
+    /** The full record of one input, for the session that owns this store. */
+    current(clientMessageId: string): PendingInput | undefined;
     read(clientMessageId: string): PendingInputRead;
+    /** The cursor of the newest committed transition; a snapshot taken now covers everything through it. */
+    get throughCursor(): number;
     snapshot(): readonly PendingInputProjection[];
     subscribe(listener: PendingInputListener): () => void;
     private serialize;
+    private admit;
     private commit;
+    /**
+     * Reduces every change, then records all that changed in ONE journal record, so a crash or a failed write
+     * keeps either all of them or none (a consumer committing a batch never sees half of it delivered).
+     */
+    private commitMany;
     private reportListenerError;
 }
 /** A previous write may have landed without being synced; only a reopen can say what the journal holds. */

package/dist/core/pending-input-store.js

@@ -14,25 +14,24 @@ export class PendingInputStore {
     static async open(options) {
         const store = new PendingInputStore(options);
         for (const record of await options.journal.read()) {
-            store.inputs.set(record.input.clientMessageId, record.input);
+            for (const input of [record.input, ...(record.batch ?? [])])
+                store.inputs.set(input.clientMessageId, input);
             store.cursor = Math.max(store.cursor, record.cursor);
         }
         for (const input of [...store.inputs.values()]) {
             if (input.phase === "delivered" || input.phase === "removed")
                 continue;
             const handle = { lifetimeId: options.lifetimeId, queuedId: options.nextQueuedId() };
-            await store.commit(input.clientMessageId, { type: "rebind", handle });
+            await store.commit(input.clientMessageId, {
+                type: "rebind",
+                handle,
+                attemptsUnsent: options.uncommittedAttemptsAreUnsent === true,
+            });
         }
         return store;
     }
     submit(event) {
-        return this.serialize(() => {
-            const handle = this.inputs.get(event.clientMessageId)?.handle ?? {
-                lifetimeId: this.options.lifetimeId,
-                queuedId: this.options.nextQueuedId(),
-            };
-            return this.commit(event.clientMessageId, { ...event, type: "submit", handle });
-        });
+        return this.serialize(() => this.admit(event));
     }
     apply(clientMessageId, event) {
         return this.serialize(() => this.commit(clientMessageId, event));
@@ -67,12 +66,32 @@ export class PendingInputStore {
             return { removed, conflicts, retained, stale };
         });
     }
+    /**
+     * Runs `work` under the gate every command shares, so a consumer can change its native buffer and the
+     * journal in one step that no edit, removal or other consumer can interleave with.
+     */
+    transaction(work) {
+        return this.serialize(() => work({
+            submit: (event) => this.admit(event),
+            apply: (clientMessageId, event) => this.commit(clientMessageId, event),
+            applyAll: (changes) => this.commitMany(changes),
+            current: (clientMessageId) => this.inputs.get(clientMessageId),
+        }));
+    }
+    /** The full record of one input, for the session that owns this store. */
+    current(clientMessageId) {
+        return this.inputs.get(clientMessageId);
+    }
     read(clientMessageId) {
         const input = this.inputs.get(clientMessageId);
         return input === undefined
             ? { status: "not_admitted", clientMessageId }
             : { status: "admitted", projection: projectPendingInput(input) };
     }
+    /** The cursor of the newest committed transition; a snapshot taken now covers everything through it. */
+    get throughCursor() {
+        return this.cursor;
+    }
     snapshot() {
         return [...this.inputs.values()].map(projectPendingInput);
     }
@@ -90,18 +109,43 @@ export class PendingInputStore {
         this.gate = run.catch(() => undefined);
         return run;
     }
+    admit(event) {
+        const handle = this.inputs.get(event.clientMessageId)?.handle ?? {
+            lifetimeId: this.options.lifetimeId,
+            queuedId: this.options.nextQueuedId(),
+        };
+        return this.commit(event.clientMessageId, { ...event, type: "submit", handle });
+    }
     async commit(clientMessageId, event) {
-        const current = this.inputs.get(clientMessageId);
-        const decision = reducePendingInput(current, event);
-        const next = decision.next;
-        const result = decision.result?.clientMessageId === "" ? { ...decision.result, clientMessageId } : decision.result;
-        if (next === undefined || decision.effects.length === 0)
-            return result;
+        return (await this.commitMany([{ clientMessageId, event }]))[0];
+    }
+    /**
+     * Reduces every change, then records all that changed in ONE journal record, so a crash or a failed write
+     * keeps either all of them or none (a consumer committing a batch never sees half of it delivered).
+     */
+    async commitMany(changes) {
+        const results = [];
+        const committed = [];
+        const staged = new Map();
+        for (const { clientMessageId, event } of changes) {
+            const current = staged.get(clientMessageId) ?? this.inputs.get(clientMessageId);
+            const decision = reducePendingInput(current, event);
+            const result = decision.result?.clientMessageId === "" ? { ...decision.result, clientMessageId } : decision.result;
+            results.push(result);
+            if (decision.next === undefined || decision.effects.length === 0)
+                continue;
+            staged.set(clientMessageId, decision.next);
+            committed.push({ next: decision.next, decision: { ...decision, result } });
+        }
+        const [first, ...rest] = committed;
+        if (first === undefined)
+            return results;
         const record = {
             type: PENDING_INPUT_TRANSITION,
             cursor: this.cursor + 1,
-            input: next,
-            ...(result === undefined ? {} : { result }),
+            input: first.next,
+            ...(first.decision.result === undefined ? {} : { result: first.decision.result }),
+            ...(rest.length === 0 ? {} : { batch: rest.map((entry) => entry.next) }),
         };
         try {
             await this.options.journal.append(record);
@@ -114,23 +158,27 @@ export class PendingInputStore {
             throw error;
         }
         this.cursor = record.cursor;
-        this.inputs.set(clientMessageId, next);
-        const projection = projectPendingInput(next);
+        for (const { next } of committed)
+            this.inputs.set(next.clientMessageId, next);
+        // One notification per record: every input it changed, under its one cursor.
+        const projections = committed.map(({ next }) => projectPendingInput(next));
         for (const listener of this.listeners) {
             try {
-                listener(projection);
+                listener(projections, record.cursor);
             }
             catch (error) {
                 this.reportListenerError(error);
             }
         }
-        for (const effect of decision.effects) {
-            if (effect.type === "dispatch")
-                this.options.dispatch?.(effect.token, next);
-            if (effect.type === "restore_to_draft")
-                this.options.restoreToDraft?.(effect.text);
+        for (const { next, decision } of committed) {
+            for (const effect of decision.effects) {
+                if (effect.type === "dispatch")
+                    this.options.dispatch?.(effect.token, next);
+                if (effect.type === "restore_to_draft")
+                    this.options.restoreToDraft?.(effect.text);
+            }
         }
-        return result;
+        return results;
     }
     reportListenerError(error) {
         const report = this.options.onListenerError;

package/dist/core/pending-input-types.d.ts

@@ -34,6 +34,8 @@ export interface SupersededVersion {
 export interface PendingInputFailure {
     readonly delivery: DeliveryCertainty;
     readonly reason: string;
+    /** The reservation that failed, kept so later evidence must name the attempt it is about. */
+    readonly attempt?: DeliveryToken;
 }
 /** The recorded answer of one operation, replayed byte for byte when the same effect id repeats. */
 export interface RecordedOperation {
@@ -94,12 +96,22 @@ export type PendingInputEvent = SubmitEvent | {
 } | {
     readonly type: "reserve";
     readonly token: DeliveryToken;
+}
+/** The consumer gave the attempt back before any of it was committed or sent: queued again, same id. */
+ | {
+    readonly type: "release";
+    readonly token: DeliveryToken;
 } | {
     readonly type: "consumed";
     readonly token: DeliveryToken;
+}
+/** A handled-command receipt: with the reservation's token, or naming the lifetime of a still-queued input. */
+ | {
+    readonly type: "handled";
+    readonly token: DeliveryToken;
 } | {
     readonly type: "handled";
-    readonly token?: DeliveryToken;
+    readonly lifetimeId: string;
 } | {
     readonly type: "refused";
     readonly token: DeliveryToken;
@@ -109,13 +121,15 @@ export type PendingInputEvent = SubmitEvent | {
     readonly token: DeliveryToken;
     readonly reason: string;
 }
-/** An identity-bearing delivery witness found after the fact (a late event or recovery). */
+/** An identity-bearing delivery witness found after the fact (a late event or recovery), for one failed attempt. */
  | {
     readonly type: "witnessed";
+    readonly attemptId: string;
 }
-/** Complete, fenced evidence that no consumer can still deliver the attempt. */
+/** Complete, fenced evidence that no consumer can still deliver the named failed attempt. */
  | {
     readonly type: "non_delivery_proven";
+    readonly attemptId: string;
 }
 /** Teardown that is not an explicit user action: reload, unload, crash, handoff. */
  | {
@@ -129,9 +143,16 @@ export type PendingInputEvent = SubmitEvent | {
     readonly type: "cancel";
     readonly cause: "stop" | "child_cancel";
     readonly consumerFenced: boolean;
-} | {
+}
+/**
+ * A reopen. `attemptsUnsent` is the journal owner's proof that an attempt still `sending` was never handed to
+ * its consumer: the engine commits consumption before any provider sees the input, so a reservation without a
+ * later delivered record returns to the queue under the same id. Without it the attempt stays uncertain.
+ */
+ | {
     readonly type: "rebind";
     readonly handle: PendingInputHandle;
+    readonly attemptsUnsent?: boolean;
 };
 export type OperationOutcome = "admitted" | "replayed" | "client_message_id_conflict" | "edited" | "removed" | "requeued" | "already_delivered" | "not_found" | "conflict" | "sending" | "not_retryable" | "not_editable" | "unresolved" | "effect_id_conflict" | "stale_handle";
 export interface PendingInputOperationResult {

package/dist/core/pending-input.js

@@ -54,15 +54,21 @@ function reduceLifecycle(current, event) {
             };
             return { next, effects: [{ type: "persist" }, { type: "dispatch", token: event.token }] };
         }
+        case "release": {
+            if (!holdsAttempt(current, event.token))
+                return unchanged(current);
+            const { attempt: _attempt, ...rest } = current;
+            return persist({ ...rest, phase: "queued" });
+        }
         case "consumed":
             return holdsAttempt(current, event.token) ? persist(deliver(current, "consumed")) : unchanged(current);
         case "handled":
-            if (current.phase === "queued")
-                return persist(deliver(current, "handled"));
-            if (event.token !== undefined && holdsAttempt(current, event.token)) {
-                return persist(deliver(current, "handled"));
-            }
-            return unchanged(current);
+            if ("token" in event)
+                return holdsAttempt(current, event.token) ? persist(deliver(current, "handled")) : unchanged(current);
+            // Without a token the receipt must name the lifetime of the still-queued input it settles.
+            return current.phase === "queued" && event.lifetimeId === current.handle.lifetimeId
+                ? persist(deliver(current, "handled"))
+                : unchanged(current);
         case "refused":
             return holdsAttempt(current, event.token)
                 ? persist(fail(current, "not_delivered", event.reason))
@@ -76,12 +82,10 @@ function reduceLifecycle(current, event) {
                 ? persist(fail(current, "uncertain", "the delivering owner was lost"))
                 : unchanged(current);
         case "witnessed":
-            return current.phase === "failed" && current.failure?.delivery === "uncertain"
-                ? persist(deliver(current, "consumed"))
-                : unchanged(current);
+            return uncertainAbout(current, event.attemptId) ? persist(deliver(current, "consumed")) : unchanged(current);
         case "non_delivery_proven":
-            return current.phase === "failed" && current.failure?.delivery === "uncertain"
-                ? persist(fail(current, "not_delivered", current.failure.reason))
+            return uncertainAbout(current, event.attemptId)
+                ? persist(fail(current, "not_delivered", current.failure?.reason ?? ""))
                 : unchanged(current);
         case "teardown":
             return current.phase === "sending"
@@ -90,7 +94,7 @@ function reduceLifecycle(current, event) {
         case "cancel":
             return cancel(current, event.cause, event.consumerFenced);
         case "rebind":
-            return rebind(current, event.handle);
+            return rebind(current, event.handle, event.attemptsUnsent === true);
     }
 }
 function cancel(current, cause, consumerFenced) {
@@ -108,13 +112,16 @@ function cancel(current, cause, consumerFenced) {
             : [{ type: "persist" }],
     };
 }
-function rebind(current, handle) {
+function rebind(current, handle, attemptsUnsent) {
     if (current.phase === "delivered" || current.phase === "removed")
         return unchanged(current);
     const rebound = { ...current, handle, revision: 1 };
-    return current.phase === "sending"
-        ? persist(fail(rebound, "uncertain", "the session reopened during handoff"))
-        : persist(rebound);
+    if (current.phase !== "sending")
+        return persist(rebound);
+    if (!attemptsUnsent)
+        return persist(fail(rebound, "uncertain", "the session reopened during handoff"));
+    const { attempt: _attempt, ...unsent } = rebound;
+    return persist({ ...unsent, phase: "queued" });
 }
 function tokenFitsInput(input, token) {
     return token.lifetimeId === input.handle.lifetimeId && token.clientMessageId === input.clientMessageId;
@@ -132,8 +139,19 @@ function deliver(input, deliveredBy) {
     return settled({ ...input, phase: "delivered", ...(deliveredBy === undefined ? {} : { deliveredBy }) });
 }
 function fail(input, delivery, reason) {
-    const { attempt: _attempt, ...rest } = input;
-    return { ...rest, phase: "failed", failure: { delivery, reason } };
+    const { attempt, ...rest } = input;
+    const failedAttempt = attempt ?? input.failure?.attempt;
+    return {
+        ...rest,
+        phase: "failed",
+        failure: { delivery, reason, ...(failedAttempt === undefined ? {} : { attempt: failedAttempt }) },
+    };
+}
+/** Late evidence only settles the uncertain failure of the exact attempt it names. */
+function uncertainAbout(input, attemptId) {
+    return (input.phase === "failed" &&
+        input.failure?.delivery === "uncertain" &&
+        input.failure.attempt?.attemptId === attemptId);
 }
 function settled(input) {
     const { attempt: _attempt, failure: _failure, ...rest } = input;

package/dist/core/session-entry-file.js

@@ -134,6 +134,7 @@ export function terminateFinalSessionLine(filePath) {
             return;
         const segment = Buffer.alloc(size - segmentStart);
         readSync(fd, segment, 0, segment.length, segmentStart);
+        // Not synced on purpose: a lost truncate only brings back an uncommitted tail, and the next append syncs.
         if (parseSessionEntryLine(segment.toString("utf8")) === null)
             ftruncateSync(fd, segmentStart);
         else

package/dist/core/session-log.js

@@ -7,7 +7,7 @@ const DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
 const MAX_STRING_LENGTH = 200;
 const DEBUG_PREFIX = `[${APP_NAME}-session]`;
 const BLOCKED_KEY = /^(?:__proto__|constructor|prototype|headers?|env(?:ironment)?|authorization|credential(?:s)?|password|secret|token|api_?key|client_?secret)$/i;
-const ALLOWED_DATA_KEY = /^(?:action|attemptId|disposition|stage|error|mode|count|willRetry|deferAdmission|delivered|restored|cause|accepted|skipped|rejectionCause|reason|durationMs|kind|retryable|phase|op|bytes|generation|requestId|tokens|tokensBefore|tokensAfter|contextWindow|attempt|aborted|sessionId|role|provider|model|source|actor|from|to|duringTurn|persistDefault)$/;
+const ALLOWED_DATA_KEY = /^(?:action|attemptId|disposition|stage|error|mode|count|willRetry|deferAdmission|delivered|restored|cause|accepted|skipped|rejectionCause|reason|durationMs|kind|retryable|phase|op|bytes|generation|requestId|tokens|tokensBefore|tokensAfter|contextWindow|attempt|aborted|sessionId|role|provider|model|source|actor|from|to|duringTurn|persistDefault|extension|handlerEvent)$/;
 const SENSITIVE_TEXT = /((?:authorization\s*[:=]\s*(?:bearer|basic)\s+)|(?:bearer\s+)|(?:[?&](?:api[_-]?key|token|secret|password|auth(?:orization)?)=))[^\s&,"'}\]]+/gi;
 export function createSessionLogger(agentDir, options = {}) {
     if (typeof agentDir !== "string" || agentDir.length === 0) {

package/dist/core/session-manager.d.ts

@@ -310,6 +310,7 @@ export declare class SessionManager {
     private sessionDir;
     private cwd;
     private persist;
+    private readonly writeGuard;
     private flushed;
     private headerWrite;
     private ownedHeaderFile;