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

package/dist/integrations/pi/engine/settings-integration.d.ts

@@ -0,0 +1,43 @@
+import type { SettingsManager } from "@earendil-works/pi-coding-agent";
+import type { AgentJsonValue, AgentSettingChangeOutcome, AgentSettingDescriptor, AgentSettingOwner, AgentSettingsPort } from "../../../contracts/agent-engine/index.js";
+import { type PiSettingOwnerHandlers } from "./settings-effects.js";
+/** Values only the running engine knows. */
+export interface PiSettingsProviders {
+    readonly themes?: () => readonly string[];
+    readonly thinkingLevels?: () => readonly string[];
+    readonly productMode?: "bare" | "comparison";
+}
+export declare const AUTOMATIC_THEME = "automatic";
+interface AutomaticTheme {
+    readonly light: string;
+    readonly dark: string;
+}
+export declare function parseAutomaticTheme(stored: string): AutomaticTheme | null;
+export declare const EXPOSED_SETTING_KEYS: readonly string[];
+export declare function settingsInventoryDrift(presented: readonly string[], mapped: readonly string[]): {
+    readonly unmapped: readonly string[];
+    readonly stale: readonly string[];
+};
+/**
+ * Pi settings boundary backed by the transactional settings coordinator. The
+ * generated metadata owns presentation while the reviewed effect registry owns
+ * timing, availability, and active behavior.
+ */
+export declare class PiSettingsIntegration implements AgentSettingsPort {
+    #private;
+    private readonly settings;
+    readonly capabilities: {
+        write: boolean;
+        flush: boolean;
+    };
+    constructor(settings: SettingsManager, providers?: PiSettingsProviders);
+    bindOwner(owner: AgentSettingOwner, handlers: PiSettingOwnerHandlers): () => void;
+    unbindOwner(owner: AgentSettingOwner): void;
+    listSettings(): Promise<readonly AgentSettingDescriptor[]>;
+    readSetting(key: string): Promise<AgentJsonValue | undefined>;
+    writeSetting(key: string, value: AgentJsonValue): Promise<AgentSettingChangeOutcome>;
+    /** Shared route used by the pinned selector and owned settings surface. */
+    writeSettingNow(key: string, value: AgentJsonValue): Promise<AgentSettingChangeOutcome>;
+    flush(): Promise<void>;
+}
+export {};

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

@@ -1,18 +1,10 @@
 import piSettingsMetadata from "./pi-settings-metadata.json" with { type: "json" };
-/**
- * The engine stores a theme as one string with two forms: a theme's name, or a
- * `light/dark` pair meaning "follow the terminal". That grammar is the engine's,
- * so it is parsed and composed here and reaches the surfaces above as ordinary
- * settings — a theme entry that offers `automatic`, and, while automatic, one
- * entry per terminal appearance.
- */
+import { PI_SETTING_EFFECTS, PiSettingsCoordinator, settingsEffectInventoryDrift, } from "./settings-effects.js";
 export const AUTOMATIC_THEME = "automatic";
-/** The themes an automatic setting names for each terminal appearance. */
 const LIGHT_APPEARANCE_THEME = "light";
 const DARK_APPEARANCE_THEME = "dark";
 const THEME_KEY = "theme";
 const THINKING_KEY = "thinkingLevel";
-/** A stored theme is automatic when it names one theme per terminal appearance. */
 export function parseAutomaticTheme(stored) {
     const at = stored.indexOf("/");
     if (at < 0 || stored.indexOf("/", at + 1) >= 0)
@@ -21,24 +13,8 @@ export function parseAutomaticTheme(stored) {
     const dark = stored.slice(at + 1).trim();
     return light.length > 0 && dark.length > 0 ? { light, dark } : null;
 }
-/**
- * How the engine presents these settings — wording, order, and the flags a
- * dialog-backed setting offers — generated from its own source by
- * `npm run update:pi-settings-metadata` and verified by a governance test, so a
- * Pi upgrade cannot silently reword or reorder what A1 shows.
- */
 const PRESENTATION = piSettingsMetadata;
-/**
- * The settings A1 exposes: the ones the engine presents. Kept as the engine's
- * own inventory rather than a list beside it, so a setting it adds or renames
- * shows up as a named test failure instead of quietly going missing.
- */
 export const EXPOSED_SETTING_KEYS = PRESENTATION.presented;
-/**
- * What has drifted between the settings the engine presents and the settings A1
- * maps to its API: the ones A1 has not caught up with, and the ones it kept
- * after the engine dropped them. Either is a build failure with a name in it.
- */
 export function settingsInventoryDrift(presented, mapped) {
     const has = new Set(mapped);
     const engine = new Set(presented);
@@ -47,62 +23,87 @@ export function settingsInventoryDrift(presented, mapped) {
         stale: mapped.filter(key => !engine.has(key)),
     };
 }
-/** What the engine offers for a setting, as the strings it words them with. */
 function offered(key) {
     return PRESENTATION.settings[key]?.values ?? [];
 }
-/**
- * The same, read as the numbers a numeric setting stores. Only for a setting
- * whose list is its whole domain: where the engine offers a few numbers but
- * accepts any within a range, the range governs and the list is only shortcuts.
- */
 function offeredNumbers(key) {
     return offered(key).map(value => Number.parseInt(value, 10)).filter(value => Number.isSafeInteger(value));
 }
+/**
+ * Pi settings boundary backed by the transactional settings coordinator. The
+ * generated metadata owns presentation while the reviewed effect registry owns
+ * timing, availability, and active behavior.
+ */
 export class PiSettingsIntegration {
     settings;
     capabilities = { write: true, flush: true };
     #operations;
     #providers;
+    #coordinator;
     constructor(settings, providers = {}) {
         this.settings = settings;
         this.#providers = providers;
-        this.#operations = new Map(operations(settings).map(operation => [operation.descriptor.key, operation]));
-        if (this.#operations.size !== EXPOSED_SETTING_KEYS.length || EXPOSED_SETTING_KEYS.some(key => !this.#operations.has(key))) {
-            throw new Error("Pi settings integration does not cover every A1-exposed setting");
+        const mapped = operations(settings, providers);
+        this.#operations = new Map(mapped.map(operation => [operation.key, operation]));
+        const presentationDrift = settingsInventoryDrift(EXPOSED_SETTING_KEYS, mapped.map(operation => operation.key));
+        const effectDrift = settingsEffectInventoryDrift(EXPOSED_SETTING_KEYS);
+        if (presentationDrift.unmapped.length > 0 || presentationDrift.stale.length > 0
+            || effectDrift.unmapped.length > 0 || effectDrift.stale.length > 0 || effectDrift.duplicated.length > 0) {
+            throw new Error([
+                `unmapped operations: ${presentationDrift.unmapped.join(", ")}`,
+                `stale operations: ${presentationDrift.stale.join(", ")}`,
+                `unmapped effects: ${effectDrift.unmapped.join(", ")}`,
+                `stale effects: ${effectDrift.stale.join(", ")}`,
+                `duplicated effects: ${effectDrift.duplicated.join(", ")}`,
+            ].join("; "));
         }
+        this.#coordinator = new PiSettingsCoordinator(mapped, {
+            productMode: providers.productMode ?? "bare",
+            flush: () => settings.flush(),
+            drainErrors: () => settings.drainErrors(),
+        });
+    }
+    bindOwner(owner, handlers) {
+        return this.#coordinator.bindOwner(owner, handlers);
+    }
+    unbindOwner(owner) {
+        this.#coordinator.unbindOwner(owner);
     }
     async listSettings() {
         const rank = (key) => {
             const at = PRESENTATION.order.indexOf(key);
             return at < 0 ? PRESENTATION.order.length : at;
         };
-        const listed = [...this.#operations.values()]
+        return [...this.#operations.values()]
+            .filter(operation => this.#coordinator.available(operation.key))
             .map(operation => {
-            const key = operation.descriptor.key;
+            const key = operation.key;
             const wording = PRESENTATION.settings[key];
             const flags = PRESENTATION.dialogs[key];
             const bounds = PRESENTATION.bounds[key];
-            return {
+            const descriptor = {
                 ...operation.descriptor,
+                application: PI_SETTING_EFFECTS[key].application,
+                owner: PI_SETTING_EFFECTS[key].owner,
+                available: true,
+                limitationReason: null,
+                writable: true,
+                storedValue: this.#coordinator.storedValue(key),
+                effectiveValue: this.#coordinator.effectiveValue(key),
                 ...(bounds === undefined ? {} : bounds),
                 ...(wording === undefined ? {} : { label: wording.label, description: wording.description }),
                 ...(flags === undefined ? {} : { flags }),
             };
+            return this.#resolved(descriptor);
         })
-            .map(descriptor => this.#resolved(descriptor))
             .sort((left, right) => rank(left.key) - rank(right.key));
-        // Following the terminal is one choice on the theme itself, not two further
-        // settings: the pair behind it is the engine's grammar, not a reader's task.
-        return listed;
     }
-    /** Overlays the values a setting can only offer once something is running. */
     #resolved(descriptor) {
         if (descriptor.key === THEME_KEY) {
             const themes = this.#themes();
             if (themes.length === 0)
                 return descriptor;
-            return { ...descriptor, valueType: "enum", writable: true, resolvedWhenRead: true, choices: [AUTOMATIC_THEME, ...themes] };
+            return { ...descriptor, valueType: "enum", resolvedWhenRead: true, choices: [AUTOMATIC_THEME, ...themes] };
         }
         if (descriptor.key === THINKING_KEY) {
             const levels = this.#providers.thinkingLevels?.() ?? [];
@@ -115,53 +116,24 @@ export class PiSettingsIntegration {
     #themes() {
         return this.#providers.themes?.() ?? [];
     }
-    #storedTheme() {
-        const stored = this.#operations.get(THEME_KEY)?.read();
-        return typeof stored === "string" ? stored : "";
-    }
     async readSetting(key) {
-        if (key === THEME_KEY) {
-            const pair = parseAutomaticTheme(this.#storedTheme());
-            return pair === null ? this.#operations.get(key)?.read() : AUTOMATIC_THEME;
-        }
-        return this.#operations.get(key)?.read();
+        return isPiSettingKey(key) && this.#operations.has(key) ? this.#coordinator.storedValue(key) : undefined;
     }
-    async writeSetting(key, value) { this.writeSettingNow(key, value); }
-    writeSettingNow(key, value) {
-        if (typeof value === "string" && key === THEME_KEY) {
-            this.#writeTheme(value);
-            return;
-        }
-        const operation = this.#operations.get(key);
-        if (!operation)
+    async writeSetting(key, value) {
+        if (!isPiSettingKey(key) || !this.#operations.has(key))
             throw new Error(`setting is unavailable: ${key}`);
-        operation.write(value);
+        return await this.#coordinator.apply(key, value);
     }
-    /**
-     * Writes the theme in the engine's own grammar. Following the terminal is
-     * stored as the pair the engine reads for it, made of the themes named for
-     * each appearance when they are installed; where they are not, the theme
-     * already in use stands for both, so the setting still round-trips.
-     */
-    #writeTheme(value) {
-        const theme = this.#operations.get(THEME_KEY);
-        if (!theme)
-            throw new Error(`setting is unavailable: ${THEME_KEY}`);
-        if (value !== AUTOMATIC_THEME) {
-            theme.write(value);
-            return;
-        }
-        if (parseAutomaticTheme(this.#storedTheme()) !== null)
-            return;
-        const installed = this.#themes();
-        const current = this.#storedTheme();
-        const light = installed.includes(LIGHT_APPEARANCE_THEME) ? LIGHT_APPEARANCE_THEME : current;
-        const dark = installed.includes(DARK_APPEARANCE_THEME) ? DARK_APPEARANCE_THEME : current;
-        theme.write(`${light}/${dark}`);
+    /** Shared route used by the pinned selector and owned settings surface. */
+    async writeSettingNow(key, value) {
+        return await this.writeSetting(key, value);
+    }
+    async flush() {
+        await this.#coordinator.flush();
     }
-    async flush() { await this.settings.flush(); }
 }
-function operations(settings) {
+function operations(settings, providers) {
+    const themes = () => providers.themes?.() ?? [];
     return [
         bool("autoCompact", () => settings.getCompactionEnabled(), value => settings.setCompactionEnabled(value)),
         bool("showImages", () => settings.getShowImages(), value => settings.setShowImages(value)),
@@ -173,12 +145,8 @@ function operations(settings) {
         choice("followUpMode", offered("followUpMode"), () => settings.getFollowUpMode(), value => settings.setFollowUpMode(value)),
         choice("transport", offered("transport"), () => settings.getTransport(), value => settings.setTransport(value)),
         numberSetting("httpIdleTimeoutMs", () => settings.getHttpIdleTimeoutMs(), value => settings.setHttpIdleTimeoutMs(value), 0),
-        // The engine reads these from the running session rather than declaring them,
-        // so they arrive through the runtime provider rather than from its source.
         choice("thinkingLevel", ["off", "minimal", "low", "medium", "high", "xhigh"], () => settings.getDefaultThinkingLevel() ?? "medium", value => settings.setDefaultThinkingLevel(value)),
-        // The raw setting, not the resolved theme: the engine hides the automatic
-        // pair behind getTheme, and the pair is the thing A1 presents parts of.
-        stringSetting("theme", () => settings.getThemeSetting() ?? "default", value => settings.setTheme(value)),
+        themeSetting(settings, themes),
         bool("hideThinkingBlock", () => settings.getHideThinkingBlock(), value => settings.setHideThinkingBlock(value)),
         choice("mermaidRenderingMode", offered("mermaidRenderingMode"), () => settings.getMermaidRenderingMode(), value => settings.setMermaidRenderingMode(value)),
         bool("showCacheMissNotices", () => settings.getShowCacheMissNotices(), value => settings.setShowCacheMissNotices(value)),
@@ -201,33 +169,59 @@ function operations(settings) {
     ];
 }
 function bool(key, read, write) {
-    return { descriptor: { key, valueType: "boolean", writable: true }, read, write(value) { if (typeof value !== "boolean")
-            invalid(key); write(value); } };
+    return operation(key, "boolean", read, value => { if (typeof value !== "boolean")
+        invalid(key); }, value => write(value));
 }
 function numberSetting(key, read, write, minimum) {
     const declared = PRESENTATION.bounds[key];
     const low = declared?.minimum ?? minimum;
     const high = declared?.maximum;
+    return operation(key, "number", read, value => {
+        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < low || (high !== undefined && value > high))
+            invalid(key);
+    }, value => write(value));
+}
+function jsonObject(key, read, write) {
+    const boundedRead = () => Object.fromEntries(Object.entries(read()).filter((entry) => typeof entry[1] === "boolean"));
+    return operation(key, "json", boundedRead, value => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            invalid(key);
+    }, write);
+}
+function choice(key, choices, read, write) {
     return {
-        descriptor: { key, valueType: "number", writable: true },
-        read,
-        write(value) {
-            if (typeof value !== "number" || !Number.isSafeInteger(value) || value < low || (high !== undefined && value > high))
-                invalid(key);
-            write(value);
-        },
+        ...operation(key, "enum", read, value => { if (!choices.includes(value))
+            invalid(key); }, write),
+        descriptor: { key, valueType: "enum", choices },
     };
 }
-function stringSetting(key, read, write) {
-    return { descriptor: { key, valueType: "string", writable: true }, read, write(value) { if (typeof value !== "string" || value.length === 0)
-            invalid(key); write(value); } };
+function themeSetting(settings, themes) {
+    const raw = () => settings.getThemeSetting() ?? "default";
+    const read = () => parseAutomaticTheme(raw()) === null ? raw() : AUTOMATIC_THEME;
+    return operation(THEME_KEY, "string", read, value => {
+        if (typeof value !== "string" || value.length === 0)
+            invalid(THEME_KEY);
+    }, value => {
+        const selected = value;
+        if (selected !== AUTOMATIC_THEME) {
+            settings.setTheme(selected);
+            return;
+        }
+        if (parseAutomaticTheme(raw()) !== null)
+            return;
+        const installed = themes();
+        const current = raw();
+        const light = installed.includes(LIGHT_APPEARANCE_THEME) ? LIGHT_APPEARANCE_THEME : current;
+        const dark = installed.includes(DARK_APPEARANCE_THEME) ? DARK_APPEARANCE_THEME : current;
+        settings.setTheme(`${light}/${dark}`);
+    });
 }
-function jsonObject(key, read, write) {
-    return { descriptor: { key, valueType: "json", writable: true }, read: () => Object.fromEntries(Object.entries(read()).filter((entry) => typeof entry[1] === "boolean")), write(value) { if (!value || typeof value !== "object" || Array.isArray(value))
-            invalid(key); write(value); } };
+function operation(key, valueType, read, validate, write) {
+    return { key, descriptor: { key, valueType }, read, validate, write };
 }
-function choice(key, choices, read, write) {
-    return { descriptor: { key, valueType: "enum", writable: true, choices }, read, write(value) { if (!choices.includes(value))
-            invalid(key); write(value); } };
+function isPiSettingKey(key) {
+    return Object.hasOwn(PI_SETTING_EFFECTS, key);
+}
+function invalid(key) {
+    throw new TypeError(`setting value is invalid: ${key}`);
 }
-function invalid(key) { throw new TypeError(`setting value is invalid: ${key}`); }

package/dist/integrations/pi/engine/tool-rendering.d.ts

@@ -0,0 +1,13 @@
+import type { OwnedUiToolRendering, OwnedUiTranscriptImageReference } from "../../../contracts/owned-ui/index.js";
+/** Text lives once on the block; content parts refer to UTF-16 slices or opaque image references. */
+export declare function toolRenderingInput(options: {
+    readonly args: unknown;
+    readonly previousArgs?: OwnedUiToolRendering | undefined;
+    readonly result?: unknown;
+    readonly payload: Record<string, unknown>;
+    readonly image: (value: unknown) => OwnedUiTranscriptImageReference | undefined;
+}): {
+    text: string;
+    toolRendering: OwnedUiToolRendering;
+    imageReferences: readonly OwnedUiTranscriptImageReference[];
+};

package/dist/integrations/pi/engine/tool-rendering.js

@@ -0,0 +1,145 @@
+const MAX_METADATA_BYTES = 64 * 1024;
+const MAX_TEXT_BYTES = 256 * 1024;
+/** Copy JSON metadata without diagnostic depth/array truncation or traversing result text/images. */
+function renderingJson(value) {
+    let remaining = MAX_METADATA_BYTES;
+    const encoded = JSON.stringify(value, function (key, item) {
+        if (key && !Array.isArray(this))
+            remaining -= jsonStringBytes(key) + 1;
+        if (typeof item === "string")
+            remaining -= jsonStringBytes(item);
+        else if (item === null || typeof item === "boolean" || typeof item === "number" && Number.isFinite(item)) {
+            remaining -= String(item).length;
+        }
+        else if (typeof item === "object")
+            remaining -= 2;
+        else if (item === undefined)
+            return item;
+        else
+            throw new TypeError("unsupported JSON metadata");
+        if (--remaining < 0)
+            throw new RangeError("metadata exceeds the supported payload limit");
+        return item;
+    });
+    if (encoded === undefined)
+        throw new TypeError("unsupported JSON metadata");
+    if (Buffer.byteLength(encoded) > MAX_METADATA_BYTES)
+        throw new RangeError("metadata exceeds the supported payload limit");
+    return JSON.parse(encoded);
+}
+function jsonStringBytes(value) {
+    // Performance: reject very large strings before allocating their escaped representation.
+    if (value.length > MAX_METADATA_BYTES)
+        throw new RangeError("metadata exceeds the supported payload limit");
+    return Buffer.byteLength(JSON.stringify(value));
+}
+/** Text lives once on the block; content parts refer to UTF-16 slices or opaque image references. */
+export function toolRenderingInput(options) {
+    const warnings = new Set();
+    let args = {};
+    try {
+        args = options.args === undefined && options.previousArgs !== undefined
+            ? options.previousArgs.arguments : renderingJson(options.args ?? {});
+        if (options.args === undefined && options.previousArgs?.unavailable?.includes("Tool arguments unavailable")) {
+            warnings.add("Tool arguments unavailable: unsupported or oversized rendering data.");
+        }
+    }
+    catch {
+        warnings.add("Tool arguments unavailable: unsupported or oversized rendering data.");
+    }
+    const imageReferences = [];
+    const content = [];
+    let contentBytes = 2;
+    let excessBoundaries = false;
+    const addPart = (part) => {
+        if (excessBoundaries)
+            return;
+        // Performance: these ASCII-only offsets/indexes are budgeted before retaining or encoding an oversized boundary array.
+        contentBytes += JSON.stringify(part).length + (content.length > 0 ? 1 : 0);
+        if (contentBytes > MAX_METADATA_BYTES)
+            excessBoundaries = true;
+        else
+            content.push(part);
+    };
+    const texts = [];
+    let length = 0;
+    let textBytes = 0;
+    const source = isRecord(options.result) ? options.result : undefined;
+    const rawContent = source === undefined ? options.result : source.content;
+    const parts = typeof rawContent === "string" ? [{ type: "text", text: rawContent }] : rawContent;
+    if (Array.isArray(parts)) {
+        for (const part of parts) {
+            if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+                const separatorBytes = texts.length > 0 ? 1 : 0;
+                // Performance: length rejects huge strings before the bounded UTF-8 count; never serialize accumulated text.
+                const partBytes = part.text.length + textBytes + separatorBytes > MAX_TEXT_BYTES
+                    ? MAX_TEXT_BYTES + 1 : Buffer.byteLength(part.text);
+                if (partBytes + textBytes + separatorBytes > MAX_TEXT_BYTES) {
+                    warnings.add("Tool text unavailable: result exceeds the supported 256 KiB text limit.");
+                    continue;
+                }
+                textBytes += partBytes + separatorBytes;
+                if (texts.length > 0)
+                    length++;
+                const start = length;
+                texts.push(part.text);
+                length += part.text.length;
+                addPart({ type: "text", start, end: length });
+            }
+            else if (isRecord(part) && part.type === "image") {
+                const reference = imageReferences.length < 16 ? options.image(part) : undefined;
+                if (reference === undefined)
+                    warnings.add("Image unavailable: unsupported data or attachment limit exceeded.");
+                else {
+                    addPart({ type: "image", imageIndex: imageReferences.length });
+                    imageReferences.push(reference);
+                }
+            }
+            else
+                warnings.add("Tool content unavailable: unsupported content part.");
+        }
+    }
+    else if (options.result !== undefined)
+        warnings.add("Tool content unavailable: malformed result.");
+    let details;
+    if (source?.details !== undefined) {
+        try {
+            details = renderingJson(source.details);
+        }
+        catch {
+            warnings.add("Tool details unavailable: unsupported or oversized rendering data.");
+        }
+    }
+    const text = texts.join("\n");
+    let toolRendering = {
+        arguments: args,
+        ...(options.result === undefined ? {} : { result: { content, ...(details === undefined ? {} : { details }) } }),
+    };
+    const warning = () => [...warnings].join(" ");
+    const fits = () => !excessBoundaries && Buffer.byteLength(JSON.stringify({ payload: options.payload, toolRendering: {
+            ...toolRendering, ...(warnings.size === 0 ? {} : { unavailable: warning() }),
+        } })) <= MAX_METADATA_BYTES;
+    if (!fits()) {
+        warnings.add("Tool details unavailable: rendering metadata exceeds the supported payload limit.");
+        if (toolRendering.result)
+            toolRendering = { ...toolRendering, result: { content } };
+    }
+    if (!fits()) {
+        warnings.add("Tool arguments unavailable: rendering metadata exceeds the supported payload limit.");
+        toolRendering = { ...toolRendering, arguments: {} };
+    }
+    if (!fits()) {
+        // Rationale: too many content boundaries exceed the metadata budget; retain text/images with an explicit fallback.
+        warnings.add("Tool content boundaries unavailable: rendering metadata exceeds the supported payload limit.");
+        toolRendering = { ...toolRendering, result: { content: [
+                    { type: "text", start: 0, end: text.length },
+                    ...imageReferences.map((_, imageIndex) => ({ type: "image", imageIndex })),
+                ] } };
+    }
+    if (warnings.size > 0)
+        toolRendering = { ...toolRendering, unavailable: warning() };
+    return { text, toolRendering, imageReferences };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/integrations/pi/engine/transcript-image-assets.d.ts

@@ -0,0 +1,11 @@
+import type { OwnedUiEvent, OwnedUiImageAttachment, OwnedUiTranscriptBlock, OwnedUiTranscriptImageReference } from "../../../contracts/owned-ui/index.js";
+export declare class TranscriptImageAssets {
+    #private;
+    resolve(id: string): OwnedUiImageAttachment | null;
+    clear(): void;
+    reference(value: unknown, source: OwnedUiTranscriptImageReference["source"]): OwnedUiTranscriptImageReference | undefined;
+    retain(block: OwnedUiTranscriptBlock): void;
+    release(block: OwnedUiTranscriptBlock): void;
+    retainEvent(event: OwnedUiEvent): () => void;
+    discardUnowned(): void;
+}

package/dist/integrations/pi/engine/transcript-image-assets.js

@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+// Security: current blocks and admitted delivery snapshots own assets independently; superseded state owns none.
+export class TranscriptImageAssets {
+    #assets = new Map();
+    #byData = new Map();
+    #unowned = new Set();
+    resolve(id) { return this.#assets.get(id)?.asset ?? null; }
+    clear() { this.#assets.clear(); this.#byData.clear(); this.#unowned.clear(); }
+    reference(value, source) {
+        if (typeof value !== "object" || value === null || !("type" in value) || value.type !== "image"
+            || !("data" in value) || typeof value.data !== "string" || value.data.length === 0
+            || !("mimeType" in value) || typeof value.mimeType !== "string" || !/^image\/[a-z0-9.+-]+$/i.test(value.mimeType))
+            return;
+        // Performance: reject oversized encoded data before allocating a decoded buffer or hashing it.
+        if (value.data.length > Math.ceil(MAX_IMAGE_BYTES / 3) * 4)
+            return;
+        // Performance: repeated accumulated results reuse the same retained bytes without decoding and hashing per chunk.
+        const cachedId = this.#byData.get(value.mimeType)?.get(value.data);
+        if (cachedId !== undefined)
+            return { assetId: cachedId, mimeType: value.mimeType, byteLength: this.#assets.get(cachedId).byteLength, source };
+        const byteLength = Buffer.from(value.data, "base64").byteLength;
+        if (byteLength < 1 || byteLength > MAX_IMAGE_BYTES)
+            return;
+        const assetId = `image-${createHash("sha256").update(value.mimeType).update("\0").update(value.data).digest("hex").slice(0, 24)}`;
+        if (!this.#assets.has(assetId)) {
+            this.#assets.set(assetId, { asset: { type: "image", data: value.data, mimeType: value.mimeType }, byteLength, owners: 0 });
+            let byData = this.#byData.get(value.mimeType);
+            if (byData === undefined)
+                this.#byData.set(value.mimeType, byData = new Map());
+            byData.set(value.data, assetId);
+            this.#unowned.add(assetId);
+        }
+        return { assetId, mimeType: value.mimeType, byteLength, source };
+    }
+    retain(block) {
+        for (const reference of block.imageReferences ?? []) {
+            const entry = this.#assets.get(reference.assetId);
+            if (entry === undefined)
+                continue;
+            entry.owners++;
+            this.#unowned.delete(reference.assetId);
+        }
+    }
+    release(block) {
+        for (const reference of block.imageReferences ?? []) {
+            const entry = this.#assets.get(reference.assetId);
+            if (entry !== undefined && --entry.owners === 0)
+                this.#delete(reference.assetId);
+        }
+    }
+    retainEvent(event) {
+        const blocks = event.type === "transcript-block" ? [event.block] : event.type === "session-view" ? event.view.transcript : [];
+        // Concurrency: capture entries, not ids; an obsolete generation's release cannot decrement a replacement asset.
+        const entries = blocks.flatMap(block => (block.imageReferences ?? []).map(ref => [ref.assetId, this.#assets.get(ref.assetId)]));
+        for (const [id, entry] of entries) {
+            if (entry === undefined)
+                continue;
+            entry.owners++;
+            this.#unowned.delete(id);
+        }
+        return () => {
+            for (const [id, entry] of entries) {
+                if (entry !== undefined && this.#assets.get(id) === entry && --entry.owners === 0)
+                    this.#delete(id);
+            }
+            entries.length = 0;
+        };
+    }
+    discardUnowned() {
+        for (const id of this.#unowned)
+            this.#delete(id);
+        this.#unowned.clear();
+    }
+    #delete(id) {
+        const entry = this.#assets.get(id);
+        if (entry === undefined)
+            return;
+        const byData = this.#byData.get(entry.asset.mimeType);
+        byData?.delete(entry.asset.data);
+        if (byData?.size === 0)
+            this.#byData.delete(entry.asset.mimeType);
+        this.#assets.delete(id);
+        this.#unowned.delete(id);
+    }
+}

package/dist/integrations/pi/engine/windows-filesystem-hygiene.d.ts

@@ -0,0 +1,21 @@
+import { type InlineExtension } from "@earendil-works/pi-coding-agent";
+interface FileMetadata {
+    isFile(): boolean;
+    isSymbolicLink(): boolean;
+}
+interface CleanupFileSystem {
+    lstat(path: string): Promise<FileMetadata>;
+    unlink(path: string): Promise<void>;
+}
+interface CleanupPaths {
+    dirname(path: string): string;
+    join(...paths: string[]): string;
+    resolve(...paths: string[]): string;
+}
+export interface WindowsNulCleanupOptions {
+    readonly platform?: NodeJS.Platform;
+    readonly fileSystem?: CleanupFileSystem;
+    readonly paths?: CleanupPaths;
+}
+export declare function createWindowsNulCleanupExtension(options?: WindowsNulCleanupOptions): InlineExtension | null;
+export {};