@timurproko/a1 0.2.7-dev.808 → 0.2.7-dev.809

package/dist/integrations/pi/engine/command-dispatch.d.ts

@@ -1,5 +1,7 @@
 import { type OwnedUiCommand, type OwnedUiCommandResult, type OwnedUiDiagnostics } from "../../../contracts/owned-ui/index.js";
 import type { PiEmittedEvent } from "./event-delivery.js";
+import type { PiEngineRuntime } from "./session-runtime.js";
+import type { EngineViewState } from "./view-state.js";
 export type AdapterCommandResult = OwnedUiCommandResult;
 export interface PiCommandDispatchPorts {
     sessionId(): string;
@@ -36,3 +38,14 @@ export declare class PiCommandDispatch {
     reset(): void;
     execute(command: OwnedUiCommand): Promise<AdapterCommandResult>;
 }
+/** What carrying out a command reaches: the running engine, the view state it updates, and disposal. */
+export interface EngineCommandContext {
+    readonly engine: Pick<PiEngineRuntime, "runtime" | "session" | "generation" | "sessionCommands">;
+    readonly state: Pick<EngineViewState, "activeModel" | "thinkingLevel" | "setTerminal" | "terminal">;
+    /** False while delivery is overloaded or admission is stopped; a late model change then stays unpublished. */
+    admissionOpen(): boolean;
+    emit(value: PiEmittedEvent): void;
+    dispose(): Promise<void>;
+}
+/** Carries out one admitted command against the running engine; throws when no session runs or the command fails. */
+export declare function performEngineCommand(command: OwnedUiCommand, context: EngineCommandContext): Promise<void>;

package/dist/integrations/pi/engine/command-dispatch.js

@@ -123,3 +123,60 @@ export class PiCommandDispatch {
         return { outcome, diagnostic };
     }
 }
+// Invariant: prompt input and session controls run through the engine's own session commands, which own queuing and images.
+async function runSessionCommand(request, context) {
+    const result = await context.engine.sessionCommands?.execute(request);
+    if (!result || result.outcome === "rejected" || result.outcome === "failed") {
+        throw new Error(request.type === "retry" ? "no previous prompt is available to retry" : `Pi session command failed: ${request.type}`);
+    }
+}
+function runPromptCommand(command, context) {
+    return runSessionCommand({
+        type: command.type,
+        text: command.text,
+        ...(command.images === undefined ? {} : { images: [...command.images] }),
+    }, context);
+}
+const ownedUiStateCommand = () => {
+    throw new Error("owned UI state commands belong to the owned UI layer, not the Pi engine adapter");
+};
+// Invariant: one handler per command type; the table is exhaustive, so a new command type cannot be silently ignored.
+const ENGINE_COMMANDS = {
+    "prompt": (command, context) => runPromptCommand(command, context),
+    "steer": (command, context) => runPromptCommand(command, context),
+    "follow-up": (command, context) => runPromptCommand(command, context),
+    "abort": (_command, context) => runSessionCommand({ type: "abort" }, context),
+    "retry": (_command, context) => runSessionCommand({ type: "retry" }, context),
+    "compact": (_command, context) => runSessionCommand({ type: "compact" }, context),
+    "set-model": async (command, context, { runtime, session, generation }) => {
+        const model = runtime.services.modelRuntime.getModel(command.model.providerId, command.model.modelId);
+        if (!model)
+            throw new Error(`model is unavailable: ${command.model.providerId}/${command.model.modelId}`);
+        await session.setModel(model);
+        if (generation === context.engine.generation && context.admissionOpen())
+            context.state.activeModel = { ...command.model };
+    },
+    "set-thinking-level": (command, context, { session }) => {
+        session.setThinkingLevel(command.thinkingLevel);
+        context.state.thinkingLevel = command.thinkingLevel;
+    },
+    "new-session": async (_command, _context, { runtime }) => { await runtime.newSession(); },
+    "resume-session": async (command, _context, { runtime }) => { await runtime.switchSession(command.sessionPath); },
+    "resize-surface": (command, context) => {
+        context.state.setTerminal(command.surface);
+        context.emit({ type: "terminal-surface", surface: context.state.terminal });
+    },
+    "shutdown": (_command, context) => context.dispose(),
+    "set-setting": ownedUiStateCommand,
+    "apply-customization": ownedUiStateCommand,
+    "remove-customization": ownedUiStateCommand,
+};
+/** Carries out one admitted command against the running engine; throws when no session runs or the command fails. */
+export async function performEngineCommand(command, context) {
+    const { runtime, session, generation } = context.engine;
+    if (!runtime || !session)
+        throw new Error("engine session is unavailable");
+    // Invariant: the table maps each type to the handler for exactly that command, so the command fits its own handler.
+    const handler = ENGINE_COMMANDS[command.type];
+    await handler(command, context, { runtime, session, generation });
+}

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

@@ -86,7 +86,7 @@ class ProcessPiEngineHost {
             return;
         this.#disposed = true;
         this.#abort.abort();
-        const live = [...this.#sessions.values()].filter(session => !session.disposed);
+        const live = [...this.#sessions.values()].filter(session => !session.identity.disposed);
         this.#sessions.clear();
         await Promise.all(live.map(session => session.dispose()));
     }
@@ -107,7 +107,7 @@ class ProcessPiEngineHost {
     }
     #forgetDisposedSessions() {
         for (const [sessionId, session] of this.#sessions)
-            if (session.disposed)
+            if (session.identity.disposed)
                 this.#sessions.delete(sessionId);
     }
     // Rationale: the profile's timeout is installed once, by whichever session loads it first; a written

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

@@ -0,0 +1,56 @@
+import type { AgentSession } from "../startup-public.js";
+import type { OwnedUiExtensionPort, OwnedUiImageAttachment, OwnedUiReleaseUpdate, OwnedUiSessionCatalogPort, OwnedUiSessionIdentityPort, OwnedUiSessionPort, OwnedUiSessionSettingsPort, OwnedUiWorkflowPort } from "../../../contracts/owned-ui/index.js";
+import type { PiPinnedSettingsCallback, PiPinnedSettingsSnapshot, PiSessionSelectorContext, PiTreeSelectorContext, PiWorkflowInteractionHost, PiWorkflowRequest, PiWorkflowResult } from "./workflows.js";
+import type { PiExtensionUiBinding } from "./extension-ui-binding.js";
+import type { PiResourceCatalog } from "./resource-catalog.js";
+import type { PiEngineRuntime } from "./session-runtime.js";
+import type { PiEngineSettings } from "./settings-port.js";
+import type { PiWorkflowContexts } from "./workflow-contexts.js";
+import type { PiWorkflowRunner } from "./workflow-runner.js";
+/**
+ * The Pi objects pinned selectors and transcript renderers are built from. They are not part of the
+ * session backend contract; only the session presenters owner reads them.
+ */
+export interface PiSessionPresentationSource {
+    pinnedModelSelectorContext(): ReturnType<PiWorkflowContexts["pinnedModelSelectorContext"]>;
+    pinnedSessionSelectorContext(): PiSessionSelectorContext;
+    pinnedTreeSelectorContext(): PiTreeSelectorContext;
+    pinnedMessageRenderer(customType: string): unknown;
+    pinnedToolRenderers(toolName: string): unknown;
+    pinnedShortcutDescriptions(bindings: Parameters<AgentSession["extensionRunner"]["getShortcuts"]>[0]): readonly {
+        readonly key: string;
+        readonly description: string;
+    }[];
+    pinnedSettingsModels(): Pick<PiPinnedSettingsSnapshot, "currentModel" | "availableDefaultModels">;
+    applyPinnedSettingValue(callback: PiPinnedSettingsCallback, value: unknown): Promise<PiWorkflowResult>;
+}
+export interface PiEngineAdapterPorts {
+    readonly identity: OwnedUiSessionIdentityPort;
+    readonly session: OwnedUiSessionPort;
+    readonly workflows: OwnedUiWorkflowPort;
+    readonly settings: OwnedUiSessionSettingsPort;
+    readonly catalog: OwnedUiSessionCatalogPort;
+    readonly extensions: OwnedUiExtensionPort;
+    readonly presentation: PiSessionPresentationSource;
+}
+/** The adapter's collaborators and its own session operations, which every port member reaches at call time. */
+export interface EnginePortParts {
+    readonly sessionId: string;
+    readonly agentDir: string;
+    readonly engine: Pick<PiEngineRuntime, "cwd" | "generation" | "bindingGeneration" | "currentSessionResumeMetadata" | "currentSessionFile">;
+    readonly contexts: PiWorkflowContexts;
+    readonly workflows: PiWorkflowRunner;
+    readonly settings: PiEngineSettings;
+    readonly resources: PiResourceCatalog;
+    readonly extensions: PiExtensionUiBinding;
+    readonly session: OwnedUiSessionPort;
+    disposed(): boolean;
+    executeWorkflow(request: PiWorkflowRequest): Promise<PiWorkflowResult>;
+    clearQueuedWorkflows(): readonly string[];
+    setWorkflowInteractionHost(interaction: PiWorkflowInteractionHost): void;
+    announceReleaseUpdate(release: OwnedUiReleaseUpdate): void;
+    resolveTranscriptImage(assetId: string): OwnedUiImageAttachment | null;
+    /** The running session's extension runner; throws when no session runs. */
+    extensionRunner(): AgentSession["extensionRunner"] | undefined;
+}
+export declare function createEnginePorts(parts: EnginePortParts): PiEngineAdapterPorts;

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

@@ -0,0 +1,89 @@
+// Invariant: every port member delegates at call time, so ports built once follow session replacement.
+export function createEnginePorts(parts) {
+    const { engine, contexts, workflows, settings, resources, extensions } = parts;
+    return {
+        identity: {
+            sessionId: parts.sessionId,
+            agentDir: parts.agentDir,
+            get cwd() { return engine.cwd; },
+            get sessionGeneration() { return engine.generation; },
+            get sessionBindingGeneration() { return engine.bindingGeneration; },
+            get disposed() { return parts.disposed(); },
+            currentSessionResumeMetadata: () => engine.currentSessionResumeMetadata(),
+            currentSessionFile: () => engine.currentSessionFile(),
+        },
+        session: parts.session,
+        workflows: {
+            executeWorkflow: request => parts.executeWorkflow(request),
+            executeBashWorkflow: (command, excludeFromContext) => workflows.executeBashWorkflow(command, excludeFromContext),
+            cycleModelWorkflow: direction => workflows.cycleModelWorkflow(direction),
+            workflowAutocompleteCommands: () => resources.workflowAutocompleteCommands(),
+            clearQueuedWorkflows: () => parts.clearQueuedWorkflows(),
+            reloadBlockedResult: () => workflows.reloadBlockedResult(),
+            copyWorkflowText: text => workflows.copyWorkflowText(text),
+            setWorkflowInteractionHost: interaction => { parts.setWorkflowInteractionHost(interaction); },
+        },
+        settings: {
+            get productMode() { return settings.productMode; },
+            snapshot: () => {
+                // Invariant: the selector-only model values travel on the presentation source, not in the neutral snapshot.
+                const { currentModel: _currentModel, availableDefaultModels: _availableDefaultModels, ...snapshot } = settings.pinnedSettingsSnapshot();
+                return snapshot;
+            },
+            bindOwner: (owner, handlers) => settings.bindSettingsOwner(owner, handlers),
+            setDefaultThinkingLevel: level => { settings.setDefaultThinkingLevel(level); },
+            configuredTheme: () => settings.configuredTheme(),
+        },
+        catalog: {
+            modelsContext: () => contexts.modelsContext(),
+            setSessionModelScope: scopeIds => { contexts.setSessionModelScope(scopeIds); },
+            persistModelScope: scopeIds => { contexts.persistModelScope(scopeIds); },
+            refreshModels: signal => contexts.refreshModels(signal),
+            pinnedScopedModelsContext: () => contexts.pinnedScopedModelsContext(),
+            updateScopedModels: enabledModelIds => { contexts.updateScopedModels(enabledModelIds); },
+            persistScopedModels: enabledModelIds => { contexts.persistScopedModels(enabledModelIds); },
+            refreshScopedModels: signal => contexts.refreshScopedModels(signal),
+            pinnedProjectTrustContext: () => contexts.pinnedProjectTrustContext(),
+            persistProjectTrust: updates => { contexts.persistProjectTrust(updates); },
+            pinnedLoginOptions: authType => contexts.loginOptions(authType),
+            pinnedLoginMethodOptions: providerReference => contexts.pinnedLoginMethodOptions(providerReference),
+            pinnedAmbientAuthentication: selection => contexts.pinnedAmbientAuthentication(selection),
+            pinnedLogoutOptions: () => contexts.logoutOptions(),
+            pinnedForkOptions: () => contexts.pinnedForkOptions(),
+        },
+        extensions: {
+            nonVisualResources: () => resources.nonVisualResources(),
+            extensionResources: () => resources.extensionResources(),
+            resolveTranscriptImage: assetId => parts.resolveTranscriptImage(assetId),
+            visualExtensionSupport: () => extensions.support(),
+            bindExtensionUi: (ui, shutdown) => extensions.bind(ui, shutdown),
+            unbindExtensionUi: () => extensions.unbind(),
+            bindClipboardWriter: writer => workflows.bindClipboardWriter(writer),
+            announceReleaseUpdate: release => { parts.announceReleaseUpdate(release); },
+        },
+        presentation: {
+            pinnedModelSelectorContext: () => contexts.pinnedModelSelectorContext(),
+            pinnedSessionSelectorContext: () => contexts.pinnedSessionSelectorContext(),
+            pinnedTreeSelectorContext: () => contexts.pinnedTreeSelectorContext(),
+            pinnedMessageRenderer: customType => parts.extensionRunner()?.getMessageRenderer?.(customType),
+            pinnedToolRenderers: toolName => {
+                const runner = parts.extensionRunner();
+                if (runner === undefined)
+                    return undefined;
+                if (typeof runner.resolveToolRenderers === "function") {
+                    return runner.resolveToolRenderers(toolName, () => runner.getToolDefinition?.(toolName));
+                }
+                return runner.getToolDefinition?.(toolName);
+            },
+            pinnedShortcutDescriptions: bindings => {
+                const shortcuts = parts.extensionRunner()?.getShortcuts?.(bindings);
+                return shortcuts === undefined ? [] : [...shortcuts].map(([key, shortcut]) => ({ key, description: shortcut.description ?? shortcut.extensionPath }));
+            },
+            pinnedSettingsModels: () => {
+                const { currentModel, availableDefaultModels } = settings.pinnedSettingsSnapshot();
+                return { ...(currentModel === undefined ? {} : { currentModel }), availableDefaultModels };
+            },
+            applyPinnedSettingValue: (callback, value) => settings.applyPinnedSettingValue(callback, value),
+        },
+    };
+}

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/native/darwin-arm64/manifest.json

@@ -7,7 +7,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "supported",
-  "builtAt": "2026-10-19T14:46:40.019Z",
+  "builtAt": "2026-10-20T08:53:57.218Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "a87eaaffcd986b624c8b044b756446cc1bdaf4334a1775b97820542fe34f9fb7",

package/dist/native/darwin-arm64/terminal-host.manifest.json

@@ -9,11 +9,11 @@
   "architecture": "arm64",
   "target": "aarch64-apple-darwin",
   "capability": "supported",
-  "builtAt": "2026-10-19T14:50:21.966Z",
+  "builtAt": "2026-10-20T08:57:24.837Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "12b73c5b9c2023badcdcbea9f2c3cca018cbb1704c0cb452303f59a551b0c407",
-    "size": 5813520
+    "sha256": "1885cc705611eb1b5a06148d77cb3e85dc99321124b7fec4be382630292555c6",
+    "size": 5747616
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

package/dist/native/darwin-x64/manifest.json

@@ -7,7 +7,7 @@
   "platform": "darwin",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-19T14:46:46.372Z",
+  "builtAt": "2026-10-20T08:54:05.958Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "783a65f0de287a1c02cd5429dbe97bc8633f4cc8a7b92e3e961180b9bdcff814",

package/dist/native/darwin-x64/terminal-host.manifest.json

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-apple-darwin",
   "capability": "supported",
-  "builtAt": "2026-10-19T14:53:04.323Z",
+  "builtAt": "2026-10-20T09:00:09.786Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "aea613cb66de9d7f87018ee32aba7d30d695a86752301e1dde771bdeb7dad724",
-    "size": 6349264
+    "sha256": "a34271e9cc5ec28a638dd4bcaff97a7fb33ac0856f4cd5b18814400d540e8da7",
+    "size": 6263000
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

package/dist/native/linux-x64/manifest.json

@@ -7,7 +7,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-19T14:46:32.168Z",
+  "builtAt": "2026-10-20T08:53:35.318Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "118e5954e3864672bd8482ab7edf419cb27dcdf2533720316979b7f5cc5a53a5",

package/dist/native/linux-x64/terminal-host.manifest.json

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-unknown-linux-gnu",
   "capability": "supported",
-  "builtAt": "2026-10-19T14:49:27.044Z",
+  "builtAt": "2026-10-20T08:55:32.085Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "890d87b2fccecb4956243c40da97c461e180a40ace6b340d5c9f808ab9f4b586",
-    "size": 7099552
+    "sha256": "5c7b589cd36b901a4a02d172f84d70111f7f4cec5ad796a6ea13524109fa4b50",
+    "size": 6988960
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

package/dist/native/win32-x64/manifest.json

@@ -7,10 +7,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-19T14:46:55.773Z",
+  "builtAt": "2026-10-20T08:54:21.248Z",
   "artifact": {
     "filename": "process-guardian.node",
-    "sha256": "e8b39eb8c589c028024164c021a08183021574d06b48fbefc34fb3fb55636c62",
+    "sha256": "aa4a36d3cb4e7f4cb9157409bbe0215ac467140f5558ca154aaf736f6105ce9b",
     "size": 402432
   },
   "provenance": {

package/dist/native/win32-x64/terminal-host.manifest.json

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-pc-windows-msvc",
   "capability": "supported",
-  "builtAt": "2026-10-19T14:49:14.794Z",
+  "builtAt": "2026-10-20T08:58:10.619Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "7661bc29672ef40853a94bcfe367fd6ed5c03b9e6e3e3ac4ac4bbea4c2aad891",
-    "size": 6323712
+    "sha256": "31360962d3614f342891adae1a8f79e65c3b1a323baab396f4a9a0f32afd3d99",
+    "size": 6072320
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

package/docs/architecture/boundaries.md

@@ -44,6 +44,20 @@ The JavaScript product path has no PTY or terminal-emulator dependency. Reintrod
 
 `scripts/governance/check-architecture.mjs` enforces the structural parts of these boundaries. Cross-cutting rationale belongs here; implementation history belongs in Git and archived OpenSpec changes.
 
+## Session shell composition
+
+The session presenter (`src/app/session-shell/session-shell.ts`) coordinates; it does not own per-concern state. Each concern implements `SessionConcern` (`session-concern.ts`): it resets its own state in `onSessionReplaced` and releases it in `dispose`, and the presenter lists its concerns once, in reset order, in `#createConcerns`. New submission, routing, dialog, login, or resident-tab behavior goes into the concern that owns it, or a new concern added to that list. The render root (`session-shell-root.ts`) likewise picks one `ShellLayout` at construction and delegates transcript caching to `TranscriptDocument`, dock chrome to `DockChrome`, workflow output to `WorkflowOutput`, extension surfaces to `ExtensionSurface`, and the dock's input surface to `InputSurfaceSwitch`. The engine adapter serves the shell through the ports built in `src/integrations/pi/engine/ports.ts`, and the composition root delegates runtime claims, the startup release note, and the resident-tab bridge to their own modules under `src/composition/`.
+
+## Unit size ratchet
+
+Module boundaries do not stop one class or function inside a module from absorbing every feature. The architecture gate therefore measures every production TypeScript class under `src/` (methods and fields) and every TypeScript or Rust function under `src/` and `native/<crate>/src/` (inclusive lines), excluding vendored sources and Rust `#[cfg(test)]` code. A unit with more than 20 methods, 15 fields, or 100 function lines must be recorded in `config/baselines/size-ratchet.json`, and its recorded counts can only shrink:
+
+- A recorded count that grows fails the gate. Split the unit instead. If growth is truly unavoidable, raise the entry by hand in the same pull request and say why in its description, so the growth is reviewed rather than silent.
+- An unrecorded unit over a threshold fails the gate; split it before it lands.
+- A count that shrinks, or a unit that falls below every threshold, fails until `node scripts/governance/update-size-ratchet.mjs` lowers or removes the entry. That script never adds or raises an entry; `--check` reports without writing.
+
+The measurement in `scripts/governance/size-ratchet-policy.mjs` masks strings, comments, and regular expressions and counts braces, so it needs no build; a file whose braces do not balance is reported rather than mismeasured. Keys are `<path>::<Class>`, `<path>::<Class>.<method>`, or `<path>::<Type>::<fn>`, so moving or renaming a unit means moving its entry.
+
 ## Multi-session limits of the pinned engine
 
 The engine host removes A1's own obstacles to several Pi sessions in one process, but three remain in the pinned Pi SDK and must be planned around, not discovered:

package/docs/architecture/resident-tabs.md

@@ -64,7 +64,7 @@ The read-only review used A1 `develop` at `b42b3c9e`, PR #586 at `8fdb7361`, `E:
 
 ### Milestone 3 failure-isolation contract (2026-10-14)
 
-- The native `core/server.rs` and `core/holder.rs` state machines are deterministic and I/O-free; the production holder uses the holder core for bounded input admission and ordered writer effects, and the production server uses the server core for heartbeat supervision. Blocking identity/termination work runs through the bounded worker shell with deadlines and stale-incarnation filtering.
+- The native `core/server.rs`, `core/holder.rs`, and `core/attach/` state machines are deterministic and I/O-free; the production holder uses the holder core for bounded input admission and ordered writer effects, the production server uses the server core for heartbeat supervision, and the attach client steps the attach core for every interaction mode (popup, rename, drag), shortcut, deferred input, and server answer while `roles/attach.rs` keeps the connection, outer terminal, encoders, and presentation. Blocking identity/termination work runs through the bounded worker shell with deadlines and stale-incarnation filtering.
 - Every attach, server, and holder role has an independent 15-second watchdog. Watchdog records are bounded, timestamped, owner-only metadata under the profile runtime directory; fault-only role freezes are refused by non-test release builds.
 - Holders read PTY output continuously, use one bounded input authority, reserve complete pastes before delivery, and emit a typed uncertain-delivery result after an admitted write failure. Each holder independently refreshes the server's latest complete retained surface even while hidden. Server-to-client control lanes are frame/byte bounded, render lanes retain one replaceable full current surface, and only the viewed tab is delivered to each attach client.
 - Server replacement is serialized by `server-start.lock` in the profile runtime directory. Recovery verifies the recorded native owner before termination, waits boundedly for the registry-writer lease, increments the durable epoch, derives holder credentials, and re-admits only exact holder/child identities and incarnations. A durable three-start/sixty-second budget stops automatic replacement; explicit `--restart` clears it.
@@ -395,12 +395,12 @@ Every queue, buffer, file, and collection the resident roles keep has a declared
 | Structured complete surface | 512 × 256 geometry, 65,536 cells, 4,096 styles, 4,096 links, and 8 MiB decoded state | `protocol.rs` `StructuredSurface::validate` | `structured_surfaces_fail_closed_on_dimensions_indexes_and_control_injection` |
 | Input per message and holder input queue | 1 MiB | `protocol.rs`, `core/holder.rs`, `roles/holder.rs` | `over_capacity_paste_delivers_no_prefix` |
 | Holder PTY ingress and work round | 64 × 16 KiB lossless chunks; at most 256 KiB or 2 ms before yielding | `roles/holder.rs` | `verify-resident-parallel-progress.mjs` concurrent and stopped-stage cases |
-| Per-client control lane | 1,024 frames and 4 MiB | `roles/server.rs` | `control_lane_is_bounded_by_frames_and_bytes` |
-| Per-client render slot | one pending full surface; a newer one replaces it | `roles/server.rs` `Peer::offer_surface` | `stalled_client_gets_one_full_current_surface` |
-| Concurrent endpoint connections | 128 | `roles/server.rs` `admit_connection` | `connections_beyond_the_cap_are_refused_and_released_slots_are_reused` |
-| Attached viewing clients | 16 | `roles/server.rs` `client_slot_available` | `attached_clients_are_capped` |
+| Per-client control lane | 1,024 frames and 4 MiB | `roles/server/mod.rs` | `control_lane_is_bounded_by_frames_and_bytes` |
+| Per-client render slot | one pending full surface; a newer one replaces it | `roles/server/mod.rs` `Peer::offer_surface` | `stalled_client_gets_one_full_current_surface` |
+| Concurrent endpoint connections | 128 | `roles/server/mod.rs` `admit_connection` | `connections_beyond_the_cap_are_refused_and_released_slots_are_reused` |
+| Attached viewing clients | 16 | `roles/server/mod.rs` `client_slot_available` | `attached_clients_are_capped` |
 | Concurrent holder starts | default 2, hard 8 | `core/server.rs` | `limits_starts_and_drops_stale_completion` |
-| Stopped tab records | 16, oldest dropped first | `roles/server.rs` `prune_stopped_records` | `stopped_records_are_bounded_oldest_first_and_live_tabs_are_kept` |
+| Stopped tab records | 16, oldest dropped first | `roles/server/mod.rs` `prune_stopped_records` | `stopped_records_are_bounded_oldest_first_and_live_tabs_are_kept` |
 | Prior tab-set archives | bounded history | `roles/registry.rs` | `prior_tab_sets_are_bounded` |
 | Abandoned blocking workers | 8 | `shell/workers.rs` | `fails_fast_after_eight_abandoned_workers` |
 | Diagnostic logs | 5 MiB × 3 generations per role | `roles/diagnostics.rs` | `logs_rotate_at_their_cap_and_keep_a_bounded_number_of_generations` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.2.7-dev.808",
+  "version": "0.2.7-dev.809",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",