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

package/dist/app/session-shell/session-shell.js

@@ -3,7 +3,7 @@ import { createResponseCopyExecutor, hasAsyncClipboardOutput, responseCopyDestin
 import { MAX_COPY_CONTROL_BYTES } from "./response-copy-protocol.js";
 import { PromptHistoryController } from "./prompt-history-controller.js";
 import { PRODUCT_TEXT } from "../../product-identity.js";
-import { boundedCleanup } from "../../foundation/terminal-cleanup/terminal-reset.js";
+import { CLEAR_EXIT_INTERVAL_MS, boundedCleanup } from "../../foundation/terminal-cleanup/terminal-reset.js";
 import { assertOwnedUiCommand, OWNED_UI_HIDDEN_COMMAND_NAMES } from "../../contracts/owned-ui/index.js";
 import { assertPromptImages, ImageAttachmentError } from "../../contracts/owned-ui/index.js";
 import { ContextualPromptSuggestionController } from "./prompt-suggestion-controller.js";
@@ -34,6 +34,7 @@ export class OwnedUiSessionPresenter {
     #host;
     #terminal;
     #cwd;
+    #residentTabOptions;
     #listeners = new Set();
     #unsubscribe;
     #unsubscribePromptSuggestions;
@@ -53,6 +54,9 @@ export class OwnedUiSessionPresenter {
     #routeHost;
     #startupRoute;
     #startupRouteTimer;
+    #residentProgressTimer;
+    #residentWorking = false;
+    #residentStalled = false;
     #dialogHandle;
     #sequence = 0;
     #editorRevision = 0;
@@ -104,6 +108,7 @@ export class OwnedUiSessionPresenter {
         this.#sessionBindingGeneration = this.backend.identity.sessionBindingGeneration;
         this.#suggestionModelKey = modelKey(this.backend.session.view());
         this.#cwd = cwd;
+        this.#residentTabOptions = options.engine.residentTab;
         this.#routeHost = routeHost ?? null;
         this.#startupRoute = options.engine.startupRoute;
         this.#customViewport = sessionLayout === "custom-viewport";
@@ -202,6 +207,7 @@ export class OwnedUiSessionPresenter {
                 onDequeue: () => this.restoreQueuedInput(),
                 onEditorChange: text => {
                     this.#editorRevision++;
+                    this.#residentTabOptions?.checkpoint?.(text);
                     promptSuggestionController?.abortPending();
                     if (text.length === 0) {
                         // Concurrency: the editor synchronizes deletion-owned autocomplete after onChange.
@@ -218,9 +224,9 @@ export class OwnedUiSessionPresenter {
                     promptSuggestionController?.invalidate();
                     this.#promptHistory?.synchronize();
                 },
-                onCopyText: text => {
+                onCopyText: (text, cut) => {
                     if (this.#responseCopy !== null) {
-                        void this.#responseCopy.submitText(text);
+                        this.#trackCopy(this.#responseCopy.submitText(text), cut ? undefined : text.length);
                         return;
                     }
                     const write = () => {
@@ -263,6 +269,7 @@ export class OwnedUiSessionPresenter {
             // Invariant: the presenter owns its root (theme subscription and helper clients) and disposes it once the
             // terminal no longer renders it.
             constructed.push(() => this.root.dispose());
+            this.#restoreResidentInput();
             const initialPiSettings = this.backend.settings.snapshot();
             this.#programStatus = new ProgramStatusReporter(status => this.#terminal.setProgramStatus(status), () => this.view().status.footer?.sessionName ?? undefined);
             this.#reloadPresentation = reloadPresentation;
@@ -474,6 +481,7 @@ export class OwnedUiSessionPresenter {
                         this.#settleStoppedLifecycle();
                     return;
                 }
+                this.#observeResidentProgress(event);
                 // Performance: a streamed chunk names one block, and touching only that block is what keeps the
                 // cost of a chunk the same in a long session as in a new one. Everything else
                 // resynchronizes the view, which is cheap next to re-reading the transcript.
@@ -626,21 +634,21 @@ export class OwnedUiSessionPresenter {
         const routed = this.root.handleViewportPreInput(data, true, Date.now(), this.root.usesDefaultInputSurface() && !this.#terminal.hasFocusedOverlay());
         if (routed.copySelection !== undefined) {
             const snapshot = routed.copySelection;
-            const acknowledgement = copyAcknowledgement(snapshot);
-            const intent = ++this.#copyIntentSequence;
-            void this.#responseCopy?.submit(snapshot, this.#pendingClipboardWrite).then(result => {
-                if (this.#disposed || !this.#terminal.running || intent !== this.#copyIntentSequence
-                    || result.outcome !== "delivered" && result.outcome !== "submitted-unverified")
-                    return;
-                if (acknowledgement.hasNonWhitespace) {
-                    this.root.showCopyAcknowledgement(`copied ${acknowledgement.characters} chars to clipboard`);
-                }
-            });
+            this.#trackCopy(this.#responseCopy?.submit(snapshot, this.#pendingClipboardWrite), copyCharacters(snapshot));
         }
         if (!routed.consumed)
             return routed.data === data ? undefined : { data: routed.data };
         return routed.data.length === 0 ? { consume: true } : { data: routed.data };
     }
+    #trackCopy(delivery, count) {
+        const intent = ++this.#copyIntentSequence;
+        void delivery?.then(({ outcome }) => {
+            if (count === undefined || this.#disposed || !this.#terminal.running || intent !== this.#copyIntentSequence
+                || outcome !== "delivered" && outcome !== "submitted-unverified")
+                return;
+            this.root.showCopyAcknowledgement(`copied ${count} chars to clipboard`);
+        });
+    }
     #promptSuggestionPresentationBlockReason(identity) {
         const view = this.view();
         if (this.#disposed)
@@ -779,15 +787,38 @@ export class OwnedUiSessionPresenter {
         const type = this.view().lifecycle === "busy" ? "steer" : "prompt";
         this.#rememberInput(this.root.omitUnsentPromptImages(displayInput).trim(), type);
         this.root.resumeViewportFollowing();
-        const finishSending = prepared.images.length === 0 ? () => { } : this.root.beginImageSubmissionStatus();
+        const command = {
+            type,
+            correlationId: this.#correlation(type),
+            sessionId: this.backend.identity.sessionId,
+            text: input,
+            ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
+        };
+        let submission;
         try {
-            return await this.#execute({
-                type,
-                correlationId: this.#correlation(type),
-                sessionId: this.backend.identity.sessionId,
+            submission = await this.#residentTabOptions?.admit?.({
+                sessionId: command.sessionId,
+                sessionFile: this.#currentSessionFile(),
+                kind: type,
                 text: input,
                 ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
-            }, displayInput);
+            });
+        }
+        catch {
+            if (this.root.editor.getText().length === 0)
+                this.root.editor.setText(displayInput);
+            const message = "Prompt was not sent because its recovery journal could not be synchronized.";
+            this.#reportSubmissionError(undefined, message);
+            return rejected(message);
+        }
+        const finishSending = prepared.images.length === 0 ? () => { } : this.root.beginImageSubmissionStatus();
+        try {
+            const result = await this.#execute(command, displayInput);
+            if (submission !== undefined && result.outcome !== "rejected") {
+                this.#residentTabOptions?.dispatched?.();
+                await this.#residentTabOptions?.correlated?.(submission.id, command.correlationId).catch(() => undefined);
+            }
+            return result;
         }
         finally {
             finishSending();
@@ -795,7 +826,7 @@ export class OwnedUiSessionPresenter {
     }
     async clearOrExit(now = Date.now()) {
         this.#promptSuggestions?.abortPending();
-        if (now - this.#lastClearTime < 500)
+        if (now - this.#lastClearTime < CLEAR_EXIT_INTERVAL_MS)
             return this.shutdown();
         this.root.editor.setText("");
         this.#lastClearTime = now;
@@ -1149,10 +1180,23 @@ export class OwnedUiSessionPresenter {
         this.#presenters.openSettingsSelector(this.#dialogHost);
     }
     shutdown() {
-        this.#shutdownPromise ??= this.#shutdown();
+        this.#shutdownPromise ??= this.#shutdown().finally(() => {
+            // Invariant: a rejected resident detach is retryable; ordinary shutdown has disposed the shell already.
+            if (!this.#disposed)
+                this.#shutdownPromise = undefined;
+        });
         return this.#shutdownPromise;
     }
     async #shutdown() {
+        const residentTab = this.#residentTab();
+        if (residentTab !== undefined) {
+            const detached = await residentTab.requestDetach().catch(() => false);
+            if (detached)
+                return { outcome: "completed", diagnostic: null };
+            this.root.appendWorkflowStatus(residentTab.unavailableNotice ?? "Press Ctrl+C twice to leave; this agent keeps running.");
+            this.#terminal.requestRender();
+            return rejected("resident tab detach is unavailable");
+        }
         try {
             const quit = this.backend.workflows.executeWorkflow({ command: "quit", argument: "" });
             // Invariant: a slow or hung engine quit never holds the terminal past the cleanup deadline. The
@@ -1168,6 +1212,75 @@ export class OwnedUiSessionPresenter {
             this.#resolveStoppedLifecycle();
         }
     }
+    #restoreResidentInput() {
+        const recovered = this.#residentTabOptions?.recovered;
+        if (recovered === undefined)
+            return;
+        const prompts = recovered.prompts.map(prompt => prompt.text).filter(Boolean);
+        if (prompts.length > 0) {
+            this.root.editor.setText(prompts[0]);
+            if (recovered.draft)
+                this.root.editor.addToHistory(recovered.draft);
+            for (const additional of prompts.slice(1))
+                this.root.editor.addToHistory(additional);
+            this.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) {
+            this.root.editor.setText(recovered.draft);
+            this.root.appendWorkflowStatus("Recovered the editor draft from the previous tab process.");
+        }
+    }
+    #currentSessionFile() {
+        const direct = this.backend.identity.currentSessionFile?.();
+        if (direct !== undefined && direct !== null)
+            return direct;
+        const resume = this.backend.identity.currentSessionResumeMetadata();
+        return resume === null ? null : `${resume.sessionDir}/${resume.sessionId}`;
+    }
+    #residentTab() {
+        return this.#residentTabOptions;
+    }
+    #observeResidentProgress(event) {
+        const resident = this.#residentTabOptions;
+        const seconds = resident?.stallNoticeSeconds;
+        if (resident === undefined || seconds === undefined)
+            return;
+        if (event.type === "session-lifecycle") {
+            this.#residentWorking = event.lifecycle === "busy";
+            if (!this.#residentWorking) {
+                if (this.#residentProgressTimer !== undefined)
+                    clearTimeout(this.#residentProgressTimer);
+                this.#residentProgressTimer = undefined;
+                this.#residentStalled = false;
+                resident.reportStatus?.("idle");
+                return;
+            }
+        }
+        else if (!this.#residentWorking || ![
+            "transcript-block", "session-view", "assistant-message-completed", "agent-run-started",
+        ].includes(event.type)) {
+            return;
+        }
+        if (this.#residentStalled) {
+            this.#residentStalled = false;
+            resident.reportStatus?.("working");
+        }
+        if (this.#residentProgressTimer !== undefined)
+            clearTimeout(this.#residentProgressTimer);
+        this.#residentProgressTimer = setTimeout(() => {
+            this.#residentProgressTimer = undefined;
+            if (this.#disposed || !this.#residentWorking)
+                return;
+            this.#residentStalled = true;
+            resident.reportStatus?.("stalled");
+            const minutes = Math.max(1, Math.round(seconds / 60));
+            this.root.appendWorkflowStatus(`No progress for ${minutes} min — Esc interrupts · use the tab restart action to restart`);
+            this.#terminal.requestRender();
+        }, seconds * 1_000);
+        this.#residentProgressTimer.unref?.();
+    }
     async runWorkflow(request) {
         if (request.command === "quit")
             return this.shutdown();
@@ -1425,6 +1538,9 @@ export class OwnedUiSessionPresenter {
             if (this.#startupRouteTimer !== undefined)
                 clearTimeout(this.#startupRouteTimer);
             this.#startupRouteTimer = undefined;
+            if (this.#residentProgressTimer !== undefined)
+                clearTimeout(this.#residentProgressTimer);
+            this.#residentProgressTimer = undefined;
         });
         attempt(() => this.#promptSuggestions?.dispose());
         attempt(() => this.#unsubscribePromptSuggestions());
@@ -1461,6 +1577,8 @@ export class OwnedUiSessionPresenter {
             }
             await historyCleanup.catch(() => false); // Security: background durability outcomes never enter terminal output.
             await boundedCleanup(() => pasteCleanup).catch(error => settled.push(error));
+            await boundedCleanup(() => this.#residentTabOptions?.gracefulStop?.(this.#currentSessionFile()) ?? Promise.resolve())
+                .catch(error => settled.push(error));
             await boundedCleanup(() => this.backend.extensions.unbindExtensionUi()).catch(error => settled.push(error));
             return settled;
         };
@@ -1641,7 +1759,8 @@ export class OwnedUiSessionPresenter {
         this.#dialogId = dialog.id;
     }
     hotkeysPresentation() {
-        return this.root.hotkeysPresentation();
+        const presentation = this.root.hotkeysPresentation();
+        return this.#residentTabOptions === undefined ? presentation : { ...presentation, residentTabs: true };
     }
     async #slashCommand(text) {
         const body = text.slice(1).trim();
@@ -1920,16 +2039,15 @@ export class OwnedUiSessionShell extends OwnedUiSessionPresenter {
 function isCoalescedStreamBlock(kind) {
     return kind === "assistant" || kind === "thinking" || kind === "tool-call" || kind === "tool-result";
 }
-function copyAcknowledgement(snapshot) {
+function copyCharacters(snapshot) {
     if (snapshot.literal !== true)
-        return { characters: snapshot.sourceUnits, hasNonWhitespace: true };
-    let characters = Math.max(0, snapshot.rows.length - 1);
-    let hasNonWhitespace = false;
-    for (const row of snapshot.rows) {
-        characters += row.text.length;
-        hasNonWhitespace ||= /\S/u.test(row.text);
-    }
-    return { characters, hasNonWhitespace };
+        return snapshot.sourceUnits;
+    let count = Math.max(0, snapshot.rows.length - 1), hasContent = false;
+    for (const { text } of snapshot.rows) {
+        count += text.length;
+        hasContent ||= /\S/u.test(text);
+    }
+    return hasContent ? count : undefined;
 }
 export function formatSessionResumeCommand(metadata) {
     const args = [PRODUCT_TEXT.commandName];

package/dist/app/session-shell/session-viewport-controller.d.ts

@@ -64,7 +64,7 @@ export declare class SessionViewportController {
     setOverlaySurfaces(surfaces: readonly PiTuiPointerSurface[] | null): void;
     get inputGeometryReady(): boolean;
     compose(input: Omit<TranscriptViewportFrameInput, "pointerPosition">): TranscriptViewportFrame;
-    composeDockOnly(dockRows: readonly string[], width: number, height: number): TranscriptViewportFrame | null;
+    composeDockOnly(dockRows: readonly string[], width: number, height: number, explicitCopyDockRows?: number): TranscriptViewportFrame | null;
     /** Returns true when document wrapping may have changed. */
     setConfig(config: OwnedUiViewportSettings): boolean;
     resumeFollowing(): void;

package/dist/app/session-shell/session-viewport-controller.js

@@ -165,8 +165,8 @@ export class SessionViewportController {
         }
         return frame;
     }
-    composeDockOnly(dockRows, width, height) {
-        return this.#viewport.composeDockOnly(dockRows, width, height);
+    composeDockOnly(dockRows, width, height, explicitCopyDockRows = 0) {
+        return this.#viewport.composeDockOnly(dockRows, width, height, explicitCopyDockRows);
     }
     /** Returns true when document wrapping may have changed. */
     setConfig(config) {
@@ -307,7 +307,7 @@ export class SessionViewportController {
                     this.#requestRender();
             }
             else if (this.#viewport.hasSelection) {
-                const copySelection = this.#viewport.captureSelectedText();
+                const copySelection = this.#viewport.captureSelectedText("explicit");
                 this.#viewport.clearSelection();
                 this.#stopSelectionAutoScroll();
                 this.#requestRender();

package/dist/app/session-shell/shell-host.d.ts

@@ -98,6 +98,8 @@ export declare class OwnedUiTerminalHost implements OwnedUiTerminalHostContract<
     active(): OwnedUiHostedPresenter | null;
     requestRender(from: OwnedUiHostedPresenter, force?: boolean): void;
     start(): void;
+    /** Hidden resident tabs retain engine/status work but stop producing terminal animation frames. */
+    setPresentationVisible(visible: boolean): void;
     /** Closes one presenter. Closing the last one ends the terminal. */
     close(presenter: OwnedUiHostedPresenter): Promise<void>;
     dispose(): Promise<void>;

package/dist/app/session-shell/shell-host.js

@@ -42,6 +42,8 @@ export class OwnedUiTerminalHost {
     #focused = false;
     #pointerReporting = false;
     #started = false;
+    #presentationVisible = true;
+    #releaseVisibilityHold;
     #ending;
     constructor(options) {
         this.#customViewport = options.layout === "custom-viewport";
@@ -147,7 +149,7 @@ export class OwnedUiTerminalHost {
         return this.#active;
     }
     requestRender(from, force = false) {
-        if (from === this.#active)
+        if (this.#presentationVisible && from === this.#active)
             this.runtime.requestRender(force);
     }
     start() {
@@ -155,9 +157,26 @@ export class OwnedUiTerminalHost {
             return;
         this.#started = true;
         this.runtime.start();
+        if (!this.#presentationVisible)
+            this.#releaseVisibilityHold = this.runtime.beginPresentationHold();
         if (this.#customViewport)
             this.#setPointerReporting(true);
     }
+    /** Hidden resident tabs retain engine/status work but stop producing terminal animation frames. */
+    setPresentationVisible(visible) {
+        if (this.#presentationVisible === visible)
+            return;
+        this.#presentationVisible = visible;
+        if (!this.#started || this.#ending !== undefined)
+            return;
+        if (visible) {
+            this.#releaseVisibilityHold?.();
+            this.#releaseVisibilityHold = undefined;
+        }
+        else if (this.#releaseVisibilityHold === undefined) {
+            this.#releaseVisibilityHold = this.runtime.beginPresentationHold();
+        }
+    }
     /** Closes one presenter. Closing the last one ends the terminal. */
     close(presenter) {
         if (this.#ending !== undefined || !this.#presenters.has(presenter))

package/dist/cli/dispatch.d.ts

@@ -1,7 +1,8 @@
-import { type InteractiveLaunchIntent, type LaunchProfileId, type SessionSelection } from "../features/launch/index.js";
+import { type InteractiveLaunchIntent, type InteractiveLaunchMode, type LaunchProfileId, type SessionSelection } from "../features/launch/index.js";
 import type { CliCapabilities } from "./capabilities.js";
 import type { PackageCommandRequest } from "./packages.js";
 import type { SessionContextRequest } from "./session-context.js";
+import type { TabsRequest } from "./tabs-request.js";
 import { type PackageCliVerb, type PackageCommandNamespace, type PackageSyntaxDiagnostic } from "./package-messages.js";
 export type UpdateChannel = "stable" | "next";
 export interface CliHandlers {
@@ -10,6 +11,7 @@ export interface CliHandlers {
     readonly update: (channel: UpdateChannel, target?: string) => Promise<number>;
     readonly packages: (request: PackageCommandRequest) => Promise<number>;
     readonly sessionContext: (request: SessionContextRequest) => Promise<number>;
+    readonly tabs: (request: TabsRequest) => Promise<number>;
 }
 export interface CliOutput {
     readonly stdout: (message: string) => void;
@@ -17,6 +19,8 @@ export interface CliOutput {
 }
 export declare function cliUsage(capabilities: CliCapabilities): string;
 export declare function cliHelp(capabilities: CliCapabilities): string;
+/** Focused help for the resident-tab maintenance forms; printing it contacts no host. */
+export declare function tabsHelp(): string;
 export declare function dispatchCli(arguments_: readonly string[], handlers: CliHandlers, output: CliOutput, capabilities: CliCapabilities): Promise<number>;
 export type CliCommand = {
     readonly kind: "noop";
@@ -33,6 +37,7 @@ export type CliCommand = {
 } | {
     readonly kind: "launch";
     readonly profileId: LaunchProfileId;
+    readonly launchMode: InteractiveLaunchMode;
     readonly sessionSelection?: SessionSelection;
 } | {
     readonly kind: "version";
@@ -46,6 +51,11 @@ export type CliCommand = {
 } | {
     readonly kind: "session-context";
     readonly request: SessionContextRequest;
+} | {
+    readonly kind: "tabs";
+    readonly request: TabsRequest;
+} | {
+    readonly kind: "tabs-help";
 } | {
     readonly kind: "error";
     readonly message: string;

package/dist/cli/dispatch.js

@@ -6,6 +6,7 @@ export function cliUsage(capabilities) {
         "",
         "--session <path|id>",
         "--session-dir <dir> --session <path|id>",
+        "solo",
         ...(capabilities.developmentComparison ? ["pi"] : []),
         "help",
         "version",
@@ -21,6 +22,10 @@ export function cliUsage(capabilities) {
         "session worktrees",
         "session link-worktree <path>",
         "session unlink-worktree",
+        "tabs",
+        "tabs stop <id>|--all",
+        "tabs host status|stop",
+        "tabs doctor",
     ]);
 }
 export function cliHelp(capabilities) {
@@ -30,6 +35,7 @@ export function cliHelp(capabilities) {
         `  ${command}`,
         `  ${command} --session <path|id>`,
         `  ${command} --session-dir <dir> --session <path|id>`,
+        `  ${command} solo`,
         ...(capabilities.developmentComparison ? [`  ${command} pi`] : []),
         `  ${command} help`,
         `  ${command} version`,
@@ -52,9 +58,32 @@ export function cliHelp(capabilities) {
         `  ${command} session link-worktree <path>`,
         `  ${command} session unlink-worktree`,
         "",
+        "Tabs:",
+        `  ${command} tabs`,
+        `  ${command} tabs stop <id>|--all`,
+        `  ${command} tabs host status|stop`,
+        `  ${command} tabs doctor`,
+        "",
+    ].join("\n");
+}
+/** Focused help for the resident-tab maintenance forms; printing it contacts no host. */
+export function tabsHelp() {
+    const command = PRODUCT_TEXT.commandName;
+    return [
+        "Resident tabs:",
+        `  ${command} tabs                    List running tabs`,
+        `  ${command} tabs stop <id>          Stop one tab; its session stays resumable`,
+        `  ${command} tabs stop --all         Stop every tab and keep the host`,
+        `  ${command} tabs host status        Show host identity, limits, and health counters`,
+        `  ${command} tabs host stop          Stop every tab and the host`,
+        `  ${command} tabs doctor             Write a redacted diagnostic bundle`,
+        "",
+        "Options:",
+        "  --json                     Print the versioned machine-readable report",
+        "",
     ].join("\n");
 }
-const PROFILE_WORDS = new Set(["pi"]);
+const PROFILE_WORDS = new Set(["pi", "solo"]);
 export async function dispatchCli(arguments_, handlers, output, capabilities) {
     const command = parseCliCommand(arguments_, capabilities);
     if (command.kind === "noop")
@@ -76,23 +105,29 @@ export async function dispatchCli(arguments_, handlers, output, capabilities) {
         return 2;
     }
     if (command.kind === "launch")
-        return await handlers.launch(interactiveLaunchIntent(command.profileId, command.sessionSelection));
+        return await handlers.launch(interactiveLaunchIntent(command.profileId, command.sessionSelection, command.launchMode));
     if (command.kind === "version")
         return await handlers.version();
     if (command.kind === "packages")
         return await handlers.packages(command.request);
     if (command.kind === "session-context")
         return await handlers.sessionContext(command.request);
+    if (command.kind === "tabs-help") {
+        output.stdout(tabsHelp());
+        return 0;
+    }
+    if (command.kind === "tabs")
+        return await handlers.tabs(command.request);
     return await handlers.update(command.channel, command.target);
 }
 export function parseCliCommand(arguments_, capabilities) {
     if (arguments_.length === 0)
-        return { kind: "launch", profileId: "a1" };
+        return { kind: "launch", profileId: "a1", launchMode: "tabs" };
     const [command, ...rest] = arguments_;
     if (command === "--session" || command === "--session-dir") {
         try {
             const sessionSelection = parseSessionSelection(arguments_);
-            return { kind: "launch", profileId: "a1", ...(sessionSelection === undefined ? {} : { sessionSelection }) };
+            return { kind: "launch", profileId: "a1", launchMode: "tabs", ...(sessionSelection === undefined ? {} : { sessionSelection }) };
         }
         catch (error) {
             return { kind: "error", message: PRODUCT_TEXT.diagnostic(`could not parse session launch: ${error instanceof Error ? error.message : String(error)}`) };
@@ -108,18 +143,57 @@ export function parseCliCommand(arguments_, capabilities) {
     if (command === "pi") {
         if (rest.length > 0)
             return parsePackageCommand(rest, "pi");
-        return capabilities.developmentComparison ? { kind: "launch", profileId: "pi" } : { kind: "noop" };
+        return capabilities.developmentComparison ? { kind: "launch", profileId: "pi", launchMode: "solo" } : { kind: "noop" };
     }
+    if (command === "solo")
+        return withoutArguments(rest, { kind: "launch", profileId: "a1", launchMode: "solo" });
     if (command === "update")
         return parseUpdate(rest);
     if (command === "session")
         return parseSessionContext(rest);
+    if (command === "tabs")
+        return parseTabs(rest);
     if (command?.startsWith("update:"))
         return { kind: "noop" };
     // Rationale: unsupported and reserved command spaces are deliberately quiet. Help is
     // explicit, and a typo must never start an interactive or maintenance path.
     return { kind: "noop" };
 }
+/** Parses `a1 tabs` before any I/O; a malformed form fails with one line and contacts no host. */
+function parseTabs(rest) {
+    if (rest.some(value => value === "--help" || value === "-h"))
+        return { kind: "tabs-help" };
+    const json = rest.includes("--json");
+    const words = rest.filter(value => value !== "--json");
+    const fail = (detail) => ({ kind: "error", message: PRODUCT_TEXT.diagnostic(`could not parse tabs: ${detail}`) });
+    const [action, value, extra] = words;
+    if (action === undefined)
+        return { kind: "tabs", request: { action: "list", json } };
+    if (action === "stop") {
+        if (value === undefined)
+            return fail("stop requires a tab id or --all.");
+        if (extra !== undefined)
+            return fail("stop accepts one tab id or --all.");
+        if (value === "--all")
+            return { kind: "tabs", request: { action: "stop-all", json } };
+        if (value.startsWith("-"))
+            return fail(`unknown option ${value}.`);
+        return { kind: "tabs", request: { action: "stop", tabId: value, json } };
+    }
+    if (action === "host") {
+        if (extra !== undefined || (value !== "status" && value !== "stop"))
+            return fail("host accepts status or stop.");
+        return { kind: "tabs", request: { action: value === "status" ? "host-status" : "host-stop", json } };
+    }
+    if (action === "doctor") {
+        if (value !== undefined)
+            return fail("doctor does not accept arguments.");
+        return { kind: "tabs", request: { action: "doctor", json } };
+    }
+    if (action.startsWith("-"))
+        return fail(`unknown option ${action}.`);
+    return fail(`unknown subcommand ${action}; use list, stop, host, or doctor.`);
+}
 function parseSessionContext(rest) {
     const [action, value, extra] = rest;
     if (action === "link-worktree") {

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

@@ -0,0 +1,7 @@
+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

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

package/dist/cli/tabs.d.ts

@@ -0,0 +1,14 @@
+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 running package root; its terminal host is a candidate after the active 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>;