@timurproko/a1 0.2.7-dev.754 → 0.2.7-dev.772

package/dist/cli/tabs.js

@@ -0,0 +1,140 @@
+import { resolveProductPaths } from "../foundation/lifecycle/index.js";
+import { CohortStateStore } 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 installedReleaseRoots(paths.dataDir, options.packageRoot);
+    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: { tabsMax: settings.tabsMax, 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 installedReleaseRoots(dataDir, packageRoot) {
+    const roots = [];
+    try {
+        const state = await new CohortStateStore(dataDir).read();
+        for (const id of [state.references.active, state.references.rollback]) {
+            if (id && state.releases[id])
+                roots.push(state.releases[id].releaseRoot);
+        }
+        roots.push(...Object.values(state.releases).map(record => record.releaseRoot));
+    }
+    catch {
+        // Rationale: unreadable release state still leaves the running package's own host.
+    }
+    if (packageRoot)
+        roots.push(packageRoot);
+    return [...new Set(roots)];
+}
+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)}`,
+        `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`;
+}

package/dist/composition/owned-ui.d.ts

@@ -10,6 +10,8 @@ import type { OwnedUiApplicationPort, PresentationTerminalPort } from "../contra
 import type { AgentSettingsPort } from "../contracts/agent-engine/index.js";
 import type { OwnedUiPromptSuggestionGeneratorPort, UiAccentColor } from "../contracts/owned-ui/index.js";
 import type { ReleaseNoteCatalog } from "../features/owned-ui/release-notes.js";
+import type { TabBridgeClient } from "../foundation/resident-tabs/bridge-client.js";
+import { ResidentTabRecovery } from "../foundation/resident-tabs/recovery.js";
 /**
  * The session backend composition wires: the owned-UI port, the prompt-suggestion generator, and
  * the agent settings port. `settingsPort` stays outside the owned-UI contract because its type
@@ -17,6 +19,7 @@ import type { ReleaseNoteCatalog } from "../features/owned-ui/release-notes.js";
  */
 export interface ComposedSessionBackend extends PiSessionPresenterBackend, OwnedUiPromptSuggestionGeneratorPort {
     settingsPort(): AgentSettingsPort | null;
+    generateResidentTabName(instruction: string, maxTokens: number, signal: AbortSignal): Promise<string | null>;
 }
 /** The process-level engine host as composition drives it: sessions, the live accent, and disposal. */
 export interface ComposedEngineHost {
@@ -38,6 +41,8 @@ export interface OwnedUiCompositionOptions {
      * session settings-free, which is what the pinned comparison paths use.
      */
     readonly profileId?: string;
+    /** Hide resident-only tab controls for the explicit direct single-agent launch. */
+    readonly hideTabSettings?: boolean;
     /**
      * Whether A1's product-specific surfaces are reachable. Comparison profiles
      * use the same composition with those surfaces withheld.
@@ -55,11 +60,32 @@ export interface OwnedUiCompositionOptions {
     readonly checkForNewerRelease?: (options: StartupReleaseCheckOptions) => Promise<AvailableRelease | null>;
     /** Exact native process inspection injected by the shipped entry; absent SDK seams do not publish claims. */
     readonly inspectProcess?: (pid: number) => Promise<NativeProcessIdentity | null>;
+    /** Private credentials were consumed by the entry before composition or extensions loaded. */
+    readonly tab?: {
+        readonly bridge: TabBridgeClient;
+        readonly dataDir: string;
+        readonly incarnation: number;
+    };
+    /** One prompt-adjacent notice explaining why a resident launch fell back. */
+    readonly residentFallbackNotice?: string;
 }
 export interface OwnedUiComposition {
     readonly application: OwnedUiApplicationPort;
     /** Present when a profile was supplied, so the caller can resolve settings before start. */
     readonly settings: OwnedSettingsManager | null;
 }
+export declare function residentStartupPresentation(resident: boolean, fallbackNotice?: string): {
+    readonly startup?: {
+        readonly quiet?: boolean;
+        readonly notices?: readonly [{
+            readonly kind: "warning";
+            readonly message: string;
+        }];
+    };
+};
 export declare function composeOwnedUiApplication(options?: OwnedUiCompositionOptions): Promise<OwnedUiApplicationPort>;
 export declare function composeOwnedUi(options?: OwnedUiCompositionOptions): Promise<OwnedUiComposition>;
+export declare function bindResidentTabBridge(tabBridge: TabBridgeClient, backend: Pick<ComposedSessionBackend, "identity" | "session" | "workflows" | "generateResidentTabName">, recovery?: Pick<ResidentTabRecovery, "settled"> | null, options?: {
+    readonly autoName?: boolean;
+    readonly onVisibility?: (visible: boolean) => void;
+}): Promise<() => void>;

package/dist/composition/owned-ui.js

@@ -4,7 +4,7 @@ import { PRODUCT_IDENTITY } from "../product-identity.js";
 import { PromptHistoryService } from "../features/prompt-history/service.js";
 import { PromptImageSidecar } from "../features/prompt-history/image-sidecar.js";
 import { resolvePromptHistoryPath } from "../features/prompt-history/paths.js";
-import { resolvePromptHistoryDataDir } from "../features/launch/profile-paths.js";
+import { resolveLaunchProfilePaths, resolvePromptHistoryDataDir } from "../features/launch/profile-paths.js";
 import { resolveProductPaths } from "../foundation/lifecycle/paths.js";
 import { applyConfiguredPiTheme, getAvailablePiThemes, setPiAccentColor, setPiPackageBorderProjectionEnabled } from "../integrations/pi/components/upstream/theme/theme.js";
 import { createPiEngineHost } from "../integrations/pi/engine/host.js";
@@ -18,7 +18,14 @@ import { createPiTerminalBridge } from "../integrations/pi/tui-runtime/presentat
 import { createOwnedRouteHost } from "./settings-route-host.js";
 import { renderPiShellChangelogLines } from "../integrations/pi/components/shell-presenters-info.js";
 import { nativeHyperlinkStyle } from "../ui/components/spans.js";
+import { ResidentTabRecovery } from "../foundation/resident-tabs/recovery.js";
+import { deriveResidentTabStatus } from "../features/resident-tab/status-deriver.js";
 const SESSION_RUNTIME_REFRESH_MS = 30_000;
+export function residentStartupPresentation(resident, fallbackNotice) {
+    if (resident)
+        return { startup: { quiet: true } };
+    return fallbackNotice === undefined ? {} : { startup: { notices: [{ kind: "warning", message: fallbackNotice }] } };
+}
 export async function composeOwnedUiApplication(options = {}) {
     return (await composeOwnedUi(options)).application;
 }
@@ -82,17 +89,33 @@ export async function composeOwnedUi(options = {}) {
         sessionRuntimeRefreshTimer.unref();
     };
     const productPaths = resolveProductPaths();
+    const profilePaths = resolveLaunchProfilePaths();
     // Rationale: the manager reads the engine's settings port lazily, after the session exists.
     let backend;
     const settings = options.profileId === undefined
         ? null
         : new OwnedSettingsManager({
-            configDir: resolveProductPaths().configDir,
+            profileDir: profilePaths.agentProfile,
             profileId: options.profileId,
+            namespace: PRODUCT_IDENTITY.commandName,
+            legacyConfigDir: productPaths.configDir,
             agentProvider: () => backend.settingsPort(),
+            ...(options.hideTabSettings ? { hiddenOwnedSettingIds: ["tabsMax", "tabsAutoName"] } : {}),
             hiddenAgentSettingIds: ["fullscreenWheelScrollLines"],
             agentSettingLabelOverrides: { fullscreenCopyOnSelect: "Copy on select" },
         });
+    const tabBridge = options.tab?.bridge ?? null;
+    if (tabBridge !== null)
+        await tabBridge.start().catch(() => false);
+    const projectTrustPrompt = options.projectTrustPrompt === undefined ? undefined : async (request) => {
+        tabBridge?.status("needs-input", false, 1, 0);
+        try {
+            return await options.projectTrustPrompt(request);
+        }
+        finally {
+            tabBridge?.status("starting");
+        }
+    };
     // Invariant: process-wide engine state has one owner. The host installs the HTTP dispatcher, applies
     // the theme singletons, and announces startup notices once; every session is created through it.
     const host = await (options.createEngineHost ?? (async (hostOptions) => createPiEngineHost(hostOptions)))({
@@ -105,21 +128,49 @@ export async function composeOwnedUi(options = {}) {
             packageBorderProjection: ownedSurfaces,
             apply: { base: applyConfiguredPiTheme, accentColor: setPiAccentColor, packageBorderProjection: setPiPackageBorderProjectionEnabled },
         },
-        ...(options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: options.projectTrustPrompt }),
+        ...(projectTrustPrompt === undefined ? {} : { projectTrustPrompt }),
     });
+    const sessionForkPrompt = options.sessionForkPrompt === undefined ? undefined : async (request) => {
+        tabBridge?.status("needs-input", false, 1, 0);
+        try {
+            return await options.sessionForkPrompt(request);
+        }
+        finally {
+            tabBridge?.status("starting");
+        }
+    };
     try {
         backend = await host.create({
             cwd,
             ...(ownedSurfaces ? { repositoryContextReader: repositoryContextReaderFor(undefined) } : {}),
             ...(options.sessionPath === undefined ? {} : { sessionPath: options.sessionPath }),
             ...(options.sessionSelection === undefined ? {} : { sessionSelection: options.sessionSelection }),
-            ...(options.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: options.sessionForkPrompt }),
+            ...(sessionForkPrompt === undefined ? {} : { sessionForkPrompt }),
         });
     }
     catch (error) {
         await host.dispose();
         throw error;
     }
+    let recoveryDegraded = false;
+    let presentRecoveryDegraded = (_degraded) => { };
+    const tabRecovery = options.tab === undefined ? null : new ResidentTabRecovery(options.tab.dataDir, {
+        onDegraded: degraded => {
+            recoveryDegraded = degraded;
+            options.tab.bridge.degraded(degraded);
+            presentRecoveryDegraded(degraded);
+        },
+    });
+    const recoveredTabInput = await tabRecovery?.initialize(currentBackendSessionFile(backend), backend.identity.sessionId);
+    if (tabBridge !== null && settings !== null && ownedSurfaces)
+        tabBridge.accent(settings.value("accentColor"));
+    let residentTabVisible = true;
+    let applyResidentTabVisibility = () => { };
+    let removeControllerBoundaryInput = () => { };
+    const unsubscribeTabBridge = tabBridge === null ? () => { } : await bindResidentTabBridge(tabBridge, backend, tabRecovery, {
+        autoName: settings?.value("tabsAutoName") ?? true,
+        onVisibility: visible => { residentTabVisible = visible; applyResidentTabVisibility(); },
+    });
     let releaseNotes = null;
     let releaseNotesFailure;
     if (ownedSurfaces) {
@@ -142,7 +193,11 @@ export async function composeOwnedUi(options = {}) {
         }));
     const unsubscribeAccent = settings === null || !ownedSurfaces
         ? () => { }
-        : settings.onChange(current => host.setAccentColor(current.value("accentColor")));
+        : settings.onChange(current => {
+            const accent = current.value("accentColor");
+            host.setAccentColor(accent);
+            tabBridge?.accent(accent);
+        });
     // Rationale: Routes open only after shell construction.
     const references = {
         changelog: async (input) => {
@@ -228,13 +283,25 @@ export async function composeOwnedUi(options = {}) {
                     },
                 }),
                 ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
+                ...(tabBridge === null || tabRecovery === null ? {} : { residentTab: {
+                        requestDetach: () => tabBridge.requestDetach(),
+                        reportStatus: status => tabBridge.status(status),
+                        stallNoticeSeconds: 300,
+                        admit: input => tabRecovery.admit({ ...input, incarnation: options.tab.incarnation }),
+                        dispatched: () => tabRecovery.dispatched(),
+                        correlated: (submissionId, entryId) => tabRecovery.correlated(submissionId, entryId),
+                        checkpoint: text => tabRecovery.checkpoint(text),
+                        gracefulStop: sessionFile => tabRecovery.gracefulStop(sessionFile),
+                        ...(recoveredTabInput === undefined ? {} : { recovered: recoveredTabInput }),
+                    } }),
             },
             presentation: {
                 ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
+                ...residentStartupPresentation(tabBridge !== null, options.residentFallbackNotice),
                 ...(clipboardDiagnostics === null ? {} : { input: { onEvent: event => clipboardDiagnostics.runtime(event) } }),
                 ...(viewportSettings === null ? {} : { viewportSettings }),
                 ...(backgroundSettings === null ? {} : { backgroundSettings }),
-                ...(settings === null || !ownedSurfaces ? {} : {
+                ...(settings === null || !ownedSurfaces || tabBridge !== null ? {} : {
                     quitOutro: { snapshot: () => quitOutroSettingsSnapshot(settings), interactive: process.stdout.isTTY === true },
                 }),
             },
@@ -254,7 +321,21 @@ export async function composeOwnedUi(options = {}) {
         // Invariant: one terminal host owns the process terminal; the session presenter reaches it only through
         // the host and paints once attached.
         terminalHost = createdTerminalHost = new OwnedUiTerminalHost(sessionTerminalHostOptions(presenterOptions));
+        if (tabBridge !== null) {
+            applyResidentTabVisibility = () => terminalHost.setPresentationVisible(residentTabVisible);
+            removeControllerBoundaryInput = terminalHost.runtime.addPreInputListener(data => ({
+                data: tabBridge.consumeControllerBoundaryInput(data),
+            }));
+        }
         presenter = new OwnedUiSessionPresenter(terminalHost, presenterOptions);
+        presentRecoveryDegraded = degraded => {
+            if (!degraded)
+                return;
+            presenter.root.appendWorkflowStatus("draft recovery degraded");
+            terminalHost.runtime.requestRender();
+        };
+        if (recoveryDegraded)
+            presentRecoveryDegraded(true);
         terminalHost.attach(presenter);
     }
     catch (error) {
@@ -294,6 +375,7 @@ export async function composeOwnedUi(options = {}) {
                 exitNotice = import("../app/session-shell/exit-notice.js")
                     .then(module => module.armExitNotice(backend, exitNoticePath), () => null);
             presenter.start();
+            applyResidentTabVisibility();
             void announceNewerRelease().catch(() => undefined);
         },
         flush: () => backend.session.flushEvents(),
@@ -308,6 +390,7 @@ export async function composeOwnedUi(options = {}) {
             finally {
                 // Invariant: the shared spares outlive every shell and stop only after the last one is disposed.
                 clipboardServices?.dispose();
+                removeControllerBoundaryInput();
                 unsubscribeAccent();
                 sessionRuntimeDisposed = true;
                 if (sessionRuntimeRefreshTimer !== null)
@@ -323,6 +406,8 @@ export async function composeOwnedUi(options = {}) {
                 await releaseNoteClaim?.release();
                 suggestionDiagnostics?.dispose();
                 clipboardDiagnostics?.dispose();
+                unsubscribeTabBridge();
+                tabBridge?.close();
                 // Invariant: the host outlives the application; disposing it cancels host-level probes last.
                 await host.dispose();
             }
@@ -330,6 +415,91 @@ export async function composeOwnedUi(options = {}) {
     };
     return { application, settings };
 }
+export async function bindResidentTabBridge(tabBridge, backend, recovery = null, options = {}) {
+    await tabBridge.start().catch(() => false);
+    tabBridge.status("starting");
+    const currentSessionFile = () => currentBackendSessionFile(backend);
+    let pendingAutoName = null;
+    const announceSession = () => {
+        const name = backend.session.view().status.footer?.sessionName ?? null;
+        const nameSource = name === pendingAutoName ? "auto" : name === null || /^agent(?: \d+)?$/i.test(name) ? "default" : "user";
+        tabBridge.session(currentSessionFile(), name, nameSource);
+    };
+    let working = false;
+    let lastTurnFailed = false;
+    let autoNameAttempted = 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,
+            ...(lastTurnFailed ? { stopReason: "error" } : {}),
+        }), false, pendingRequests, queuedInput);
+    };
+    announceSession();
+    const unsubscribeCommands = typeof tabBridge.onCommand === "function" ? tabBridge.onCommand(command => {
+        if (command.type === "visibility") {
+            options.onVisibility?.(command.visible);
+        }
+        else if (command.type === "rename") {
+            void backend.workflows.executeWorkflow({ command: "name", argument: command.name }).catch(() => { });
+        }
+        else if (command.type === "stop") {
+            void backend.session.dispose().catch(() => { });
+        }
+    }) : () => { };
+    const unsubscribeEvents = backend.session.onEvent(event => {
+        if (event.type === "session-lifecycle") {
+            const wasWorking = working;
+            working = event.lifecycle === "busy";
+            if (working)
+                lastTurnFailed = false;
+            reportStatus(event.lifecycle);
+            if (wasWorking && !working && recovery !== null) {
+                void recovery.settled(currentSessionFile()).catch(() => tabBridge.degraded(true));
+            }
+            if (wasWorking && !working && options.autoName === true && !autoNameAttempted) {
+                autoNameAttempted = true;
+                const view = backend.session.view();
+                const currentName = view.status.footer?.sessionName;
+                const prompt = view.transcript.find(block => block.kind === "user")?.text.trim();
+                if (prompt && (currentName == null || /^agent(?: \d+)?$/i.test(currentName))) {
+                    void import("../features/resident-tab/index.js").then(({ generateAutoName }) => generateAutoName(prompt, request => backend.generateResidentTabName(request.prompt, request.maxTokens, request.signal))).then(async (name) => {
+                        pendingAutoName = name;
+                        const result = await backend.workflows.executeWorkflow({ command: "name", argument: name });
+                        if (result.outcome === "completed")
+                            tabBridge.session(currentSessionFile(), name, "auto");
+                        else if (pendingAutoName === name)
+                            pendingAutoName = null;
+                    }).catch(() => { pendingAutoName = null; });
+                }
+            }
+        }
+        if (event.type === "agent-run-settled") {
+            lastTurnFailed = !event.successful && !event.aborted;
+            tabBridge.prompt(event.aborted);
+            reportStatus();
+        }
+        if (event.type === "session-view") {
+            announceSession();
+            reportStatus();
+        }
+    });
+    return () => {
+        unsubscribeCommands();
+        unsubscribeEvents();
+    };
+}
+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}`;
+}
 async function readPackageVersion() {
     const manifest = JSON.parse(await readFile(new URL("../../package.json", import.meta.url), "utf8"));
     const version = manifest?.version;

package/dist/contracts/owned-ui/session-backend.d.ts

@@ -36,6 +36,7 @@ export interface OwnedUiSessionIdentityPort {
     /** Actual session replacements, excluding delivery-only invalidation of callbacks. */
     readonly sessionBindingGeneration: number;
     readonly disposed: boolean;
+    currentSessionFile(): string | null;
     currentSessionResumeMetadata(): OwnedUiSessionResumeMetadata | null;
 }
 /** The session lifecycle, its view, its event stream, and command admission. */

package/dist/features/launch/index.d.ts

@@ -3,7 +3,7 @@ export type { DevelopmentLaunchEnvironment } from "./development-launch.js";
 export { PI_PROFILE_RESOURCE_DIRECTORIES, initializeProductProfile } from "./initialize-profile.js";
 export type { InitializedProfile } from "./initialize-profile.js";
 export { interactiveLaunchIntent, parseSessionSelection } from "./intent.js";
-export type { InteractiveLaunchIntent, LaunchIntent, LaunchProfileId, SessionSelection } from "./intent.js";
+export type { InteractiveLaunchIntent, InteractiveLaunchMode, LaunchIntent, LaunchProfileId, SessionSelection } from "./intent.js";
 export { configurationRootForProfile, resolveLaunchProfilePaths, resolvePromptHistoryDataDir } from "./profile-paths.js";
 export type { LaunchProfilePathOptions, LaunchProfilePaths } from "./profile-paths.js";
 export { prepareInteractiveLaunch } from "./prepare-launch.js";

package/dist/features/launch/intent.d.ts

@@ -3,10 +3,12 @@ import type { LaunchProfileId } from "../../foundation/lifecycle/index.js";
 export { parseSessionSelection } from "../../foundation/lifecycle/index.js";
 export type { SessionSelection } from "../../foundation/lifecycle/index.js";
 export type { LaunchProfileId } from "../../foundation/lifecycle/index.js";
+export type InteractiveLaunchMode = "tabs" | "solo";
 export interface InteractiveLaunchIntent {
     readonly kind: "interactive";
     readonly profileId: LaunchProfileId;
+    readonly launchMode: InteractiveLaunchMode;
     readonly sessionSelection?: SessionSelection;
 }
 export type LaunchIntent = InteractiveLaunchIntent;
-export declare function interactiveLaunchIntent(profileId: LaunchProfileId, sessionSelection?: SessionSelection): InteractiveLaunchIntent;
+export declare function interactiveLaunchIntent(profileId: LaunchProfileId, sessionSelection?: SessionSelection, launchMode?: InteractiveLaunchMode): InteractiveLaunchIntent;

package/dist/features/launch/intent.js

@@ -1,8 +1,11 @@
 import { sessionSelectionArguments } from "../../foundation/lifecycle/index.js";
 export { parseSessionSelection } from "../../foundation/lifecycle/index.js";
-export function interactiveLaunchIntent(profileId, sessionSelection) {
-    if (sessionSelection !== undefined && profileId !== "a1")
-        throw new Error("session selection requires the normal A1 profile");
+export function interactiveLaunchIntent(profileId, sessionSelection, launchMode = profileId === "a1" ? "tabs" : "solo") {
+    if (sessionSelection !== undefined && (profileId !== "a1" || launchMode === "solo")) {
+        throw new Error("session selection requires the normal tabbed A1 launch");
+    }
+    if (profileId === "pi" && launchMode !== "solo")
+        throw new Error("the Pi comparison launch is always solo");
     sessionSelectionArguments(sessionSelection);
-    return Object.freeze({ kind: "interactive", profileId, ...(sessionSelection === undefined ? {} : { sessionSelection }) });
+    return Object.freeze({ kind: "interactive", profileId, launchMode, ...(sessionSelection === undefined ? {} : { sessionSelection }) });
 }