@skrr-ai/cli 0.1.71 → 0.1.73

package/dist/base-command.js

@@ -1322,6 +1322,7 @@ class BaseCommand extends core_1.Command {
                     exit: 1,
                     retryable: isRetryableFailure(e.status, body),
                     details: body ?? undefined,
+                    requestId: stringProp(body, 'requestId') || e.requestId,
                 });
             }
             else if ((0, outbox_1.isOutageFailure)(e)) {

package/dist/commands/agents/chat.js

@@ -14,6 +14,7 @@ const node_fs_1 = require("node:fs");
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
+const api_fetch_1 = require("../../lib/api-fetch");
 const agent_home_workspace_1 = require("../../lib/agent-home-workspace");
 const agentic_stream_1 = require("../../lib/agentic-stream");
 const web_url_1 = require("../../lib/web-url");
@@ -594,6 +595,7 @@ class AgentsChat extends base_command_1.BaseCommand {
             quiet,
             approveTools: flags['approve-tools'],
             reconcileTerminal,
+            replayEnvelopes: (from) => (0, api_fetch_1.apiFetch)(`/api/agentic/sessions/${encodeURIComponent(started.sessionId)}/envelopes?from=${from}&limit=500`, { credential: this.resolvedCredential, signal: AbortSignal.timeout(5000) }),
         });
         // OSK-2938 — Ctrl-C must be bounded, visible, and honest about what it
         // did NOT stop.

package/dist/commands/agents/releases/create.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
+function betaWriteMayHaveCommitted(error) {
+    const failure = error;
+    const status = failure?.status ?? failure?.response?.status;
+    return status === 408 || (typeof status === 'number' && status >= 500) ||
+        ['ECONNRESET', 'ETIMEDOUT', 'EAI_AGAIN', 'ENOTFOUND'].includes(failure?.code ?? '') ||
+        /fetch failed|socket hang up|timed? ?out/i.test(failure?.message ?? '');
+}
 class AgentsReleasesCreate extends base_command_1.BaseCommand {
     static description = 'Create a private agent release';
     static args = { agentId: core_1.Args.string({ required: true, ignoreStdin: true }) };
@@ -27,24 +34,63 @@ class AgentsReleasesCreate extends base_command_1.BaseCommand {
                 exit: 2,
             });
         }
-        const result = flags.beta
-            ? await data_provider_1.dataService.createBetaAgentRelease({
-                agentId: args.agentId,
-                changelog: flags.changelog,
-                versionMajor: flags['version-major'],
-                versionMinor: flags['version-minor'],
-                releaseId: flags['release-id'],
-                offerVersionId: flags['offer-version-id'],
-            })
-            : await data_provider_1.dataService.createPrivateAgentRelease({
+        let result;
+        let recoveredAfterTransportFailure = false;
+        if (flags.beta) {
+            try {
+                result = await data_provider_1.dataService.createBetaAgentRelease({
+                    agentId: args.agentId,
+                    changelog: flags.changelog,
+                    versionMajor: flags['version-major'],
+                    versionMinor: flags['version-minor'],
+                    releaseId: flags['release-id'],
+                    offerVersionId: flags['offer-version-id'],
+                });
+            }
+            catch (error) {
+                if (!betaWriteMayHaveCommitted(error))
+                    throw error;
+                const releaseId = flags['release-id'];
+                let verification = 'unavailable';
+                try {
+                    const releases = await data_provider_1.dataService.getAgentReleases(args.agentId);
+                    const found = releases.data?.find((release) => release.id === releaseId);
+                    if (found) {
+                        result = found;
+                        recoveredAfterTransportFailure = true;
+                    }
+                    else {
+                        verification = 'not_observed';
+                    }
+                }
+                catch {
+                    // A failed read cannot settle whether the write reached the server.
+                }
+                if (!result) {
+                    const suggestion = `Run skrr agents releases list ${args.agentId} --json and check for ${releaseId} before retrying.`;
+                    this.failWithCliError({
+                        message: `The beta publish request ended before the server confirmed its outcome. ${suggestion}`,
+                        code: 'BETA_RELEASE_OUTCOME_UNCONFIRMED',
+                        exit: 1,
+                        retryable: false,
+                        details: { agentId: args.agentId, releaseId, verification, suggestion },
+                    });
+                }
+            }
+        }
+        else {
+            result = await data_provider_1.dataService.createPrivateAgentRelease({
                 agentId: args.agentId,
                 changelog: flags.changelog,
                 versionMajor: flags['version-major'],
                 versionMinor: flags['version-minor'],
             });
+        }
         this.log(flags.json
             ? this.agentJson(args.agentId, result)
-            : `Created release for agent ${args.agentId}`);
+            : recoveredAfterTransportFailure
+                ? `Beta release ${flags['release-id']} exists for agent ${args.agentId}; the publish response was interrupted.`
+                : `Created release for agent ${args.agentId}`);
         if (!flags.json)
             this.printAgentUrl(args.agentId);
     }

package/dist/commands/machines/dedicated/cp.js

@@ -105,6 +105,9 @@ class DedicatedMachinesCp extends base_command_1.BaseCommand {
             if (err instanceof dedicated_copy_1.DedicatedCopyError) {
                 this.error(err.message, { exit: 1, code: err.code });
             }
+            // Keep the API status, request id and explicit retry decision together.
+            if ((0, base_command_1.apiRefusal)(err).body?.retryable === true)
+                this.handleApiError(err);
             const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
             if (message)
                 this.error(message, { exit: 1, code: (0, dedicated_machines_1.dedicatedRuntimeApiErrorCode)(err) });

package/dist/commands/machines/dedicated/exec.js

@@ -154,6 +154,9 @@ class DedicatedMachinesExec extends base_command_1.BaseCommand {
                 err instanceof dedicated_exec_1.DedicatedExecIdempotencyUnsupportedError) {
                 this.error(err.message, { exit: 1, code: err.code });
             }
+            // Keep the API status, request id and explicit retry decision together.
+            if ((0, base_command_1.apiRefusal)(err).body?.retryable === true)
+                this.handleApiError(err);
             const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
             if (message)
                 this.error(message, { exit: 1, code: (0, dedicated_machines_1.dedicatedRuntimeApiErrorCode)(err) });

package/dist/commands/spaces/snapshot.d.ts

@@ -8,6 +8,7 @@ export default class SpacesSnapshot extends BaseCommand {
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'update-template': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         title: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         description: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'short-description': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/spaces/snapshot.js

@@ -21,12 +21,13 @@ const CATEGORY_OPTIONS = [
     'other',
 ];
 class SpacesSnapshot extends base_command_1.BaseCommand {
-    static description = 'Create a snapshot (template) from a space';
+    static description = 'Create or recapture a template from a space';
     static examples = [
         '<%= config.bin %> spaces snapshot <space-id> --title "Q2 Launch Template"',
         '<%= config.bin %> spaces snapshot <space-id> --title "Support" --category engineering --public',
         '<%= config.bin %> spaces snapshot <space-id> --from-json snapshot.json',
         '<%= config.bin %> spaces snapshot <space-id> --from-json snapshot.json --title "Override"',
+        '<%= config.bin %> spaces snapshot <source-space-id> --update-template <template-id> --title "Q2 Launch v2"',
     ];
     static args = {
         id: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
@@ -36,6 +37,9 @@ class SpacesSnapshot extends base_command_1.BaseCommand {
         'from-json': core_1.Flags.string({
             description: 'Path to a JSON file (or "-" for stdin) to use as the request body',
         }),
+        'update-template': core_1.Flags.string({
+            description: 'Recapture this existing template from its original Space',
+        }),
         title: core_1.Flags.string({ description: 'Snapshot title (required unless set via --from-json)' }),
         description: core_1.Flags.string({ description: 'Snapshot description' }),
         'short-description': core_1.Flags.string({ description: 'Short description (one liner)' }),
@@ -58,6 +62,7 @@ class SpacesSnapshot extends base_command_1.BaseCommand {
             this.error(err.message, { exit: 1 });
         }
         const payload = (0, prompt_1.mergeDefined)(body, {
+            templateId: flags['update-template'],
             title: flags.title,
             description: flags.description,
             shortDescription: flags['short-description'],
@@ -83,7 +88,7 @@ class SpacesSnapshot extends base_command_1.BaseCommand {
             return;
         }
         const s = result;
-        this.log(`Snapshot created: ${s.id ?? s._id ?? '?'} — ${String(payload.title)}`);
+        this.log(`Snapshot ${payload.templateId ? 'updated' : 'created'}: ${s.id ?? s._id ?? '?'} — ${String(payload.title)}`);
     }
 }
 exports.default = SpacesSnapshot;

package/dist/commands/store/installs.js

@@ -19,10 +19,9 @@ class StoreInstalls extends base_command_1.BaseCommand {
         this.requireAuth();
         const { flags } = await this.parse(StoreInstalls);
         const workspaceId = await (0, workspaces_1.ambientWorkspaceId)();
-        (0, data_provider_1.setWorkspaceIdHeader)(workspaceId ?? null);
         let response;
         try {
-            response = await data_provider_1.dataService.getStoreInstalls();
+            response = await data_provider_1.dataService.getStoreInstalls(workspaceId);
         }
         catch (error) {
             this.handleApiError(error);

package/dist/commands/store/signals.js

@@ -34,6 +34,9 @@ class StoreSignals extends base_command_1.BaseCommand {
                 const fmt = (v) => `$${((v ?? 0) / 1_000_000).toFixed(4)}`;
                 this.log(`Run cost ${fmt(s.measuredRunCost.minCostMicros)}–${fmt(s.measuredRunCost.maxCostMicros)} per run (measured, ${s.measuredRunCost.cohorts} buyers, ${s.measuredRunCost.windowDays}d)`);
             }
+            else {
+                this.log('Run cost Insufficient data (fewer than 5 independent buyers)');
+            }
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/store/uninstall.js

@@ -42,7 +42,7 @@ function parseReceipt(body) {
         : null;
 }
 class StoreUninstall extends base_command_1.BaseCommand {
-    static description = 'Uninstall an agent you installed from the store. Reinstalling restores it — unless you pass --erase, which also deletes its memory and ends its commitments (irreversible). The agent, your purchase and its delivered tasks are always kept.';
+    static description = 'Uninstall is reversible: reinstalling restores the Agent copy. --erase permanently removes its Memory and ends commitments; the Agent, purchase, and delivered tasks remain.';
     static examples = [
         '<%= config.bin %> store uninstall agent_abc123',
         '<%= config.bin %> store uninstall agent_abc123 --erase',

package/dist/commands/subscriptions/subscribe.js

@@ -5,7 +5,7 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const prompt_1 = require("../../lib/prompt");
 class SubscriptionsSubscribe extends base_command_1.BaseCommand {
-    static description = 'Subscribe to a published Service — pays its first period from your balance, installs your own managed instance, and opens the obligation it is delivered through. Shows the price and asks you to confirm first.';
+    static description = 'Subscribe to a published Service. By default, this shows the first-period price before buying from your balance, installing a managed instance, and opening its delivery obligation. Use --trial for the Service\'s card-free trial instead.';
     static examples = [
         '<%= config.bin %> subscriptions subscribe agent_abc123',
         '<%= config.bin %> subscriptions subscribe agent_abc123 --space space_xyz --yes --json',
@@ -29,7 +29,7 @@ class SubscriptionsSubscribe extends base_command_1.BaseCommand {
             description: 'Activate a period that was already paid (its grant id) instead of buying one. Nothing is charged.',
         }),
         trial: core_1.Flags.boolean({
-            description: 'Start the card-free trial instead of buying: 7 days, nothing charged, does not renew (OSK-12281).',
+            description: 'Start this Service\'s card-free trial instead of buying. Its duration and compute terms are shown before confirmation; nothing is charged and it does not renew.',
         }),
         yes: core_1.Flags.boolean({
             char: 'y',

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

@@ -60,6 +60,12 @@ export type ReconciledTerminal = {
  * drift (OSK-7629).
  */
 export declare function writeJsonLine(output: NodeJS.WritableStream, value: unknown): void;
+export type EnvelopeReplayPage = {
+    envelopes: unknown[];
+    hasMore?: boolean;
+    nextSeq?: number;
+    gap?: boolean;
+};
 export type AgenticStreamOptions = {
     baseURL: string;
     token: string;
@@ -89,6 +95,10 @@ export type AgenticStreamOptions = {
      * the stream alone.
      */
     reconcileTerminal?: () => Promise<ReconciledTerminal | null>;
+    /** Owner-authorized canonical envelopes, including events emitted before room admission. */
+    replayEnvelopes?: (from: number) => Promise<EnvelopeReplayPage>;
+    /** Bounded live catch-up cadence while a run is active. Default 2s. */
+    envelopeReplayIntervalMs?: number;
     /** Silence before the first durable-record probe. Default 20s. */
     idleTerminalProbeMs?: number;
     /** How long to keep trying to attach before reporting a detach. Default 30s. */
@@ -376,6 +386,12 @@ export declare class AgenticStreamClient {
     private accumulated;
     /** Highest envelope `__seq` folded into `accumulated`, for gap detection. */
     private highestSeq;
+    private readonly pendingEnvelopes;
+    private replayTimer;
+    private replayFlight;
+    private replayGeneration;
+    private replayFailures;
+    private finishingReplay;
     private reportedGap;
     private readonly seenEnvelopes;
     /**
@@ -487,6 +503,12 @@ export declare class AgenticStreamClient {
      * what the run reports — only what the reader is told while it is happening.
      */
     private reportSeqGap;
+    /** Keep later live frames behind missing earlier frames while canonical replay catches up. */
+    private receiveSessionOutput;
+    private flushPendingEnvelopes;
+    /** Poll even while a tool is quiet: a pre-join start has no later live event to reveal its gap. */
+    private catchUpEnvelopes;
+    private applySessionOutput;
     private installHandlers;
     private handlePermission;
     private handleQuestion;
@@ -534,6 +556,7 @@ export declare class AgenticStreamClient {
     private emitToolEvent;
     private emit;
     private finish;
+    private finishAfterReplay;
     /**
      * The answer as the durable record holds it, for a run whose stream had a
      * hole. Bounded: the record is written before the terminal event is sent, so

package/dist/lib/agentic-stream.js

@@ -628,6 +628,12 @@ class AgenticStreamClient {
     accumulated = '';
     /** Highest envelope `__seq` folded into `accumulated`, for gap detection. */
     highestSeq = 0;
+    pendingEnvelopes = new Map();
+    replayTimer = null;
+    replayFlight = null;
+    replayGeneration = 0;
+    replayFailures = 0;
+    finishingReplay = false;
     reportedGap = false;
     // Envelope keys already applied, so a re-delivered `session:output` frame is
     // not appended twice (OSK-4834). Cleared on `execution:stream-reset`.
@@ -726,6 +732,7 @@ class AgenticStreamClient {
         this.socket.emit('session:join', this.sessionJoinPayload());
         this.emit({ type: 'session.joined', sessionId: this.options.sessionId });
         this.armIdleProbe();
+        void this.catchUpEnvelopes();
         return result;
     }
     /**
@@ -835,6 +842,10 @@ class AgenticStreamClient {
             clearTimeout(this.idleTimer);
             this.idleTimer = null;
         }
+        if (this.replayTimer)
+            clearTimeout(this.replayTimer);
+        this.replayTimer = null;
+        this.pendingEnvelopes.clear();
         this.abandonConnectWait?.();
         const socket = this.socket;
         this.socket = null;
@@ -883,12 +894,145 @@ class AgenticStreamClient {
                 this.highestSeq = seq;
         }
     }
+    /** Keep later live frames behind missing earlier frames while canonical replay catches up. */
+    receiveSessionOutput(event) {
+        if (this.closed || this.settled)
+            return;
+        const envelopes = event.envelopes;
+        if (!this.options.replayEnvelopes || !Array.isArray(envelopes)) {
+            this.applySessionOutput(event);
+            return;
+        }
+        for (const envelope of envelopes) {
+            const seq = Number(envelope?.__seq);
+            if (!Number.isSafeInteger(seq) || seq <= 0) {
+                this.applySessionOutput({ ...event, envelopes: [envelope] });
+            }
+            else if (seq > this.highestSeq && !this.pendingEnvelopes.has(seq)) {
+                this.pendingEnvelopes.set(seq, { envelope, event });
+            }
+        }
+        this.flushPendingEnvelopes(false);
+        if (this.pendingEnvelopes.size > 2000)
+            this.flushPendingEnvelopes(true);
+        if (this.pendingEnvelopes.size)
+            void this.catchUpEnvelopes();
+    }
+    flushPendingEnvelopes(allowGap, through = Infinity) {
+        const seqs = [...this.pendingEnvelopes.keys()].sort((a, b) => a - b);
+        for (const seq of seqs) {
+            if (seq > through)
+                break;
+            if (!allowGap && seq !== this.highestSeq + 1)
+                break;
+            const item = this.pendingEnvelopes.get(seq);
+            this.pendingEnvelopes.delete(seq);
+            this.applySessionOutput({ ...item.event, envelopes: [item.envelope] });
+        }
+    }
+    /** Poll even while a tool is quiet: a pre-join start has no later live event to reveal its gap. */
+    catchUpEnvelopes() {
+        if (!this.options.replayEnvelopes || this.closed || this.settled)
+            return Promise.resolve();
+        if (this.replayFlight)
+            return this.replayFlight;
+        if (this.replayTimer)
+            clearTimeout(this.replayTimer);
+        this.replayTimer = null;
+        const generation = this.replayGeneration;
+        this.replayFlight = (async () => {
+            try {
+                for (let page = 0; page < 4; page += 1) {
+                    const from = this.highestSeq;
+                    const result = await this.options.replayEnvelopes(from);
+                    if (this.closed || this.settled || generation !== this.replayGeneration)
+                        return;
+                    this.replayFailures = 0;
+                    this.receiveSessionOutput({ type: 'session.output', sessionId: this.options.sessionId, source: 'replay', envelopes: result.envelopes });
+                    // The canonical endpoint explicitly identifies retention gaps. Only
+                    // then may later frames pass with the existing honest gap notice.
+                    if (result.gap) {
+                        // A retention gap proves only this page, never a later live frame.
+                        const pageSeqs = result.envelopes.map((e) => Number(e?.__seq)).filter(Number.isSafeInteger);
+                        if (pageSeqs.length)
+                            this.flushPendingEnvelopes(true, Math.max(...pageSeqs));
+                        this.flushPendingEnvelopes(false);
+                    }
+                    if (!result.hasMore || this.highestSeq <= from)
+                        break;
+                }
+            }
+            catch {
+                // Recovery failure says nothing about the producer. After bounded
+                // retries retain the existing live/gap/final-record fallback.
+                this.replayFailures += 1;
+                if (this.replayFailures >= 3)
+                    this.flushPendingEnvelopes(true);
+            }
+        })().finally(() => {
+            this.replayFlight = null;
+            if (!this.closed && !this.settled && !this.finishingReplay) {
+                this.replayTimer = setTimeout(() => void this.catchUpEnvelopes(), this.options.envelopeReplayIntervalMs ?? 2000);
+            }
+        });
+        return this.replayFlight;
+    }
+    applySessionOutput(event) {
+        // The agent's words arrive HERE for agentic runs, inside `envelopes`, and
+        // `event.text` is null. Normalising the frame without reading them meant
+        // `skrr agents chat` printed two header lines and exited having shown
+        // nothing, while the agent had answered perfectly — and `--no-stream
+        // --json` returned `status: completed` with `response: ""`.
+        //
+        // Only `ev.t === 'text'` counts. The same envelope stream carries tool
+        // and status frames, and folding those into the answer would put machine
+        // chatter in `response`.
+        // Dedupe re-delivered envelopes (session room + user room + join replay):
+        // append and reprint only the ones we have not applied yet (OSK-4834).
+        const rawEnvelopes = event.envelopes;
+        if (Array.isArray(rawEnvelopes) && rawEnvelopes.length > 0) {
+            const fresh = unseenEnvelopes(event, this.seenEnvelopes);
+            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
+            // seqs and would read as a gap that never happened.
+            this.reportSeqGap(fresh);
+            const envelopeText = envelopesText(scoped);
+            if (envelopeText) {
+                this.accumulated += envelopeText;
+                this.emit({ ...scoped, type: 'text.delta', text: this.accumulated });
+            }
+            // A daemon-routed turn carries its tool calls HERE and nowhere else.
+            // Projecting them gives both execution paths one vocabulary (OSK-7730).
+            for (const projected of projectDaemonToolEvents(fresh, this.toolNamesByCall)) {
+                this.emitToolEvent({ ...projected, sessionId: this.options.sessionId });
+            }
+            // Notices meant for the person — a local harness that could not resume
+            // its previous session and started a fresh one (OSK-12131). A plain
+            // `service` line is diagnostic chatter and stays in the envelope; one
+            // marked `notice` is said out loud.
+            for (const notice of projectSessionNotices(fresh)) {
+                this.emit({ ...notice, sessionId: this.options.sessionId });
+            }
+            // Who decided each permission request — a person (and where), the
+            // mode, a policy — said beside the decision (OSK-12113).
+            for (const resolved of projectPermissionResolutions(fresh, this.toolNamesByPermission)) {
+                this.emit({ ...resolved, sessionId: this.options.sessionId });
+            }
+            this.emit({ ...scoped, type: 'session.output' });
+            return;
+        }
+        this.emit({ ...event, type: 'session.output' });
+    }
     installHandlers() {
         const socket = this.socket;
         const match = (event) => !event.sessionId || event.sessionId === this.options.sessionId;
         socket.on('connect', () => {
             socket.emit('session:join', this.sessionJoinPayload());
             this.emit({ type: 'transport.connected', sessionId: this.options.sessionId });
+            void this.catchUpEnvelopes();
         });
         socket.on('disconnect', (reason) => {
             this.transportDropped = true;
@@ -942,55 +1086,8 @@ class AgenticStreamClient {
             this.emit({ ...event, type: 'text.delta' });
         });
         socket.on('session:output', (event) => {
-            if (!match(event))
-                return;
-            // The agent's words arrive HERE for agentic runs, inside `envelopes`, and
-            // `event.text` is null. Normalising the frame without reading them meant
-            // `skrr agents chat` printed two header lines and exited having shown
-            // nothing, while the agent had answered perfectly — and `--no-stream
-            // --json` returned `status: completed` with `response: ""`.
-            //
-            // Only `ev.t === 'text'` counts. The same envelope stream carries tool
-            // and status frames, and folding those into the answer would put machine
-            // chatter in `response`.
-            // Dedupe re-delivered envelopes (session room + user room + join replay):
-            // append and reprint only the ones we have not applied yet (OSK-4834).
-            const rawEnvelopes = event.envelopes;
-            if (Array.isArray(rawEnvelopes) && rawEnvelopes.length > 0) {
-                const fresh = unseenEnvelopes(event, this.seenEnvelopes);
-                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
-                // seqs and would read as a gap that never happened.
-                this.reportSeqGap(fresh);
-                const envelopeText = envelopesText(scoped);
-                if (envelopeText) {
-                    this.accumulated += envelopeText;
-                    this.emit({ ...scoped, type: 'text.delta', text: this.accumulated });
-                }
-                // A daemon-routed turn carries its tool calls HERE and nowhere else.
-                // Projecting them gives both execution paths one vocabulary (OSK-7730).
-                for (const projected of projectDaemonToolEvents(fresh, this.toolNamesByCall)) {
-                    this.emitToolEvent({ ...projected, sessionId: this.options.sessionId });
-                }
-                // Notices meant for the person — a local harness that could not resume
-                // its previous session and started a fresh one (OSK-12131). A plain
-                // `service` line is diagnostic chatter and stays in the envelope; one
-                // marked `notice` is said out loud.
-                for (const notice of projectSessionNotices(fresh)) {
-                    this.emit({ ...notice, sessionId: this.options.sessionId });
-                }
-                // Who decided each permission request — a person (and where), the
-                // mode, a policy — said beside the decision (OSK-12113).
-                for (const resolved of projectPermissionResolutions(fresh, this.toolNamesByPermission)) {
-                    this.emit({ ...resolved, sessionId: this.options.sessionId });
-                }
-                this.emit({ ...scoped, type: 'session.output' });
-                return;
-            }
-            this.emit({ ...event, type: 'session.output' });
+            if (match(event))
+                this.receiveSessionOutput(event);
         });
         socket.on('tool:start', (event) => {
             if (match(event))
@@ -1011,6 +1108,8 @@ class AgenticStreamClient {
             this.renderedText = '';
             // Seqs restart with the stream, so a fresh low seq is not a gap.
             this.highestSeq = 0;
+            this.replayGeneration += 1;
+            this.pendingEnvelopes.clear();
             this.reportedGap = 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).
@@ -1429,6 +1528,27 @@ class AgenticStreamClient {
         }
     }
     finish(status, event) {
+        if (this.settled || this.finishingReplay)
+            return;
+        if (this.options.replayEnvelopes) {
+            this.finishingReplay = true;
+            const activeReplay = this.replayFlight;
+            void (async () => {
+                if (activeReplay)
+                    await activeReplay;
+                // A request already in flight may have read before the terminal event.
+                await this.catchUpEnvelopes();
+            })().finally(() => {
+                if (this.closed || this.settled)
+                    return;
+                this.flushPendingEnvelopes(true);
+                this.finishAfterReplay(status, event);
+            });
+            return;
+        }
+        this.finishAfterReplay(status, event);
+    }
+    finishAfterReplay(status, event) {
         if (this.settled)
             return;
         this.settled = true;