@timurproko/a1 0.2.7-dev.767 → 0.2.7-dev.779

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

@@ -19,6 +19,7 @@ import { ResidentTabRecovery } from "../foundation/resident-tabs/recovery.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 {
@@ -40,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.
@@ -63,7 +66,7 @@ export interface OwnedUiCompositionOptions {
         readonly dataDir: string;
         readonly incarnation: number;
     };
-    /** One prompt-adjacent notice explaining why an opted-in resident launch fell back. */
+    /** One prompt-adjacent notice explaining why a resident launch fell back. */
     readonly residentFallbackNotice?: string;
 }
 export interface OwnedUiComposition {
@@ -82,4 +85,7 @@ export declare function residentStartupPresentation(resident: boolean, fallbackN
 };
 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">, recovery?: Pick<ResidentTabRecovery, "settled"> | null): Promise<() => void>;
+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

@@ -19,6 +19,7 @@ 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)
@@ -99,9 +100,22 @@ export async function composeOwnedUi(options = {}) {
             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)))({
@@ -114,22 +128,30 @@ 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;
     }
-    const tabBridge = options.tab?.bridge ?? null;
     let recoveryDegraded = false;
     let presentRecoveryDegraded = (_degraded) => { };
     const tabRecovery = options.tab === undefined ? null : new ResidentTabRecovery(options.tab.dataDir, {
@@ -140,7 +162,15 @@ export async function composeOwnedUi(options = {}) {
         },
     });
     const recoveredTabInput = await tabRecovery?.initialize(currentBackendSessionFile(backend), backend.identity.sessionId);
-    const unsubscribeTabBridge = tabBridge === null ? () => { } : await bindResidentTabBridge(tabBridge, backend, tabRecovery);
+    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) {
@@ -163,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) => {
@@ -251,9 +285,8 @@ export async function composeOwnedUi(options = {}) {
                 ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
                 ...(tabBridge === null || tabRecovery === null ? {} : { residentTab: {
                         requestDetach: () => tabBridge.requestDetach(),
-                        requestRestart: () => tabBridge.requestRestart(),
                         reportStatus: status => tabBridge.status(status),
-                        stallNoticeSeconds: settings?.value("tabsStallNoticeSeconds") ?? 300,
+                        stallNoticeSeconds: 300,
                         admit: input => tabRecovery.admit({ ...input, incarnation: options.tab.incarnation }),
                         dispatched: () => tabRecovery.dispatched(),
                         correlated: (submissionId, entryId) => tabRecovery.correlated(submissionId, entryId),
@@ -288,6 +321,12 @@ 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)
@@ -336,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(),
@@ -350,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)
@@ -374,27 +415,83 @@ export async function composeOwnedUi(options = {}) {
     };
     return { application, settings };
 }
-export async function bindResidentTabBridge(tabBridge, backend, recovery = null) {
+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 = () => {
-        tabBridge.session(currentSessionFile(), backend.session.view().status.footer?.sessionName ?? null);
+        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();
-    return backend.session.onEvent(event => {
+    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";
-            tabBridge.status(working ? "working" : event.lifecycle === "starting" ? "starting" : "idle");
+            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")
+        if (event.type === "session-view") {
             announceSession();
+            reportStatus();
+        }
     });
+    return () => {
+        unsubscribeCommands();
+        unsubscribeEvents();
+    };
 }
 function currentBackendSessionFile(backend) {
     const direct = backend.identity.currentSessionFile?.();

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 }) });
 }

package/dist/features/resident-tab/auto-name.d.ts

@@ -0,0 +1,11 @@
+export declare const AUTO_NAME_MAX_LENGTH = 16;
+export declare const AUTO_NAME_TIMEOUT_MS = 10000;
+export declare const AUTO_NAME_MAX_TOKENS = 64;
+export declare function normalizeAutoName(value: string): string | null;
+export declare function fallbackAutoName(prompt: string): string;
+export interface AutoNameCompletion {
+    readonly prompt: string;
+    readonly maxTokens: number;
+    readonly signal: AbortSignal;
+}
+export declare function generateAutoName(firstPrompt: string, complete: (request: AutoNameCompletion) => Promise<string | null>, timeoutMs?: number): Promise<string>;

package/dist/features/resident-tab/auto-name.js

@@ -0,0 +1,42 @@
+export const AUTO_NAME_MAX_LENGTH = 16;
+export const AUTO_NAME_TIMEOUT_MS = 10_000;
+export const AUTO_NAME_MAX_TOKENS = 64;
+export function normalizeAutoName(value) {
+    const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+    if (!normalized)
+        return null;
+    if (normalized.length <= AUTO_NAME_MAX_LENGTH)
+        return normalized;
+    const clipped = normalized.slice(0, AUTO_NAME_MAX_LENGTH + 1);
+    const boundary = clipped.lastIndexOf("-");
+    const result = (boundary >= 4 ? clipped.slice(0, boundary) : normalized.slice(0, AUTO_NAME_MAX_LENGTH)).replace(/-+$/g, "");
+    return result || null;
+}
+export function fallbackAutoName(prompt) {
+    const words = prompt.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+    return normalizeAutoName(words.slice(0, 3).join("-")) ?? "new-task";
+}
+export async function generateAutoName(firstPrompt, complete, timeoutMs = AUTO_NAME_TIMEOUT_MS) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        timer.unref?.();
+        try {
+            const response = await complete({
+                prompt: `Name this coding task with a lowercase hyphenated title of at most ${AUTO_NAME_MAX_LENGTH} characters. Reply only with the title.\n\n${firstPrompt.slice(0, 500)}`,
+                maxTokens: AUTO_NAME_MAX_TOKENS,
+                signal: controller.signal,
+            });
+            const name = response === null ? null : normalizeAutoName(response);
+            if (name !== null)
+                return name;
+        }
+        catch {
+            // Rationale: naming is best effort; one retry precedes the deterministic fallback.
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    return fallbackAutoName(firstPrompt);
+}

package/dist/features/resident-tab/index.d.ts

@@ -0,0 +1,3 @@
+export { AUTO_NAME_MAX_LENGTH, AUTO_NAME_MAX_TOKENS, AUTO_NAME_TIMEOUT_MS, fallbackAutoName, generateAutoName, normalizeAutoName, type AutoNameCompletion, } from "./auto-name.js";
+export { RESIDENT_TAB_SHORTCUTS, residentTabShortcutRegistry, type ResidentTabAction, type ResidentTabShortcut, } from "./shortcuts.js";
+export { deriveResidentTabStatus, type ResidentTabDerivedStatus, type ResidentTabFacts, } from "./status-deriver.js";

package/dist/features/resident-tab/index.js

@@ -0,0 +1,3 @@
+export { AUTO_NAME_MAX_LENGTH, AUTO_NAME_MAX_TOKENS, AUTO_NAME_TIMEOUT_MS, fallbackAutoName, generateAutoName, normalizeAutoName, } from "./auto-name.js";
+export { RESIDENT_TAB_SHORTCUTS, residentTabShortcutRegistry, } from "./shortcuts.js";
+export { deriveResidentTabStatus, } from "./status-deriver.js";

package/dist/features/resident-tab/shortcuts.d.ts

@@ -0,0 +1,10 @@
+import { ShortcutRegistry } from "../../ui/components/index.js";
+export type ResidentTabAction = "tabs.new" | "tabs.close" | "tabs.rename" | "tabs.retry" | "tabs.fresh" | "tabs.next" | "tabs.previous" | "tabs.moveRight" | "tabs.moveLeft" | `tabs.jump${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}`;
+export interface ResidentTabShortcut {
+    readonly id: ResidentTabAction;
+    readonly defaultKey: string | null;
+    readonly scope: "global" | "failed-banner";
+    readonly description: string;
+}
+export declare const RESIDENT_TAB_SHORTCUTS: readonly ResidentTabShortcut[];
+export declare function residentTabShortcutRegistry(assignments?: Readonly<Partial<Record<ResidentTabAction, string | null>>>): ShortcutRegistry<ResidentTabAction>;

package/dist/features/resident-tab/shortcuts.js

@@ -0,0 +1,35 @@
+import { GLOBAL_SCOPE, ShortcutRegistry } from "../../ui/components/index.js";
+const jumps = Array.from({ length: 10 }, (_, index) => ({
+    id: `tabs.jump${index + 1}`,
+    defaultKey: `alt+${(index + 1) % 10}`,
+    scope: "global",
+    description: `View A1 tab ${index + 1}`,
+}));
+export const RESIDENT_TAB_SHORTCUTS = Object.freeze([
+    { id: "tabs.new", defaultKey: "alt+a", scope: "global", description: "New A1 tab" },
+    { id: "tabs.close", defaultKey: "alt+w", scope: "global", description: "Close A1 tab" },
+    { id: "tabs.rename", defaultKey: "f2", scope: "global", description: "Rename A1 tab" },
+    ...jumps,
+    { id: "tabs.next", defaultKey: null, scope: "global", description: "View next A1 tab" },
+    { id: "tabs.previous", defaultKey: null, scope: "global", description: "View previous A1 tab" },
+    { id: "tabs.moveRight", defaultKey: null, scope: "global", description: "Move A1 tab right" },
+    { id: "tabs.moveLeft", defaultKey: null, scope: "global", description: "Move A1 tab left" },
+    { id: "tabs.retry", defaultKey: "r", scope: "failed-banner", description: "Retry failed A1 tab" },
+    { id: "tabs.fresh", defaultKey: "f", scope: "failed-banner", description: "Start failed A1 tab fresh" },
+]);
+export function residentTabShortcutRegistry(assignments = {}) {
+    const registry = new ShortcutRegistry();
+    for (const shortcut of RESIDENT_TAB_SHORTCUTS) {
+        const key = assignments[shortcut.id] === undefined ? shortcut.defaultKey : assignments[shortcut.id];
+        if (!key)
+            continue;
+        const declaration = {
+            key,
+            scope: shortcut.scope === "global" ? GLOBAL_SCOPE : shortcut.scope,
+            section: "Tabs",
+            description: shortcut.description,
+        };
+        registry.declare(declaration, shortcut.id);
+    }
+    return registry;
+}

package/dist/features/resident-tab/status-deriver.d.ts

@@ -0,0 +1,9 @@
+export type ResidentTabDerivedStatus = "starting" | "working" | "needs-input" | "done-unseen" | "idle" | "failed";
+export interface ResidentTabFacts {
+    readonly lifecycle: string;
+    readonly pendingRequests: number;
+    readonly queuedInput: number;
+    readonly stopReason?: string;
+    readonly settledUnseen?: boolean;
+}
+export declare function deriveResidentTabStatus(facts: ResidentTabFacts): ResidentTabDerivedStatus;

package/dist/features/resident-tab/status-deriver.js

@@ -0,0 +1,15 @@
+export function deriveResidentTabStatus(facts) {
+    if (facts.lifecycle === "failed")
+        return "failed";
+    if (facts.pendingRequests > 0)
+        return "needs-input";
+    if (facts.lifecycle === "busy" || facts.queuedInput > 0)
+        return "working";
+    if (facts.lifecycle === "starting")
+        return "starting";
+    if (facts.stopReason === "error")
+        return "failed";
+    if (facts.settledUnseen === true)
+        return "done-unseen";
+    return "idle";
+}

package/dist/foundation/launch-context/index.d.ts

@@ -6,6 +6,7 @@ export declare const PRIVATE_ENVIRONMENT: Readonly<{
     releaseDigest: "LAUNCH_CONTEXT_RELEASE_DIGEST";
     releaseLayers: "LAUNCH_CONTEXT_RELEASE_LAYERS";
     launchProfile: "LAUNCH_CONTEXT_PROFILE";
+    launchMode: "LAUNCH_CONTEXT_MODE";
     immutableWarmup: "LAUNCH_CONTEXT_WARMUP";
     residentRootExecutable: "LAUNCH_CONTEXT_RESIDENT_ROOT_EXECUTABLE";
     residentRootArguments: "LAUNCH_CONTEXT_RESIDENT_ROOT_ARGUMENTS";
@@ -33,11 +34,14 @@ export interface LaunchContext {
     readonly releaseDigest?: string;
     readonly releaseLayers?: string;
     readonly launchProfile?: "a1" | "pi";
+    readonly launchMode?: "tabs" | "solo";
     readonly immutableWarmup?: "1";
     readonly residentRootExecutable?: string;
     readonly residentRootArguments?: string;
     readonly residentFallback?: string;
 }
+/** The Tabs settings configure resident tabs; a direct-route launch, by `a1 solo` or by a fallback, hides them. */
+export declare function hidesTabSettings(context: Pick<LaunchContext, "launchMode" | "residentFallback">): boolean;
 export type LaunchContextRequirement = "optional" | "profile" | "release" | "warmup";
 /** Read current keys, fall back to superseded keys per field, with bounded diagnostics. */
 export declare function readLaunchContext(environment: NodeJS.ProcessEnv, requirement?: LaunchContextRequirement, platform?: NodeJS.Platform): LaunchContext;

package/dist/foundation/launch-context/index.js

@@ -6,6 +6,7 @@ export const PRIVATE_ENVIRONMENT = Object.freeze({
     releaseDigest: "LAUNCH_CONTEXT_RELEASE_DIGEST",
     releaseLayers: "LAUNCH_CONTEXT_RELEASE_LAYERS",
     launchProfile: "LAUNCH_CONTEXT_PROFILE",
+    launchMode: "LAUNCH_CONTEXT_MODE",
     immutableWarmup: "LAUNCH_CONTEXT_WARMUP",
     residentRootExecutable: "LAUNCH_CONTEXT_RESIDENT_ROOT_EXECUTABLE",
     residentRootArguments: "LAUNCH_CONTEXT_RESIDENT_ROOT_ARGUMENTS",
@@ -30,6 +31,10 @@ const SUPERSEDED_ENTRIES = Object.entries(SUPERSEDED_ENVIRONMENT);
 const PRIVATE_KEYS = new Set([...Object.values(PRIVATE_ENVIRONMENT), ...Object.values(SUPERSEDED_ENVIRONMENT)]);
 const LOGICAL_KEYS = new Map(PRIVATE_ENTRIES.map(([logical, key]) => [key, logical]));
 const SUPERSEDED_LOGICAL_KEYS = new Map(SUPERSEDED_ENTRIES.map(([logical, key]) => [key, logical]));
+/** The Tabs settings configure resident tabs; a direct-route launch, by `a1 solo` or by a fallback, hides them. */
+export function hidesTabSettings(context) {
+    return context.launchMode === "solo" || context.residentFallback !== undefined;
+}
 /** Read current keys, fall back to superseded keys per field, with bounded diagnostics. */
 export function readLaunchContext(environment, requirement = "optional", platform = process.platform) {
     const values = {};
@@ -64,6 +69,11 @@ export function readLaunchContext(environment, requirement = "optional", platfor
     if (values.launchProfile !== undefined && values.launchProfile !== "a1" && values.launchProfile !== "pi") {
         throw invalidContext("launchProfile", "unsupported profile");
     }
+    if (values.launchMode !== undefined && values.launchMode !== "tabs" && values.launchMode !== "solo") {
+        throw invalidContext("launchMode", "unsupported launch mode");
+    }
+    if (values.launchProfile === "pi" && values.launchMode === "tabs")
+        throw invalidContext("launchMode", "Pi comparison cannot use tabs");
     if (values.immutableWarmup !== undefined && values.immutableWarmup !== "1")
         throw invalidContext("immutableWarmup", "invalid permission flag");
     if ((values.residentRootExecutable === undefined) !== (values.residentRootArguments === undefined))