@timurproko/a1 0.2.7-dev.1275 → 0.2.7-dev.1285

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

@@ -1,3 +1,4 @@
+import type { DeliveryFailure } from "./event-delivery.js";
 import { PiEngineAdapter } from "./adapter.js";
 import { type StartupPhase } from "../../../foundation/startup/startup-runtime.js";
 import type { PiEnginePackageUpdateProbe, PiEngineRuntimeFactory, PiRepositoryContextReader } from "./session-runtime.js";
@@ -21,6 +22,7 @@ export interface PiEngineHostTheme {
 }
 export interface PiEngineHostOptions {
     readonly productMode: "bare" | "comparison";
+    readonly deliveryIncident?: (failure: DeliveryFailure) => void;
     readonly theme: PiEngineHostTheme;
     /** Themes installed on this machine, listed by the component adapter that owns the theme unit. */
     readonly availableThemes?: () => readonly string[];
@@ -41,6 +43,7 @@ export interface PiEngineSessionRequest extends OwnedUiSessionRequest {
     readonly sessionSelection?: PiSessionSelection;
     readonly sessionForkPrompt?: PiSessionForkPrompt;
     readonly repositoryContextReader?: PiRepositoryContextReader;
+    readonly worktreeCwdReader?: import("./worktree-tools.js").PiWorktreeCwdReader;
 }
 /** The dispatcher policy in force for the process and the session that put it there. */
 export interface PiEngineHttpPolicy {

package/dist/integrations/pi/engine/host.js

@@ -26,6 +26,7 @@ class ProcessPiEngineHost {
         this.#markStartupPhase = options.markStartupPhase ?? (phase => markStartupPhase(process.env, phase));
         this.#sessionPorts = {
             signal: this.#abort.signal,
+            deliveryIncident: failure => options.deliveryIncident?.(failure),
             markStartupPhase: phase => this.#tracePhase(phase),
             httpPolicyLoaded: (timeoutMs, sessionId) => { this.#applyHttpPolicy(timeoutMs, sessionId, "startup"); },
             httpPolicyChanged: (timeoutMs, sessionId) => { this.#applyHttpPolicy(timeoutMs, sessionId, "setting"); },
@@ -68,6 +69,7 @@ class ProcessPiEngineHost {
             ...(request.sessionSelection === undefined ? {} : { sessionSelection: request.sessionSelection }),
             ...(request.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: request.sessionForkPrompt }),
             ...(request.repositoryContextReader === undefined ? {} : { repositoryContextReader: request.repositoryContextReader }),
+            ...(request.worktreeCwdReader === undefined ? {} : { worktreeCwdReader: request.worktreeCwdReader }),
         });
         this.#sessions.set(sessionId, adapter);
         try {

package/dist/integrations/pi/engine/package-integration.js

@@ -17,6 +17,8 @@ export function createPiPackagesPort(input) {
     const { profileRoot, cwd } = input;
     // Compatibility: model-only refresh bypasses package settings and their diagnostics, as Pi does.
     let packageManager;
+    let updateChanges = [];
+    let updateWarningCount = 0;
     const manager = () => {
         if (packageManager)
             return packageManager;
@@ -29,9 +31,16 @@ export function createPiPackagesPort(input) {
         }
         packageManager = new DefaultPackageManager({ cwd, agentDir: profileRoot, settingsManager });
         packageManager.setProgressCallback(event => {
-            if (event.type !== "start")
-                return;
-            input.onProgress?.({ operation: operationFor(event.action), message: String(event.message) });
+            if (event.type === "result" && event.action === "update" && event.message) {
+                updateChanges.push(event.message);
+            }
+            else if (event.type === "start") {
+                input.onProgress?.({ operation: operationFor(event.action), message: String(event.message) });
+            }
+            else if (event.type === "progress" && event.message) {
+                updateWarningCount++;
+                input.onProgress?.({ operation: operationFor(event.action), message: event.message, severity: "warning" });
+            }
         });
         return packageManager;
     };
@@ -65,8 +74,14 @@ export function createPiPackagesPort(input) {
         async update(source) {
             return await attempt("update", source ?? null, async () => {
                 // Compatibility: Pi owns source identity and its contextual no-match suggestions.
+                updateChanges = [];
+                updateWarningCount = 0;
                 await manager().update(source);
-                return agentPackageOutcome("update", "completed", null, source ?? null, configured());
+                // Compatibility: Pi's offline predicate is not part of its package-root public API.
+                const offline = ["1", "true", "yes"].includes(process.env.PI_OFFLINE?.toLowerCase() ?? "");
+                return agentPackageOutcome("update", "completed", null, source ?? null, configured(), {
+                    offline, warningCount: updateWarningCount, changes: updateChanges,
+                });
             });
         },
         async refreshModels() {

package/dist/integrations/pi/engine/pending-delivery.d.ts

@@ -2,8 +2,11 @@ import type { OwnedUiEvent } from "../../../contracts/owned-ui/index.js";
 /** Intrusive FIFO + segment index: replacement unlinks in O(1), never changes source ordering. */
 export declare class PendingEngineDelivery {
     #private;
+    rejection: "event-count" | "retained-bytes" | null;
     private readonly retain;
-    constructor(retain?: (event: OwnedUiEvent) => () => void);
+    private readonly current;
+    private readonly externalBytes;
+    constructor(retain?: (event: OwnedUiEvent) => () => void, current?: () => unknown, externalBytes?: (excluding?: OwnedUiEvent) => number);
     get size(): number;
     diagnostics(): {
         pending: number;

package/dist/integrations/pi/engine/pending-delivery.js

@@ -1,3 +1,4 @@
+import { DeliveryRetention } from "./delivery-retention.js";
 const MAX_PENDING_EVENTS = 1024;
 const MAX_PENDING_EVENT_BYTES = 8 * 1024 * 1024;
 /** Actual shell semantics: only live complete block state has no independent side effect. */
@@ -29,21 +30,32 @@ export class PendingEngineDelivery {
     #head;
     #tail;
     #size = 0;
-    #bytes = 0;
+    #retention = new DeliveryRetention();
     #protected = 0;
     #generation = -1;
     #superseded = 0;
     #peakNodes = 0;
     #peakBytes = 0;
+    rejection = null;
     retain;
-    constructor(retain) { this.retain = retain; }
+    current;
+    externalBytes;
+    constructor(retain, current, externalBytes) {
+        this.retain = retain;
+        this.current = current;
+        this.externalBytes = externalBytes;
+    }
     get size() { return this.#size; }
+    get #bytes() { return this.#retention.bytes + this.#size * 128 + (this.externalBytes?.() ?? 0); }
     diagnostics() {
         return { pending: this.#size, bytes: this.#bytes, protected: this.#protected,
             superseded: this.#superseded, peakNodes: this.#peakNodes, peakBytes: this.#peakBytes };
     }
     /** False means not admitted. The caller must enter its reserved recovery protocol, never evict. */
     push(event, generation, reconcile) {
+        this.rejection = null;
+        if (this.current)
+            this.#retention.baseline(this.current());
         const key = replaceableEventKey(event);
         if (generation !== this.#generation || key === null) {
             if (!this.seal())
@@ -51,14 +63,23 @@ export class PendingEngineDelivery {
             this.#generation = generation;
         }
         const prior = key === null ? undefined : this.#replaceable.get(key);
-        let bytes = retainedEventBytes(event);
-        const marker = key !== null && bytes > 64 * 1024 && reconcile !== undefined;
-        if (marker)
-            bytes = 128;
+        // Compatibility: production owns exact immutable revisions through the ledger. Legacy standalone
+        // queues retain the compact-marker contract when no authoritative owner is supplied.
+        const marker = this.current === undefined && key !== null && retainedEventBytes(event) > 64 * 1024 && reconcile !== undefined;
+        const charge = marker ? undefined : this.#retention.retain(event);
+        const release = marker ? undefined : this.retain?.(event);
+        prior?.charge?.();
+        const bytes = this.#retention.bytes + this.#size * 128 + (this.externalBytes?.(prior?.event) ?? 0);
         if (this.#size - (prior === undefined ? 0 : 1) >= MAX_PENDING_EVENTS
-            || this.#bytes - (prior?.bytes ?? 0) + bytes > MAX_PENDING_EVENT_BYTES)
+            || bytes + (prior === undefined ? 128 : 0) > MAX_PENDING_EVENT_BYTES) {
+            this.rejection = this.#size - (prior === undefined ? 0 : 1) >= MAX_PENDING_EVENTS ? "event-count" : "retained-bytes";
+            charge?.();
+            release?.();
+            if (prior?.event)
+                prior.charge = this.#retention.retain(prior.event);
             return false;
-        const node = { key, generation, bytes, ...(marker ? { resolve: reconcile } : { event, release: this.retain?.(event) }) };
+        }
+        const node = { key, generation, charge, ...(marker ? { resolve: reconcile } : { event, release }) };
         if (prior !== undefined) {
             this.#unlink(prior);
             this.#superseded = Math.min(Number.MAX_SAFE_INTEGER, this.#superseded + 1);
@@ -70,7 +91,6 @@ export class PendingEngineDelivery {
             this.#head = node;
         this.#tail = node;
         this.#size++;
-        this.#bytes += bytes;
         if (key === null)
             this.#protected++;
         else
@@ -101,9 +121,17 @@ export class PendingEngineDelivery {
             return undefined;
         const event = node.event ?? node.resolve();
         const release = node.release ?? this.retain?.(event);
+        const charge = node.charge;
         this.#unlink(node, false);
-        // Invariant: a consumed snapshot retains its assets through synchronous listener delivery, including reentrant production.
-        return { event, generation: node.generation, ...(release === undefined ? {} : { release }) };
+        // Invariant: keep the exact revision and assets charged through reentrant listener production.
+        let released = false;
+        return { event, generation: node.generation, release: () => {
+                if (released)
+                    return;
+                released = true;
+                charge?.();
+                release?.();
+            } };
     }
     // Invariant: a barrier freezes lazy authoritative markers before a later segment can change them.
     seal() {
@@ -111,22 +139,28 @@ export class PendingEngineDelivery {
             if (node.resolve === undefined)
                 continue;
             const event = node.resolve();
-            const bytes = retainedEventBytes(event);
-            if (this.#bytes - node.bytes + bytes > MAX_PENDING_EVENT_BYTES)
+            const charge = this.#retention.retain(event);
+            const release = this.retain?.(event);
+            if (this.#bytes > MAX_PENDING_EVENT_BYTES) {
+                this.rejection = "retained-bytes";
+                charge();
+                release?.();
                 return false;
-            this.#bytes += bytes - node.bytes;
-            node.bytes = bytes;
+            }
+            node.charge = charge;
             node.event = event;
             node.resolve = undefined;
-            node.release = this.retain?.(event);
+            node.release = release;
             this.#peakBytes = Math.max(this.#peakBytes, this.#bytes);
         }
         this.#replaceable.clear();
         return true;
     }
     #unlink(node, release = true) {
-        if (release)
+        if (release) {
+            node.charge?.();
             node.release?.();
+        }
         if (node.previous !== undefined)
             node.previous.next = node.next;
         else
@@ -136,7 +170,6 @@ export class PendingEngineDelivery {
         else
             this.#tail = node.previous;
         this.#size--;
-        this.#bytes -= node.bytes;
         if (node.key === null)
             this.#protected--;
         else if (this.#replaceable.get(node.key) === node)