@timurproko/a1 0.1.8-dev.472 → 0.1.8-dev.508

package/dist/integrations/pi/engine/session-events.d.ts

@@ -0,0 +1,48 @@
+import { type OwnedUiModelInfo, type OwnedUiThinkingLevel, type OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+import type { PiEmittedEvent } from "./event-delivery.js";
+import type { PiTranscriptProjection } from "./transcript-projection.js";
+export interface PiSessionEventPorts {
+    sessionGeneration(): number;
+    /** The session-authoritative messages, read at settlement. */
+    sessionMessages(): readonly unknown[];
+    activeModel(): OwnedUiModelInfo | null;
+    /** Replace the projected transcript behind the delivery seal. */
+    replaceTranscript(blocks: OwnedUiTranscriptBlock[]): void;
+    emit(value: PiEmittedEvent): void;
+    emitView(): void;
+    /** The session became busy with the named work; the adapter publishes lifecycle and status. */
+    enterWork(message: string): void;
+    /** Every work state ended; the adapter publishes the ready lifecycle and a cleared status. */
+    leaveWork(): void;
+    /** Compaction progress for the status view, in whole percent. */
+    workProgress(percent: number): void;
+    /** The engine's queued steering and follow-up submissions changed. */
+    queueChanged(queuedSubmissions: readonly string[]): void;
+    thinkingLevelChanged(level: OwnedUiThinkingLevel): void;
+    /** Usage moved at a message or lifecycle boundary; the memoized usage view is stale. */
+    usageInvalidated(): void;
+    compactionStarted(): void;
+    compactionEnded(): void;
+    deliverQueuedAfterCompaction(): void;
+}
+/**
+ * Translates pinned Pi's session events into transcript projection updates, run and response
+ * sequencing, work-state transitions, and the semantic owned UI events (run started, message
+ * completed, run settled). It owns the run counters and the current work-state kind; the adapter
+ * owns the lifecycle, status, editor, and model state the ports write.
+ */
+export declare class PiSessionEvents {
+    #private;
+    constructor(projection: PiTranscriptProjection, ports: PiSessionEventPorts);
+    /** Increments at each agent start within the bound session. */
+    get runSequence(): number;
+    /** Increments at each completed assistant message within the bound session. */
+    get responseSequence(): number;
+    /** A new session was bound: no run is active and the counters restart. */
+    reset(): void;
+    /** The run was abandoned by overload recovery; the counters keep their values so stale suggestions stay stale. */
+    abandonRun(): void;
+    compactionProgress(percent: number): void;
+    /** Apply one pinned Pi session event; image assets no block references any more are released afterwards. */
+    handle(event: unknown): void;
+}

package/dist/integrations/pi/engine/session-events.js

@@ -0,0 +1,223 @@
+import { isRecord, readStringArray, readThinkingLevel, stringValue, textFromContent } from "./message-values.js";
+import { transcriptToolState } from "../../../contracts/owned-ui/index.js";
+/**
+ * Translates pinned Pi's session events into transcript projection updates, run and response
+ * sequencing, work-state transitions, and the semantic owned UI events (run started, message
+ * completed, run settled). It owns the run counters and the current work-state kind; the adapter
+ * owns the lifecycle, status, editor, and model state the ports write.
+ */
+export class PiSessionEvents {
+    #projection;
+    #ports;
+    #agentRunActive = false;
+    #agentRunSequence = 0;
+    #assistantResponseSequence = 0;
+    #statusKind = null;
+    constructor(projection, ports) {
+        this.#projection = projection;
+        this.#ports = ports;
+    }
+    /** Increments at each agent start within the bound session. */
+    get runSequence() {
+        return this.#agentRunSequence;
+    }
+    /** Increments at each completed assistant message within the bound session. */
+    get responseSequence() {
+        return this.#assistantResponseSequence;
+    }
+    /** A new session was bound: no run is active and the counters restart. */
+    reset() {
+        this.#agentRunActive = false;
+        this.#agentRunSequence = 0;
+        this.#assistantResponseSequence = 0;
+        this.#statusKind = null;
+    }
+    /** The run was abandoned by overload recovery; the counters keep their values so stale suggestions stay stale. */
+    abandonRun() {
+        this.#agentRunActive = false;
+        this.#statusKind = null;
+    }
+    // Invariant: the named work state is the only state a matching end may clear.
+    #enterWorkState(kind, message) {
+        this.#statusKind = kind;
+        this.#ports.enterWork(message);
+    }
+    // Invariant: ending retry or compaction cannot clear a different active work state.
+    #endWorkState(kind) {
+        if (this.#statusKind !== kind)
+            return;
+        if (this.#agentRunActive) {
+            this.#enterWorkState("working", "Working");
+            return;
+        }
+        this.#leaveWorkStates();
+    }
+    #leaveWorkStates() {
+        this.#statusKind = null;
+        this.#ports.leaveWork();
+    }
+    // Invariant: progress belongs to the compaction state only and is published when the integer changes.
+    compactionProgress(percent) {
+        if (this.#statusKind !== "compaction")
+            return;
+        this.#ports.workProgress(percent);
+    }
+    /** Apply one pinned Pi session event; image assets no block references any more are released afterwards. */
+    handle(event) {
+        try {
+            this.#applyPiEvent(event);
+        }
+        finally {
+            this.#projection.assets.discardUnowned();
+        }
+    }
+    #applyPiEvent(event) {
+        if (!isRecord(event) || typeof event.type !== "string")
+            return;
+        // Invariant: usage moves at message and lifecycle boundaries, not with stream chunks, so the
+        // two streaming event kinds keep the memo and everything else drops it.
+        if (event.type !== "message_update" && event.type !== "tool_execution_update")
+            this.#ports.usageInvalidated();
+        switch (event.type) {
+            case "agent_start":
+                this.#agentRunActive = true;
+                this.#agentRunSequence += 1;
+                this.#ports.emit({ type: "agent-run-started" });
+                this.#enterWorkState("working", "Working");
+                return;
+            case "message_start":
+                this.#projection.upsertMessage(event.message, "live");
+                return;
+            case "message_update": {
+                const delta = isRecord(event.assistantMessageEvent) && typeof event.assistantMessageEvent.delta === "string"
+                    ? event.assistantMessageEvent.delta
+                    : undefined;
+                // Invariant: the delta is folded in before the block is stored, so a chunk is one update to
+                // one block rather than a store without the delta followed by a store with it.
+                const blocks = this.#projection.messageBlocks(event.message, "live", this.#projection.blocks.length);
+                for (const [index, block] of blocks.entries()) {
+                    this.#projection.upsert(index === 0 && delta !== undefined && !block.text.endsWith(delta)
+                        ? { ...block, text: `${block.text}${delta}` }
+                        : block);
+                }
+                return;
+            }
+            case "message_end":
+                this.#projection.upsertMessage(event.message, "finalized");
+                this.#projection.settleFailedDeclarations(event.message);
+                // Compatibility: preserve the same semantic boundary v2 counted. Transcript block
+                // finalization is intentionally not a substitute: rebuilds, retries,
+                // thinking parts, and tool rows can all finalize independently.
+                if (isRecord(event.message) && event.message.role === "assistant") {
+                    this.#assistantResponseSequence += 1;
+                    const content = Array.isArray(event.message.content) ? event.message.content : [];
+                    const stopReason = stringValue(event.message.stopReason) ?? null;
+                    const toolContinuation = stopReason === "toolUse"
+                        || content.some(item => isRecord(item) && item.type === "toolCall");
+                    const successful = stringValue(event.message.errorMessage) === undefined
+                        && stopReason !== "error"
+                        && stopReason !== "aborted"
+                        && textFromContent(content).trim().length > 0;
+                    this.#ports.emit({
+                        type: "assistant-message-completed",
+                        sessionGeneration: this.#ports.sessionGeneration(),
+                        runSequence: this.#agentRunSequence,
+                        responseSequence: this.#assistantResponseSequence,
+                        model: this.#ports.activeModel(),
+                        assistantMessageCount: this.#projection.blocks.filter(block => block.kind === "assistant").length,
+                        successful,
+                        stopReason,
+                        toolContinuation,
+                    });
+                }
+                return;
+            case "turn_end":
+                this.#projection.upsertMessage(event.message, "finalized");
+                if (Array.isArray(event.toolResults)) {
+                    for (const result of event.toolResults)
+                        this.#projection.upsertMessage(result, "finalized");
+                }
+                return;
+            case "tool_execution_start":
+            case "tool_execution_end": {
+                this.#projection.upsertToolExecution(event);
+                return;
+            }
+            case "tool_execution_update":
+                this.#projection.upsertToolExecution(event);
+                return;
+            case "agent_settled":
+            case "agent_end": {
+                if (event.type === "agent_end" && event.willRetry === true)
+                    return;
+                // Protocol: agent_end is run-local; only settlement reads the complete session scope.
+                const finalMessages = event.type === "agent_settled"
+                    ? this.#ports.sessionMessages()
+                    : Array.isArray(event.messages) ? event.messages : [];
+                if (event.type === "agent_end")
+                    this.#projection.mergeRun(finalMessages, this.#ports.sessionMessages());
+                else if (finalMessages.length > 0)
+                    this.#ports.replaceTranscript(this.#projection.rebuild(finalMessages, "finalized"));
+                // Invariant: missing final messages must not erase accumulated content or invent tool outcomes.
+                if (finalMessages.length === 0)
+                    this.#ports.replaceTranscript(this.#projection.blocks.map(block => block.status === "live" && transcriptToolState(block) === undefined
+                        ? { ...block, status: "finalized", revision: block.revision + 1 } : block));
+                // Compatibility: ending a turn leaves the working state, as the recorded pinned baseline does, but
+                // it leaves only that state: a compaction or retry being shown outlives the turn
+                // that ended under it. Settlement ends the run, and with it every state — the
+                // engine ends a turn for each continuation it makes and settles once.
+                if (event.type === "agent_settled") {
+                    this.#agentRunActive = false;
+                    this.#leaveWorkStates();
+                }
+                else if (this.#statusKind === null || this.#statusKind === "working") {
+                    this.#leaveWorkStates();
+                }
+                this.#ports.emitView();
+                if (event.type === "agent_settled") {
+                    const assistants = finalMessages.filter(message => isRecord(message) && message.role === "assistant");
+                    const lastAssistant = assistants.at(-1);
+                    const successful = lastAssistant !== undefined
+                        && stringValue(lastAssistant.errorMessage) === undefined
+                        && stringValue(lastAssistant.stopReason) !== "error"
+                        && stringValue(lastAssistant.stopReason) !== "aborted";
+                    this.#ports.emit({
+                        type: "agent-run-settled",
+                        sessionGeneration: this.#ports.sessionGeneration(),
+                        runSequence: this.#agentRunSequence,
+                        responseSequence: this.#assistantResponseSequence,
+                        model: this.#ports.activeModel(),
+                        assistantMessageCount: assistants.length,
+                        successful,
+                    });
+                }
+                return;
+            }
+            case "queue_update": {
+                this.#ports.queueChanged([...readStringArray(event.steering), ...readStringArray(event.followUp)]);
+                return;
+            }
+            case "auto_retry_start":
+                this.#enterWorkState("retry", "Retrying");
+                return;
+            case "auto_retry_end":
+                this.#endWorkState("retry");
+                return;
+            case "compaction_start":
+                this.#enterWorkState("compaction", "Compacting");
+                this.#ports.compactionStarted();
+                return;
+            case "compaction_end":
+                this.#ports.compactionEnded();
+                this.#endWorkState("compaction");
+                if (event.reason === "manual")
+                    this.#ports.deliverQueuedAfterCompaction();
+                return;
+            case "thinking_level_changed":
+                this.#ports.thinkingLevelChanged(readThinkingLevel(event.level));
+                return;
+            default:
+                return;
+        }
+    }
+}

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

@@ -1,14 +1,12 @@
 import { AGENT_ENGINE_CONTRACT_VERSION, } from "../../../contracts/agent-engine/index.js";
 /** Routes neutral session commands to Pi while preserving Pi streaming and retry semantics. */
 export class PiSessionCommandIntegration {
-    session;
     #lastPrompt = null;
     // Rationale: Pi's queue restore returns text only, so the attachments of messages queued
     // during compaction are kept here until the queue is delivered or cleared.
     #queuedImages = [];
-    constructor(session) {
-        this.session = session;
-    }
+    session;
+    constructor(session) { this.session = session; }
     async execute(command) {
         switch (command.type) {
             case "prompt":

package/dist/integrations/pi/engine/session-runtime.d.ts

@@ -0,0 +1,84 @@
+import { PiSessionCommandIntegration } from "./session-integration.js";
+import { type AgentSession, type AgentSessionRuntime, type AgentSessionServices } from "../startup-public.js";
+import type { PiProjectTrustPreflightPrompt } from "./project-trust-preflight.js";
+import type { PiSessionForkPrompt, PiSessionSelection } from "./session-selection.js";
+import type { OwnedUiDiagnostics } from "../../../contracts/owned-ui/index.js";
+import type { PiSessionResumeMetadata, PiWorkflowHost } from "./workflows.js";
+export interface PiEngineRuntimeFactoryInput {
+    readonly cwd: string;
+    readonly agentDir: string;
+    readonly sessionId: string;
+    readonly sessionPath?: string;
+    readonly sessionSelection?: PiSessionSelection;
+    readonly sessionForkPrompt?: PiSessionForkPrompt;
+    readonly projectTrustPrompt?: PiProjectTrustPreflightPrompt;
+}
+export type PiEngineRuntimeFactory = (input: PiEngineRuntimeFactoryInput) => Promise<AgentSessionRuntime>;
+export type PiEnginePackageUpdateProbe = (settingsManager: AgentSessionServices["settingsManager"]) => Promise<readonly string[]>;
+export interface PiEngineRuntimeOptions {
+    readonly cwd: string;
+    readonly agentDir: string;
+    readonly sessionId: string;
+    readonly sessionPath: string | undefined;
+    readonly sessionSelection: PiSessionSelection | undefined;
+    readonly sessionForkPrompt: PiSessionForkPrompt | undefined;
+    readonly projectTrustPrompt: PiProjectTrustPreflightPrompt | undefined;
+    readonly createRuntime: PiEngineRuntimeFactory | undefined;
+    readonly checkPackageUpdates: PiEnginePackageUpdateProbe | undefined;
+    readonly host: PiWorkflowHost;
+}
+export interface PiEngineRuntimePorts {
+    disposed(): boolean;
+    /** The runtime exists and its cwd and git branch are known; nothing is bound yet. */
+    started(runtime: AgentSessionRuntime): void;
+    /** True while a runtime-initiated rebind must be ignored: delivery overload, stopped admission, or disposal. */
+    rebindBlocked(): boolean;
+    /** The current session is about to be replaced; admitted work that belongs to it is cancelled here. */
+    sessionReplacing(): void;
+    /** A session was bound and subscribed under a new generation; the adapter rebuilds the state it derives from one. */
+    sessionReplaced(session: AgentSession): void;
+    /** A runtime-initiated rebind completed; the adapter publishes the rebuilt view. */
+    rebound(): void;
+    /** A pinned Pi session event for the current generation. */
+    event(event: unknown): void;
+    compactionProgress(percent: number): void;
+    diagnostic(severity: OwnedUiDiagnostics["severity"], code: string, message: string, recoverable: boolean): void;
+    emitView(): void;
+}
+/**
+ * The pinned Pi runtime and the session bound to it: creation through the runtime factory, the
+ * session generation that stamps and invalidates events, the subscription that forwards session
+ * events, compaction progress observation, the queued-input integration, and disposal order. The
+ * adapter derives its view state from the session it is handed and never touches these directly.
+ */
+export declare class PiEngineRuntime {
+    #private;
+    constructor(options: PiEngineRuntimeOptions, ports: PiEngineRuntimePorts);
+    get runtime(): AgentSessionRuntime | undefined;
+    get session(): AgentSession | undefined;
+    /** Bumped on every bind and on overload recovery; events from an earlier generation are invalid. */
+    get generation(): number;
+    /** Actual session replacements, excluding delivery-only invalidation of callbacks. */
+    get bindingGeneration(): number;
+    get cwd(): string;
+    get gitBranch(): string | null;
+    get sessionCommands(): PiSessionCommandIntegration | undefined;
+    get started(): boolean;
+    /** Create the runtime, bind its first session, and announce the changelog; startup failures propagate. */
+    start(): Promise<AgentSessionRuntime>;
+    /** Probe extension packages for updates after startup and report them as an informational diagnostic. */
+    announcePackageUpdates(): Promise<void>;
+    currentSessionFile(): string | null;
+    currentSessionResumeMetadata(): PiSessionResumeMetadata | null;
+    /** Replace the bound session under a new generation and subscribe to its events. */
+    bindSession(session: AgentSession): void;
+    /** Stop forwarding the current session's events and open a new generation; overload recovery resumes or abandons it. */
+    suspend(): void;
+    /** Forward the current session's events again under the current generation. */
+    resume(): void;
+    compactionStarted(): void;
+    compactionEnded(): void;
+    deliverQueuedAfterCompaction(): void;
+    /** Unsubscribe, stop observing compaction, and dispose the runtime; the session reference is kept for final reads. */
+    dispose(): Promise<void>;
+}

package/dist/integrations/pi/engine/session-runtime.js

@@ -0,0 +1,249 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { promisify } from "node:util";
+import { PRODUCT_IDENTITY } from "../../../product-identity.js";
+import { observeCompactionProgress } from "./compaction-progress.js";
+import { createPiRuntimeIntegration } from "./runtime-integration.js";
+import { PiSessionCommandIntegration } from "./session-integration.js";
+import { DefaultPackageManager, VERSION } from "../startup-public.js";
+const execFileAsync = promisify(execFile);
+/**
+ * The pinned Pi runtime and the session bound to it: creation through the runtime factory, the
+ * session generation that stamps and invalidates events, the subscription that forwards session
+ * events, compaction progress observation, the queued-input integration, and disposal order. The
+ * adapter derives its view state from the session it is handed and never touches these directly.
+ */
+export class PiEngineRuntime {
+    #options;
+    #ports;
+    #runtimeFactory;
+    #checkPackageUpdates;
+    #cwd;
+    #runtime;
+    #session;
+    #unsubscribe;
+    #sessionGeneration = 0;
+    #sessionBindingGeneration = 0;
+    #sessionCommands;
+    #compactionProgress = null;
+    #gitBranch = null;
+    constructor(options, ports) {
+        this.#options = options;
+        this.#ports = ports;
+        this.#cwd = options.cwd;
+        this.#runtimeFactory = options.createRuntime ?? createDefaultPiRuntime;
+        this.#checkPackageUpdates = options.checkPackageUpdates
+            ?? (options.createRuntime
+                ? async () => []
+                : settingsManager => checkDefaultPiPackageUpdates(this.#cwd, options.agentDir, settingsManager));
+    }
+    get runtime() {
+        return this.#runtime;
+    }
+    get session() {
+        return this.#session;
+    }
+    /** Bumped on every bind and on overload recovery; events from an earlier generation are invalid. */
+    get generation() {
+        return this.#sessionGeneration;
+    }
+    /** Actual session replacements, excluding delivery-only invalidation of callbacks. */
+    get bindingGeneration() {
+        return this.#sessionBindingGeneration;
+    }
+    get cwd() {
+        return this.#runtime?.cwd ?? this.#cwd;
+    }
+    get gitBranch() {
+        return this.#gitBranch;
+    }
+    get sessionCommands() {
+        return this.#sessionCommands;
+    }
+    get started() {
+        return this.#runtime !== undefined;
+    }
+    /** Create the runtime, bind its first session, and announce the changelog; startup failures propagate. */
+    async start() {
+        const runtime = await this.#runtimeFactory({
+            cwd: this.#cwd,
+            agentDir: this.#options.agentDir,
+            sessionId: this.#options.sessionId,
+            ...(this.#options.sessionPath === undefined ? {} : { sessionPath: this.#options.sessionPath }),
+            ...(this.#options.sessionSelection === undefined ? {} : { sessionSelection: this.#options.sessionSelection }),
+            ...(this.#options.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: this.#options.sessionForkPrompt }),
+            ...(this.#options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: this.#options.projectTrustPrompt }),
+        });
+        this.#runtime = runtime;
+        this.#cwd = runtime.cwd ?? this.#cwd;
+        this.#gitBranch = await readGitBranch(this.#cwd);
+        this.#ports.started(runtime);
+        runtime.setRebindSession(async (session) => {
+            if (this.#ports.rebindBlocked())
+                return;
+            this.bindSession(session);
+            this.#ports.rebound();
+        });
+        for (const diagnostic of [...runtime.diagnostics, ...runtime.services.diagnostics]) {
+            this.#ports.diagnostic(diagnostic.type === "error" ? "error" : diagnostic.type === "warning" ? "warning" : "info", "engine-startup", diagnostic.message, diagnostic.type !== "error");
+        }
+        this.bindSession(runtime.session);
+        await this.#announceChangelog(runtime.services.settingsManager);
+        return runtime;
+    }
+    /** Probe extension packages for updates after startup and report them as an informational diagnostic. */
+    async announcePackageUpdates() {
+        const runtime = this.#runtime;
+        if (process.env.PI_OFFLINE || runtime === undefined)
+            return;
+        let updates;
+        try {
+            updates = await this.#checkPackageUpdates(runtime.services.settingsManager);
+        }
+        catch {
+            return;
+        }
+        if (this.#ports.disposed() || updates.length === 0)
+            return;
+        const packages = updates.map(name => `- ${name}`).join("\n");
+        this.#ports.diagnostic("info", "package-updates", `Package updates are available. Run ${PRODUCT_IDENTITY.commandName} pi update --extensions\nPackages:\n${packages}`, true);
+        this.#ports.emitView();
+    }
+    currentSessionFile() {
+        const value = this.#session?.sessionManager?.getSessionFile?.();
+        return typeof value === "string" && value.length > 0 ? value : null;
+    }
+    currentSessionResumeMetadata() {
+        const manager = this.#session?.sessionManager;
+        if (manager === undefined
+            || typeof manager.isPersisted !== "function"
+            || typeof manager.getSessionId !== "function"
+            || typeof manager.getSessionDir !== "function"
+            || typeof manager.usesDefaultSessionDir !== "function"
+            || manager.isPersisted() !== true
+            || !existsSync(this.currentSessionFile() ?? ""))
+            return null;
+        const sessionId = manager.getSessionId();
+        const sessionDir = manager.getSessionDir();
+        if (!sessionId || !sessionDir)
+            return null;
+        return { sessionId, sessionDir, usesDefaultSessionDir: manager.usesDefaultSessionDir() };
+    }
+    /** Replace the bound session under a new generation and subscribe to its events. */
+    bindSession(session) {
+        this.#unsubscribe?.();
+        this.#ports.sessionReplacing();
+        this.#sessionGeneration += 1;
+        this.#sessionBindingGeneration += 1;
+        this.#session = session;
+        this.#sessionCommands = new PiSessionCommandIntegration(session);
+        this.#compactionProgress?.dispose();
+        this.#compactionProgress = observeCompactionProgress(session, percent => {
+            if (this.#session === session && !this.#ports.disposed())
+                this.#ports.compactionProgress(percent);
+        });
+        // Invariant: the subscription is live before the adapter rebuilds its state so the extension
+        // rebind that finishes the rebuild cannot emit an event nobody is listening to.
+        this.#subscribe();
+        this.#ports.sessionReplaced(session);
+    }
+    /** Stop forwarding the current session's events and open a new generation; overload recovery resumes or abandons it. */
+    suspend() {
+        this.#unsubscribe?.();
+        this.#unsubscribe = undefined;
+        this.#compactionProgress?.dispose();
+        this.#compactionProgress = null;
+        ++this.#sessionGeneration;
+    }
+    /** Forward the current session's events again under the current generation. */
+    resume() {
+        if (this.#session === undefined)
+            return;
+        this.#subscribe();
+    }
+    compactionStarted() {
+        this.#compactionProgress?.begin();
+    }
+    compactionEnded() {
+        this.#compactionProgress?.end();
+    }
+    // Rationale: a manual compaction ends with an idle session, so the engine would never consume
+    // the messages queued during it; automatic compaction returns to a run or a pending prompt.
+    deliverQueuedAfterCompaction() {
+        const commands = this.#sessionCommands;
+        const generation = this.#sessionGeneration;
+        if (commands === undefined)
+            return;
+        const report = (error) => {
+            if (generation !== this.#sessionGeneration || this.#ports.disposed())
+                return;
+            this.#ports.diagnostic("error", "engine-command", `Queued input could not be sent after compaction: ${error instanceof Error ? error.message : String(error)}`, true);
+            this.#ports.emitView();
+        };
+        commands.deliverQueuedAfterCompaction(report).catch(report);
+    }
+    /** Unsubscribe, stop observing compaction, and dispose the runtime; the session reference is kept for final reads. */
+    async dispose() {
+        this.#unsubscribe?.();
+        this.#unsubscribe = undefined;
+        this.#compactionProgress?.dispose();
+        this.#compactionProgress = null;
+        await this.#runtime?.dispose();
+    }
+    #subscribe() {
+        const session = this.#session;
+        if (session === undefined)
+            return;
+        const generation = this.#sessionGeneration;
+        this.#unsubscribe = session.subscribe(event => {
+            if (generation === this.#sessionGeneration && !this.#ports.disposed())
+                this.#ports.event(event);
+        });
+    }
+    async #announceChangelog(settingsManager) {
+        if (!settingsManager || typeof settingsManager.getLastChangelogVersion !== "function"
+            || typeof settingsManager.setLastChangelogVersion !== "function")
+            return;
+        if ((this.#session?.messages.length ?? 0) > 0)
+            return;
+        const lastVersion = settingsManager.getLastChangelogVersion();
+        if (lastVersion === VERSION)
+            return;
+        if (!lastVersion) {
+            settingsManager.setLastChangelogVersion(VERSION);
+            await settingsManager.flush();
+            return;
+        }
+        const markdown = await this.#options.host.readChangelog(lastVersion).catch(() => "");
+        if (markdown.trim().length > 0) {
+            this.#ports.diagnostic("info", settingsManager.getCollapseChangelog() ? "changelog-collapsed" : "changelog-expanded", markdown, true);
+            settingsManager.setLastChangelogVersion(VERSION);
+            await settingsManager.flush();
+        }
+    }
+}
+async function createDefaultPiRuntime(input) {
+    return createPiRuntimeIntegration({
+        cwd: input.cwd,
+        agentDir: input.agentDir,
+        ...(input.sessionPath === undefined ? {} : { sessionPath: input.sessionPath }),
+        ...(input.sessionSelection === undefined ? {} : { sessionSelection: input.sessionSelection }),
+        ...(input.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: input.sessionForkPrompt }),
+        ...(input.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: input.projectTrustPrompt }),
+    });
+}
+async function checkDefaultPiPackageUpdates(cwd, agentDir, settingsManager) {
+    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
+    const updates = await packageManager.checkForAvailableUpdates();
+    return updates.map(update => update.displayName);
+}
+async function readGitBranch(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["branch", "--show-current"], { cwd, windowsHide: true });
+        const branch = stdout.trim();
+        return branch.length > 0 ? branch : null;
+    }
+    catch {
+        return null;
+    }
+}