@timurproko/a1 0.1.8-dev.322 → 0.1.8-dev.335

package/dist/foundation/release/update.d.ts

@@ -112,5 +112,7 @@ export type UpdateOwnershipAction = "clean-dead-record" | "leave-running" | "end
  */
 export declare function planUpdateOwnership(ownership: "live-verified" | "dead", runsFromRetainedRelease: boolean): UpdateOwnershipAction;
 export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem, output?: UpdateOutput): UpdateLifecycleCoordinator;
+/** Renders the terminal-only update meter; the visual preview shares this exact frame. */
+export declare function renderUpdateProgressBar(percent: number): string;
 export declare function runSelfUpdate(options: SelfUpdateOptions): Promise<number>;
 export declare function assertUpdatePerformanceBudget(evidence: UpdatePerformanceEvidence, maximumPostNpmDurationMs?: number): void;

package/dist/foundation/release/update.js

@@ -5,7 +5,7 @@ import { isAbsolute, relative, resolve, sep } from "node:path";
 import crossSpawn from "cross-spawn";
 import { valid as validSemver } from "semver";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
-import { certifyMaterializedRelease, probeOwnership, readEndpointMetadata, removeEndpointArtifacts, startSupervisor, waitForProcessExit, waitForVerifiedEndpoint, } from "./bootstrap.js";
+import { certifyMaterializedRelease, probeOwnership, readEndpointMetadata, removeEndpointArtifacts, ensureSupervisor, waitForProcessExit, } from "./bootstrap.js";
 import { resolveCohortEndpoint, resolveProductPaths } from "../lifecycle/index.js";
 import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
 import { CohortStateStore } from "./cohort-state.js";
@@ -13,7 +13,6 @@ import { cleanupVerifiedOwner, processIsAlive } from "./process-cleanup.js";
 import { materializeRelease, readMaterializedRelease } from "./release-store.js";
 import { scheduleReleaseCleanup } from "./release-gc.js";
 import { warmMaterializedRelease } from "./warmup.js";
-import { assertCurrentLaunchContract } from "../launch-context/index.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
 import { removeUpdateRecoveryCapsule, runProtectedPackageReplacement } from "./update-recovery.js";
 export const PRODUCT_PACKAGE = PRODUCT_TEXT.packageName;
@@ -78,8 +77,6 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
         async targetIsActive(targetVersion) {
             const state = await stateStore.read();
             const activeId = state.references.active;
-            if (activeId)
-                assertCurrentLaunchContract(state.releases[activeId] ?? {});
             if (!activeId || state.releases[activeId]?.packageVersion !== targetVersion)
                 return false;
             const endpoint = await readActiveEndpoint(paths, activeId, environment);
@@ -88,8 +85,6 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
         async shutdownVerifiedOwners(targetVersion) {
             const state = await stateStore.read();
             const activeId = state.references.active;
-            if (activeId)
-                assertCurrentLaunchContract(state.releases[activeId] ?? {});
             const priorActiveVersion = activeId ? state.releases[activeId]?.packageVersion ?? null : null;
             const owner = await readActiveEndpoint(paths, activeId, environment);
             if (!owner)
@@ -168,17 +163,17 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
             const diagnostics = await certifyMaterializedRelease(candidate, paths.dataDir);
             await stateStore.approve(candidate.releaseId, diagnostics);
             await phase("certified");
-            await stateStore.activate(candidate.releaseId);
-            await phase("active-reference-committed");
             onWarmup?.("started");
             await warmMaterializedRelease(candidate, environment);
             onWarmup?.("completed");
-            const startup = await startSupervisor(candidate, environment);
-            await waitForVerifiedEndpoint(resolveCohortEndpoint(paths, candidate.releaseId, environment).endpointMetadataPath, candidate, 8_000, startup);
+            await ensureSupervisor(candidate, environment);
+            // Invariant: warmup and authenticated readiness precede changing the active reference.
+            await stateStore.activate(candidate.releaseId);
+            await phase("active-reference-committed");
         },
     };
 }
-const PROGRESS_BAR_WIDTH = 39;
+const PROGRESS_BAR_WIDTH = 40;
 const PROGRESS_TICK_MS = 200;
 /**
  * Copying the release owns 78–92 and is reported file by file, so the bar crosses
@@ -191,10 +186,15 @@ const ACTIVATION_PROGRESS = {
     certified: { at: 94, creepTo: 96 },
     "active-reference-committed": { at: 96, creepTo: 99 },
 };
-function renderProgressBar(percent) {
+/** Renders the terminal-only update meter; the visual preview shares this exact frame. */
+export function renderUpdateProgressBar(percent) {
     const bounded = Math.min(100, Math.max(0, Math.round(percent)));
     const filled = Math.round((bounded / 100) * PROGRESS_BAR_WIDTH);
-    return `${"█".repeat(filled)}${"░".repeat(PROGRESS_BAR_WIDTH - filled)} ${bounded}%`;
+    // Rationale: a gray line, a darker gray track, and one space before the percentage.
+    // Explicit RGB keeps both grays neutral even when the terminal remaps its ANSI palette.
+    const gray = "\u001b[38;2;128;128;128m";
+    const track = "\u001b[38;2;102;102;102m";
+    return `${gray}${"━".repeat(filled)}${track}${"─".repeat(PROGRESS_BAR_WIDTH - filled)}${gray} ${bounded}%\u001b[39m`;
 }
 function createUpdateProgress(output, enabled) {
     let visible = false;
@@ -207,7 +207,7 @@ function createUpdateProgress(output, enabled) {
             return;
         shown = rounded;
         visible = true;
-        output.stdout(`\r${renderProgressBar(rounded)}`);
+        output.stdout(`\r${renderUpdateProgressBar(rounded)}`);
     };
     const stopCreep = () => {
         if (timer !== null) {
@@ -380,11 +380,7 @@ export async function runSelfUpdate(options) {
         : async () => await scheduleReleaseCleanup(paths.dataDir, paths));
     let transaction = await transactionStore.read();
     try {
-        if (await lifecycle.targetIsActive(targetVersion)) {
-            if (transaction?.status === "active") {
-                await transactionStore.advance("supervisor-verified");
-                await transactionStore.finish("completed");
-            }
+        if ((!transaction || transaction.status === "completed") && await lifecycle.targetIsActive(targetVersion)) {
             await maintenance();
             await transactionStore.clearCompleted();
             output.stdout(`${PRODUCT_TEXT.commandName} is up to date — no update needed.\n`);
@@ -453,7 +449,7 @@ export async function runSelfUpdate(options) {
                     transaction = await transactionStore.advance("package-installed");
                 if (replacement.cancelled) {
                     progress.clear();
-                    output.stderr(`${PRODUCT_TEXT.diagnostic("update cancelled safely; the A1 launcher is available and the transaction can be resumed.")}\n`);
+                    output.stderr(`${PRODUCT_TEXT.diagnostic("update cancelled safely; the launcher is available and the transaction can be resumed.")}\n`);
                     return 130;
                 }
                 if (replacement.outcome !== "installed") {
@@ -515,13 +511,14 @@ export async function runSelfUpdate(options) {
         options.onPhaseTiming?.({ phase: "supervisor-verified", durationMs: Math.max(0, now() - activationPhaseStartedAt) });
         const transactionStartedAt = now();
         await transactionStore.advance("supervisor-verified");
-        await transactionStore.finish("completed");
         if (transaction.recovery?.capsulePath)
             await removeUpdateRecoveryCapsule(paths.dataDir, transaction.transactionId);
         // Invariant: successful output follows the durable cleanup disposition. Slow recursive
         // removal belongs to the detached worker started by this maintenance coordinator.
         await maintenance();
-        await transactionStore.clearCompleted();
+        // Concurrency: this is the launch cutover. No failure-prone update work follows success.
+        await transactionStore.finish("completed");
+        await transactionStore.clearCompleted().catch(() => undefined);
         options.onPhaseTiming?.({ phase: "transaction-complete", durationMs: Math.max(0, now() - transactionStartedAt) });
         progress.finish();
         output.stdout(`${PRODUCT_TEXT.commandName} updated successfully: ${targetVersion}\n`);
@@ -614,11 +611,8 @@ async function rollbackPriorCohort(dataDir, environment, priorReleaseId) {
             throw new Error(`prior release ${priorReleaseId} is not the recorded rollback cohort`);
     }
     const release = await readMaterializedRelease(prior.releaseRoot);
-    const paths = resolveProductPaths(environment);
-    // Invariant: rollback re-points the active reference and starts the prior cohort on its own endpoint;
-    // a cohort that survived the update keeps serving the work it already had.
-    const startup = await startSupervisor(release, environment);
-    await waitForVerifiedEndpoint(resolveCohortEndpoint(paths, release.releaseId, environment).endpointMetadataPath, release, 8_000, startup);
+    // Invariant: rollback reuses a surviving prior cohort rather than racing its occupied endpoint.
+    await ensureSupervisor(release, environment);
     return "rolled back";
 }
 function phaseBefore(current, target) {

package/dist/foundation/release/warmup.js

@@ -1,17 +1,28 @@
 import { spawn } from "node:child_process";
 import { resolveReleaseEntryPoint } from "./release-store.js";
 import { releaseEnvironment } from "./bootstrap.js";
-import { PRIVATE_ENVIRONMENT, assertCurrentLaunchContract } from "../launch-context/index.js";
+import { launchContractTarget, launchEnvironmentKeys } from "../launch-context/index.js";
+const WARMUP_DIAGNOSTIC_LIMIT = 2_000;
+/** Summarize the child's own failure text without letting an unbounded graph error escape. */
+function warmupDiagnostics(text) {
+    const lines = text.split(/\r?\n/).map(line => line.trim()).filter(line => line.length > 0);
+    return lines.length === 0 ? "" : `: ${lines.slice(0, 4).join(" | ").slice(0, WARMUP_DIAGNOSTIC_LIMIT)}`;
+}
 /** Import the exact immutable startup graph in a terminal-free bounded child process. */
 export async function warmMaterializedRelease(release, environment, timeoutMs = 30_000) {
-    assertCurrentLaunchContract(release);
     const entry = await resolveReleaseEntryPoint(release, "bin/warmup.js");
     await new Promise((resolvePromise, rejectPromise) => {
+        // Rationale: the child still gets no terminal, but a discarded failure reason leaves an
+        // update reporting only an exit status. Its own diagnostics are read and bounded so the
+        // transaction journal records why the graph could not be imported.
         const child = spawn(process.execPath, [entry], {
-            env: { ...releaseEnvironment(environment, release), [PRIVATE_ENVIRONMENT.immutableWarmup]: "1" },
-            stdio: "ignore",
+            env: { ...releaseEnvironment(environment, release), [launchEnvironmentKeys(launchContractTarget(release)).immutableWarmup]: "1" },
+            stdio: ["ignore", "ignore", "pipe"],
             windowsHide: true,
         });
+        let diagnostics = "";
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", chunk => { diagnostics = `${diagnostics}${chunk}`.slice(-WARMUP_DIAGNOSTIC_LIMIT); });
         let settled = false;
         const finish = (error) => {
             if (settled)
@@ -26,7 +37,7 @@ export async function warmMaterializedRelease(release, environment, timeoutMs =
         child.once("error", error => finish(error));
         child.once("close", (code, signal) => finish(code === 0
             ? undefined
-            : new Error(`immutable startup warmup exited with ${code === null ? signal ?? "unknown status" : `status ${code}`}`)));
+            : new Error(`immutable startup warmup exited with ${code === null ? signal ?? "unknown status" : `status ${code}`}${warmupDiagnostics(diagnostics)}`)));
         const timer = setTimeout(() => {
             child.kill();
             finish(new Error(`immutable startup warmup exceeded ${timeoutMs}ms`));

package/dist/foundation/supervision/main.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { resolve } from "node:path";
-import { assertImmutableExecutionRoot, CohortStateStore, readCertifiedReleaseManifest, recordParentCertifiedRelease } from "../release/index.js";
+import { assertImmutableExecutionRoot, CohortStateStore, readCertifiedReleaseManifest, recordParentCertifiedRelease, selectSupervisorLaunchReleaseId, UpdateTransactionStore } from "../release/index.js";
 import { publishSupervisorStartupResult, supervisorStartupFailure, supervisorStartupReady, supervisorStartupResultPath } from "../lifecycle/index.js";
 import { ControlStore } from "../storage/index.js";
 import { resolveCohortEndpoint, resolveProductPaths } from "./paths.js";
@@ -38,7 +38,10 @@ export async function runSupervisor(arguments_ = []) {
         const bootNonce = randomUUID();
         const store = new ControlStore(paths.databasePath, bootNonce);
         const cohortState = new CohortStateStore(paths.dataDir);
-        server = new SupervisorServer(store, paths, release, bootNonce, undefined, undefined, undefined, async () => (await cohortState.read()).references.active);
+        server = new SupervisorServer(store, paths, release, bootNonce, undefined, undefined, undefined, async () => {
+            const transaction = await new UpdateTransactionStore(paths.dataDir).read();
+            return selectSupervisorLaunchReleaseId(await cohortState.read(), transaction);
+        });
         stage = "endpoint-listen";
         await server.listen();
         if (resultPath && attemptId)

package/dist/foundation/supervision/server.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { chmod, lstat, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { chmod, lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { createConnection, createServer } from "node:net";
 import { platform } from "node:os";
 import { dirname } from "node:path";
@@ -54,6 +54,7 @@ export class SupervisorServer {
     startedAt = new Date().toISOString();
     paths;
     #server = null;
+    #ownsEndpoint = false;
     #instances = new Map();
     #instanceOwners = new Map();
     #clientIds = new Map();
@@ -104,15 +105,24 @@ export class SupervisorServer {
         if (platform() !== "win32") {
             if (this.paths.endpointDirectory)
                 await ensureManagedEndpointDirectory(dirname(this.paths.endpoint));
-            if (await endpointIsLive(this.paths.endpoint))
-                throw new Error(PRODUCT_TEXT.diagnostic(`supervisor already owns ${this.paths.endpoint}`));
-            await rm(this.paths.endpoint, { force: true });
+            const existing = await lstat(this.paths.endpoint).catch(error => {
+                if (error.code === "ENOENT")
+                    return null;
+                throw error;
+            });
+            if (existing) {
+                if (await endpointIsLive(this.paths.endpoint)) {
+                    throw Object.assign(new Error(PRODUCT_TEXT.diagnostic(`supervisor already owns ${this.paths.endpoint}`)), { code: "EADDRINUSE" });
+                }
+                await rm(this.paths.endpoint, { force: true });
+            }
         }
         const server = createServer(socket => this.#attach(socket));
         this.#server = server;
         await new Promise((resolve, reject) => {
             server.once("error", reject);
             server.listen(this.paths.endpoint, () => {
+                this.#ownsEndpoint = true;
                 server.off("error", reject);
                 resolve();
             });
@@ -146,7 +156,9 @@ export class SupervisorServer {
         await this.close(false);
     }
     async close(stopAgents = false) {
-        if (stopAgents && !await this.#drainInstances("update", this.shutdownDeadlineMs)) {
+        if (this.#closing)
+            return;
+        if (stopAgents && this.#ownsEndpoint && !await this.#drainInstances("update", this.shutdownDeadlineMs)) {
             throw new Error("active launch instances did not release ownership within the shutdown deadline");
         }
         this.#closing = true;
@@ -155,14 +167,27 @@ export class SupervisorServer {
         this.#supersededPoll = null;
         for (const client of this.#clients)
             client.destroy();
-        if (this.#server)
-            await new Promise(resolve => this.#server?.close(() => resolve()));
-        this.#server = null;
-        this.store.close();
-        await this.#metadataWrites;
-        await rm(this.paths.endpointMetadataPath, { force: true });
-        if (platform() !== "win32")
-            await rm(this.paths.endpoint, { force: true });
+        try {
+            await this.#metadataWrites.catch(() => undefined);
+            if (this.#ownsEndpoint) {
+                // Concurrency: remove only our publication, before releasing the listening endpoint.
+                // A contender that failed to bind must never erase the successful owner's discovery file.
+                const metadata = await readFile(this.paths.endpointMetadataPath, "utf8").then(source => JSON.parse(source)).catch(() => null);
+                if (metadata?.supervisorId === this.id && metadata.bootNonce === this.bootNonce) {
+                    await rm(this.paths.endpointMetadataPath, { force: true });
+                }
+                // Platform: Node unlinks its Unix socket when the server closes; unlinking it early would
+                // let a replacement bind before the old server finishes releasing that path.
+            }
+        }
+        finally {
+            // Platform: a metadata sharing error must not leave a bound but undiscoverable listener.
+            if (this.#server)
+                await new Promise(resolve => this.#server?.close(() => resolve()));
+            this.#server = null;
+            this.#ownsEndpoint = false;
+            this.store.close();
+        }
     }
     async closeForReleaseReplacement(stopAgents) {
         await this.close(stopAgents);
@@ -473,6 +498,8 @@ export class SupervisorServer {
         return [...this.#instances.keys()];
     }
     #writeEndpointMetadata() {
+        if (this.#closing)
+            return Promise.resolve();
         const liveInstanceIds = this.#liveInstanceIds();
         const metadata = {
             schema: PRODUCT_IDENTITY.protocol.supervisorSchema,

package/dist/integrations/pi/components/owned-editor-ux.d.ts

@@ -8,7 +8,7 @@ import type { PiShellClipboardContent, PiShellEditorTextRange } from "./shell-sh
  * Pi editor port and gives future interactions one registration point.
  */
 export interface OwnedEditorUxInterceptor {
-    handleInput(data: string, next: () => void): void;
+    handleInput(data: string, next: (data?: string) => void): void;
     render(width: number, next: () => string[]): string[];
     reset(): void;
     handlePointer?(event: OwnedEditorPointerEvent): boolean;

package/dist/integrations/pi/components/owned-editor-ux.js

@@ -8,15 +8,15 @@ export class OwnedEditorUxInterception {
         this.fallback = fallback;
     }
     handleInput(data) {
-        const invoke = (index) => {
+        const invoke = (index, input) => {
             const interceptor = this.interceptors[index];
             if (interceptor === undefined) {
-                this.fallback.handleInput(data);
+                this.fallback.handleInput(input);
                 return;
             }
-            interceptor.handleInput(data, () => invoke(index + 1));
+            interceptor.handleInput(input, (replacement = input) => invoke(index + 1, replacement));
         };
-        invoke(0);
+        invoke(0, data);
     }
     render(width) {
         const invoke = (index) => {
@@ -65,6 +65,7 @@ class PromptSelectionInterceptor {
     #redoStack = [];
     #selectionRevision = 0;
     #pasteGeneration = 0;
+    #terminalPaste;
     #wordDirection;
     #geometry;
     constructor(editor, keybindings, options) {
@@ -74,6 +75,8 @@ class PromptSelectionInterceptor {
         installAtomicSegmentation(editor, options.atomicRanges, () => this.#wordDirection);
     }
     handleInput(data, next) {
+        if (this.#handleTerminalPaste(data, next))
+            return;
         if (this.keybindings.matches(data, "owned.editor.selectAll")) {
             this.#selectAll();
             return;
@@ -105,23 +108,6 @@ class PromptSelectionInterceptor {
             this.#redo();
             return;
         }
-        const terminalPaste = bracketedPasteContent(data);
-        if (terminalPaste !== undefined) {
-            if (terminalPaste.length === 0) {
-                this.pasteClipboard();
-                return;
-            }
-            const transformed = this.options.transformPastedContent({ kind: "text", text: terminalPaste });
-            if (transformed !== terminalPaste) {
-                if (this.#orderedSelection() !== undefined)
-                    this.#replaceSelection(transformed);
-                else
-                    this.editor.insertTextAtCursor(transformed);
-                this.#redoStack = [];
-                this.#requestRender();
-                return;
-            }
-        }
         if (this.keybindings.matches(data, "tui.editor.undo")) {
             const before = this.#snapshot();
             this.#clearSelection(false);
@@ -291,7 +277,10 @@ class PromptSelectionInterceptor {
         this.#redoStack = [];
         this.#selectionRevision += 1;
     }
-    cancelPendingPastes() { this.#pasteGeneration += 1; }
+    cancelPendingPastes() {
+        this.#pasteGeneration += 1;
+        this.#terminalPaste = undefined;
+    }
     hasSelection() {
         return this.#activeRange() !== undefined;
     }
@@ -450,6 +439,46 @@ class PromptSelectionInterceptor {
         this.#selectionRevision += 1;
         this.#requestRender();
     }
+    #handleTerminalPaste(data, next) {
+        const start = data.indexOf("\x1b[200~");
+        if (this.#terminalPaste === undefined) {
+            if (start < 0)
+                return false;
+            if (start > 0) {
+                const before = data.slice(0, start);
+                this.handleInput(before, (replacement = before) => next(replacement));
+            }
+            this.#terminalPaste = "";
+            data = data.slice(start + 6);
+        }
+        // Compatibility: the terminal's StdinBuffer assembles split opening delimiters;
+        // retain the body here too so editor-level chunks cannot allocate a native paste ID.
+        this.#terminalPaste += data;
+        const end = this.#terminalPaste.indexOf("\x1b[201~");
+        if (end < 0)
+            return true;
+        const text = this.#terminalPaste.slice(0, end);
+        const remaining = this.#terminalPaste.slice(end + 6);
+        this.#terminalPaste = undefined;
+        if (text.length === 0)
+            this.pasteClipboard();
+        else {
+            const transformed = this.options.transformPastedContent({ kind: "text", text });
+            if (transformed === text && this.#orderedSelection() === undefined)
+                next(`\x1b[200~${text}\x1b[201~`);
+            else {
+                if (this.#orderedSelection() !== undefined)
+                    this.#replaceSelection(transformed);
+                else
+                    this.editor.insertTextAtCursor(transformed);
+                this.#redoStack = [];
+                this.#requestRender();
+            }
+        }
+        if (remaining.length > 0)
+            this.handleInput(remaining, (replacement = remaining) => next(replacement));
+        return true;
+    }
     #pasteFromClipboard() {
         if (this.options.beginClipboardPaste !== undefined) {
             const generation = this.#pasteGeneration;
@@ -802,11 +831,6 @@ function isEditorSegment(value) {
     const input = Reflect.get(value, "input");
     return typeof segment === "string" && typeof index === "number" && typeof input === "string";
 }
-function bracketedPasteContent(data) {
-    const start = data.indexOf("\u001b[200~");
-    const end = data.indexOf("\u001b[201~", start + 6);
-    return start < 0 || end < 0 ? undefined : data.slice(start + 6, end);
-}
 function insertedText(data) {
     if (!data || data.includes("\u001b[200~"))
         return undefined;

package/dist/integrations/pi/engine/adapter.d.ts

@@ -6,6 +6,10 @@ import { PiSettingsIntegration } from "./settings-integration.js";
 import type { PiSettingOwnerHandlers } from "./settings-effects.js";
 import type { PiProjectTrustPreflightPrompt } from "./project-trust-preflight.js";
 import type { AgentSettingOwner } from "../../../contracts/agent-engine/index.js";
+/** Explicit flush failure when required delivery was interrupted rather than completed. */
+export declare class EngineDeliveryError extends Error {
+    constructor();
+}
 export interface PiEngineRuntimeFactoryInput {
     readonly cwd: string;
     readonly agentDir: string;
@@ -133,6 +137,8 @@ export declare class PiEngineAdapter implements OwnedUiPromptSuggestionGenerator
     setWorkflowInteractionHost(interaction: PiWorkflowInteractionHost): void;
     get sessionId(): string;
     get sessionGeneration(): number;
+    /** Actual session replacements, excluding delivery-only invalidation of callbacks. */
+    get sessionBindingGeneration(): number;
     get cwd(): string;
     get agentDir(): string;
     resolveTranscriptImage(assetId: string): OwnedUiImageAttachment | null;
@@ -142,6 +148,20 @@ export declare class PiEngineAdapter implements OwnedUiPromptSuggestionGenerator
     generate(request: OwnedUiPromptSuggestionRequest): Promise<OwnedUiPromptSuggestionResult>;
     start(): Promise<OwnedUiSessionViewModel>;
     onEvent(listener: (event: OwnedUiEvent) => void): () => void;
+    /** Developer-only pressure evidence; never mirrored into visible diagnostic/status arrays. */
+    deliveryDiagnostics(): {
+        overloads: number;
+        recovering: boolean;
+        pendingCommands: number;
+        reservedOutcomes: number;
+        invalidatedEvents: number;
+        pending: number;
+        bytes: number;
+        protected: number;
+        superseded: number;
+        peakNodes: number;
+        peakBytes: number;
+    };
     flushEvents(): Promise<void>;
     nonVisualResources(): readonly OwnedPiResourceSummary[];
     extensionResources(): readonly OwnedPiExtensionResourceSummary[];