@skrr-ai/cli 0.1.84 → 0.1.86

package/dist/commands/agents/chat.js

@@ -265,8 +265,13 @@ class AgentsChat extends base_command_1.BaseCommand {
                 'so folding both doubles the answer: pick ONE lane. Inside a `session.output`, ' +
                 '`envelopes[].__seq` is the dedupe key and the ordering key — the same envelope is ' +
                 'delivered by more than one room, and a re-delivery repeats its `__seq`. A ' +
-                '`stream.gap` event means envelopes in that seq range never arrived and the streamed ' +
-                'text is short; `run.result` and the persisted message remain authoritative. Tool ' +
+                '`stream.gap` event means envelopes in that seq range never arrived and replay from ' +
+                'the server could not recover them; a hole replay fills, or one that held only ' +
+                'invisible envelopes (`service`, `status`), emits nothing. When the persisted message ' +
+                'could be checked, `verified` is true and `missing` names what the stream is short of ' +
+                '(`text`, `tool`), and the event arrives just before the terminal event; `verified: ' +
+                'false` means it could not be checked and the text MAY be short. `run.result` and the ' +
+                'persisted message remain authoritative. Tool ' +
                 'calls arrive as `tool.started` / `tool.completed`, once per `toolUseId`, on cloud ' +
                 'and local-harness runs alike. A `session.notice` with `notice: ' +
                 '"harness-session-reset"` means the local harness could not resume its previous ' +
@@ -376,7 +381,9 @@ class AgentsChat extends base_command_1.BaseCommand {
         this.requireAuth();
         const { args, flags } = await this.parse(AgentsChat);
         if (flags.quick && flags.task)
-            this.error('--task requires a runtime session; remove --quick to bind this turn.', { exit: 2 });
+            this.error('--task requires a runtime session; remove --quick to bind this turn.', {
+                exit: 2,
+            });
         if (flags.json && !flags['no-stream'] && !flags.quick) {
             this.error('--json is only supported with --no-stream or --quick; use --jsonl for streaming.', {
                 exit: 2,

package/dist/commands/agents/endpoint/enable.js

@@ -40,6 +40,12 @@ class AgentsEndpointEnable extends base_command_1.BaseCommand {
         }
         (0, agent_endpoints_1.printAgentEndpoint)(this, endpoint);
         this.log('');
+        if (!(0, agent_endpoints_1.endpointWillRun)(endpoint)) {
+            // On is not the same as runnable: say so rather than end on a connect
+            // line that leads to a refused first call (OSK-13521).
+            this.log(endpoint.notice ||
+                `The endpoint is on, but it will not run a turn until ${endpoint.blocked_by?.code ?? 'its blocker'} clears.`);
+        }
         this.log('Connect a client with: skrr agents endpoint connect ' + args.id + ' --space <space-id>');
     }
 }

package/dist/commands/store/acquisitions/approve.js

@@ -66,6 +66,9 @@ class StoreAcquisitionsApprove extends base_command_1.BaseCommand {
                 exit: 1,
             });
         }
+        if (request.invalidReason === 'buyer_terms_missing') {
+            this.error(`This request was recorded without buyer terms, so it cannot be approved. Decline it with \`skrr store acquisitions decline ${request.id}\`; the agent's next attempt opens a new request that carries the terms.`, { exit: 1 });
+        }
         if (!request.buyerTerms) {
             this.error('Buyer terms are not configured, so this purchase cannot be approved.', {
                 exit: 1,

package/dist/lib/agent-endpoints.d.ts

@@ -23,11 +23,14 @@ export interface AgentEndpoint {
     enabled_at?: string | null;
     switchable: boolean;
     ready: boolean;
-    /** The gate that would refuse a turn right now (see docs/cli/SKRR_AGENT_ENDPOINTS.md). */
-    blocked_by: {
-        code: string;
-        message: string;
-    } | null;
+    /**
+     * The gate that would refuse a turn right now (see docs/cli/SKRR_AGENT_ENDPOINTS.md).
+     * Includes the agent-worker runtime admission endpoint turns run on — e.g.
+     * `RUNTIME_METERING_BACKLOG_BLOCKED` — with the next step in `remedy`.
+     */
+    blocked_by: AgentEndpointBlocker | null;
+    /** Set by `enable` when the endpoint is on but a turn would still be refused. */
+    notice?: string;
     release?: {
         id: string;
         version_label: string | null;
@@ -44,6 +47,12 @@ export interface AgentEndpoint {
     };
     workspace_id?: string | null;
 }
+export interface AgentEndpointBlocker {
+    code: string;
+    message: string;
+    remedy?: string | null;
+    details?: Record<string, unknown>;
+}
 export declare function getAgentEndpoint(agentId: string): Promise<AgentEndpoint>;
 /** Turn a Store instance's endpoint on or off. Owner only, enforced server-side. */
 export declare function setAgentEndpointEnabled(agentId: string, enabled: boolean): Promise<AgentEndpoint>;
@@ -56,6 +65,11 @@ export declare const AGENT_ENDPOINT_SCOPE = "agents:invoke";
 export declare function mcpClientCommand(endpoint: AgentEndpoint, secret: string): string;
 /** One human line for the state an endpoint is in. */
 export declare function describeEndpointState(endpoint: AgentEndpoint): string;
+/**
+ * Whether the endpoint would run a turn now. `ready` alone is the answer; this
+ * exists so a caller never reads `enabled` as "it works" (OSK-13521).
+ */
+export declare function endpointWillRun(endpoint: AgentEndpoint): boolean;
 /** The human rendering every `agents endpoint` command prints. */
 export declare function printAgentEndpoint(cmd: {
     log: (line: string) => void;

package/dist/lib/agent-endpoints.js

@@ -5,6 +5,7 @@ exports.getAgentEndpoint = getAgentEndpoint;
 exports.setAgentEndpointEnabled = setAgentEndpointEnabled;
 exports.mcpClientCommand = mcpClientCommand;
 exports.describeEndpointState = describeEndpointState;
+exports.endpointWillRun = endpointWillRun;
 exports.printAgentEndpoint = printAgentEndpoint;
 const api_fetch_1 = require("./api-fetch");
 async function getAgentEndpoint(agentId) {
@@ -40,11 +41,21 @@ function describeEndpointState(endpoint) {
     }
     return 'on';
 }
+/**
+ * Whether the endpoint would run a turn now. `ready` alone is the answer; this
+ * exists so a caller never reads `enabled` as "it works" (OSK-13521).
+ */
+function endpointWillRun(endpoint) {
+    return endpoint.enabled && endpoint.ready && !endpoint.blocked_by;
+}
 /** The human rendering every `agents endpoint` command prints. */
 function printAgentEndpoint(cmd, endpoint) {
     cmd.log(`Agent     ${endpoint.agent_id}${endpoint.agent_name ? ` (${endpoint.agent_name})` : ''}`);
     cmd.log(`Kind      ${endpoint.kind.replace(/_/g, ' ')}`);
     cmd.log(`Endpoint  ${describeEndpointState(endpoint)}`);
+    if (endpoint.blocked_by?.remedy) {
+        cmd.log(`Next step ${endpoint.blocked_by.remedy}`);
+    }
     if (endpoint.url) {
         cmd.log(`URL       ${endpoint.url}  (MCP, ${endpoint.transport})`);
         cmd.log(`Key scope ${endpoint.scope}`);

package/dist/lib/agentic-stream.d.ts

@@ -99,6 +99,13 @@ export type AgenticStreamOptions = {
     replayEnvelopes?: (from: number) => Promise<EnvelopeReplayPage>;
     /** Bounded live catch-up cadence while a run is active. Default 2s. */
     envelopeReplayIntervalMs?: number;
+    /**
+     * Where debug-level records go — a seq hole that replay filled, or one that
+     * was never filled but provably carried nothing the reader sees. Default:
+     * stderr when `DEBUG` is set, otherwise nowhere. Never stdout: `--jsonl`
+     * owns that stream and its contract does not include diagnostics.
+     */
+    debug?: (line: string) => void;
     /** Silence before the first durable-record probe. Default 20s. */
     idleTerminalProbeMs?: number;
     /** How long to keep trying to attach before reporting a detach. Default 30s. */
@@ -335,16 +342,19 @@ export declare function jitteredRetryDelay(retryAfterMs: number, random?: () =>
  * is the more dangerous of the two to leave silent, because a truncated live
  * answer looks like a complete short answer.
  *
- * The web client already detects this (`client_envelope_seq_gap_detected_total`)
- * and rehydrates the missing range from the envelope ring. The CLI had neither
- * the detection nor the backfill, so the only correction it could make was at
- * the terminal — which it does: `run.result` and the persisted message are
- * authoritative and already correct here. What was missing was any admission,
- * WHILE READING, that the text on screen is not all of it.
+ * The web client detects this (`client_envelope_seq_gap_detected_total`) and
+ * rehydrates the missing range from the envelope ring; the CLI now does the
+ * same through `replayEnvelopes` (the canonical
+ * `GET /api/agentic/sessions/:id/envelopes`), holding later frames behind a
+ * hole until replay fills it.
  *
- * Tracks the highest seq applied and reports the first gap. Deliberately does
- * not try to reconstruct: a client that guesses at missing text is worse than
- * one that says it is missing.
+ * A hole replay fills is not a gap at all. One it cannot fill is judged at the
+ * terminal against the persisted message, and is warned about only when the
+ * stream is proven short of text or of a tool call (OSK-13518): the commonest
+ * hole — `service` / `slash-commands-available` envelopes a daemon published
+ * before the viewer joined the room — carries nothing the reader sees. Still
+ * never reconstructs: a client that guesses at missing text is worse than one
+ * that says it is missing.
  */
 export type SeqGap = {
     from: number;
@@ -358,8 +368,23 @@ export type SeqGap = {
  */
 export declare function projectSessionNotices(envelopes: unknown[]): AgenticStreamEvent[];
 export declare function detectSeqGap(highestApplied: number, incoming: number): SeqGap | null;
+/** What a lost range is proven to have cost the reader. */
+export type SeqGapLoss = 'text' | 'tool';
 /**
- * The notice a reader sees when chunks went missing.
+ * The notice a reader sees when chunks went missing AND stayed missing.
+ *
+ * A hole in `__seq` is not by itself a loss: most of the envelopes a daemon
+ * publishes before the viewer is admitted to the room — `service`
+ * ("Spawning Codex session"), `slash-commands-available`, `status` — carry
+ * nothing the reader sees, and the replay endpoint returns them anyway
+ * (OSK-13518). So this sentence is only ever built for a range that replay
+ * could NOT fill, and it says exactly as much as is known about it:
+ *
+ * - `missing` given: the range was checked against the persisted message and
+ *   the stream is proven short of `text`, or a `tool` call's start never
+ *   arrived (its end did). The sentence says which.
+ * - `missing` absent: nothing could check it — no record, or the record could
+ *   not be read — so it says "may", never "is".
  *
  * It names `run.result` only when this client will actually fill `run.result`
  * from the persisted message (`recordBackfill`). The sentence used to promise
@@ -367,9 +392,20 @@ export declare function detectSeqGap(highestApplied: number, incoming: number):
  * that DID arrive — so the one run told to trust `run.result` was the run whose
  * `run.result.text` was empty, with the answer only in the record (OSK-12132).
  */
-export declare function seqGapNotice(gap: SeqGap, options?: {
+export declare function seqGapNotice(gaps: SeqGap | readonly SeqGap[], options?: {
     recordBackfill?: boolean;
+    missing?: readonly SeqGapLoss[];
 }): string;
+/**
+ * Did the stream show everything the record holds?
+ *
+ * Whitespace-insensitive containment, not equality: the record may join text
+ * blocks with blank lines the envelopes never carried, and on some paths it
+ * holds only the last block of an answer the stream showed in full (OSK-7703).
+ * Both of those are "nothing missing". What is missing is persisted text the
+ * stream never showed — and that is the only thing this answers yes to.
+ */
+export declare function streamShowsRecordedText(streamed: string, recorded: string): boolean;
 /**
  * The permission mode a `run.started` reports, and where it came from
  * (OSK-12089). `null` when the event carries no mode report at all — a cloud
@@ -392,7 +428,19 @@ export declare class AgenticStreamClient {
     private replayGeneration;
     private replayFailures;
     private finishingReplay;
+    /** A frame was held while a replay read was already in flight (see catchUpEnvelopes). */
+    private heldDuringFlight;
+    /** A user-visible `stream.gap` was emitted; at most one per stream. */
     private reportedGap;
+    /**
+     * Seq ranges passed over WITHOUT recovery. Not yet a loss: whether they cost
+     * the reader anything is decided against the record at the terminal.
+     */
+    private readonly lostRanges;
+    /** Daemon tool calls whose `tool-call-start` was applied. */
+    private readonly startedDaemonCalls;
+    /** A `tool-call-end` arrived whose start never did — proof a tool envelope was lost. */
+    private orphanToolEnd;
     private readonly seenEnvelopes;
     /**
      * Lifecycle events already emitted, by their own identity (OSK-7632/7689/7709).
@@ -494,15 +542,34 @@ export declare class AgenticStreamClient {
     probeTerminal(reason: string): Promise<boolean>;
     cancel(reason?: string): void;
     close(): void;
+    private debug;
+    /**
+     * Record a hole being passed over — the moment replay has given up on it.
+     *
+     * Reaching here means the range is NOT recoverable: with a replay path every
+     * held frame waits behind the hole until the canonical endpoint fills it, and
+     * is only released past it on an explicit retention gap, repeated replay
+     * failure, or the terminal. What it is not yet is a LOSS. A hole made of
+     * `service` / `slash-commands-available` / `status` envelopes costs the
+     * reader nothing, and a warning about it is false (OSK-13518). So when the
+     * record can be read at the terminal, the verdict waits for it
+     * ({@link settleGapVerdict}). Only a client with no record to consult says
+     * something now, and then only what it knows: "may be incomplete".
+     */
+    private noteSeqGap;
+    private emitGap;
+    /** Track daemon tool starts, and notice an end whose start never arrived. */
+    private noteDaemonToolEnvelopes;
     /**
-     * Report the first hole in the live envelope sequence, once.
+     * Decide, against the persisted message, whether unrecovered ranges cost the
+     * reader anything — and say so only if they did.
      *
-     * Once, not per gap: a stream that has already lost its beginning tends to
-     * lose more, and one honest sentence is the useful form of that. The terminal
-     * result is authoritative and reconciled separately, so this never changes
-     * what the run reports — only what the reader is told while it is happening.
+     * `recorded` undefined means the record could not be read: unverifiable, so
+     * the hedged notice. Otherwise the stream is short of text exactly when the
+     * record holds text the stream never showed, and short of a tool call exactly
+     * when an end arrived without its start. Neither → a debug record and silence.
      */
-    private reportSeqGap;
+    private settleGapVerdict;
     /** Keep later live frames behind missing earlier frames while canonical replay catches up. */
     private receiveSessionOutput;
     private flushPendingEnvelopes;

package/dist/lib/agentic-stream.js

@@ -19,6 +19,7 @@ exports.jitteredRetryDelay = jitteredRetryDelay;
 exports.projectSessionNotices = projectSessionNotices;
 exports.detectSeqGap = detectSeqGap;
 exports.seqGapNotice = seqGapNotice;
+exports.streamShowsRecordedText = streamShowsRecordedText;
 exports.describeRunPermission = describeRunPermission;
 exports.toWebSocketOrigin = toWebSocketOrigin;
 const node_readline_1 = require("node:readline");
@@ -571,7 +572,20 @@ function detectSeqGap(highestApplied, incoming) {
     return { from: highestApplied + 1, to: incoming - 1 };
 }
 /**
- * The notice a reader sees when chunks went missing.
+ * The notice a reader sees when chunks went missing AND stayed missing.
+ *
+ * A hole in `__seq` is not by itself a loss: most of the envelopes a daemon
+ * publishes before the viewer is admitted to the room — `service`
+ * ("Spawning Codex session"), `slash-commands-available`, `status` — carry
+ * nothing the reader sees, and the replay endpoint returns them anyway
+ * (OSK-13518). So this sentence is only ever built for a range that replay
+ * could NOT fill, and it says exactly as much as is known about it:
+ *
+ * - `missing` given: the range was checked against the persisted message and
+ *   the stream is proven short of `text`, or a `tool` call's start never
+ *   arrived (its end did). The sentence says which.
+ * - `missing` absent: nothing could check it — no record, or the record could
+ *   not be read — so it says "may", never "is".
  *
  * It names `run.result` only when this client will actually fill `run.result`
  * from the persisted message (`recordBackfill`). The sentence used to promise
@@ -579,15 +593,44 @@ function detectSeqGap(highestApplied, incoming) {
  * that DID arrive — so the one run told to trust `run.result` was the run whose
  * `run.result.text` was empty, with the answer only in the record (OSK-12132).
  */
-function seqGapNotice(gap, options = {}) {
-    const count = gap.to - gap.from + 1;
-    const where = options.recordBackfill === false
+function seqGapNotice(gaps, options = {}) {
+    const ranges = Array.isArray(gaps) ? gaps : [gaps];
+    const count = ranges.reduce((n, g) => n + (g.to - g.from + 1), 0);
+    const where = ranges.map((g) => (g.from === g.to ? `${g.from}` : `${g.from}-${g.to}`)).join(', ');
+    const head = `[${count} stream chunk${count === 1 ? '' : 's'} (seq ${where}) never arrived ` +
+        'and could not be recovered';
+    const record = options.recordBackfill === false
         ? 'The full answer is in the persisted message.'
         : 'The full answer is in the persisted message and in run.result.';
-    return (`[${count} stream chunk${count === 1 ? '' : 's'} (seq ${gap.from}` +
-        `${count === 1 ? '' : `-${gap.to}`}) never arrived — the text above is incomplete. ` +
-        `${where}]`);
+    const missing = options.missing;
+    if (!missing) {
+        return `${head} — the text above may be incomplete. ${record}]`;
+    }
+    const lostText = missing.includes('text');
+    const lostTool = missing.includes('tool');
+    if (!lostText) {
+        return `${head} — a tool call above is missing its start; the answer text is complete. The persisted message has the whole turn.]`;
+    }
+    const what = lostTool ? 'text and tool calls above are' : 'text above is';
+    return `${head} — the streamed ${what} incomplete. ${record}]`;
 }
+/**
+ * Did the stream show everything the record holds?
+ *
+ * Whitespace-insensitive containment, not equality: the record may join text
+ * blocks with blank lines the envelopes never carried, and on some paths it
+ * holds only the last block of an answer the stream showed in full (OSK-7703).
+ * Both of those are "nothing missing". What is missing is persisted text the
+ * stream never showed — and that is the only thing this answers yes to.
+ */
+function streamShowsRecordedText(streamed, recorded) {
+    const squash = (s) => s.replace(/\s+/g, '');
+    return squash(streamed).includes(squash(recorded));
+}
+const defaultStreamDebug = (line) => {
+    if (process.env.DEBUG)
+        process.stderr.write(`[agentic-stream debug] ${line}\n`);
+};
 /** How long, at most, a gapped run waits for the record before settling anyway. */
 const GAP_BACKFILL_ATTEMPTS = 3;
 const GAP_BACKFILL_RETRY_MS = 400;
@@ -635,7 +678,19 @@ class AgenticStreamClient {
     replayGeneration = 0;
     replayFailures = 0;
     finishingReplay = false;
+    /** A frame was held while a replay read was already in flight (see catchUpEnvelopes). */
+    heldDuringFlight = false;
+    /** A user-visible `stream.gap` was emitted; at most one per stream. */
     reportedGap = false;
+    /**
+     * Seq ranges passed over WITHOUT recovery. Not yet a loss: whether they cost
+     * the reader anything is decided against the record at the terminal.
+     */
+    lostRanges = [];
+    /** Daemon tool calls whose `tool-call-start` was applied. */
+    startedDaemonCalls = new Set();
+    /** A `tool-call-end` arrived whose start never did — proof a tool envelope was lost. */
+    orphanToolEnd = false;
     // Envelope keys already applied, so a re-delivered `session:output` frame is
     // not appended twice (OSK-4834). Cleared on `execution:stream-reset`.
     seenEnvelopes = new Set();
@@ -868,34 +923,113 @@ class AgenticStreamClient {
         this.readline?.close();
         this.readline = null;
     }
+    debug(line) {
+        try {
+            (this.options.debug ?? defaultStreamDebug)(`session ${this.options.sessionId}: ${line}`);
+        }
+        catch {
+            // A diagnostic sink must never break the stream it describes.
+        }
+    }
     /**
-     * Report the first hole in the live envelope sequence, once.
+     * Record a hole being passed over — the moment replay has given up on it.
      *
-     * Once, not per gap: a stream that has already lost its beginning tends to
-     * lose more, and one honest sentence is the useful form of that. The terminal
-     * result is authoritative and reconciled separately, so this never changes
-     * what the run reports — only what the reader is told while it is happening.
+     * Reaching here means the range is NOT recoverable: with a replay path every
+     * held frame waits behind the hole until the canonical endpoint fills it, and
+     * is only released past it on an explicit retention gap, repeated replay
+     * failure, or the terminal. What it is not yet is a LOSS. A hole made of
+     * `service` / `slash-commands-available` / `status` envelopes costs the
+     * reader nothing, and a warning about it is false (OSK-13518). So when the
+     * record can be read at the terminal, the verdict waits for it
+     * ({@link settleGapVerdict}). Only a client with no record to consult says
+     * something now, and then only what it knows: "may be incomplete".
      */
-    reportSeqGap(envelopes) {
+    noteSeqGap(envelopes) {
         for (const envelope of envelopes) {
             const seq = Number(envelope?.__seq);
             if (!Number.isFinite(seq) || seq <= 0)
                 continue;
             const gap = detectSeqGap(this.highestSeq, seq);
-            if (gap && !this.reportedGap) {
-                this.reportedGap = true;
-                this.emit({
-                    type: 'stream.gap',
-                    sessionId: this.options.sessionId,
-                    fromSeq: gap.from,
-                    toSeq: gap.to,
-                    message: seqGapNotice(gap, { recordBackfill: Boolean(this.options.reconcileTerminal) }),
-                });
+            if (gap) {
+                this.lostRanges.push(gap);
+                this.debug(`seq ${gap.from}-${gap.to} passed over unrecovered`);
+                if (!this.options.reconcileTerminal && !this.reportedGap) {
+                    // Said WHILE READING, which is the only moment it helps (OSK-7631)
+                    // — and hedged, because nothing will ever check it.
+                    this.emitGap([gap]);
+                }
             }
             if (seq > this.highestSeq)
                 this.highestSeq = seq;
         }
     }
+    emitGap(ranges, missing) {
+        if (this.reportedGap || ranges.length === 0)
+            return;
+        this.reportedGap = true;
+        this.emit({
+            type: 'stream.gap',
+            sessionId: this.options.sessionId,
+            fromSeq: ranges[0].from,
+            toSeq: ranges[ranges.length - 1].to,
+            ...(ranges.length > 1
+                ? { ranges: ranges.map((g) => ({ fromSeq: g.from, toSeq: g.to })) }
+                : {}),
+            verified: Boolean(missing),
+            ...(missing ? { missing } : {}),
+            message: seqGapNotice(ranges, {
+                recordBackfill: Boolean(this.options.reconcileTerminal),
+                ...(missing ? { missing } : {}),
+            }),
+        });
+    }
+    /** Track daemon tool starts, and notice an end whose start never arrived. */
+    noteDaemonToolEnvelopes(envelopes) {
+        for (const envelope of envelopes) {
+            const ev = envelope?.ev;
+            if (!ev || typeof ev.call !== 'string')
+                continue;
+            if (ev.t === 'tool-call-start')
+                this.startedDaemonCalls.add(ev.call);
+            else if (ev.t === 'tool-call-end' && !this.startedDaemonCalls.has(ev.call)) {
+                this.orphanToolEnd = true;
+            }
+        }
+    }
+    /**
+     * Decide, against the persisted message, whether unrecovered ranges cost the
+     * reader anything — and say so only if they did.
+     *
+     * `recorded` undefined means the record could not be read: unverifiable, so
+     * the hedged notice. Otherwise the stream is short of text exactly when the
+     * record holds text the stream never showed, and short of a tool call exactly
+     * when an end arrived without its start. Neither → a debug record and silence.
+     */
+    settleGapVerdict(streamedText, recorded) {
+        if (this.lostRanges.length === 0 || this.reportedGap)
+            return;
+        const ranges = this.lostRanges.map((g) => `${g.from}-${g.to}`).join(', ');
+        if (!recorded) {
+            this.debug(`seq ${ranges} unrecovered and the record was unreadable; warning unverified`);
+            this.emitGap(this.lostRanges);
+            return;
+        }
+        const missing = [];
+        if (recorded.text && !streamShowsRecordedText(streamedText, recorded.text))
+            missing.push('text');
+        if (this.orphanToolEnd)
+            missing.push('tool');
+        if (missing.length === 0) {
+            this.debug(`seq ${ranges} unrecovered but carried nothing visible (record matches stream)`);
+            return;
+        }
+        this.emitGap(this.lostRanges, missing);
+        // The notice says the text above is short; what follows it is the whole
+        // answer from the record, printed in full rather than as a tail appended
+        // to a fragment the reader now knows is wrong.
+        if (missing.includes('text'))
+            this.renderedText = '';
+    }
     /** Keep later live frames behind missing earlier frames while canonical replay catches up. */
     receiveSessionOutput(event) {
         if (this.closed || this.settled)
@@ -912,6 +1046,11 @@ class AgenticStreamClient {
             }
             else if (seq > this.highestSeq && !this.pendingEnvelopes.has(seq)) {
                 this.pendingEnvelopes.set(seq, { envelope, event });
+                // A read already in flight may have been issued BEFORE this frame was
+                // published, and so before the earlier seqs it is waiting on were
+                // stamped. Its answer proves nothing about them; see catchUpEnvelopes.
+                if (this.replayFlight && event.source !== 'replay')
+                    this.heldDuringFlight = true;
             }
         }
         this.flushPendingEnvelopes(false);
@@ -942,6 +1081,7 @@ class AgenticStreamClient {
             clearTimeout(this.replayTimer);
         this.replayTimer = null;
         const generation = this.replayGeneration;
+        this.heldDuringFlight = false;
         this.replayFlight = (async () => {
             try {
                 for (let page = 0; page < 4; page += 1) {
@@ -950,6 +1090,14 @@ class AgenticStreamClient {
                     if (this.closed || this.settled || generation !== this.replayGeneration)
                         return;
                     this.replayFailures = 0;
+                    if (this.pendingEnvelopes.size && result.envelopes.length) {
+                        const seqs = result.envelopes
+                            .map((e) => Number(e?.__seq))
+                            .filter((n) => Number.isSafeInteger(n) && n > from);
+                        if (seqs.length) {
+                            this.debug(`seq ${Math.min(...seqs)}-${Math.max(...seqs)} backfilled by replay`);
+                        }
+                    }
                     this.receiveSessionOutput({
                         type: 'session.output',
                         sessionId: this.options.sessionId,
@@ -981,7 +1129,14 @@ class AgenticStreamClient {
         })().finally(() => {
             this.replayFlight = null;
             if (!this.closed && !this.settled && !this.finishingReplay) {
-                this.replayTimer = setTimeout(() => void this.catchUpEnvelopes(), this.options.envelopeReplayIntervalMs ?? 2000);
+                // The server stamps and persists an envelope BEFORE it fans it out, so
+                // a read issued after a live frame arrived is guaranteed to see every
+                // earlier seq. A frame held while a stale read was in flight therefore
+                // gets one immediate re-read, instead of sitting behind a pre-join
+                // hole for a whole poll interval (OSK-13518). Bounded: the flag is
+                // cleared when that read starts and set again only by a NEW live frame.
+                const again = this.heldDuringFlight && this.pendingEnvelopes.size > 0;
+                this.replayTimer = setTimeout(() => void this.catchUpEnvelopes(), again ? 0 : (this.options.envelopeReplayIntervalMs ?? 2000));
             }
         });
         return this.replayFlight;
@@ -1004,10 +1159,11 @@ class AgenticStreamClient {
             if (fresh.length === 0)
                 return; // a pure re-delivery — drop it whole
             const scoped = { ...event, envelopes: fresh };
-            // Say what never arrived, once, before folding this batch in
-            // (OSK-7631). Checked against the FRESH set: a re-delivery carries old
+            // Note what never arrived before folding this batch in (OSK-7631,
+            // OSK-13518). Checked against the FRESH set: a re-delivery carries old
             // seqs and would read as a gap that never happened.
-            this.reportSeqGap(fresh);
+            this.noteSeqGap(fresh);
+            this.noteDaemonToolEnvelopes(fresh);
             const envelopeText = envelopesText(scoped);
             if (envelopeText) {
                 this.accumulated += envelopeText;
@@ -1120,6 +1276,9 @@ class AgenticStreamClient {
             this.replayGeneration += 1;
             this.pendingEnvelopes.clear();
             this.reportedGap = false;
+            this.lostRanges.length = 0;
+            this.startedDaemonCalls.clear();
+            this.orphanToolEnd = false;
             // A reset restarts the stream, so envelope seqs may repeat; forget the
             // seen keys or the fresh post-reset text would be deduped away (OSK-4834).
             this.seenEnvelopes.clear();
@@ -1562,13 +1721,19 @@ class AgenticStreamClient {
             return;
         this.settled = true;
         this.lastEvent = event;
-        // A stream that lost chunks told its reader the full answer would be in
-        // `run.result`. The terminal event does not always carry it — a failed
-        // turn's `execution:error` has no `result` — so read it from the record
-        // before settling, or the promise is false exactly when it was made
-        // (OSK-12132).
-        if (this.reportedGap && this.options.reconcileTerminal) {
-            void this.readRecordedText().then((recorded) => this.settle(status, event, recorded));
+        // A stream that passed over unrecovered chunks reads the record before
+        // settling, for two reasons. The verdict: whether those chunks cost the
+        // reader anything is a comparison with the persisted message, and only a
+        // proven loss is said out loud (OSK-13518). And the answer: the terminal
+        // event does not always carry it — a failed turn's `execution:error` has
+        // no `result` — so `run.result` is filled from the record, or the notice's
+        // promise is false exactly when it was made (OSK-12132).
+        if (this.lostRanges.length && this.options.reconcileTerminal) {
+            const streamedText = this.accumulated;
+            void this.readRecordedText().then((recorded) => {
+                this.settleGapVerdict(streamedText, recorded);
+                this.settle(status, event, recorded?.text || undefined);
+            });
             return;
         }
         this.settle(status, event, undefined);
@@ -1583,19 +1748,25 @@ class AgenticStreamClient {
         const reconcile = this.options.reconcileTerminal;
         if (!reconcile)
             return undefined;
+        // A terminal record with no text is still a reading — "the turn persisted
+        // no answer" — and is kept in case a later attempt finds none either.
+        let empty;
         for (let attempt = 0; attempt < GAP_BACKFILL_ATTEMPTS; attempt += 1) {
             if (attempt > 0)
                 await new Promise((r) => setTimeout(r, GAP_BACKFILL_RETRY_MS));
             try {
                 const terminal = await reconcile();
-                if (terminal && typeof terminal.text === 'string' && terminal.text)
-                    return terminal.text;
+                if (terminal && typeof terminal.text === 'string' && terminal.text) {
+                    return { text: terminal.text };
+                }
+                if (terminal)
+                    empty = { text: '' };
             }
             catch {
                 // No evidence either way; try again, then settle on the stream.
             }
         }
-        return undefined;
+        return empty;
     }
     settle(status, event, recordedText) {
         // `execution:complete` carries the final answer as `result`, and it is