@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

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/transcript-projection.d.ts

@@ -0,0 +1,39 @@
+import { TranscriptImageAssets } from "./transcript-image-assets.js";
+import { type OwnedUiTranscriptBlock, type OwnedUiTranscriptImageReference } from "../../../contracts/owned-ui/index.js";
+export interface PiTranscriptProjectionPorts {
+    /** Pinned Pi's current retry attempt, which words an aborted declaration's failure text. */
+    retryAttempt(): number;
+    /** Called once per stored block change, in order, so the adapter can deliver it. */
+    blockChanged(block: OwnedUiTranscriptBlock): void;
+}
+/**
+ * The transcript as the owned UI sees it: Pi's session messages and tool events projected into
+ * ordered, revisioned blocks. The projection owns block identity (message and tool ids that stay
+ * stable across streaming, settlement, and rebuilds), revision numbering, image asset retention,
+ * and the reconciliation rules that keep late or duplicate events from disturbing a settled
+ * block. It never touches delivery: the adapter seals pending snapshots before a replacement and
+ * receives each changed block through the ports.
+ */
+export declare class PiTranscriptProjection {
+    #private;
+    readonly assets: TranscriptImageAssets;
+    constructor(ports: PiTranscriptProjectionPorts);
+    /** The current blocks in transcript order; not a copy. */
+    get blocks(): readonly OwnedUiTranscriptBlock[];
+    /** A frozen copy that stays identical until the next change, so views can share it. */
+    snapshot(): readonly OwnedUiTranscriptBlock[];
+    /** Replace every block; the caller has already sealed pending delivery snapshots. */
+    replace(blocks: OwnedUiTranscriptBlock[]): void;
+    block(id: string): OwnedUiTranscriptBlock | undefined;
+    /** Fold a finished run's messages into the transcript without replacing session-authoritative scope. */
+    mergeRun(messages: readonly unknown[], sessionMessages: readonly unknown[]): void;
+    /** Build the authoritative block list for `messages`, reusing unchanged blocks so their rendered rows survive. */
+    rebuild(messages: readonly unknown[], status: OwnedUiTranscriptBlock["status"]): OwnedUiTranscriptBlock[];
+    upsertMessage(message: unknown, status: OwnedUiTranscriptBlock["status"]): OwnedUiTranscriptBlock | undefined;
+    messageBlocks(message: unknown, status: OwnedUiTranscriptBlock["status"], fallbackIndex: number, occurrence?: number, currentBlock?: (id: string) => OwnedUiTranscriptBlock | undefined): OwnedUiTranscriptBlock[];
+    settleFailedDeclarations(message: unknown): void;
+    imageReferences(content: unknown, source: OwnedUiTranscriptImageReference["source"]): readonly OwnedUiTranscriptImageReference[];
+    upsertToolExecution(event: Record<string, unknown>): void;
+    upsert(block: OwnedUiTranscriptBlock): void;
+    nextRevision(id: string): number;
+}

package/dist/integrations/pi/engine/transcript-projection.js

@@ -0,0 +1,405 @@
+import { toolRenderingInput } from "./tool-rendering.js";
+import { TranscriptImageAssets } from "./transcript-image-assets.js";
+import { acceptsTranscriptUpdate, transcriptToolState } from "../../../contracts/owned-ui/index.js";
+import { assistantContent, contentImageCount, isRecord, jsonSummary, messageFallbackKey, retainCompletedArguments, sameBlockContent, sanitizeJson, stringValue, textFromContent } from "./message-values.js";
+/**
+ * The transcript as the owned UI sees it: Pi's session messages and tool events projected into
+ * ordered, revisioned blocks. The projection owns block identity (message and tool ids that stay
+ * stable across streaming, settlement, and rebuilds), revision numbering, image asset retention,
+ * and the reconciliation rules that keep late or duplicate events from disturbing a settled
+ * block. It never touches delivery: the adapter seals pending snapshots before a replacement and
+ * receives each changed block through the ports.
+ */
+export class PiTranscriptProjection {
+    assets = new TranscriptImageAssets();
+    #transcript = [];
+    #transcriptIndex = new Map();
+    #transcriptSnapshot;
+    #messageBlockIds = new WeakMap();
+    #messageFallbackIds = new Map();
+    #toolBlockIds = new Map();
+    #nextBlockSequence = 0;
+    #ports;
+    constructor(ports) {
+        this.#ports = ports;
+    }
+    /** The current blocks in transcript order; not a copy. */
+    get blocks() {
+        return this.#transcript;
+    }
+    /** A frozen copy that stays identical until the next change, so views can share it. */
+    snapshot() {
+        return this.#transcriptSnapshot ??= Object.freeze([...this.#transcript]);
+    }
+    // Performance: replacing the transcript rebuilds its index so block lookup stays constant-time.
+    /** Replace every block; the caller has already sealed pending delivery snapshots. */
+    replace(blocks) {
+        for (const block of blocks)
+            this.assets.retain(block);
+        for (const block of this.#transcript)
+            this.assets.release(block);
+        this.#transcript = blocks;
+        this.#transcriptIndex.clear();
+        for (const [index, block] of blocks.entries())
+            this.#transcriptIndex.set(block.id, index);
+        this.assets.discardUnowned();
+        this.#transcriptSnapshot = undefined;
+    }
+    block(id) {
+        const index = this.#transcriptIndex.get(id);
+        return index === undefined ? undefined : this.#transcript[index];
+    }
+    // Invariant: run-local completion may restate messages, but never owns transcript membership.
+    /** Fold a finished run's messages into the transcript without replacing session-authoritative scope. */
+    mergeRun(messages, sessionMessages) {
+        const positions = new Map();
+        const sessionOccurrences = new Map();
+        for (const [index, message] of sessionMessages.entries()) {
+            const key = messageFallbackKey(message, index);
+            const occurrence = sessionOccurrences.get(key) ?? 0;
+            sessionOccurrences.set(key, occurrence + 1);
+            positions.set(message, { index, occurrence });
+        }
+        const runOccurrences = new Map();
+        for (const [index, message] of messages.entries()) {
+            const key = messageFallbackKey(message, index);
+            const occurrence = runOccurrences.get(key) ?? 0;
+            runOccurrences.set(key, occurrence + 1);
+            const position = positions.get(message) ?? { index, occurrence };
+            for (const block of this.messageBlocks(message, "finalized", position.index, position.occurrence)) {
+                this.upsert(block);
+            }
+            this.settleFailedDeclarations(message);
+        }
+    }
+    // Invariant: full replacement is reserved for session-authoritative scope (bind/settlement).
+    /** Build the authoritative block list for `messages`, reusing unchanged blocks so their rendered rows survive. */
+    rebuild(messages, status) {
+        const blocks = [];
+        const blockIndexes = new Map();
+        const occurrences = new Map();
+        for (const [index, message] of messages.entries()) {
+            const key = messageFallbackKey(message, index);
+            const occurrence = occurrences.get(key) ?? 0;
+            occurrences.set(key, occurrence + 1);
+            for (const block of this.messageBlocks(message, status, index, occurrence, id => blocks[blockIndexes.get(id) ?? -1] ?? this.block(id))) {
+                const existingIndex = blockIndexes.get(block.id);
+                if (existingIndex === undefined) {
+                    blockIndexes.set(block.id, blocks.length);
+                    blocks.push(block);
+                    continue;
+                }
+                const existing = blocks[existingIndex];
+                if (existing !== undefined) {
+                    blocks[existingIndex] = {
+                        ...block,
+                        payload: {
+                            ...(isRecord(existing.payload) ? existing.payload : {}),
+                            ...(isRecord(block.payload) ? block.payload : {}),
+                        },
+                    };
+                }
+            }
+        }
+        // Performance: an authoritative rebuild restates most of what is already there. Reusing the block
+        // that already says it keeps its revision, and with it the rows the shell rendered for
+        // it — otherwise every turn that ends re-renders the whole session.
+        return blocks.map(block => {
+            const existing = this.block(block.id);
+            const next = existing === undefined ? block : retainCompletedArguments(existing, block);
+            return existing !== undefined && sameBlockContent(existing, next) ? existing : next;
+        });
+    }
+    upsertMessage(message, status) {
+        const blocks = this.messageBlocks(message, status, this.#transcript.length);
+        const first = blocks[0];
+        for (const block of blocks)
+            this.upsert(block);
+        return first;
+    }
+    messageBlocks(message, status, fallbackIndex, occurrence, currentBlock = id => this.block(id)) {
+        if (!isRecord(message) || typeof message.role !== "string")
+            return [];
+        const baseId = this.#messageBlockId(message, fallbackIndex, status, occurrence);
+        if (message.role === "user") {
+            return [{
+                    id: baseId,
+                    kind: "user",
+                    status,
+                    revision: this.nextRevision(baseId),
+                    title: "User",
+                    text: textFromContent(message.content),
+                    imageReferences: this.imageReferences(message.content, "user"),
+                    payload: {
+                        role: "user",
+                        imageCount: contentImageCount(message.content),
+                        timestamp: typeof message.timestamp === "number" && Number.isFinite(message.timestamp) ? message.timestamp : null,
+                    },
+                }];
+        }
+        if (message.role === "bashExecution") {
+            return [{
+                    id: baseId,
+                    kind: "bash",
+                    status,
+                    revision: this.nextRevision(baseId),
+                    title: stringValue(message.command) ?? "Bash",
+                    text: stringValue(message.output) ?? "",
+                    payload: {
+                        role: "bashExecution",
+                        command: stringValue(message.command) ?? "",
+                        exitCode: typeof message.exitCode === "number" ? message.exitCode : null,
+                        cancelled: message.cancelled === true,
+                        truncated: message.truncated === true,
+                        fullOutputPath: stringValue(message.fullOutputPath) ?? null,
+                        excludeFromContext: message.excludeFromContext === true,
+                    },
+                }];
+        }
+        if (message.role === "custom") {
+            if (message.display === false)
+                return [];
+            return [{
+                    id: baseId,
+                    kind: "custom",
+                    status,
+                    revision: this.nextRevision(baseId),
+                    title: stringValue(message.customType) ?? "Custom",
+                    text: textFromContent(message.content),
+                    payload: {
+                        role: "custom",
+                        customType: stringValue(message.customType) ?? "custom",
+                        display: true,
+                        details: message.details,
+                        timestamp: typeof message.timestamp === "number" ? message.timestamp : 0,
+                    },
+                }];
+        }
+        if (message.role === "compactionSummary" || message.role === "branchSummary") {
+            return [{
+                    id: baseId,
+                    kind: "compaction",
+                    status,
+                    revision: this.nextRevision(baseId),
+                    title: message.role === "branchSummary" ? "Branch summary" : "Compaction summary",
+                    text: stringValue(message.summary) ?? "",
+                    payload: {
+                        role: message.role,
+                        tokensBefore: typeof message.tokensBefore === "number" ? message.tokensBefore : 0,
+                        fromId: stringValue(message.fromId) ?? null,
+                        timestamp: typeof message.timestamp === "number" ? message.timestamp : 0,
+                    },
+                }];
+        }
+        if (message.role === "toolResult") {
+            const toolCallId = stringValue(message.toolCallId);
+            const blockId = toolCallId === undefined
+                ? baseId
+                : this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
+            if (toolCallId !== undefined)
+                this.#toolBlockIds.set(toolCallId, blockId);
+            const existing = currentBlock(blockId);
+            const existingPayload = isRecord(existing?.payload) ? existing.payload : undefined;
+            const payload = {
+                role: "toolResult", toolCallId: toolCallId ?? null,
+                toolName: stringValue(message.toolName) ?? stringValue(existingPayload?.toolName) ?? "unknown",
+                argsComplete: true, partialResult: status === "live", isError: message.isError === true,
+            };
+            const rendering = toolRenderingInput({ args: undefined, previousArgs: existing?.toolRendering,
+                result: message, payload, image: part => this.imageReferences([part], "tool-result")[0] });
+            return [{
+                    id: blockId,
+                    kind: "tool-result",
+                    status,
+                    toolState: { argsComplete: true, execution: status === "live" ? "running" : message.isError === true ? "failed" : "succeeded" },
+                    revision: this.nextRevision(blockId),
+                    title: stringValue(message.toolName) ?? existing?.title ?? "Tool result",
+                    ...rendering,
+                    payload,
+                }];
+        }
+        if (message.role !== "assistant" || !Array.isArray(message.content))
+            return [];
+        const blocks = [{
+                id: baseId,
+                kind: "assistant",
+                status,
+                revision: this.nextRevision(baseId),
+                title: "Assistant",
+                text: textFromContent(message.content),
+                payload: {
+                    role: "assistant",
+                    content: assistantContent(message.content),
+                    provider: stringValue(message.provider) ?? null,
+                    model: stringValue(message.model) ?? null,
+                    api: stringValue(message.api) ?? null,
+                    usage: sanitizeJson(message.usage),
+                    stopReason: stringValue(message.stopReason) ?? null,
+                    errorMessage: stringValue(message.errorMessage) ?? null,
+                    timestamp: typeof message.timestamp === "number" ? message.timestamp : 0,
+                },
+            }];
+        for (const item of message.content) {
+            if (!isRecord(item) || item.type !== "toolCall")
+                continue;
+            const toolCallId = stringValue(item.id) ?? `${baseId}:${blocks.length}`;
+            const blockId = this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
+            this.#toolBlockIds.set(toolCallId, blockId);
+            const failure = status === "finalized" ? this.#declarationFailure(message) : undefined;
+            const payload = { toolCallId, toolName: stringValue(item.name) ?? "unknown",
+                argsComplete: failure === undefined && status === "finalized",
+                ...(failure === undefined ? {} : { isError: true }) };
+            const rendering = toolRenderingInput({ args: item.arguments, payload,
+                ...(failure === undefined ? {} : { result: { content: [{ type: "text", text: failure.text }] } }),
+                image: () => undefined });
+            blocks.push({
+                id: blockId,
+                kind: failure === undefined ? "tool-call" : "tool-result",
+                status: failure === undefined ? "live" : "finalized",
+                toolState: {
+                    argsComplete: failure === undefined && status === "finalized",
+                    execution: failure?.execution ?? "pending",
+                },
+                revision: this.nextRevision(blockId),
+                title: stringValue(item.name) ?? "Tool",
+                ...rendering,
+                text: failure?.text ?? jsonSummary(item.arguments).summary,
+                payload,
+            });
+        }
+        return blocks;
+    }
+    #declarationFailure(message) {
+        // Provenance: pinned interactive-mode message_end and history reconstruction settle pending tools.
+        if (message.role !== "assistant")
+            return undefined;
+        if (message.stopReason === "aborted") {
+            const attempts = this.#ports.retryAttempt();
+            return { execution: "aborted", text: attempts > 0
+                    ? `Aborted after ${attempts} retry attempt${attempts > 1 ? "s" : ""}` : "Operation aborted" };
+        }
+        return message.stopReason === "error"
+            ? { execution: "failed", text: stringValue(message.errorMessage) || "Error" } : undefined;
+    }
+    settleFailedDeclarations(message) {
+        if (!isRecord(message))
+            return;
+        const failure = this.#declarationFailure(message);
+        if (failure === undefined)
+            return;
+        for (const block of this.#transcript) {
+            const state = transcriptToolState(block);
+            if (state === undefined || state.execution !== "pending" && state.execution !== "running")
+                continue;
+            const payload = { ...(isRecord(block.payload) ? block.payload : {}), partialResult: false, isError: true };
+            this.upsert({
+                ...block, kind: "tool-result", status: "finalized", revision: block.revision + 1,
+                ...toolRenderingInput({ args: undefined, previousArgs: block.toolRendering, payload,
+                    result: { content: [{ type: "text", text: failure.text }] }, image: () => undefined }),
+                toolState: { ...state, execution: failure.execution }, payload,
+            });
+        }
+    }
+    imageReferences(content, source) {
+        if (!Array.isArray(content))
+            return [];
+        const references = [];
+        for (const item of content) {
+            if (references.length >= 16)
+                break;
+            const reference = this.assets.reference(item, source);
+            if (reference !== undefined)
+                references.push(reference);
+        }
+        return references;
+    }
+    upsertToolExecution(event) {
+        const toolCallId = stringValue(event.toolCallId);
+        if (!toolCallId)
+            return;
+        const blockId = this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
+        this.#toolBlockIds.set(toolCallId, blockId);
+        const ended = event.type === "tool_execution_end";
+        const existing = this.block(blockId);
+        const state = existing === undefined ? undefined : transcriptToolState(existing);
+        // Invariant: duplicate starts cannot blank accumulated output; late events cannot reopen a settled invocation.
+        if (state !== undefined && (state.execution !== "pending" && state.execution !== "running"
+            || event.type === "tool_execution_start" && state.execution === "running"))
+            return;
+        const source = ended ? event.result : event.partialResult;
+        const payload = { toolCallId, toolName: stringValue(event.toolName) ?? "unknown",
+            partialResult: event.type === "tool_execution_update", argsComplete: true, isError: event.isError === true };
+        const rendering = toolRenderingInput({ args: event.args, previousArgs: existing?.toolRendering, result: source,
+            payload, image: part => this.imageReferences([part], "tool-result")[0] });
+        this.upsert({
+            id: blockId,
+            kind: ended ? "tool-result" : "tool-call",
+            status: ended ? "finalized" : "live",
+            toolState: { argsComplete: true, execution: ended ? event.isError === true ? "failed" : "succeeded" : "running" },
+            revision: this.nextRevision(blockId),
+            title: stringValue(event.toolName) ?? "Tool",
+            ...rendering,
+            payload,
+        });
+    }
+    upsert(block) {
+        const index = this.#transcriptIndex.get(block.id);
+        if (index !== undefined) {
+            const existing = this.#transcript[index];
+            // Invariant: argument completion is not execution finality; stale phases still stay rejected.
+            if (existing !== undefined && !acceptsTranscriptUpdate(existing, block))
+                return;
+            if (existing !== undefined)
+                block = retainCompletedArguments(existing, block);
+            // Performance: nothing is emitted for a block that repeats itself, and keeping the
+            // revision keeps the rows it already rendered.
+            if (existing !== undefined && sameBlockContent(existing, block))
+                return;
+            this.assets.retain(block);
+            if (existing !== undefined)
+                this.assets.release(existing);
+            this.#transcript[index] = block;
+        }
+        else {
+            this.assets.retain(block);
+            this.#transcriptIndex.set(block.id, this.#transcript.length);
+            this.#transcript.push(block);
+        }
+        this.#transcriptSnapshot = undefined;
+        this.#ports.blockChanged(block);
+    }
+    #messageBlockId(message, fallbackIndex, status, occurrence) {
+        const existing = this.#messageBlockIds.get(message);
+        if (existing)
+            return existing;
+        const fallback = messageFallbackKey(message, fallbackIndex);
+        const cached = this.#messageFallbackIds.get(fallback) ?? [];
+        let id;
+        if (occurrence !== undefined) {
+            id = cached[occurrence];
+            if (id === undefined) {
+                id = `${fallback}-${occurrence}`;
+                cached[occurrence] = id;
+            }
+        }
+        else {
+            id = [...cached].reverse().find(candidate => this.block(candidate)?.status === "live");
+            if (id === undefined && status === "finalized")
+                id = cached.at(-1);
+            if (id === undefined) {
+                id = `${fallback}-${cached.length}`;
+                cached.push(id);
+            }
+        }
+        this.#messageFallbackIds.set(fallback, cached);
+        this.#messageBlockIds.set(message, id);
+        return id;
+    }
+    nextRevision(id) {
+        const existing = this.block(id);
+        if (existing)
+            return existing.revision + 1;
+        this.#nextBlockSequence += 1;
+        return this.#nextBlockSequence;
+    }
+}

package/dist/integrations/pi/engine/usage-view.d.ts

@@ -0,0 +1,4 @@
+import type { AgentSession, AgentSessionRuntime } from "../startup-public.js";
+import type { OwnedUiModelInfo, OwnedUiUsageView } from "../../../contracts/owned-ui/index.js";
+/** Token, cost, cache, and context usage summed from the session's entries for the status footer. */
+export declare function readUsageView(session: AgentSession | undefined, runtime: AgentSessionRuntime | undefined, activeModel: OwnedUiModelInfo | null): OwnedUiUsageView;

package/dist/integrations/pi/engine/usage-view.js

@@ -0,0 +1,56 @@
+import { finiteNumber, isRecord } from "./message-values.js";
+/** Token, cost, cache, and context usage summed from the session's entries for the status footer. */
+export function readUsageView(session, runtime, activeModel) {
+    let input = 0;
+    let output = 0;
+    let cacheRead = 0;
+    let cacheWrite = 0;
+    let cost = 0;
+    let latestCacheHitRate = null;
+    let latestPrompt = null;
+    const entries = session?.sessionManager?.getEntries?.()
+        ?? (session?.messages ?? []).map(message => ({ type: "message", message }));
+    for (const entry of entries) {
+        if (!isRecord(entry))
+            continue;
+        const message = entry.type === "message" && isRecord(entry.message) ? entry.message : undefined;
+        const usage = message !== undefined && isRecord(message.usage)
+            ? message.usage
+            : (entry.type === "branch_summary" || entry.type === "compaction") && isRecord(entry.usage) ? entry.usage : undefined;
+        if (usage === undefined)
+            continue;
+        input += finiteNumber(usage.input);
+        output += finiteNumber(usage.output);
+        cacheRead += finiteNumber(usage.cacheRead);
+        cacheWrite += finiteNumber(usage.cacheWrite);
+        cost += isRecord(usage.cost) ? finiteNumber(usage.cost.total) : 0;
+        if (message?.role === "assistant") {
+            latestPrompt = {
+                input: finiteNumber(usage.input),
+                cacheRead: finiteNumber(usage.cacheRead),
+                cacheWrite: finiteNumber(usage.cacheWrite),
+            };
+            const promptTokens = latestPrompt.input + latestPrompt.cacheRead + latestPrompt.cacheWrite;
+            latestCacheHitRate = promptTokens > 0 ? (latestPrompt.cacheRead / promptTokens) * 100 : null;
+        }
+    }
+    const context = session?.getContextUsage?.();
+    const providerId = activeModel?.providerId;
+    const usingSubscription = providerId === "kimi-coding"
+        || (providerId !== undefined && runtime?.services.modelRuntime.isUsingSubscription?.(providerId) === true);
+    return {
+        input,
+        output,
+        cacheRead,
+        cacheWrite,
+        cost,
+        latestCacheHitRate,
+        latestPrompt,
+        contextAvailable: context !== undefined,
+        contextTokens: context?.tokens ?? null,
+        contextWindow: context?.contextWindow ?? 0,
+        contextPercent: context?.percent ?? null,
+        usingSubscription,
+        autoCompactEnabled: runtime?.services.settingsManager?.getCompactionEnabled?.() ?? true,
+    };
+}

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

@@ -0,0 +1,21 @@
+import { type InlineExtension } from "../startup-public.js";
+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 {};

package/dist/integrations/pi/engine/windows-filesystem-hygiene.js

@@ -0,0 +1,55 @@
+import { isBashToolResult, isEditToolResult, isWriteToolResult, } from "../startup-public.js";
+import { lstat, unlink } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+const DEFAULT_FILE_SYSTEM = { lstat, unlink };
+const DEFAULT_PATHS = { dirname, join, resolve };
+const SIMPLE_CD = /(?:^|[;&|\n])\s*cd\s+(?:"([^"\r\n]+)"|'([^'\r\n]+)'|([^\s;&|]+))/;
+export function createWindowsNulCleanupExtension(options = {}) {
+    if ((options.platform ?? process.platform) !== "win32")
+        return null;
+    const fileSystem = options.fileSystem ?? DEFAULT_FILE_SYSTEM;
+    const paths = options.paths ?? DEFAULT_PATHS;
+    return {
+        name: "windows-nul-file-cleanup",
+        factory: pi => registerNulCleanup(pi, fileSystem, paths),
+    };
+}
+function registerNulCleanup(pi, fileSystem, paths) {
+    const cleanDirectory = async (directory) => {
+        const candidate = paths.join(directory, "nul");
+        try {
+            const metadata = await fileSystem.lstat(candidate);
+            if (metadata.isFile() && !metadata.isSymbolicLink())
+                await fileSystem.unlink(candidate);
+        }
+        catch {
+            return;
+        }
+    };
+    pi.on("session_start", async (_event, ctx) => {
+        await cleanDirectory(ctx.cwd);
+    });
+    pi.on("tool_result", async (event, ctx) => {
+        const directories = new Set([ctx.cwd]);
+        if (isBashToolResult(event)) {
+            const command = stringInput(event.input, "command");
+            const target = command === null ? null : simpleCdTarget(command);
+            if (target !== null)
+                directories.add(paths.resolve(ctx.cwd, target));
+        }
+        if (isWriteToolResult(event) || isEditToolResult(event)) {
+            const target = stringInput(event.input, "path");
+            if (target !== null)
+                directories.add(paths.dirname(paths.resolve(ctx.cwd, target)));
+        }
+        await Promise.all(Array.from(directories, cleanDirectory));
+    });
+}
+function simpleCdTarget(command) {
+    const match = SIMPLE_CD.exec(command);
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+function stringInput(input, key) {
+    const value = input[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}