@timurproko/a1 0.2.6-dev.736 → 0.2.7-dev.1221

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

@@ -1,8 +1,63 @@
+import { closeSync, mkdirSync, openSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, resolveModelScopeWithDiagnostics, SessionManager, SettingsManager, } from "../startup-public.js";
 import { resolvePiProjectTrustPreflight, } from "./project-trust-preflight.js";
-import { openSelectedPiSession, resolveSessionArgumentPath } from "./session-selection.js";
+import { openSelectedPiSession, resolveSessionArgumentPath, takeSelectedSessionWriter } from "./session-selection.js";
 import { markStartupPhase } from "../../../foundation/startup/startup-runtime.js";
 import { createWindowsNulCleanupExtension } from "./windows-filesystem-hygiene.js";
+import { acquireSessionWriter, } from "../../../foundation/session-writer-lock/index.js";
+class SessionWriterCoordinator {
+    #current;
+    prepare(manager) {
+        const selected = takeSelectedSessionWriter(manager);
+        if (selected !== undefined)
+            return { handle: selected, alreadyCurrent: false };
+        const path = manager.getSessionFile();
+        if (path === undefined)
+            return undefined;
+        if (this.#current?.path === path)
+            return { handle: this.#current, alreadyCurrent: true };
+        const handle = acquireSessionWriter(path);
+        try {
+            if (!handle.bound) {
+                const header = manager.getHeader();
+                if (header === null)
+                    throw new Error("new session is missing its generated header");
+                mkdirSync(dirname(path), { recursive: true });
+                const descriptor = openSync(path, "wx", 0o600);
+                try {
+                    handle.bind(path);
+                    writeFileSync(descriptor, `${JSON.stringify(header)}\n`);
+                }
+                finally {
+                    closeSync(descriptor);
+                }
+                manager.setSessionFile(path);
+            }
+            return { handle, alreadyCurrent: false };
+        }
+        catch (error) {
+            handle.release();
+            throw error;
+        }
+    }
+    activate(pending) {
+        if (pending === undefined || pending.alreadyCurrent)
+            return;
+        const previous = this.#current;
+        this.#current = pending.handle;
+        previous?.release();
+    }
+    abandon(pending) {
+        if (pending !== undefined && !pending.alreadyCurrent)
+            pending.handle.release();
+    }
+    release() {
+        this.#current?.release();
+        this.#current = undefined;
+    }
+}
+const runtimeSessionWriters = new WeakMap();
 /**
  * Mirrors pinned Pi's CLI startup: resolve the `models` patterns from settings
  * into a scoped model list, keep the resolver's warnings (e.g. "No models match
@@ -69,40 +124,52 @@ export async function createPiRuntimeIntegration(options) {
             cwd: options.cwd, selection,
             ...(sessionDir === undefined ? {} : { sessionDir }),
             ...(options.sessionForkPrompt === undefined ? {} : { forkPrompt: options.sessionForkPrompt }),
+            guardWriter: true,
         });
+    const sessionWriters = new SessionWriterCoordinator();
     const createRuntime = async ({ cwd, sessionManager: targetSessionManager, sessionStartEvent, }) => {
-        const { services, trust } = await createPiRuntimeServicesAfterTrust({
-            cwd,
-            agentDir: options.agentDir,
-            ...(options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: options.projectTrustPrompt }),
-            ...(options.preflightDependencies === undefined ? {} : { preflightDependencies: options.preflightDependencies }),
-            ...(options.markStartupPhase === undefined ? {} : { markStartupPhase: options.markStartupPhase }),
-        });
-        const modelScope = await resolveConfiguredModelScope(services, options.signal);
-        const hasExistingSession = targetSessionManager.buildSessionContext().messages.length > 0;
-        const created = await createAgentSessionFromServices({
-            services,
-            sessionManager: targetSessionManager,
-            ...(sessionStartEvent ? { sessionStartEvent } : {}),
-            ...(modelScope.model && !hasExistingSession ? { model: modelScope.model } : {}),
-            ...(modelScope.thinkingLevel && !hasExistingSession ? { thinkingLevel: modelScope.thinkingLevel } : {}),
-            ...(modelScope.scopedModels.length > 0 ? { scopedModels: [...modelScope.scopedModels] } : {}),
-        });
-        await (options.markStartupPhase ?? defaultStartupPhaseMarker)("session-created");
-        return {
-            ...created,
-            services,
-            diagnostics: [
-                ...(trust.diagnostic === null ? [] : [{ type: "warning", code: "project-trust", message: trust.diagnostic }]),
-                ...modelScope.diagnostics,
-            ],
-        };
+        const pendingWriter = sessionWriters.prepare(targetSessionManager);
+        try {
+            const { services, trust } = await createPiRuntimeServicesAfterTrust({
+                cwd,
+                agentDir: options.agentDir,
+                ...(options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: options.projectTrustPrompt }),
+                ...(options.preflightDependencies === undefined ? {} : { preflightDependencies: options.preflightDependencies }),
+                ...(options.markStartupPhase === undefined ? {} : { markStartupPhase: options.markStartupPhase }),
+            });
+            const modelScope = await resolveConfiguredModelScope(services, options.signal);
+            const hasExistingSession = targetSessionManager.buildSessionContext().messages.length > 0;
+            const created = await createAgentSessionFromServices({
+                services,
+                sessionManager: targetSessionManager,
+                ...(sessionStartEvent ? { sessionStartEvent } : {}),
+                ...(modelScope.model && !hasExistingSession ? { model: modelScope.model } : {}),
+                ...(modelScope.thinkingLevel && !hasExistingSession ? { thinkingLevel: modelScope.thinkingLevel } : {}),
+                ...(modelScope.scopedModels.length > 0 ? { scopedModels: [...modelScope.scopedModels] } : {}),
+            });
+            sessionWriters.activate(pendingWriter);
+            await (options.markStartupPhase ?? defaultStartupPhaseMarker)("session-created");
+            return {
+                ...created,
+                services,
+                diagnostics: [
+                    ...(trust.diagnostic === null ? [] : [{ type: "warning", code: "project-trust", message: trust.diagnostic }]),
+                    ...modelScope.diagnostics,
+                ],
+            };
+        }
+        catch (error) {
+            sessionWriters.abandon(pendingWriter);
+            throw error;
+        }
     };
-    return createAgentSessionRuntime(createRuntime, {
+    const runtime = await createAgentSessionRuntime(createRuntime, {
         cwd: sessionManager.getCwd(),
         agentDir: options.agentDir,
         sessionManager,
     });
+    runtimeSessionWriters.set(runtime, sessionWriters);
+    return runtime;
 }
 function defaultStartupPhaseMarker(phase) {
     return markStartupPhase(process.env, phase);
@@ -119,5 +186,11 @@ export async function replacePiRuntimeSession(runtime, replacement) {
 export async function disposePiRuntimeIntegration(runtime) {
     runtime.setRebindSession(undefined);
     runtime.setBeforeSessionInvalidate(undefined);
-    await runtime.dispose();
+    try {
+        await runtime.dispose();
+    }
+    finally {
+        runtimeSessionWriters.get(runtime)?.release();
+        runtimeSessionWriters.delete(runtime);
+    }
 }

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

@@ -64,12 +64,6 @@ export interface PiEngineRuntimePorts {
     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);

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

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
 import { promisify } from "node:util";
 import { PRODUCT_IDENTITY } from "../../../product-identity.js";
+import { residentProgressObserver } from "../../../foundation/resident-tabs/progress-observation.js";
 import { observeCompactionProgress } from "./compaction-progress.js";
 import { createPiRuntimeIntegration } from "./runtime-integration.js";
 import { PiSessionCommandIntegration } from "./session-integration.js";
@@ -18,6 +19,9 @@ const GIT_BRANCH_MAX_BUFFER_BYTES = 4 * 1024;
  * 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.
  */
+function hasSessionContent(path, session) {
+    return path !== null && existsSync(path) && session.messages.length > 0;
+}
 export class PiEngineRuntime {
     #options;
     #ports;
@@ -154,14 +158,16 @@ export class PiEngineRuntime {
         return typeof value === "string" && value.length > 0 ? value : null;
     }
     currentSessionResumeMetadata() {
-        const manager = this.#session?.sessionManager;
-        if (manager === undefined
+        const session = this.#session;
+        const manager = session?.sessionManager;
+        if (session === undefined
+            || manager === undefined
             || typeof manager.isPersisted !== "function"
             || typeof manager.getSessionId !== "function"
             || typeof manager.getSessionDir !== "function"
             || typeof manager.usesDefaultSessionDir !== "function"
             || manager.isPersisted() !== true
-            || !existsSync(this.currentSessionFile() ?? ""))
+            || !hasSessionContent(this.currentSessionFile(), session))
             return null;
         const sessionId = manager.getSessionId();
         const sessionDir = manager.getSessionDir();
@@ -364,8 +370,10 @@ export class PiEngineRuntime {
             return;
         const generation = this.#sessionGeneration;
         this.#unsubscribe = session.subscribe(event => {
-            if (generation === this.#sessionGeneration && !this.#ports.disposed())
-                this.#ports.event(event);
+            if (generation !== this.#sessionGeneration || this.#ports.disposed())
+                return;
+            residentProgressObserver()?.engineDelivery(event);
+            this.#ports.event(event);
         });
     }
     /**

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

@@ -1,4 +1,5 @@
 import { SessionManager, type SessionInfo } from "../startup-public.js";
+import { type SessionWriterHandle } from "../../../foundation/session-writer-lock/index.js";
 export interface PiSessionSelection {
     readonly target: string;
     readonly sessionDir?: string;
@@ -16,11 +17,13 @@ interface SessionSelectionOptions {
     readonly selection: PiSessionSelection;
     readonly sessionDir?: string;
     readonly forkPrompt?: PiSessionForkPrompt;
+    readonly guardWriter?: boolean;
     /** Public API seam for deterministic lookup/open race and listing-order evidence. */
     readonly sessions?: Pick<typeof SessionManager, "list" | "open" | "forkFrom"> & {
         readonly listAll: (sessionDir?: string) => Promise<SessionInfo[]>;
     };
 }
+export declare function takeSelectedSessionWriter(manager: SessionManager): SessionWriterHandle | undefined;
 /** Pinned Pi 0.84.2 main.ts policy, using SDK APIs rather than importing the CLI. */
 export declare function openSelectedPiSession(options: SessionSelectionOptions): Promise<SessionManager>;
 /** Resolve before switching effective cwd, including quoted home-relative paths. */

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

@@ -2,6 +2,7 @@ import { accessSync, constants, existsSync, realpathSync, statSync } from "node:
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { SessionManager } from "../startup-public.js";
+import { acquireExisting, acquireSessionWriter, SessionWriterConflict, } from "../../../foundation/session-writer-lock/index.js";
 /** Expected resume outcomes are concise CLI diagnostics, not engine crashes. */
 export class PiSessionSelectionError extends Error {
     exitCode;
@@ -11,13 +12,23 @@ export class PiSessionSelectionError extends Error {
         this.name = "PiSessionSelectionError";
     }
 }
+const selectedSessionWriters = new WeakMap();
+export function takeSelectedSessionWriter(manager) {
+    const writer = selectedSessionWriters.get(manager);
+    selectedSessionWriters.delete(manager);
+    return writer;
+}
+function holdSelectedWriter(manager, writer) {
+    selectedSessionWriters.set(manager, writer);
+    return manager;
+}
 /** Pinned Pi 0.84.2 main.ts policy, using SDK APIs rather than importing the CLI. */
 export async function openSelectedPiSession(options) {
+    const sessions = options.sessions ?? SessionManager;
+    const cwd = resolve(options.cwd);
+    const directory = options.selection.sessionDir ?? options.sessionDir ?? process.env.PI_CODING_AGENT_SESSION_DIR;
+    const sessionDir = directory === undefined ? undefined : resolveSessionArgumentPath(directory, cwd);
     try {
-        const sessions = options.sessions ?? SessionManager;
-        const cwd = resolve(options.cwd);
-        const directory = options.selection.sessionDir ?? options.sessionDir ?? process.env.PI_CODING_AGENT_SESSION_DIR;
-        const sessionDir = directory === undefined ? undefined : resolveSessionArgumentPath(directory, cwd);
         const target = options.selection.target;
         let path;
         let global;
@@ -43,18 +54,43 @@ export async function openSelectedPiSession(options) {
             }
             assertResumeFile(path);
             assertCwd(cwd);
-            return sessions.forkFrom(path, cwd, sessionDir);
+            const manager = sessions.forkFrom(path, cwd, sessionDir);
+            if (!options.guardWriter)
+                return manager;
+            const target = manager.getSessionFile();
+            if (target === undefined)
+                throw new PiSessionSelectionError("Fork did not create a session file");
+            return holdSelectedWriter(manager, acquireSessionWriter(target));
         }
         // Invariant: no await between the final guard and SDK open. A disappeared target
         // can otherwise produce a new in-memory header instead of an existing session.
-        const manager = sessions.open(path, sessionDir);
-        assertResumeFile(path);
-        assertCwd(manager.getCwd());
-        return manager;
+        const writer = options.guardWriter ? acquireExisting(path) : undefined;
+        try {
+            const manager = sessions.open(path, sessionDir);
+            assertResumeFile(path);
+            assertCwd(manager.getCwd());
+            return writer === undefined ? manager : holdSelectedWriter(manager, writer);
+        }
+        catch (error) {
+            writer?.release();
+            throw error;
+        }
     }
     catch (error) {
         if (error instanceof PiSessionSelectionError)
             throw error;
+        if (error instanceof SessionWriterConflict) {
+            if (options.forkPrompt && await options.forkPrompt({ sourceCwd: cwd })) {
+                const manager = sessions.forkFrom(error.path, cwd, sessionDir);
+                if (!options.guardWriter)
+                    return manager;
+                const target = manager.getSessionFile();
+                if (target === undefined)
+                    throw new PiSessionSelectionError("Fork did not create a session file");
+                return holdSelectedWriter(manager, acquireSessionWriter(target));
+            }
+            throw new PiSessionSelectionError("session is open in another A1 process");
+        }
         throw new PiSessionSelectionError(`Could not resume session: ${error instanceof Error ? error.message : String(error)}`);
     }
 }

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

@@ -80,6 +80,11 @@ export interface PiSettingsModelChoice {
     readonly description: string;
     readonly levels: readonly string[];
 }
+/** The engine's rule: no reasoning means "off" only; xhigh and max exist only where the model maps them. */
+export declare function supportedThinkingLevels(model: {
+    readonly reasoning?: boolean;
+    readonly thinkingLevelMap?: Readonly<Record<string, unknown>>;
+}): readonly string[];
 /** The choice that clears a per-model override; the engine then applies its global default. */
 export declare const MODEL_THINKING_DEFAULT = "default";
 export declare const AUTOMATIC_THEME = "automatic";

package/dist/integrations/pi/engine/settings-bridge.js

@@ -24,6 +24,7 @@ export const PI_SETTING_EFFECTS = Object.freeze({
     enableInstallTelemetry: effect("next-start", "installation", "none", "install lifecycle and its pinned failure diagnostic", "settings-effects-installation-parity"),
     quietStartup: hiddenEffect("next-start", "startup", "pinned startup suppression lifecycle", "pi-startup-composition-parity"),
     defaultProjectTrust: effect("next-start", "startup", "startup-selector", "pinned pre-resource project trust selector", "project-trust-startup-parity"),
+    sessionShareDestination: effect("live", "agent", "none", "pinned /share Radius or gist upload and its status rows", "pinned-share-destination-parity"),
     doubleEscapeAction: effect("live", "shell", "selector", "pinned tree or fork selector", "pinned-selector-parity"),
     treeFilterMode: effect("live", "shell", "selector", "pinned tree selector filter, rows, and hints", "pinned-selector-parity"),
     showHardwareCursor: effect("live", "terminal", "terminal-cursor", "pinned editor, overlay, blur, failure, and exit cursor operations", "pi-terminal-operation-parity"),
@@ -251,6 +252,19 @@ function outcome(status, application, storedValue, effectiveValue, failure, limi
 function describe(error) {
     return error instanceof Error ? error.message : String(error);
 }
+/** The engine's rule: no reasoning means "off" only; xhigh and max exist only where the model maps them. */
+export function supportedThinkingLevels(model) {
+    if (!model.reasoning)
+        return ["off"];
+    return ["off", "minimal", "low", "medium", "high", "xhigh", "max"].filter(level => {
+        const mapped = model.thinkingLevelMap?.[level];
+        if (mapped === null)
+            return false;
+        if (level === "xhigh" || level === "max")
+            return mapped !== undefined;
+        return true;
+    });
+}
 /** The choice that clears a per-model override; the engine then applies its global default. */
 export const MODEL_THINKING_DEFAULT = "default";
 export const AUTOMATIC_THEME = "automatic";
@@ -411,6 +425,7 @@ function operations(settings, providers) {
         bool("enableInstallTelemetry", () => settings.getEnableInstallTelemetry(), value => settings.setEnableInstallTelemetry(value)),
         quietStartupSetting(settings),
         choice("defaultProjectTrust", offered("defaultProjectTrust"), () => settings.getDefaultProjectTrust(), value => settings.setDefaultProjectTrust(value)),
+        choice("sessionShareDestination", offered("sessionShareDestination"), () => settings.getSessionShareDestination(), value => settings.setSessionShareDestination(value)),
         choice("doubleEscapeAction", offered("doubleEscapeAction"), () => settings.getDoubleEscapeAction(), value => settings.setDoubleEscapeAction(value)),
         choice("treeFilterMode", offered("treeFilterMode"), () => settings.getTreeFilterMode(), value => settings.setTreeFilterMode(value)),
         bool("showHardwareCursor", () => settings.getShowHardwareCursor(), value => settings.setShowHardwareCursor(value)),

package/dist/integrations/pi/engine/settings-port.js

@@ -1,6 +1,6 @@
 import { isRecord, readThinkingLevel, stringProperty } from "./message-values.js";
 import { collectionResult } from "./resource-catalog.js";
-import { MODEL_THINKING_DEFAULT, PiSettingsBridge } from "./settings-bridge.js";
+import { MODEL_THINKING_DEFAULT, PiSettingsBridge, supportedThinkingLevels } from "./settings-bridge.js";
 import { workflowResult } from "./workflow-support.js";
 import { PINNED_PI_SETTINGS_CALLBACKS } from "./workflows.js";
 /**
@@ -142,6 +142,12 @@ export class PiEngineSettings {
                         session.setThinkingLevel(level);
                         this.#ports.thinkingLevelChanged(readThinkingLevel(session.thinkingLevel));
                     } },
+                sessionShareDestination: { apply: value => {
+                        if (value !== "auto" && value !== "gist" && value !== "radius")
+                            throw new TypeError("Session share destination is invalid");
+                        // Invariant: `/share` reads the manager per run, so persisting is the whole live effect.
+                        settings.setSessionShareDestination(value);
+                    } },
                 warnings: { apply: value => {
                         if (!isRecord(value) || Object.values(value).some(flag => typeof flag !== "boolean"))
                             throw new TypeError("Warnings setting is invalid");
@@ -222,6 +228,7 @@ export class PiEngineSettings {
             autocompleteMaxVisible: setting(settings?.getAutocompleteMaxVisible, 5),
             quietStartup: setting(settings?.getQuietStartup, false),
             defaultProjectTrust: setting(settings?.getDefaultProjectTrust, "ask"),
+            sessionShareDestination: setting(settings?.getSessionShareDestination, "auto"),
             clearOnShrink: setting(settings?.getClearOnShrink, false),
             showTerminalProgress: setting(settings?.getShowTerminalProgress, false),
             tuiMode: setting(settings?.getTuiMode, "regular"),
@@ -274,6 +281,7 @@ export class PiEngineSettings {
                 onEnableInstallTelemetryChange: snapshot.enableInstallTelemetry,
                 onQuietStartupChange: snapshot.quietStartup,
                 onDefaultProjectTrustChange: snapshot.defaultProjectTrust,
+                onSessionShareDestinationChange: snapshot.sessionShareDestination,
                 onDoubleEscapeActionChange: snapshot.doubleEscapeAction,
                 onTreeFilterModeChange: snapshot.treeFilterMode,
                 onShowHardwareCursorChange: snapshot.showHardwareCursor,
@@ -331,7 +339,8 @@ function settingKeyForCallback(callback) {
         onHideThinkingBlockChange: "hideThinkingBlock", onMermaidRenderingModeChange: "mermaidRenderingMode",
         onShowCacheMissNoticesChange: "showCacheMissNotices", onCollapseChangelogChange: "collapseChangelog",
         onEnableInstallTelemetryChange: "enableInstallTelemetry", onQuietStartupChange: "quietStartup",
-        onDefaultProjectTrustChange: "defaultProjectTrust", onDoubleEscapeActionChange: "doubleEscapeAction",
+        onDefaultProjectTrustChange: "defaultProjectTrust", onSessionShareDestinationChange: "sessionShareDestination",
+        onDoubleEscapeActionChange: "doubleEscapeAction",
         onTreeFilterModeChange: "treeFilterMode", onShowHardwareCursorChange: "showHardwareCursor",
         onEditorPaddingXChange: "editorPaddingX", onOutputPadChange: "outputPad", onAutocompleteMaxVisibleChange: "autocompleteMaxVisible",
         onClearOnShrinkChange: "clearOnShrink", onShowTerminalProgressChange: "showTerminalProgress", onTuiModeChange: "tuiMode",
@@ -352,19 +361,6 @@ function agentJsonValue(value) {
 function isThinkingLevel(value) {
     return typeof value === "string" && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value);
 }
-/** The engine's own rule: no reasoning means "off" only; xhigh and max exist only where the model maps them. */
-function supportedThinkingLevels(model) {
-    if (!model.reasoning)
-        return ["off"];
-    return ["off", "minimal", "low", "medium", "high", "xhigh", "max"].filter(level => {
-        const mapped = model.thinkingLevelMap?.[level];
-        if (mapped === null)
-            return false;
-        if (level === "xhigh" || level === "max")
-            return mapped !== undefined;
-        return true;
-    });
-}
 function settingLabel(callback) {
     return callback
         .replace(/^on/, "")

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

@@ -0,0 +1,42 @@
+import type { OwnedUiDiagnostics, OwnedUiEditorState, OwnedUiModelInfo, OwnedUiSessionViewModel, OwnedUiStatusView, OwnedUiTerminalSurface, OwnedUiThinkingLevel, OwnedUiUsageView } from "../../../contracts/owned-ui/index.js";
+/**
+ * The engine adapter's own view-model state: lifecycle, editor, status, terminal surface, active
+ * model, thinking level, the usage cache, diagnostics, and the view revision. Every change that
+ * touches more than one field is one named mutator, so the adapter and its collaborators never
+ * rebuild these objects inline.
+ */
+export declare class EngineViewState {
+    #private;
+    lifecycle: OwnedUiSessionViewModel["lifecycle"];
+    activeModel: OwnedUiModelInfo | null;
+    thinkingLevel: OwnedUiThinkingLevel;
+    get revision(): number;
+    get editor(): OwnedUiEditorState;
+    get status(): OwnedUiStatusView;
+    get terminal(): OwnedUiTerminalSurface;
+    get diagnostics(): readonly OwnedUiDiagnostics[];
+    /** Any emitted event advances the revision. */
+    advance(): void;
+    /** A full view is about to be published: usage is recomputed and the revision advances. */
+    invalidate(): void;
+    invalidateUsage(): void;
+    /** The cached usage view, computed once per published view. */
+    usage(read: () => OwnedUiUsageView): OwnedUiUsageView;
+    /** The engine started: the session is ready and accepts submissions. */
+    markReady(): void;
+    /** A run started with `message` as its working status; true when the session was already busy. */
+    enterWork(message: string): boolean;
+    leaveWork(): void;
+    /** Records compaction or retry progress; false when it did not change. */
+    setWorkProgress(percent: Exclude<OwnedUiStatusView["workingProgress"], undefined>): boolean;
+    setQueuedSubmissions(queuedSubmissions: readonly string[]): void;
+    /** Fills an empty editor with `text`, as tree navigation does for the selected branch's prompt. */
+    offerEditorText(text: string): void;
+    setHardwareCursor(hardwareCursor: boolean): void;
+    setTerminal(surface: OwnedUiTerminalSurface): void;
+    /** A replaced session starts with an empty editor that accepts submissions and no working status. */
+    replaceSession(): void;
+    /** Delivery overload ended the run: ready when it can resume, stopped once disposed, otherwise failed. */
+    settleOverload(canResume: boolean, disposed: boolean): void;
+    recordDiagnostic(severity: OwnedUiDiagnostics["severity"], code: string, message: string, recoverable: boolean): OwnedUiDiagnostics;
+}

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

@@ -0,0 +1,126 @@
+const DEFAULT_SURFACE = {
+    columns: 100,
+    rows: 32,
+    focusedRegion: "editor",
+    hardwareCursor: false,
+};
+const MAX_DIAGNOSTICS = 100;
+const MAX_STATUS_DIAGNOSTICS = 8;
+/**
+ * The engine adapter's own view-model state: lifecycle, editor, status, terminal surface, active
+ * model, thinking level, the usage cache, diagnostics, and the view revision. Every change that
+ * touches more than one field is one named mutator, so the adapter and its collaborators never
+ * rebuild these objects inline.
+ */
+export class EngineViewState {
+    #revision = 0;
+    #editor = {
+        text: "",
+        queuedSubmissions: [],
+        selection: null,
+        cursorOffset: 0,
+        historyRevision: 0,
+        submitEnabled: false,
+    };
+    #status = {
+        title: "Pi",
+        workingMessage: null,
+        diagnostics: [],
+        badges: [],
+    };
+    #terminal = DEFAULT_SURFACE;
+    lifecycle = "starting";
+    activeModel = null;
+    thinkingLevel = "medium";
+    #usage;
+    #diagnostics = [];
+    get revision() { return this.#revision; }
+    get editor() { return this.#editor; }
+    get status() { return this.#status; }
+    get terminal() { return this.#terminal; }
+    get diagnostics() { return this.#diagnostics; }
+    /** Any emitted event advances the revision. */
+    advance() {
+        this.#revision += 1;
+    }
+    /** A full view is about to be published: usage is recomputed and the revision advances. */
+    invalidate() {
+        this.#usage = undefined;
+        this.#revision += 1;
+    }
+    invalidateUsage() {
+        this.#usage = undefined;
+    }
+    /** The cached usage view, computed once per published view. */
+    usage(read) {
+        return this.#usage ??= read();
+    }
+    /** The engine started: the session is ready and accepts submissions. */
+    markReady() {
+        this.lifecycle = "ready";
+        this.#editor = { ...this.#editor, submitEnabled: true };
+    }
+    /** A run started with `message` as its working status; true when the session was already busy. */
+    enterWork(message) {
+        const wasBusy = this.lifecycle === "busy";
+        this.lifecycle = "busy";
+        this.#status = { ...this.#status, workingMessage: message, workingProgress: null };
+        return wasBusy;
+    }
+    leaveWork() {
+        this.lifecycle = "ready";
+        this.#status = { ...this.#status, workingMessage: null, workingProgress: null };
+    }
+    /** Records compaction or retry progress; false when it did not change. */
+    setWorkProgress(percent) {
+        if (this.#status.workingProgress === percent)
+            return false;
+        this.#status = { ...this.#status, workingProgress: percent };
+        return true;
+    }
+    setQueuedSubmissions(queuedSubmissions) {
+        this.#editor = { ...this.#editor, queuedSubmissions: [...queuedSubmissions], historyRevision: this.#editor.historyRevision + 1 };
+    }
+    /** Fills an empty editor with `text`, as tree navigation does for the selected branch's prompt. */
+    offerEditorText(text) {
+        if (!this.#editor.text.trim()) {
+            this.#editor = { ...this.#editor, text, selection: null, cursorOffset: text.length };
+        }
+    }
+    setHardwareCursor(hardwareCursor) {
+        this.#terminal = { ...this.#terminal, hardwareCursor };
+    }
+    setTerminal(surface) {
+        this.#terminal = { ...surface };
+    }
+    /** A replaced session starts with an empty editor that accepts submissions and no working status. */
+    replaceSession() {
+        this.#editor = {
+            text: "",
+            queuedSubmissions: [],
+            selection: null,
+            cursorOffset: 0,
+            historyRevision: this.#editor.historyRevision + 1,
+            submitEnabled: true,
+        };
+        this.#status = { ...this.#status, workingMessage: null, workingProgress: null, badges: [] };
+    }
+    /** Delivery overload ended the run: ready when it can resume, stopped once disposed, otherwise failed. */
+    settleOverload(canResume, disposed) {
+        this.#status = { ...this.#status, workingMessage: null, workingProgress: null };
+        this.lifecycle = disposed ? "stopped" : canResume ? "ready" : "failed";
+        this.#editor = { ...this.#editor, submitEnabled: canResume && !disposed };
+        this.#revision += 1;
+    }
+    recordDiagnostic(severity, code, message, recoverable) {
+        const diagnostic = { sequence: this.#diagnostics.length, code, severity, message, recoverable };
+        this.#diagnostics.push(diagnostic);
+        if (this.#diagnostics.length > MAX_DIAGNOSTICS)
+            this.#diagnostics.shift();
+        this.#status = {
+            ...this.#status,
+            diagnostics: [...this.#status.diagnostics, message].slice(-MAX_STATUS_DIAGNOSTICS),
+        };
+        return diagnostic;
+    }
+}

package/dist/integrations/pi/engine/workflow-contexts.js

@@ -3,6 +3,7 @@ import { dirname, resolve } from "node:path";
 import { dynamicObject, isRecord, requireCapability, stringProperty } from "./message-values.js";
 import { ProjectTrustStore, SessionManager } from "../startup-public.js";
 import { resolveConfiguredModelIds, scopedModelRecords, scopedModelReference, workflowOptions } from "./workflow-support.js";
+import { acquireExisting } from "../../../foundation/session-writer-lock/index.js";
 /**
  * The selector contexts and option lists the owned UI's workflow dialogs read from pinned Pi:
  * model, scoped-model, session, tree, fork, project-trust, and provider-authentication state,
@@ -102,7 +103,15 @@ export class PiWorkflowContexts {
                 const next = (nextName ?? "").trim();
                 if (!next)
                     return;
-                SessionManager.open(sessionFilePath).appendSessionInfo(next);
+                const isCurrent = typeof currentSessionFilePath === "string"
+                    && resolve(currentSessionFilePath) === resolve(sessionFilePath);
+                const writer = isCurrent ? undefined : acquireExisting(sessionFilePath);
+                try {
+                    SessionManager.open(sessionFilePath).appendSessionInfo(next);
+                }
+                finally {
+                    writer?.release();
+                }
             },
         };
     }