@timurproko/a1 0.1.8-dev.3b54f21 → 0.1.8-dev.402

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

@@ -0,0 +1,2 @@
+export declare function readPinnedCommandChangelog(sinceVersion?: string): Promise<string>;
+export declare function formatPinnedCommandChangelog(content: string, sinceVersion?: string): string;

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

@@ -0,0 +1,63 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { posix } from "node:path";
+const REPOSITORY = "https://github.com/earendil-works/pi";
+export async function readPinnedCommandChangelog(sinceVersion) {
+    const path = new URL("./resources/changelog.json", import.meta.url);
+    if (!existsSync(path))
+        return sinceVersion === undefined ? "No changelog entries found." : "";
+    try {
+        const resource = JSON.parse(await readFile(path, "utf8"));
+        if (!resource || typeof resource !== "object" || !("data" in resource) || typeof resource.data !== "string")
+            throw new TypeError("Invalid owned changelog resource");
+        const markdown = resource.data;
+        return formatPinnedCommandChangelog(markdown, sinceVersion);
+    }
+    catch (error) {
+        // Compatibility: Pi's data-file parser reports a warning and supplies an empty changelog.
+        console.error(`Warning: Could not parse changelog: ${error}`);
+        return sinceVersion === undefined ? "No changelog entries found." : "";
+    }
+}
+export function formatPinnedCommandChangelog(content, sinceVersion) {
+    // Provenance: behavior follows Pi 0.84.2 utils/changelog.ts at 914cf1472e715297caa30db4b9535d534a9eb718.
+    // Runtime reads only the owned data resource; maintenance tooling verifies its pinned provenance.
+    let releases = content.split(/(?=^## )/m).flatMap((section) => {
+        const version = /^##\s+\[?(\d+)\.(\d+)\.(\d+)\]?/.exec(section);
+        return version ? [{ version: version.slice(1).map(Number), markdown: section.trim() }] : [];
+    });
+    if (sinceVersion !== undefined) {
+        const previous = sinceVersion.split(".").map(value => Number(value) || 0);
+        releases = releases.filter(release => {
+            for (let index = 0; index < 3; index++) {
+                const difference = release.version[index] - (previous[index] ?? 0);
+                if (difference !== 0)
+                    return difference > 0;
+            }
+            return false;
+        });
+    }
+    else
+        releases.reverse();
+    if (releases.length === 0)
+        return sinceVersion === undefined ? "No changelog entries found." : "";
+    return releases.map(release => release.markdown.replace(/(!?\[[^\]\n]+\]\()([^\s)]+)((?:\s+[^)]*)?\))/g, (_match, prefix, target, suffix) => `${prefix}${releaseLink(target, `v${release.version.join(".")}`)}${suffix}`)).join("\n\n");
+}
+function releaseLink(target, tag) {
+    const canonical = target
+        .replace(/^https:\/\/github\.com\/(?:badlogic|earendil-works)\/pi-mono(?=\/|$)/, REPOSITORY)
+        .replace(/^(https:\/\/github\.com\/earendil-works\/pi\/(?:blob|tree)\/)(?:main|master)\//, `$1${tag}/`);
+    if (/^(?:#|\/\/|[a-z][a-z0-9+.-]*:)/i.test(canonical))
+        return canonical;
+    const boundary = canonical.search(/[?#]/);
+    const path = boundary === -1 ? canonical : canonical.slice(0, boundary);
+    const suffix = boundary === -1 ? "" : canonical.slice(boundary);
+    if (!path)
+        return canonical;
+    const normalized = path.replaceAll("\\", "/");
+    const repositoryPath = posix.normalize(normalized.startsWith("/") ? normalized.replace(/^\/+/, "") : posix.join("packages/coding-agent", normalized));
+    if (repositoryPath === "." || repositoryPath === ".." || repositoryPath.startsWith("../"))
+        return canonical;
+    const route = path.endsWith("/") || !posix.basename(repositoryPath).includes(".") ? "tree" : "blob";
+    return `${REPOSITORY}/${route}/${tag}/${encodeURI(repositoryPath)}${suffix}`;
+}

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/conformance.d.ts

@@ -7,12 +7,13 @@ export declare const REQUIRED_PI_CAPABILITY_OPERATIONS: Readonly<{
     readonly "public-exports": readonly ["services.create", "session.create", "runtime.create"];
     readonly "session-lifecycle": readonly ["session.new", "session.resume", "session.rebind", "session.dispose"];
     readonly "commands-events": readonly ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
-    readonly "models-authentication": readonly ["models.list", "models.refresh", "auth.status", "auth.login", "auth.logout", "auth.cancel"];
+    readonly "models-authentication": readonly ["models.list", "models.refresh", "models.completeSimple", "auth.status", "auth.login", "auth.logout", "auth.cancel"];
     readonly settings: readonly ["settings.read", "settings.write", "settings.flush"];
-    readonly "resources-extensions": readonly ["resources.discover", "extensions.bind", "extensions.reload", "renderers.invoke"];
+    readonly "resources-extensions": readonly ["resources.discover", "extensions.inline", "extensions.bind", "extensions.reload", "renderers.invoke"];
     readonly workflows: readonly ["workflow.route", "workflow.validate", "workflow.diagnostics"];
     readonly disposal: readonly ["subscription.dispose", "session.dispose", "services.cleanup"];
 }>;
+/** Identifies one required Pi capability operation that differs from the accepted integration contract. */
 export declare class PiCapabilityCompatibilityError extends Error {
     readonly packageVersion: string;
     readonly capability: string;
@@ -29,6 +30,7 @@ export interface PiUpgradeConformanceReport {
     readonly commandSurface: readonly string[];
     readonly capabilities: readonly PiCapabilityConformanceResult[];
 }
+/** Identifies the public Pi SDK stage that failed during upgrade conformance. */
 export declare class PiUpgradeConformanceError extends Error {
     readonly stage: "exports" | "services" | "session";
     constructor(stage: "exports" | "services" | "session", cause: unknown);

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/conformance.js

@@ -2,18 +2,20 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, ModelRuntime, SessionManager, VERSION, } from "@earendil-works/pi-coding-agent";
-import { OWNED_UI_CONTRACT_VERSION } from "../owned-ui-contracts/index.js";
-import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { OWNED_UI_CONTRACT_VERSION } from "../../../contracts/owned-ui/index.js";
+import { PRODUCT_IDENTITY } from "../../../product-identity.js";
+import { createWindowsNulCleanupExtension } from "./windows-filesystem-hygiene.js";
 export const REQUIRED_PI_CAPABILITY_OPERATIONS = Object.freeze({
     "public-exports": ["services.create", "session.create", "runtime.create"],
     "session-lifecycle": ["session.new", "session.resume", "session.rebind", "session.dispose"],
     "commands-events": ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"],
-    "models-authentication": ["models.list", "models.refresh", "auth.status", "auth.login", "auth.logout", "auth.cancel"],
+    "models-authentication": ["models.list", "models.refresh", "models.completeSimple", "auth.status", "auth.login", "auth.logout", "auth.cancel"],
     settings: ["settings.read", "settings.write", "settings.flush"],
-    "resources-extensions": ["resources.discover", "extensions.bind", "extensions.reload", "renderers.invoke"],
+    "resources-extensions": ["resources.discover", "extensions.inline", "extensions.bind", "extensions.reload", "renderers.invoke"],
     workflows: ["workflow.route", "workflow.validate", "workflow.diagnostics"],
     disposal: ["subscription.dispose", "session.dispose", "services.cleanup"],
 });
+/** Identifies one required Pi capability operation that differs from the accepted integration contract. */
 export class PiCapabilityCompatibilityError extends Error {
     packageVersion;
     capability;
@@ -26,6 +28,7 @@ export class PiCapabilityCompatibilityError extends Error {
         this.name = "PiCapabilityCompatibilityError";
     }
 }
+/** Identifies the public Pi SDK stage that failed during upgrade conformance. */
 export class PiUpgradeConformanceError extends Error {
     stage;
     constructor(stage, cause) {
@@ -57,11 +60,18 @@ export async function runPiUpgradeConformance() {
                 refreshOnCreate: false,
                 allowModelNetwork: false,
             });
+            const cleanupExtension = createWindowsNulCleanupExtension({ platform: "win32" });
+            if (cleanupExtension === null)
+                throw new Error("Windows NUL cleanup extension is unavailable");
             services = await createAgentSessionServices({
                 cwd: root,
                 agentDir: join(root, "agent"),
                 modelRuntime,
+                resourceLoaderOptions: { extensionFactories: [cleanupExtension] },
             });
+            if (!services.resourceLoader.getExtensions().extensions.some(extension => extension.path === "<inline:windows-nul-file-cleanup>")) {
+                throw new Error("named inline extension factory was not loaded");
+            }
         }
         catch (error) {
             throw new PiUpgradeConformanceError("services", error);
@@ -76,7 +86,7 @@ export async function runPiUpgradeConformance() {
             const session = created.session;
             sessionId = session.sessionId;
             requireMethods(session, "session commands", ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"]);
-            requireMethods(services.modelRuntime, "models/authentication", ["getModels", "getModel", "checkAuth", "login", "logout", "refresh"]);
+            requireMethods(services.modelRuntime, "models/authentication", ["getModels", "getModel", "completeSimple", "checkAuth", "login", "logout", "refresh"]);
             requireMethods(services.settingsManager, "settings", ["getGlobalSettings", "getProjectSettings", "flush"]);
             requireMethods(services.resourceLoader, "resources/extensions", ["getExtensions", "getSkills", "getPrompts", "getThemes", "reload"]);
             const unsubscribe = session.subscribe(() => undefined);

package/dist/integrations/pi/engine/http-dispatcher.d.ts

@@ -0,0 +1,4 @@
+/** Apply the profile's HTTP timeout to npm undici and its fetch globals. */
+export declare function configureOwnedHttpDispatcher(timeoutMs: number): void;
+/** Test and diagnostics seam; reports configured semantics, not the max-int implementation detail. */
+export declare function configuredOwnedHttpIdleTimeoutMs(): number | null;

package/dist/integrations/pi/engine/http-dispatcher.js

@@ -0,0 +1,25 @@
+// Provenance: mechanically adapted from Pi commit 914cf14
+// packages/coding-agent/src/core/http-dispatcher.ts (MIT).
+// Local modifications: expose only A1's owned timeout seam and retain no private Pi imports.
+import { EnvHttpProxyAgent, install, setGlobalDispatcher } from "undici";
+const MAX_DISABLED_TIMEOUT_MS = 2_147_483_647;
+let configuredTimeoutMs = null;
+/** Apply the profile's HTTP timeout to npm undici and its fetch globals. */
+export function configureOwnedHttpDispatcher(timeoutMs) {
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0)
+        throw new TypeError("HTTP idle timeout is invalid");
+    const effectiveTimeoutMs = timeoutMs === 0 ? MAX_DISABLED_TIMEOUT_MS : timeoutMs;
+    const dispatcher = new EnvHttpProxyAgent({
+        allowH2: false,
+        bodyTimeout: effectiveTimeoutMs,
+        headersTimeout: effectiveTimeoutMs,
+        connect: { autoSelectFamilyAttemptTimeout: 2_000 },
+    });
+    setGlobalDispatcher(dispatcher);
+    install?.();
+    configuredTimeoutMs = timeoutMs;
+}
+/** Test and diagnostics seam; reports configured semantics, not the max-int implementation detail. */
+export function configuredOwnedHttpIdleTimeoutMs() {
+    return configuredTimeoutMs;
+}

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/index.d.ts

@@ -1,9 +1,13 @@
 export * from "./adapter.js";
 export * from "./conformance.js";
 export * from "./runtime-integration.js";
+export * from "./session-selection.js";
 export * from "./session-integration.js";
 export * from "./model-auth-integration.js";
 export * from "./settings-integration.js";
+export * from "./settings-effects.js";
+export * from "./project-trust-preflight.js";
+export * from "./http-dispatcher.js";
 export * from "./package-integration.js";
 export * from "./resource-extension-integration.js";
 export * from "./workflow-controllers.js";

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/index.js

@@ -1,9 +1,13 @@
 export * from "./adapter.js";
 export * from "./conformance.js";
 export * from "./runtime-integration.js";
+export * from "./session-selection.js";
 export * from "./session-integration.js";
 export * from "./model-auth-integration.js";
 export * from "./settings-integration.js";
+export * from "./settings-effects.js";
+export * from "./project-trust-preflight.js";
+export * from "./http-dispatcher.js";
 export * from "./package-integration.js";
 export * from "./resource-extension-integration.js";
 export * from "./workflow-controllers.js";

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/model-auth-integration.d.ts

@@ -1,5 +1,5 @@
 import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
-import type { AgentAuthenticationPort, AgentModelDescriptor, AgentModelPort } from "../agent-engine-contracts/index.js";
+import type { AgentAuthenticationPort, AgentModelDescriptor, AgentModelPort } from "../../../contracts/agent-engine/index.js";
 export type PiDocumentedModelRuntime = Pick<ModelRuntime, "getAvailableSnapshot" | "getModel" | "getProvider" | "hasConfiguredAuth" | "refresh" | "logout">;
 export interface PiModelAuthenticationOptions {
     readonly runtime: PiDocumentedModelRuntime;
@@ -9,6 +9,7 @@ export interface PiModelAuthenticationOptions {
     readonly timeoutMs?: number;
     readonly scopedModelIds?: () => readonly string[] | undefined;
 }
+/** Adapts the pinned model runtime to neutral model selection and authentication operations. */
 export declare class PiModelAuthenticationIntegration implements AgentModelPort, AgentAuthenticationPort {
     #private;
     private readonly options;

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/model-auth-integration.js

@@ -1,3 +1,4 @@
+/** Adapts the pinned model runtime to neutral model selection and authentication operations. */
 export class PiModelAuthenticationIntegration {
     options;
     capabilities = { selection: true, refresh: true, scopedCatalog: true, login: true, logout: true };

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/package-integration.d.ts

@@ -1,4 +1,4 @@
-import { type AgentPackagesPort, type AgentPackagesPortInput } from "../agent-engine-contracts/index.js";
+import { type AgentPackagesPort, type AgentPackagesPortInput } from "../../../contracts/agent-engine/index.js";
 /**
  * Pinned Pi's package manager already takes the profile root as an argument, so
  * this binds it to the root A1 chose rather than to whatever the configuration-root

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/package-integration.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { DefaultPackageManager, ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
-import { agentPackageOutcome, } from "../agent-engine-contracts/index.js";
+import { agentPackageOutcome, } from "../../../contracts/agent-engine/index.js";
 const MODEL_REFRESH_TIMEOUT_MS = 15_000;
 /**
  * Pinned Pi's package manager already takes the profile root as an argument, so
@@ -15,21 +15,33 @@ const MODEL_REFRESH_TIMEOUT_MS = 15_000;
  */
 export function createPiPackagesPort(input) {
     const { profileRoot, cwd } = input;
-    const settingsManager = SettingsManager.create(cwd, profileRoot, { projectTrusted: false });
-    const packageManager = new DefaultPackageManager({ cwd, agentDir: profileRoot, settingsManager });
-    packageManager.setProgressCallback(event => {
-        if (event.type !== "start" || !event.message)
-            return;
-        input.onProgress?.({ operation: operationFor(event.action), message: event.message });
-    });
-    const configured = () => packageManager.listConfiguredPackages()
+    // Compatibility: model-only refresh bypasses package settings and their diagnostics, as Pi does.
+    let packageManager;
+    const manager = () => {
+        if (packageManager)
+            return packageManager;
+        const settingsManager = SettingsManager.create(cwd, profileRoot, { projectTrusted: false });
+        for (const { scope, error } of settingsManager.drainErrors()) {
+            input.onDiagnostic?.({
+                message: `Warning (package command, ${scope} settings): ${error.message}`,
+                ...(error.stack ? { detail: error.stack } : {}),
+            });
+        }
+        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) });
+        });
+        return packageManager;
+    };
+    const configured = () => manager().listConfiguredPackages()
         .filter(entry => entry.scope === "user")
         .map(entry => Object.freeze({
         source: entry.source,
         installedPath: entry.installedPath ?? null,
         filtered: entry.filtered,
     }));
-    const isConfigured = (source) => configured().some(entry => entry.source === source || entry.source.startsWith(`${source}@`));
     return Object.freeze({
         capabilities: Object.freeze({ install: true, remove: true, update: true, refreshModels: true }),
         profileRoot,
@@ -38,13 +50,13 @@ export function createPiPackagesPort(input) {
         },
         async install(source) {
             return await attempt("install", source, async () => {
-                await packageManager.installAndPersist(source);
+                await manager().installAndPersist(source);
                 return agentPackageOutcome("install", "completed", null, source, configured());
             });
         },
         async remove(source) {
             return await attempt("remove", source, async () => {
-                const removed = await packageManager.removeAndPersist(source);
+                const removed = await manager().removeAndPersist(source);
                 if (!removed)
                     return agentPackageOutcome("remove", "not-found", null, source);
                 return agentPackageOutcome("remove", "completed", null, source, configured());
@@ -52,11 +64,8 @@ export function createPiPackagesPort(input) {
         },
         async update(source) {
             return await attempt("update", source ?? null, async () => {
-                // Asking first keeps "that package is not installed here" a structural
-                // answer rather than a string a caller would have to recognize.
-                if (source !== undefined && !isConfigured(source))
-                    return agentPackageOutcome("update", "not-found", null, source);
-                await packageManager.update(source);
+                // Compatibility: Pi owns source identity and its contextual no-match suggestions.
+                await manager().update(source);
                 return agentPackageOutcome("update", "completed", null, source ?? null, configured());
             });
         },
@@ -73,7 +82,9 @@ async function attempt(operation, source, run) {
         return await run();
     }
     catch (error) {
-        return agentPackageOutcome(operation, "failed", describe(error), source);
+        const detail = error instanceof Error ? error.message : operation === "refresh-models"
+            ? "Unknown model catalog refresh error" : "Unknown package command error";
+        return agentPackageOutcome(operation, "failed", detail, source);
     }
 }
 async function refreshModelCatalogs(profileRoot) {
@@ -88,9 +99,10 @@ async function refreshModelCatalogs(profileRoot) {
         });
         const result = await modelRuntime.refresh({ allowNetwork: true, force: true, signal: controller.signal });
         if (result.aborted)
-            throw new Error(`model catalog refresh timed out after ${MODEL_REFRESH_TIMEOUT_MS}ms`);
+            throw new Error("Model catalog refresh timed out.");
         if (result.errors.size > 0) {
-            throw new Error(Array.from(result.errors, ([provider, error]) => `${provider}: ${error.message}`).join("; "));
+            const details = Array.from(result.errors, ([provider, error]) => `${provider}: ${error.message}`).join("; ");
+            throw new Error(`Could not refresh model catalogs: ${details}`);
         }
     }
     finally {
@@ -104,9 +116,3 @@ function operationFor(action) {
         return "remove";
     return "update";
 }
-function describe(error) {
-    const message = (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim();
-    if (message.length === 0)
-        return "unknown package failure";
-    return message.length > 600 ? `${message.slice(0, 597)}...` : message;
-}

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

@@ -0,0 +1,30 @@
+import type { OwnedUiEvent } from "../../../contracts/owned-ui/index.js";
+export declare const MAX_PENDING_EVENTS = 1024;
+export declare const MAX_PENDING_EVENT_BYTES: number;
+/** Actual shell semantics: only live complete block state has no independent side effect. */
+export declare function replaceableEventKey(event: OwnedUiEvent): string | null;
+/** Intrusive FIFO + segment index: replacement unlinks in O(1), never changes source ordering. */
+export declare class PendingEngineDelivery {
+    #private;
+    private readonly retain?;
+    constructor(retain?: ((event: OwnedUiEvent) => () => void) | undefined);
+    get size(): number;
+    diagnostics(): {
+        pending: number;
+        bytes: number;
+        protected: number;
+        superseded: number;
+        peakNodes: number;
+        peakBytes: number;
+    };
+    /** False means not admitted. The caller must enter its reserved recovery protocol, never evict. */
+    push(event: OwnedUiEvent, generation: number, reconcile?: () => OwnedUiEvent): boolean;
+    /** Session replacement invalidates old view state without resolving its lazy block references. */
+    discardObsolete(generation: number): number;
+    shift(): {
+        event: OwnedUiEvent;
+        generation: number;
+        release?: (() => void) | undefined;
+    } | undefined;
+    seal(): boolean;
+}

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

@@ -0,0 +1,158 @@
+export const MAX_PENDING_EVENTS = 1024;
+export const MAX_PENDING_EVENT_BYTES = 8 * 1024 * 1024;
+/** Actual shell semantics: only live complete block state has no independent side effect. */
+export function replaceableEventKey(event) {
+    switch (event.type) {
+        case "transcript-block": return event.block.status === "live" && !(typeof event.block.payload === "object" && event.block.payload !== null && "isError" in event.block.payload && event.block.payload.isError === true) ? event.block.id : null;
+        case "session-view": // Invariant: may clear compaction work, replace editor/session state, or preempt presentation.
+        case "status": // Invariant: retry/compaction transitions invalidate suggestion work.
+        case "editor-state":
+        case "terminal-surface":
+        case "session-lifecycle":
+        case "agent-run-started":
+        case "agent-run-settled":
+        case "assistant-message-completed":
+        case "command-outcome":
+        case "diagnostic":
+        case "dialog":
+        case "overlay":
+        case "customization": return null;
+        default: {
+            const exhaustive = event;
+            return exhaustive;
+        }
+    }
+}
+/** Intrusive FIFO + segment index: replacement unlinks in O(1), never changes source ordering. */
+export class PendingEngineDelivery {
+    retain;
+    #replaceable = new Map();
+    #head;
+    #tail;
+    #size = 0;
+    #bytes = 0;
+    #protected = 0;
+    #generation = -1;
+    #superseded = 0;
+    #peakNodes = 0;
+    #peakBytes = 0;
+    constructor(retain) {
+        this.retain = retain;
+    }
+    get size() { return this.#size; }
+    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) {
+        const key = replaceableEventKey(event);
+        if (generation !== this.#generation || key === null) {
+            if (!this.seal())
+                return false;
+            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;
+        if (this.#size - (prior === undefined ? 0 : 1) >= MAX_PENDING_EVENTS
+            || this.#bytes - (prior?.bytes ?? 0) + bytes > MAX_PENDING_EVENT_BYTES)
+            return false;
+        const node = { key, generation, bytes, ...(marker ? { resolve: reconcile } : { event, release: this.retain?.(event) }) };
+        if (prior !== undefined) {
+            this.#unlink(prior);
+            this.#superseded = Math.min(Number.MAX_SAFE_INTEGER, this.#superseded + 1);
+        }
+        node.previous = this.#tail;
+        if (this.#tail !== undefined)
+            this.#tail.next = node;
+        else
+            this.#head = node;
+        this.#tail = node;
+        this.#size++;
+        this.#bytes += bytes;
+        if (key === null)
+            this.#protected++;
+        else
+            this.#replaceable.set(key, node);
+        this.#peakNodes = Math.max(this.#peakNodes, this.#size);
+        this.#peakBytes = Math.max(this.#peakBytes, this.#bytes);
+        return true;
+    }
+    /** Session replacement invalidates old view state without resolving its lazy block references. */
+    discardObsolete(generation) {
+        let discarded = 0;
+        let node = this.#head;
+        while (node !== undefined) {
+            const next = node.next;
+            if (node.generation !== generation && node.event?.type !== "command-outcome") {
+                this.#unlink(node);
+                discarded++;
+            }
+            node = next;
+        }
+        this.#replaceable.clear();
+        this.#generation = generation;
+        return discarded;
+    }
+    shift() {
+        const node = this.#head;
+        if (node === undefined)
+            return undefined;
+        const event = node.event ?? node.resolve();
+        const release = node.release ?? this.retain?.(event);
+        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: a barrier freezes lazy authoritative markers before a later segment can change them.
+    seal() {
+        for (const node of this.#replaceable.values()) {
+            if (node.resolve === undefined)
+                continue;
+            const event = node.resolve();
+            const bytes = retainedEventBytes(event);
+            if (this.#bytes - node.bytes + bytes > MAX_PENDING_EVENT_BYTES)
+                return false;
+            this.#bytes += bytes - node.bytes;
+            node.bytes = bytes;
+            node.event = event;
+            node.resolve = undefined;
+            node.release = this.retain?.(event);
+            this.#peakBytes = Math.max(this.#peakBytes, this.#bytes);
+        }
+        this.#replaceable.clear();
+        return true;
+    }
+    #unlink(node, release = true) {
+        if (release)
+            node.release?.();
+        if (node.previous !== undefined)
+            node.previous.next = node.next;
+        else
+            this.#head = node.next;
+        if (node.next !== undefined)
+            node.next.previous = node.previous;
+        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)
+            this.#replaceable.delete(node.key);
+    }
+}
+/** Conservative UTF-16 payload bound. String length is O(1); never encode accumulated text per chunk. */
+function retainedEventBytes(value) {
+    if (typeof value === "string")
+        return 16 + value.length * 2;
+    if (value === null || typeof value !== "object")
+        return 8;
+    let bytes = 32;
+    for (const [key, item] of Object.entries(value))
+        bytes += 16 + key.length * 2 + retainedEventBytes(item);
+    return bytes;
+}

package/dist/integrations/pi/engine/project-trust-preflight.d.ts

@@ -0,0 +1,22 @@
+export interface PiProjectTrustPreflightRequest {
+    readonly cwd: string;
+    readonly defaultDecision: "ask" | "always" | "never";
+}
+export type PiProjectTrustPreflightPrompt = (request: PiProjectTrustPreflightRequest) => Promise<boolean | null>;
+export interface PiProjectTrustPreflightResult {
+    readonly trusted: boolean;
+    readonly source: "no-project-resources" | "saved" | "default" | "interactive" | "fail-closed";
+    readonly diagnostic: string | null;
+}
+export interface ResolvePiProjectTrustPreflightOptions {
+    readonly cwd: string;
+    readonly agentDir: string;
+    readonly prompt?: PiProjectTrustPreflightPrompt;
+    readonly hasProjectResources?: (cwd: string) => boolean;
+}
+/**
+ * Resolves trust from global state only. It never constructs a project-trusted
+ * settings manager or resource loader; callers may do that only after this
+ * result exists.
+ */
+export declare function resolvePiProjectTrustPreflight(options: ResolvePiProjectTrustPreflightOptions): Promise<PiProjectTrustPreflightResult>;

package/dist/integrations/pi/engine/project-trust-preflight.js

@@ -0,0 +1,50 @@
+import { hasTrustRequiringProjectResources, ProjectTrustStore, SettingsManager, } from "@earendil-works/pi-coding-agent";
+/**
+ * Resolves trust from global state only. It never constructs a project-trusted
+ * settings manager or resource loader; callers may do that only after this
+ * result exists.
+ */
+export async function resolvePiProjectTrustPreflight(options) {
+    const hasProjectResources = options.hasProjectResources ?? hasTrustRequiringProjectResources;
+    if (!hasProjectResources(options.cwd)) {
+        return { trusted: true, source: "no-project-resources", diagnostic: null };
+    }
+    const trustStore = new ProjectTrustStore(options.agentDir);
+    const saved = trustStore.get(options.cwd);
+    if (saved !== null)
+        return { trusted: saved, source: "saved", diagnostic: null };
+    // Security: projectTrusted:false is the boundary: this read may see global
+    // settings but cannot consume project settings or construct project resources.
+    const globalSettings = SettingsManager.create(options.cwd, options.agentDir, { projectTrusted: false });
+    const fallback = globalSettings.getDefaultProjectTrust();
+    if (fallback === "always")
+        return { trusted: true, source: "default", diagnostic: null };
+    if (fallback === "never")
+        return { trusted: false, source: "default", diagnostic: null };
+    if (options.prompt === undefined) {
+        return {
+            trusted: false,
+            source: "fail-closed",
+            diagnostic: `Project resources in ${options.cwd} were withheld because trust requires interaction`,
+        };
+    }
+    try {
+        const decision = await options.prompt({ cwd: options.cwd, defaultDecision: fallback });
+        if (decision === null) {
+            return {
+                trusted: false,
+                source: "fail-closed",
+                diagnostic: `Project resources in ${options.cwd} were withheld because trust selection was cancelled`,
+            };
+        }
+        trustStore.set(options.cwd, decision);
+        return { trusted: decision, source: "interactive", diagnostic: null };
+    }
+    catch (error) {
+        return {
+            trusted: false,
+            source: "fail-closed",
+            diagnostic: `Project resources in ${options.cwd} were withheld because trust resolution failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/resource-extension-integration.d.ts

@@ -1,10 +1,11 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
-import type { AgentExtensionBinding, AgentExtensionFailure, AgentExtensionPort, AgentResourceDescriptor, AgentResourcesPort, AgentSessionMetadata } from "../agent-engine-contracts/index.js";
+import type { AgentExtensionBinding, AgentExtensionFailure, AgentExtensionPort, AgentResourceDescriptor, AgentResourcesPort, AgentSessionMetadata } from "../../../contracts/agent-engine/index.js";
 export interface PiResourceExtensionOptions {
     readonly session: AgentSession;
     readonly bindUi: () => Promise<void>;
     readonly unbindUi: () => Promise<void>;
 }
+/** Adapts Pi resource discovery and extension binding while containing extension failures at the port. */
 export declare class PiResourceExtensionIntegration implements AgentResourcesPort, AgentExtensionPort {
     #private;
     private readonly options;

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/resource-extension-integration.js

@@ -1,3 +1,4 @@
+/** Adapts Pi resource discovery and extension binding while containing extension failures at the port. */
 export class PiResourceExtensionIntegration {
     options;
     capabilities = { reload: true, extensionBinding: true, binding: true, renderers: true };