@timurproko/a1 0.2.7-dev.1249 → 0.2.7-dev.1252

package/dist/app/session-shell/resident-tab-coordinator.js

@@ -1,77 +0,0 @@
-/**
- * The session presenter's side of a resident tab: recovered input, the idle status it reports to
- * the strip, prompt admission and correlation through the recovery journal, draft checkpoints,
- * detach on quit, and the graceful stop when the presenter is released. Outside a resident tab
- * every operation is a no-op.
- */
-export class ResidentTabCoordinator {
-    #options;
-    #ports;
-    constructor(options, ports) {
-        this.#options = options;
-        this.#ports = ports;
-    }
-    /** True inside a resident tab, where Settings and the session name live in the global strip. */
-    get active() {
-        return this.#options !== undefined;
-    }
-    checkpoint(text) {
-        this.#options?.checkpoint?.(text);
-    }
-    closeOwnedRoute(route) {
-        this.#options?.closeOwnedRoute?.(route);
-    }
-    /** Puts the prompts and draft a previous tab process left unfinished back into the editor. */
-    restoreInput(imageSidecar) {
-        const recovered = this.#options?.recovered;
-        if (recovered === undefined)
-            return;
-        const { root } = this.#ports;
-        const prompts = recovered.prompts
-            .map(prompt => root.rehydrateHistoryText(prompt.text, id => imageSidecar?.readAttachment(id) ?? null))
-            .filter(Boolean);
-        if (prompts.length > 0) {
-            root.editor.setText(prompts[0]);
-            if (recovered.draft)
-                root.editor.addToHistory(recovered.draft);
-            for (const additional of prompts.slice(1))
-                root.editor.addToHistory(additional);
-            root.appendWorkflowStatus(recovered.draft
-                ? `Recovered an unfinished prompt; the prior draft and ${Math.max(0, prompts.length - 1)} additional prompt${prompts.length === 2 ? "" : "s"} are in editor history.`
-                : `Recovered an unfinished prompt${prompts.length > 1 ? `; ${prompts.length - 1} additional prompts are in editor history` : ""}.`);
-        }
-        else if (recovered.draft) {
-            root.editor.setText(recovered.draft);
-            root.appendWorkflowStatus("Recovered the editor draft from the previous tab process.");
-        }
-    }
-    /** Reports idle to the strip whenever the session leaves its busy lifecycle. */
-    observeLifecycle(event) {
-        if (event.type === "session-lifecycle" && event.lifecycle !== "busy")
-            this.#options?.reportStatus?.("idle");
-    }
-    /** Journals a prompt before it is sent; undefined outside a resident tab. Rejects when the journal cannot sync. */
-    admit(input) {
-        return this.#options?.admit?.(input) ?? Promise.resolve(undefined);
-    }
-    /** The admitted prompt reached the engine; its journal entry is correlated with the engine's entry. */
-    async dispatched(submissionId, entryId) {
-        this.#options?.dispatched?.();
-        await this.#options?.correlated?.(submissionId, entryId).catch(() => undefined);
-    }
-    /**
-     * Leaves the tab without stopping its engine. Returns undefined outside a resident tab, true when
-     * the client detached, or the notice to show when detaching is unavailable.
-     */
-    async detach() {
-        const resident = this.#options;
-        if (resident === undefined)
-            return undefined;
-        const detached = await resident.requestDetach().catch(() => false);
-        return detached ? true : resident.unavailableNotice ?? "Press Ctrl+C twice to leave; this agent keeps running.";
-    }
-    gracefulStop(sessionFile) {
-        return this.#options?.gracefulStop?.(sessionFile) ?? Promise.resolve();
-    }
-    dispose() { }
-}

package/dist/cli/tabs-request.d.ts

@@ -1,7 +0,0 @@
-export type TabsAction = "list" | "stop" | "stop-all" | "host-status" | "host-stop" | "doctor";
-/** One parsed `a1 tabs` form. Parsing finishes before any host is contacted. */
-export interface TabsRequest {
-    readonly action: TabsAction;
-    readonly tabId?: string;
-    readonly json: boolean;
-}

package/dist/cli/tabs-request.js

@@ -1 +0,0 @@
-export {};

package/dist/cli/tabs.d.ts

@@ -1,14 +0,0 @@
-import { runTerminalHostMaintenance, writeDoctorBundle } from "../foundation/resident-tabs/index.js";
-import type { TabsRequest } from "./tabs-request.js";
-export type { TabsRequest } from "./tabs-request.js";
-export interface TabsCommandOptions {
-    /** The invoking package, never a different active or retained release. */
-    readonly packageRoot?: string;
-    readonly environment?: NodeJS.ProcessEnv;
-    readonly stdout?: (message: string) => void;
-    readonly stderr?: (message: string) => void;
-    readonly maintenance?: typeof runTerminalHostMaintenance;
-    readonly doctor?: typeof writeDoctorBundle;
-}
-/** `a1 tabs`: inspect or stop resident tabs without attaching, and never start a host to report state. */
-export declare function runTabsCommand(request: TabsRequest, options?: TabsCommandOptions): Promise<number>;

package/dist/cli/tabs.js

@@ -1,151 +0,0 @@
-import { resolveProductPaths } from "../foundation/lifecycle/index.js";
-import { materializeRelease } from "../foundation/release/index.js";
-import { readResidentTabLaunchSettings, runTerminalHostMaintenance, writeDoctorBundle, } from "../foundation/resident-tabs/index.js";
-import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../product-identity.js";
-/** `a1 tabs`: inspect or stop resident tabs without attaching, and never start a host to report state. */
-export async function runTabsCommand(request, options = {}) {
-    const environment = options.environment ?? process.env;
-    const stdout = options.stdout ?? (message => process.stdout.write(message));
-    const stderr = options.stderr ?? (message => process.stderr.write(message));
-    const paths = resolveProductPaths(environment);
-    const profileRoot = environment[PRODUCT_IDENTITY.environment.profileHome] ?? paths.configDir;
-    const releaseRoots = await invokingReleaseRoots(paths.dataDir, options.packageRoot, environment);
-    const maintenance = options.maintenance ?? runTerminalHostMaintenance;
-    const report = await maintenance({
-        action: request.action === "doctor" ? "host-status" : request.action,
-        ...(request.tabId === undefined ? {} : { tabId: request.tabId }),
-        profileRoot,
-        dataDir: paths.dataDir,
-        runtimeDir: paths.runtimeDir,
-        releaseRoots,
-        environment,
-    });
-    if (request.action === "doctor") {
-        if (!report.stateDir) {
-            stderr(`${PRODUCT_TEXT.diagnostic(`tabs doctor could not locate resident state: ${report.message ?? report.host}`)}\n`);
-            return 1;
-        }
-        const settings = await readResidentTabLaunchSettings(environment.PI_CODING_AGENT_DIR ?? paths.configDir, PRODUCT_IDENTITY.commandName, paths.configDir, "a1");
-        const bundle = await (options.doctor ?? writeDoctorBundle)({
-            stateDir: report.stateDir,
-            hostStatus: report,
-            releaseRoots,
-            settings: { tabsAutoName: settings.tabsAutoName },
-        });
-        if (request.json)
-            stdout(`${JSON.stringify({ schema: "a1-tabs-doctor-v1", path: bundle.path, bytes: bundle.bytes, dropped: bundle.dropped })}\n`);
-        else
-            stdout(`Wrote ${bundle.path}\n`);
-        return 0;
-    }
-    if (request.json) {
-        const { exitCode: _exitCode, ...printed } = report;
-        stdout(`${JSON.stringify(printed)}\n`);
-    }
-    else {
-        const text = describe(request, report);
-        if (report.exitCode === 0)
-            stdout(text);
-        else
-            stderr(text);
-    }
-    return report.exitCode === 0 ? 0 : 1;
-}
-async function invokingReleaseRoots(dataDir, packageRoot, environment) {
-    if (!packageRoot)
-        return [];
-    if (environment[PRODUCT_IDENTITY.environment.developmentInstanceId])
-        return [packageRoot];
-    try {
-        // Invariant: immutable materialization selects exact payload bytes without activating or starting a host.
-        return [(await materializeRelease(packageRoot, dataDir)).releaseRoot];
-    }
-    catch {
-        return [];
-    }
-}
-const NO_TABS = "No resident tabs are running.\n";
-function describe(request, report) {
-    const command = PRODUCT_TEXT.commandName;
-    if (report.host === "none")
-        return NO_TABS;
-    if (report.host === "unavailable")
-        return `${PRODUCT_TEXT.diagnostic(`tabs could not run maintenance: ${report.message ?? "terminal host unavailable"}`)}\n`;
-    if (report.host === "unresponsive") {
-        return `The resident host (pid ${report.pid ?? "unknown"}) is not responding. Run \`${command} tabs host stop\` to stop it.\n`;
-    }
-    if (report.host === "incompatible") {
-        return `${PRODUCT_TEXT.diagnostic(report.message ?? "running tabs use another version")} Run \`${command} tabs host stop\` from that version.\n`;
-    }
-    if (report.host === "unverifiable" || report.host === "refused") {
-        return `${PRODUCT_TEXT.diagnostic(report.message ?? "the resident host could not be verified; nothing was changed")}\n`;
-    }
-    const result = report.result ?? {};
-    if (request.action === "list")
-        return listing(result);
-    if (request.action === "host-status")
-        return status(result);
-    if (request.action === "host-stop") {
-        if (report.host === "stopped")
-            return "Stopped every tab and the resident host.\n";
-        return `Could not stop every tab: ${remaining(result)}. The host is still running.\n`;
-    }
-    if (result.accepted === false && typeof result.message === "string") {
-        return `${PRODUCT_TEXT.diagnostic(`tabs stop: ${result.message === "unknown tab" ? `no tab ${request.tabId ?? ""}` : result.message}`)}\n`;
-    }
-    const stopped = Array.isArray(result.stopped) ? result.stopped.length : 0;
-    if (result.accepted === false)
-        return `Could not stop: ${remaining(result)}.\n`;
-    if (request.action === "stop")
-        return `Stopped tab ${request.tabId ?? ""}; its session can be resumed.\n`;
-    return stopped === 0 ? NO_TABS : `Stopped ${stopped} tab${stopped === 1 ? "" : "s"}; their sessions can be resumed.\n`;
-}
-function remaining(result) {
-    return Array.isArray(result.remaining) && result.remaining.length > 0 ? result.remaining.join(", ") : "unknown tabs";
-}
-function listing(result) {
-    const tabs = Array.isArray(result.tabs) ? result.tabs : [];
-    if (tabs.length === 0)
-        return NO_TABS;
-    const rows = [
-        ["ID", "NAME", "STATUS", "CWD", "RELEASE", "HOLDER"],
-        ...tabs.map(tab => [tab.tabId, tab.name, tab.status, tab.cwd, tab.release, tab.holderPid ?? "-"].map(value => String(value ?? "-"))),
-    ];
-    const widths = rows[0].map((_, column) => Math.max(...rows.map(row => row[column].length)));
-    return `${rows.map(row => row.map((cell, column) => column === row.length - 1 ? cell : cell.padEnd(widths[column])).join("  ")).join("\n")}\n`;
-}
-function status(result) {
-    const limits = (result.limits ?? {});
-    const counters = (result.counters ?? {});
-    const byStatus = (result.tabsByStatus ?? {});
-    const lines = [
-        `pid: ${String(result.pid ?? "-")}`,
-        `build: ${String(result.build ?? "-")}`,
-        `release: ${String(result.release ?? "-")}`,
-        `generation: ${String(result.generation ?? "-")}`,
-        `epoch: ${String(result.epoch ?? "-")}`,
-        `uptime: ${String(result.uptimeSeconds ?? "-")}s`,
-        `detachment: ${String(result.detachmentMode ?? "unknown")}${result.detachmentVerified === false ? " (not verified)" : ""}`,
-        `tabs: ${String(result.tabs ?? 0)}${Object.keys(byStatus).length > 0 ? ` (${Object.entries(byStatus).map(([key, value]) => `${key} ${String(value)}`).join(", ")})` : ""}`,
-        `clients: ${String(result.clients ?? 0)}`,
-        ...startsAndLifecycle(result),
-        `limits: ${Object.entries(limits).map(([key, value]) => `${key} ${String(value)}`).join(", ")}`,
-        `counters: ${Object.entries(counters).map(([key, value]) => `${key} ${String(value)}`).join(", ")}`,
-        ...(Array.isArray(result.logs) ? result.logs.map(path => `log: ${String(path)}`) : []),
-    ];
-    return `${lines.join("\n")}\n`;
-}
-/** Lifecycle work running this long means a terminal's tab requests are stuck. */
-const LIFECYCLE_STALL_MS = 10_000;
-function startsAndLifecycle(result) {
-    const lines = [];
-    const starts = result.starts;
-    if (starts)
-        lines.push(`starts: active ${String(starts.active ?? 0)}, waiting ${String(starts.interactiveWaiting ?? 0)}, recovering ${String(starts.recoverySlots ?? 0)}`);
-    const lifecycle = result.lifecycle;
-    if (lifecycle) {
-        const oldest = typeof lifecycle.oldestMs === "number" ? lifecycle.oldestMs : 0;
-        lines.push(`lifecycle: pending ${String(lifecycle.pending ?? 0)}, oldest ${oldest}ms${oldest > LIFECYCLE_STALL_MS ? " (stalled)" : ""}`);
-    }
-    return lines;
-}

package/dist/composition/resident-tab-bridge.d.ts

@@ -1,41 +0,0 @@
-import type { OwnedUiReleaseUpdate } from "../contracts/owned-ui/index.js";
-import type { TabBridgeClient } from "../foundation/resident-tabs/bridge-client.js";
-import { type ResidentTabRoute } from "../foundation/resident-tabs/routes.js";
-import type { ResidentTabRecovery } from "../foundation/resident-tabs/recovery.js";
-import type { PiKeybindingsHost } from "../integrations/pi/components/shell-shared-facade.js";
-import type { ComposedSessionBackend } from "./session-backend.js";
-import type { OwnedRouteHostOptions } from "./settings-route-host.js";
-/**
- * The keybindings the shells borrow. Inside a resident tab the host dispatches and labels the tab
- * shortcuts this child projects from its effective declarations, so the projection is published now
- * and again after every customization reload.
- */
-export declare function residentTabKeybindings(tabBridge: TabBridgeClient | null, agentDir: string, keybindingsHost: PiKeybindingsHost): PiKeybindingsHost;
-/**
- * How owned screens are presented in a resident tab: a Settings or Changelog tab's screen is the tab, and the Plus menu entry opens
- * the tab bar's own Plus Menu dialog while this tab's controlling client can show it.
- */
-export declare function residentRouteHostOptions(tabBridge: TabBridgeClient | null): OwnedRouteHostOptions;
-/** Closes a utility tab when its own screen closes. Invariant: a utility tab's screen is the tab. */
-export declare function closeResidentUtilityRoute(tabBridge: Pick<TabBridgeClient, "tabId" | "requestClose">, route: string): void;
-export declare function bindResidentTabBridge(tabBridge: TabBridgeClient, backend: Pick<ComposedSessionBackend, "identity" | "session" | "workflows" | "generateResidentTabName">, recovery?: Pick<ResidentTabRecovery, "settled"> | null, options?: {
-    readonly autoName?: boolean;
-    readonly openRoute?: (route: ResidentTabRoute) => void;
-    readonly onClientVersion?: (version: string) => void;
-}): Promise<() => void>;
-export declare function createResidentClientIdentity(announce: (update: OwnedUiReleaseUpdate) => void): {
-    current: () => string | null;
-    onChange: (listener: () => void) => void;
-    observe: (next: string) => void;
-};
-/** Input ownership is established before the presenter starts, and released if bridge binding fails. */
-export declare function bindResidentPresentation(bridge: TabBridgeClient | null, backend: Parameters<typeof bindResidentTabBridge>[1], recovery: Parameters<typeof bindResidentTabBridge>[2], options: Parameters<typeof bindResidentTabBridge>[3], input: {
-    addPreInputListener(listener: (data: string) => {
-        data: string;
-    }): () => void;
-}): Promise<{
-    unsubscribeTabBridge: () => void;
-    removeControllerBoundaryInput: () => void;
-}>;
-export declare function correlateResidentTabSubmission(recovery: Pick<ResidentTabRecovery, "correlated" | "settled">, backend: Pick<ComposedSessionBackend, "identity" | "session">, submissionId: string, entryId: string): Promise<void>;
-export declare function currentBackendSessionFile(backend: Pick<ComposedSessionBackend, "identity">): string | null;

package/dist/composition/resident-tab-bridge.js

@@ -1,209 +0,0 @@
-import { residentUtilityRoute } from "../foundation/resident-tabs/routes.js";
-import { deriveResidentTabStatus } from "../features/resident-tab/status-deriver.js";
-import { projectResidentTabShortcuts } from "../features/resident-tab/shortcut-projection.js";
-import { readShortcutBindingsFile } from "../features/resident-tab/shortcut-bindings-file.js";
-/**
- * The keybindings the shells borrow. Inside a resident tab the host dispatches and labels the tab
- * shortcuts this child projects from its effective declarations, so the projection is published now
- * and again after every customization reload.
- */
-export function residentTabKeybindings(tabBridge, agentDir, keybindingsHost) {
-    if (tabBridge === null)
-        return keybindingsHost;
-    const publish = () => tabBridge.shortcuts(projectResidentTabShortcuts({
-        configured: readShortcutBindingsFile(agentDir),
-        reserved: keybindingsHost.manager.getEffectiveConfig(),
-    }).assignments);
-    publish();
-    return { ...keybindingsHost, reload: () => { keybindingsHost.reload(); publish(); } };
-}
-/**
- * How owned screens are presented in a resident tab: a Settings or Changelog tab's screen is the tab, and the Plus menu entry opens
- * the tab bar's own Plus Menu dialog while this tab's controlling client can show it.
- */
-export function residentRouteHostOptions(tabBridge) {
-    return {
-        ...(tabBridge === null ? {} : { tabRoute: residentUtilityRoute(tabBridge.tabId) }),
-        configurePlusMenu: () => {
-            if (tabBridge === null || !tabBridge.available || tabBridge.captureAttachment() === null)
-                return false;
-            void tabBridge.requestAction("configure-plus");
-            return true;
-        },
-    };
-}
-/** Closes a utility tab when its own screen closes. Invariant: a utility tab's screen is the tab. */
-export function closeResidentUtilityRoute(tabBridge, route) {
-    if (residentUtilityRoute(tabBridge.tabId) === route)
-        void tabBridge.requestClose();
-}
-export async function bindResidentTabBridge(tabBridge, backend, recovery = null, options = {}) {
-    await tabBridge.start().catch(() => false);
-    tabBridge.status("starting");
-    const currentSessionFile = () => currentBackendSessionFile(backend);
-    let pendingAutoName = null;
-    // Invariant: while a generated name is being applied, the session name it produces is automatic
-    // even if the session normalizes it; reporting it as `user` would block the strip's title
-    // animation and every later automatic rename.
-    let applyingAutoName = false;
-    const isDefaultName = (name) => name == null || /^agent(?: \d+)?$/i.test(name);
-    const currentSessionName = () => backend.session.view().status.footer?.sessionName ?? null;
-    const announceSession = () => {
-        const name = currentSessionName();
-        // Invariant: the session may announce the applied name after the workflow resolves; the
-        // first non-default name announced for a pending auto-name is that automatic name.
-        if (applyingAutoName && !isDefaultName(name)) {
-            pendingAutoName = name;
-            applyingAutoName = false;
-        }
-        const automatic = name === pendingAutoName;
-        const nameSource = automatic ? "auto" : isDefaultName(name) ? "default" : "user";
-        tabBridge.session(currentSessionFile(), name, nameSource);
-    };
-    let working = false;
-    // Invariant: the last turn's settlement stays reported until the next turn starts.
-    let lastTurn;
-    let autoNameAttempted = false;
-    let autoNameArmed = false;
-    // Invariant: naming launches once per tab during an agent run, as soon as its prompt is projected,
-    // and runs beside the turn instead of waiting for it to settle.
-    const launchAutoName = () => {
-        if (!autoNameArmed || autoNameAttempted || options.autoName !== true || !isDefaultName(currentSessionName()))
-            return;
-        const prompt = backend.session.view().transcript.find(block => block.kind === "user")?.text.trim();
-        if (!prompt)
-            return;
-        autoNameAttempted = true;
-        void import("../features/resident-tab/index.js").then(({ generateAutoName }) => generateAutoName(prompt, request => backend.generateResidentTabName(request.prompt, request.maxTokens, request.signal))).then(async (name) => {
-            // Invariant: a manual rename made while generation was pending owns both the session and the tab.
-            if (!isDefaultName(currentSessionName()))
-                return;
-            pendingAutoName = name;
-            applyingAutoName = true;
-            const result = await backend.workflows.executeWorkflow({ command: "name", argument: name });
-            if (result.outcome !== "completed") {
-                applyingAutoName = false;
-                if (pendingAutoName === name)
-                    pendingAutoName = null;
-                return;
-            }
-            const current = currentSessionName();
-            if (current !== null && !isDefaultName(current)) {
-                // Invariant: The session already holds the applied name; report it as automatic now.
-                pendingAutoName = current;
-                applyingAutoName = false;
-                tabBridge.session(currentSessionFile(), current, "auto");
-            }
-            else {
-                // Invariant: The session announces later; show the generated name meanwhile, still automatic.
-                tabBridge.session(currentSessionFile(), name, "auto");
-            }
-        }).catch(() => { pendingAutoName = null; applyingAutoName = false; });
-    };
-    const reportStatus = (lifecycle) => {
-        const view = backend.session.view();
-        const pendingRequests = view.dialog == null ? 0 : 1;
-        const queuedInput = view.editor?.queuedSubmissions.length ?? 0;
-        tabBridge.status(deriveResidentTabStatus({
-            lifecycle: lifecycle ?? view.lifecycle,
-            pendingRequests,
-            queuedInput,
-            ...(lastTurn === undefined ? {} : { lastTurn }),
-        }), false, pendingRequests, queuedInput);
-    };
-    announceSession();
-    const unsubscribeCommands = typeof tabBridge.onCommand === "function"
-        ? tabBridge.onCommand(command => applyBridgeCommand(command, backend, options)) : () => { };
-    const unsubscribeEvents = backend.session.onEvent(event => {
-        if (event.type === "session-lifecycle") {
-            const wasWorking = working;
-            working = event.lifecycle === "busy";
-            if (working)
-                lastTurn = undefined;
-            reportStatus(event.lifecycle);
-            if (wasWorking && !working && recovery !== null) {
-                void recovery.settled(currentSessionFile()).catch(() => tabBridge.degraded(true));
-            }
-        }
-        if (event.type === "agent-run-started") {
-            autoNameArmed = true;
-            launchAutoName();
-        }
-        // Rationale: Pi starts the run before it projects the user message, so the prompt may arrive later.
-        if (event.type === "transcript-block" || event.type === "session-view")
-            launchAutoName();
-        if (event.type === "agent-run-settled") {
-            launchAutoName();
-            autoNameArmed = false;
-            lastTurn = event.aborted ? "aborted" : event.successful ? "done" : "error";
-            tabBridge.prompt(event.aborted);
-            reportStatus();
-        }
-        if (event.type === "session-view") {
-            announceSession();
-            reportStatus();
-        }
-    });
-    return () => {
-        unsubscribeCommands();
-        unsubscribeEvents();
-    };
-}
-function applyBridgeCommand(command, backend, options) {
-    // Invariant: visibility never pauses resident rendering or autonomous work.
-    if (command.type === "client")
-        options.onClientVersion?.(command.version);
-    else if (command.type === "rename")
-        void backend.workflows.executeWorkflow({ command: "name", argument: command.name }).catch(() => { });
-    else if (command.type === "route") {
-        if (options.openRoute !== undefined)
-            options.openRoute(command.route);
-        else
-            void backend.workflows.executeWorkflow({ command: command.route, argument: "" }).catch(() => { });
-    }
-    else if (command.type === "stop")
-        void backend.session.dispose().catch(() => { });
-}
-export function createResidentClientIdentity(announce) {
-    let version = null;
-    let changed;
-    return {
-        current: () => version,
-        onChange: (listener) => { changed = listener; },
-        observe: (next) => {
-            if (next === version)
-                return;
-            version = next;
-            announce({ status: "client-connected", version: next });
-            changed?.();
-        },
-    };
-}
-/** Input ownership is established before the presenter starts, and released if bridge binding fails. */
-export async function bindResidentPresentation(bridge, backend, recovery, options, input) {
-    if (bridge === null)
-        return { unsubscribeTabBridge() { }, removeControllerBoundaryInput() { } };
-    const removeControllerBoundaryInput = input.addPreInputListener(data => ({ data: bridge.consumeControllerBoundaryInput(data) }));
-    try {
-        return { unsubscribeTabBridge: await bindResidentTabBridge(bridge, backend, recovery, options), removeControllerBoundaryInput };
-    }
-    catch (error) {
-        removeControllerBoundaryInput();
-        throw error;
-    }
-}
-export async function correlateResidentTabSubmission(recovery, backend, submissionId, entryId) {
-    await recovery.correlated(submissionId, entryId);
-    // Concurrency: a normal prompt command can resolve after the ready transition already fired.
-    // Re-read lifecycle only after correlation is active; a concurrent ready observer and this path
-    // safely race because recovery consumes the active entry once and retirement is idempotent.
-    if (backend.session.view().lifecycle !== "busy")
-        await recovery.settled(currentBackendSessionFile(backend));
-}
-export function currentBackendSessionFile(backend) {
-    const direct = backend.identity.currentSessionFile?.();
-    if (direct !== undefined && direct !== null)
-        return direct;
-    const resume = backend.identity.currentSessionResumeMetadata();
-    return resume === null ? null : `${resume.sessionDir}/${resume.sessionId}`;
-}

package/dist/composition/utility-tab.d.ts

@@ -1,28 +0,0 @@
-import type { OwnedUiApplicationPort, PresentationTerminalPort } from "../contracts/presentation/index.js";
-import type { TabBridgeClient } from "../foundation/resident-tabs/bridge-client.js";
-import type { ResidentTabRoute } from "../foundation/resident-tabs/routes.js";
-import type { ReleaseNoteCatalog } from "../features/owned-ui/release-notes.js";
-import type { UiRouteHost } from "../ui/apps/contracts.js";
-import type { OwnedSettingsManager } from "../ui/settings/manager.js";
-import { terminateOwnedUiProcess } from "../features/owned-ui/run.js";
-export { terminateOwnedUiProcess };
-export interface UtilityTabOptions {
-    readonly route: ResidentTabRoute;
-    readonly bridge: TabBridgeClient;
-    readonly cwd?: string;
-    readonly profileId?: string;
-    readonly terminal?: PresentationTerminalPort;
-    readonly agentDir?: string;
-    readonly settings?: OwnedSettingsManager;
-    readonly routeHost?: UiRouteHost;
-    readonly releaseNotes?: ReleaseNoteCatalog;
-    readonly onApplication?: (application: OwnedUiApplicationPort) => void;
-}
-export interface UtilityTabComposition {
-    readonly application: OwnedUiApplicationPort;
-    readonly settings: OwnedSettingsManager;
-}
-/** Runs one pinned Settings or Changelog screen without constructing an Agent engine or session. */
-export declare function runUtilityTab(options: UtilityTabOptions): Promise<number>;
-export declare function composeUtilityTab(options: UtilityTabOptions): Promise<UtilityTabComposition>;
-export declare function utilityAgentDir(environment?: NodeJS.ProcessEnv): string;