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

package/dist/integrations/pi/engine/workflow-share.d.ts

@@ -0,0 +1,9 @@
+import type { AgentSession, AgentSessionRuntime } from "../startup-public.js";
+import type { PiWorkflowHost, PiWorkflowRequest, PiWorkflowResult } from "./workflows.js";
+export interface PiShareCall {
+    readonly request: PiWorkflowRequest;
+    readonly session: AgentSession;
+    readonly runtime: AgentSessionRuntime;
+    readonly host: PiWorkflowHost;
+}
+export declare function runShareWorkflow({ request, session, runtime, host }: PiShareCall): Promise<PiWorkflowResult>;

package/dist/integrations/pi/engine/workflow-share.js

@@ -0,0 +1,168 @@
+/**
+ * Pinned Pi's `/share` workflow: the Radius artifact route with a gist fallback. The runner loads
+ * this module on the first `/share`, so its network clients stay off the startup path.
+ */
+import { randomUUID } from "node:crypto";
+import { readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { PRODUCT_IDENTITY } from "../../../product-identity.js";
+import { isRecord, requireCapability, stringProperty } from "./message-values.js";
+import { commandMissing, errorMessage, isAbortError, workflowResult } from "./workflow-support.js";
+// Provenance: the pinned engine's modes/interactive/session-share.ts Radius route and the model
+// runtime's DEFAULT_RADIUS_GATEWAY; neither is in the public API, so each upgrade re-checks them.
+const RADIUS_SHARE_GATEWAY = "https://radius.pi.dev";
+const RADIUS_AUTH_MIN_VALIDITY_MS = 5 * 60_000;
+export async function runShareWorkflow({ request, session, runtime, host }) {
+    const signal = request.signal;
+    if (signal?.aborted)
+        return shareCancelled(request);
+    const destination = runtime.services.settingsManager?.getSessionShareDestination?.() ?? "auto";
+    if (destination !== "gist") {
+        const radius = await shareViaRadius({ request, session, runtime, host });
+        if (radius !== undefined)
+            return radius;
+        if (destination === "radius")
+            return workflowResult(request.command, "failed", "Radius authentication is not configured. Run '/login radius' first.");
+    }
+    request.onProgress?.("Creating gist…");
+    try {
+        await host.runCommand("gh", ["auth", "status"], signal === undefined ? undefined : { signal });
+    }
+    catch (error) {
+        if (signal?.aborted || isAbortError(error))
+            return shareCancelled(request);
+        const message = commandMissing(error)
+            ? "GitHub CLI (gh) is not installed. Install it from https://cli.github.com/"
+            : "GitHub CLI is not logged in. Run 'gh auth login' first.";
+        return workflowResult(request.command, "failed", message);
+    }
+    const temporary = join(tmpdir(), `${PRODUCT_IDENTITY.filesystem.temporaryPrefix}pi-session-${process.pid}.html`);
+    try {
+        try {
+            await requireCapability(session.exportToHtml, "exportToHtml").call(session, temporary);
+        }
+        catch (error) {
+            return workflowResult(request.command, "failed", `Failed to export session: ${errorMessage(error, "Unknown error")}`);
+        }
+        if (signal?.aborted)
+            return shareCancelled(request);
+        let gist;
+        try {
+            gist = await host.runCommand("gh", ["gist", "create", "--public=false", temporary], signal === undefined ? undefined : { signal });
+        }
+        catch (error) {
+            if (signal?.aborted || isAbortError(error))
+                return shareCancelled(request);
+            return workflowResult(request.command, "failed", `Failed to create gist: ${shareCommandFailureDetail(error)}`);
+        }
+        if (signal?.aborted)
+            return shareCancelled(request);
+        const gistUrl = gist.stdout.trim();
+        const gistId = gistUrl.split("/").at(-1);
+        if (!gistId)
+            return workflowResult(request.command, "failed", "Failed to parse gist ID from gh output");
+        return workflowResult(request.command, "completed", `Share URL: ${shareViewerUrl(gistId)}`, gistUrl);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+function shareCancelled(request) {
+    return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
+}
+// Protocol: the pinned Radius `/share` route. Undefined means Radius has no provider or credential,
+// so the caller may fall back to a gist; any other outcome, including an upload failure, is final.
+async function shareViaRadius({ request, session, runtime, host }) {
+    const signal = request.signal;
+    const models = runtime.services.modelRuntime;
+    if (models.getProvider?.("radius") === undefined)
+        return undefined;
+    const token = radiusAuthCredential(await models.getAuth("radius", { minOAuthValidityMs: RADIUS_AUTH_MIN_VALIDITY_MS }));
+    if (!token)
+        return undefined;
+    if (signal?.aborted)
+        return shareCancelled(request);
+    request.onProgress?.("Uploading to Radius…");
+    const temporary = join(tmpdir(), `${PRODUCT_IDENTITY.filesystem.temporaryPrefix}pi-session-${process.pid}.jsonl`);
+    let body;
+    try {
+        requireCapability(session.exportToJsonl, "exportToJsonl").call(session, temporary);
+        body = withRadiusShareTrailingEntry(await readFile(temporary, "utf8"), session.state ?? {}, randomUUID().slice(0, 8));
+    }
+    catch (error) {
+        return workflowResult(request.command, "failed", `Failed to export session: ${errorMessage(error, "Unknown error")}`);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    const url = new URL("/v1/artifacts", RADIUS_SHARE_GATEWAY);
+    url.searchParams.set("visibility", "organization");
+    url.searchParams.set("title", "Pi session");
+    try {
+        const response = await (host.fetch ?? fetch)(url, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/x-ndjson" },
+            body,
+            ...(signal === undefined ? {} : { signal }),
+        });
+        const json = await response.json().catch(() => null);
+        if (signal?.aborted)
+            return shareCancelled(request);
+        const artifact = isRecord(json) && isRecord(json.artifact) ? json.artifact : undefined;
+        const shareUrl = artifact === undefined ? undefined : stringProperty(artifact, "canonical_url");
+        if (!response.ok || shareUrl === undefined) {
+            const detail = (isRecord(json) ? stringProperty(json, "error") : undefined) || response.statusText || String(response.status);
+            return workflowResult(request.command, "failed", `Failed to upload Radius artifact: ${detail}`);
+        }
+        return workflowResult(request.command, "completed", `Share URL: ${shareUrl}`);
+    }
+    catch (error) {
+        if (signal?.aborted || isAbortError(error))
+            return shareCancelled(request);
+        return workflowResult(request.command, "failed", `Failed to upload Radius artifact: ${errorMessage(error, "Unknown error")}`);
+    }
+}
+function shareCommandFailureDetail(error) {
+    // Compatibility: Pi reports a failed child's stderr, not execFile's command wrapper.
+    if (isRecord(error) && (typeof error.code === "number" || typeof error.signal === "string") && typeof error.stderr === "string") {
+        return error.stderr.trim() || "Unknown error";
+    }
+    return errorMessage(error, "Unknown error");
+}
+function shareViewerUrl(gistId) {
+    const baseUrl = process.env.PI_SHARE_VIEWER_URL || "https://pi.dev/session/";
+    return `${baseUrl}#${gistId}`;
+}
+/** The bearer token in a model-runtime auth result: an API key or an `Authorization: Bearer` header. */
+function radiusAuthCredential(auth) {
+    const resolved = isRecord(auth) && isRecord(auth.auth) ? auth.auth : undefined;
+    if (resolved === undefined)
+        return undefined;
+    if (typeof resolved.apiKey === "string" && resolved.apiKey)
+        return resolved.apiKey;
+    const headers = isRecord(resolved.headers) ? resolved.headers : {};
+    const authorization = Object.entries(headers).find(([name]) => name.toLowerCase() === "authorization")?.[1];
+    return typeof authorization === "string" ? /^Bearer\s+(.+)$/iu.exec(authorization)?.[1] : undefined;
+}
+/**
+ * Append the pinned `pi.share` trailing entry (system prompt and tool schemas for the session viewer)
+ * to a branch JSONL export. It chains to the last exported entry and reuses the header timestamp.
+ */
+function withRadiusShareTrailingEntry(jsonl, state, id) {
+    const lines = jsonl.split("\n").filter(line => line.length > 0);
+    const header = lines[0] === undefined ? undefined : JSON.parse(lines[0]);
+    const last = lines.length > 1 ? JSON.parse(lines.at(-1)) : undefined;
+    const entry = {
+        type: "custom",
+        customType: "pi.share",
+        id,
+        parentId: isRecord(last) && typeof last.id === "string" ? last.id : null,
+        timestamp: isRecord(header) && typeof header.timestamp === "string" ? header.timestamp : new Date().toISOString(),
+        data: {
+            systemPrompt: state.systemPrompt,
+            tools: (state.tools ?? []).filter(isRecord).map(tool => ({ name: tool.name, description: tool.description, parameters: tool.parameters })),
+        },
+    };
+    return `${[...lines, JSON.stringify(entry)].join("\n")}\n`;
+}

package/dist/integrations/pi/engine/workflow-support.d.ts

@@ -7,33 +7,14 @@ export declare function pinnedSessionInfoPresentation(value: unknown, sessionNam
     readonly mode: unknown;
     readonly status: unknown;
 }): PiSessionInfoPresentation;
-/** The engine reports warming as a mode plus, once it has acted, the decision that produced the state. */
-export declare function pinnedCacheWarming(mode: unknown, status: unknown): PiSessionInfoPresentation["cacheWarming"];
-export declare function pinnedUsageCostBreakdown(entries: readonly unknown[]): PiSessionInfoPresentation["usageBreakdown"];
-export declare function pinnedCacheWaste(entries: readonly unknown[], modelRuntime: PiServicesApi["modelRuntime"]): PiSessionInfoPresentation["cacheWaste"];
 export declare function defaultWorkflowHost(): PiWorkflowHost;
 export declare function workflowLoginNotification(event: unknown): PiWorkflowLoginNotification | undefined;
 export declare function workflowResult(command: PiWorkflowRequest["command"], outcome: PiWorkflowResult["outcome"], message: string, detail?: string, messageKind?: PiWorkflowResult["messageKind"], messages?: readonly PiWorkflowMessage[]): PiWorkflowResult;
 export declare function workflowConfirmation(command: PiWorkflowRequest["command"], message: string, detail?: string): PiWorkflowResult;
 export declare function errorMessage(error: unknown, fallback: string): string;
-export declare function shareCommandFailureDetail(error: unknown): string;
 export declare function commandMissing(error: unknown): boolean;
 export declare function isAbortError(error: unknown): boolean;
-export declare function shareViewerUrl(gistId: string): string;
-export declare const RADIUS_SHARE_GATEWAY = "https://radius.pi.dev";
-export declare const RADIUS_AUTH_MIN_VALIDITY_MS: number;
-/** The bearer token in a model-runtime auth result: an API key or an `Authorization: Bearer` header. */
-export declare function radiusAuthCredential(auth: unknown): string | undefined;
-/**
- * Append the pinned `pi.share` trailing entry (system prompt and tool schemas for the session viewer)
- * to a branch JSONL export. It chains to the last exported entry and reuses the header timestamp.
- */
-export declare function withRadiusShareTrailingEntry(jsonl: string, state: {
-    readonly systemPrompt?: unknown;
-    readonly tools?: readonly unknown[];
-}, id: string): string;
 export declare function workflowOptions(value: unknown, idKey: string, labelKey: string): readonly PiWorkflowOption[];
-export declare function sessionInfoOptions(value: readonly unknown[]): readonly PiWorkflowOption[];
 export declare function pathArgument(value: string): string | undefined;
 export declare function pinnedHotkeySummary(): string;
 export declare function scopedModelRecords(modelRuntime: PiServicesApi["modelRuntime"]): readonly {
@@ -44,7 +25,6 @@ export declare function scopedModelReference(value: unknown): string | undefined
 export declare function resolveConfiguredModelIds(patterns: readonly string[], models: readonly {
     readonly descriptor: PiScopedModelDescriptor;
 }[]): readonly string[];
-export declare function wildcardMatcher(pattern: string): RegExp;
 export declare function isUnknownModel(value: unknown): boolean;
 export declare function findExactWorkflowModel<T>(reference: string, models: readonly T[]): T | undefined;
 export {};

package/dist/integrations/pi/engine/workflow-support.js

@@ -80,7 +80,7 @@ export function pinnedSessionInfoPresentation(value, sessionName, entries, model
     };
 }
 /** The engine reports warming as a mode plus, once it has acted, the decision that produced the state. */
-export function pinnedCacheWarming(mode, status) {
+function pinnedCacheWarming(mode, status) {
     const resolved = stringValue(mode) ?? "off";
     if (!isRecord(status))
         return { mode: resolved };
@@ -110,7 +110,7 @@ export function pinnedCacheWarming(mode, status) {
         },
     };
 }
-export function pinnedUsageCostBreakdown(entries) {
+function pinnedUsageCostBreakdown(entries) {
     const totals = new Map();
     for (const entry of entries) {
         if (!isRecord(entry))
@@ -147,7 +147,7 @@ export function pinnedUsageCostBreakdown(entries) {
         .filter(entry => entry.cost > 0 || entry.tokens > 0)
         .sort((a, b) => b.cost - a.cost);
 }
-export function pinnedCacheWaste(entries, modelRuntime) {
+function pinnedCacheWaste(entries, modelRuntime) {
     let previous;
     const totals = { missedTokens: 0, missedCost: 0, missCount: 0 };
     for (const entry of entries) {
@@ -262,59 +262,12 @@ export function workflowConfirmation(command, message, detail) {
 export function errorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
-export function shareCommandFailureDetail(error) {
-    // Compatibility: Pi reports a failed child's stderr, not execFile's command wrapper.
-    if (isRecord(error) && (typeof error.code === "number" || typeof error.signal === "string") && typeof error.stderr === "string") {
-        return error.stderr.trim() || "Unknown error";
-    }
-    return errorMessage(error, "Unknown error");
-}
 export function commandMissing(error) {
     return isRecord(error) && error.code === "ENOENT";
 }
 export function isAbortError(error) {
     return isRecord(error) && (error.name === "AbortError" || error.code === "ABORT_ERR");
 }
-export function shareViewerUrl(gistId) {
-    const baseUrl = process.env.PI_SHARE_VIEWER_URL || "https://pi.dev/session/";
-    return `${baseUrl}#${gistId}`;
-}
-// Provenance: the pinned engine's modes/interactive/session-share.ts Radius route and the model
-// runtime's DEFAULT_RADIUS_GATEWAY; neither is in the public API, so each upgrade re-checks them.
-export const RADIUS_SHARE_GATEWAY = "https://radius.pi.dev";
-export const RADIUS_AUTH_MIN_VALIDITY_MS = 5 * 60_000;
-/** The bearer token in a model-runtime auth result: an API key or an `Authorization: Bearer` header. */
-export function radiusAuthCredential(auth) {
-    const resolved = isRecord(auth) && isRecord(auth.auth) ? auth.auth : undefined;
-    if (resolved === undefined)
-        return undefined;
-    if (typeof resolved.apiKey === "string" && resolved.apiKey)
-        return resolved.apiKey;
-    const headers = isRecord(resolved.headers) ? resolved.headers : {};
-    const authorization = Object.entries(headers).find(([name]) => name.toLowerCase() === "authorization")?.[1];
-    return typeof authorization === "string" ? /^Bearer\s+(.+)$/iu.exec(authorization)?.[1] : undefined;
-}
-/**
- * Append the pinned `pi.share` trailing entry (system prompt and tool schemas for the session viewer)
- * to a branch JSONL export. It chains to the last exported entry and reuses the header timestamp.
- */
-export function withRadiusShareTrailingEntry(jsonl, state, id) {
-    const lines = jsonl.split("\n").filter(line => line.length > 0);
-    const header = lines[0] === undefined ? undefined : JSON.parse(lines[0]);
-    const last = lines.length > 1 ? JSON.parse(lines.at(-1)) : undefined;
-    const entry = {
-        type: "custom",
-        customType: "pi.share",
-        id,
-        parentId: isRecord(last) && typeof last.id === "string" ? last.id : null,
-        timestamp: isRecord(header) && typeof header.timestamp === "string" ? header.timestamp : new Date().toISOString(),
-        data: {
-            systemPrompt: state.systemPrompt,
-            tools: (state.tools ?? []).filter(isRecord).map(tool => ({ name: tool.name, description: tool.description, parameters: tool.parameters })),
-        },
-    };
-    return `${[...lines, JSON.stringify(entry)].join("\n")}\n`;
-}
 export function workflowOptions(value, idKey, labelKey) {
     if (!Array.isArray(value))
         return [];
@@ -325,20 +278,6 @@ export function workflowOptions(value, idKey, labelKey) {
         return [{ id, label: stringProperty(item, labelKey) ?? id }];
     });
 }
-export function sessionInfoOptions(value) {
-    return value.filter(isRecord).flatMap(info => {
-        const path = stringProperty(info, "path");
-        if (!path)
-            return [];
-        const modified = info.modified instanceof Date ? info.modified.toISOString() : stringProperty(info, "modified") ?? "unknown time";
-        const messageCount = typeof info.messageCount === "number" ? info.messageCount : 0;
-        return [{
-                id: path,
-                label: stringProperty(info, "name") ?? stringProperty(info, "firstMessage") ?? stringProperty(info, "id") ?? path,
-                description: `${messageCount} messages · ${modified}`,
-            }];
-    });
-}
 export function pathArgument(value) {
     if (!value)
         return undefined;
@@ -390,7 +329,7 @@ export function resolveConfiguredModelIds(patterns, models) {
     }
     return resolved;
 }
-export function wildcardMatcher(pattern) {
+function wildcardMatcher(pattern) {
     let source = "";
     for (const character of pattern) {
         if (character === "*")

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

@@ -1,5 +1,5 @@
 import type { SessionInfo } from "../startup-public.js";
-import { type OwnedUiAuthenticationProviderOption, type OwnedUiAuthenticationProviderStatus, type OwnedUiBashWorkflowResult, type OwnedUiCacheWarmingPresentation, type OwnedUiHiddenWorkflowCommandName, type OwnedUiModelsCommandName, type OwnedUiModelsContext, type OwnedUiModelsRefreshResult, type OwnedUiProjectTrustContext, type OwnedUiProjectTrustUpdate, type OwnedUiScopedModelDescriptor, type OwnedUiScopedModelsContext, type OwnedUiScopedModelsRefreshResult, type OwnedUiSessionInfoPresentation, type OwnedUiSessionProductMode, type OwnedUiSessionResumeMetadata, type OwnedUiSessionSettingsSnapshot, type OwnedUiWorkflowAutocompleteCommand, type OwnedUiWorkflowCommandName, type OwnedUiWorkflowInteractionHost, type OwnedUiWorkflowInteractionRequest, type OwnedUiWorkflowLoginNotification, type OwnedUiWorkflowLoginStart, type OwnedUiWorkflowMessage, type OwnedUiWorkflowMessageKind, type OwnedUiWorkflowOption, type OwnedUiWorkflowOutcome, type OwnedUiWorkflowPresentation, type OwnedUiWorkflowRequest, type OwnedUiWorkflowResult, type OwnedUiWorkflowRoute } from "../../../contracts/owned-ui/index.js";
+import { type OwnedUiAuthenticationProviderOption, type OwnedUiAuthenticationProviderStatus, type OwnedUiBashWorkflowResult, type OwnedUiHiddenWorkflowCommandName, type OwnedUiModelsCommandName, type OwnedUiModelsContext, type OwnedUiModelsRefreshResult, type OwnedUiProjectTrustContext, type OwnedUiProjectTrustUpdate, type OwnedUiScopedModelDescriptor, type OwnedUiScopedModelsContext, type OwnedUiScopedModelsRefreshResult, type OwnedUiSessionInfoPresentation, type OwnedUiSessionProductMode, type OwnedUiSessionResumeMetadata, type OwnedUiSessionSettingsSnapshot, type OwnedUiWorkflowAutocompleteCommand, type OwnedUiWorkflowCommandName, type OwnedUiWorkflowInteractionHost, type OwnedUiWorkflowInteractionRequest, type OwnedUiWorkflowLoginNotification, type OwnedUiWorkflowLoginStart, type OwnedUiWorkflowMessage, type OwnedUiWorkflowMessageKind, type OwnedUiWorkflowOption, type OwnedUiWorkflowOutcome, type OwnedUiWorkflowPresentation, type OwnedUiWorkflowRequest, type OwnedUiWorkflowResult, type OwnedUiWorkflowRoute } from "../../../contracts/owned-ui/index.js";
 export declare const PINNED_PI_WORKFLOW_COMMAND_NAMES: readonly ["settings", "model", "tree", "thinking", "scoped-models", "export", "import", "share", "copy", "name", "session", "changelog", "hotkeys", "fork", "clone", "trust", "login", "logout", "new", "compact", "resume", "reload", "quit"];
 export declare const PINNED_PI_HIDDEN_COMMAND_NAMES: readonly ["debug", "arminsayshi", "dementedelves"];
 /**
@@ -12,8 +12,8 @@ export declare const PINNED_PI_DECLINED_COMMAND_NAMES: readonly ["bug"];
 export type PiWorkflowCommandName = OwnedUiWorkflowCommandName;
 export type PiHiddenWorkflowCommandName = OwnedUiHiddenWorkflowCommandName;
 export declare const OWNED_MODELS_COMMAND_NAME: "models";
-export type OwnedModelsCommandName = OwnedUiModelsCommandName;
-export type OwnedWorkflowCommandName = Exclude<PiWorkflowCommandName, "model" | "scoped-models"> | OwnedModelsCommandName;
+type OwnedModelsCommandName = OwnedUiModelsCommandName;
+type OwnedWorkflowCommandName = Exclude<PiWorkflowCommandName, "model" | "scoped-models"> | OwnedModelsCommandName;
 /** Bare A1's advertised catalog: `models` replaces the pinned pair and is followed by `thinking`. */
 export declare const OWNED_WORKFLOW_COMMAND_NAMES: readonly OwnedWorkflowCommandName[];
 export type PiProductMode = OwnedUiSessionProductMode;
@@ -33,7 +33,6 @@ export type PiAuthenticationProviderOption = OwnedUiAuthenticationProviderOption
 export type PiWorkflowRequest = OwnedUiWorkflowRequest;
 export type PiWorkflowOutcome = OwnedUiWorkflowOutcome;
 export type PiSessionInfoPresentation = OwnedUiSessionInfoPresentation;
-export type PiCacheWarmingPresentation = OwnedUiCacheWarmingPresentation;
 export type PiWorkflowPresentation = OwnedUiWorkflowPresentation;
 export type PiWorkflowMessageKind = OwnedUiWorkflowMessageKind;
 export type PiWorkflowMessage = OwnedUiWorkflowMessage;
@@ -75,10 +74,11 @@ export interface PiTreeSelectorContext {
  * Progress a session listing reports. `partialSessions` carries what the pinned manager has
  * loaded so far, so the selector can show results before the listing finishes.
  */
-export type PiSessionListProgress = (loaded: number, total: number, partialSessions?: readonly SessionInfo[]) => void;
+type PiSessionListProgress = (loaded: number, total: number, partialSessions?: readonly SessionInfo[]) => void;
 export interface PiSessionSelectorContext {
     readonly currentSessionFilePath: string | undefined;
     readonly loadCurrentSessions: (onProgress?: PiSessionListProgress) => Promise<SessionInfo[]>;
     readonly loadAllSessions: (onProgress?: PiSessionListProgress) => Promise<SessionInfo[]>;
     readonly renameSession: (sessionFilePath: string, nextName: string | undefined) => Promise<void>;
 }
+export {};

package/dist/integrations/pi/session-presenters/components.d.ts

@@ -0,0 +1,3 @@
+import type { OwnedUiShellComponents, OwnedUiShellLazySelectorLoader } from "../../../contracts/owned-ui/index.js";
+/** The Pi components and helpers behind the shell's neutral component record. */
+export declare function createPiShellComponents(loadLazySelectors: () => Promise<OwnedUiShellLazySelectorLoader>): OwnedUiShellComponents;

package/dist/integrations/pi/session-presenters/components.js

@@ -0,0 +1,75 @@
+import { createPiShellEditor } from "../components/shell-editor-autocomplete.js";
+import { createPiExtensionUiBridge } from "../components/shell-extension-ui.js";
+import { createPiQueuedInputStatus, createPiShellFooter, createPiShellHeader, createPiShellLoadedResources, createPiShellStatus, } from "../components/shell-footer-status.js";
+import { createPiShellChangelog, createPiShellCollapsedChangelog, createPiShellHotkeys, createPiShellSessionInfo, renderPiShellCommandMessage, renderPiShellPackageUpdateNotice, renderPiShellReleaseUpdateBanner, renderPiShellReleaseUpdateNotice, renderPiShellStatusText, } from "../components/shell-presenters-info.js";
+import { createPiShellTranscriptComponent, isPiPromptStyleCompaction, renderPiShellStartupDiagnostic, renderPiShellTranscriptBlock, } from "../components/shell-presenters-transcript.js";
+import { createPiShellArmin, createPiShellAuthProviderSelector, createPiShellDialog, createPiShellEarendilAnnouncement, createPiShellExtensionSelector, createPiShellLoginDialog, createPiShellReloadBox, createPiShellSelector, createPiShellSkillsSelector, createPiShellTrustSelector, createPiShellUserMessageSelector, } from "../components/shell-selectors-dialogs.js";
+import { piShellHyperlink, piShellTruncateToWidth, piShellVisibleWidth, renderPiShellInstalledUpdateStatus, } from "../components/shell-shared-facade.js";
+import { SKILLS_COMMAND_NAME, findSkillByArgument, rewriteSkillsTunnelSubmission, skillPrompt, skillsFromCommands, } from "../components/skills-command.js";
+import { ProgramStatusReporter } from "../components/upstream/program-status-reporter.js";
+import { workflowCommandNames } from "../engine/workflows.js";
+/** The Pi components and helpers behind the shell's neutral component record. */
+export function createPiShellComponents(loadLazySelectors) {
+    return {
+        editor: { create: createPiShellEditor },
+        chrome: {
+            header: createPiShellHeader,
+            status: createPiShellStatus,
+            footer: createPiShellFooter,
+            queuedInput: createPiQueuedInputStatus,
+            loadedResources: createPiShellLoadedResources,
+            installedUpdateStatus: renderPiShellInstalledUpdateStatus,
+            releaseUpdateBanner: renderPiShellReleaseUpdateBanner,
+            programStatusReporter: (report, getSessionName, app) => new ProgramStatusReporter(report, getSessionName, app),
+        },
+        transcript: {
+            component: createPiShellTranscriptComponent,
+            renderBlock: renderPiShellTranscriptBlock,
+            renderStartupDiagnostic: renderPiShellStartupDiagnostic,
+            isPromptStyleCompaction: isPiPromptStyleCompaction,
+        },
+        info: {
+            changelog: createPiShellChangelog,
+            collapsedChangelog: createPiShellCollapsedChangelog,
+            hotkeys: createPiShellHotkeys,
+            sessionInfo: createPiShellSessionInfo,
+            commandMessage: renderPiShellCommandMessage,
+            statusText: renderPiShellStatusText,
+            packageUpdateNotice: renderPiShellPackageUpdateNotice,
+            releaseUpdateNotice: renderPiShellReleaseUpdateNotice,
+            armin: createPiShellArmin,
+            earendilAnnouncement: createPiShellEarendilAnnouncement,
+            reloadBox: createPiShellReloadBox,
+        },
+        dialogs: {
+            dialog: createPiShellDialog,
+            selector: createPiShellSelector,
+            extensionSelector: createPiShellExtensionSelector,
+            authProviderSelector: createPiShellAuthProviderSelector,
+            loginDialog: createPiShellLoginDialog,
+            skillsSelector: createPiShellSkillsSelector,
+            trustSelector: createPiShellTrustSelector,
+            userMessageSelector: createPiShellUserMessageSelector,
+            async shareProgress(runtime, message, style) {
+                // Rationale: sharing is rare, so its progress surfaces stay off the startup graph.
+                const surfaces = await import("../components/share-operation-dialog.js");
+                return (style === "dialog" ? surfaces.createPiShellShareOperationDialog : surfaces.createPiShellOperationLoader)(runtime, message);
+            },
+            extensionUiBridge: createPiExtensionUiBridge,
+            lazySelectors: loadLazySelectors,
+        },
+        text: {
+            visibleWidth: piShellVisibleWidth,
+            truncateToWidth: piShellTruncateToWidth,
+            hyperlink: piShellHyperlink,
+        },
+        workflows: { commandNames: workflowCommandNames },
+        skills: {
+            commandName: SKILLS_COMMAND_NAME,
+            fromCommands: skillsFromCommands,
+            findByArgument: findSkillByArgument,
+            rewriteTunnelSubmission: rewriteSkillsTunnelSubmission,
+            prompt: skillPrompt,
+        },
+    };
+}

package/dist/integrations/pi/session-presenters/index.d.ts

@@ -1,2 +1,3 @@
+export { PI_SHELL_PRESENTATION } from "./presentation.js";
 export { createPiSessionPresenters } from "./presenters.js";
 export type { PiSessionPresenterBackend, PiSessionPresentersOptions } from "./presenters.js";

package/dist/integrations/pi/session-presenters/index.js

@@ -1 +1,2 @@
+export { PI_SHELL_PRESENTATION } from "./presentation.js";
 export { createPiSessionPresenters } from "./presenters.js";

package/dist/integrations/pi/session-presenters/presentation.d.ts

@@ -0,0 +1,3 @@
+import type { ShellPresentationPorts } from "../../../contracts/presentation/index.js";
+/** Everything the shell takes from Pi's presentation, assembled once from the component and TUI adapters. */
+export declare const PI_SHELL_PRESENTATION: ShellPresentationPorts;

package/dist/integrations/pi/session-presenters/presentation.js

@@ -0,0 +1,10 @@
+import { PI_THEME_SOURCE } from "../components/theme.js";
+import { piCanvasBackgroundAnsi, PINNED_PI_LAYOUT } from "../components/upstream/theme/theme.js";
+import { PI_TERMINAL_RUNTIME } from "../tui-runtime/runtime-factory.js";
+/** Everything the shell takes from Pi's presentation, assembled once from the component and TUI adapters. */
+export const PI_SHELL_PRESENTATION = Object.freeze({
+    theme: PI_THEME_SOURCE,
+    canvasBackground: (style) => piCanvasBackgroundAnsi(style),
+    pinnedOutputPad: PINNED_PI_LAYOUT.outputPad,
+    terminalRuntime: PI_TERMINAL_RUNTIME,
+});

package/dist/integrations/pi/session-presenters/presenters.d.ts

@@ -1,4 +1,5 @@
 import type { OwnedUiSessionBackend, OwnedUiSessionPresenters } from "../../../contracts/owned-ui/index.js";
+import type { ShellPresentationPorts } from "../../../contracts/presentation/index.js";
 import type { PiSessionPresentationSource } from "../engine/adapter.js";
 import type { PiShellLazySelectorLoader } from "../components/lazy-selectors.js";
 /** The session backend plus the Pi objects its selectors are built from; the Pi engine adapter is one. */
@@ -13,4 +14,4 @@ export interface PiSessionPresentersOptions {
  * Builds the selectors and transcript renderers whose inputs are Pi engine objects. This owner is the one place
  * that sees both the engine adapter and the Pi components, so the shell only ever holds the neutral port.
  */
-export declare function createPiSessionPresenters(adapter: PiSessionPresenterBackend, options?: PiSessionPresentersOptions): OwnedUiSessionPresenters;
+export declare function createPiSessionPresenters(adapter: PiSessionPresenterBackend, options?: PiSessionPresentersOptions): OwnedUiSessionPresenters & ShellPresentationPorts;

package/dist/integrations/pi/session-presenters/presenters.js

@@ -1,4 +1,6 @@
 import { createPiShellModelSelector, createPiShellModelsDialog, createPiShellScopedModelsSelector, createPiShellSessionSelector, createPiShellSettingsSelector, } from "../components/shell-selectors-dialogs.js";
+import { PI_SHELL_PRESENTATION } from "./presentation.js";
+import { createPiShellComponents } from "./components.js";
 const MODEL_REFRESH_TIMEOUT_MS = 15_000;
 const MODEL_REFRESH_TIMED_OUT = "Model refresh timed out; showing cached models.";
 /**
@@ -24,7 +26,7 @@ export function createPiSessionPresenters(adapter, options = {}) {
         // Compatibility: the component adapter passes Pi's own keybinding config through the neutral port.
         getShortcuts: bindings => source().pinnedShortcutDescriptions(bindings),
     };
-    return {
+    return { ...PI_SHELL_PRESENTATION, components: createPiShellComponents(loadLazySelectors),
         transcriptRenderers: () => renderers,
         openModelSelector(host, initialSearchInput) {
             const context = source().pinnedModelSelectorContext();

package/dist/integrations/pi/tui-runtime/adapter.d.ts

@@ -1,5 +1,5 @@
 import { type ProgramStatus, type WheelScrollLines } from "@earendil-works/pi-tui";
-import type { PiTuiComponentPort, PiTuiInputListener, PiTuiOverlayHandle, PiTuiOverlayOptions, PiTuiPreInputListener, PiTuiRuntimeAdapterOptions, PiTuiRuntimeState, PiTuiScrollState, PiTuiStopOptions, PiTuiViewport } from "./contracts.js";
+import type { TerminalComponentPort, TerminalInputListener, TerminalOverlayHandle, TerminalOverlayOptions, TerminalPreInputListener, TerminalRuntimeOptions, TerminalRuntimeState, TerminalStopOptions, TerminalViewport } from "../../../contracts/presentation/index.js";
 /**
  * Re-encodes one key report decoded by pi-tui in the legacy form, so a kitty-keyboard terminal
  * and a legacy terminal produce the same owned-screen action. Releases decode
@@ -15,19 +15,14 @@ export declare class PiTuiRuntimeError extends Error {
 /** Bridges neutral presentation ports to one Pi TUI instance and owns terminal restoration on stop. */
 export declare class PiTuiRuntimeAdapter {
     #private;
-    constructor(options: PiTuiRuntimeAdapterOptions);
-    get state(): PiTuiRuntimeState;
+    constructor(options: TerminalRuntimeOptions);
+    get state(): TerminalRuntimeState;
     get active(): boolean;
     get mode(): "regular" | "fullscreen";
     get fullRedraws(): number;
-    viewport(): PiTuiViewport;
-    scrollState(id?: string): PiTuiScrollState;
-    scrollBy(lines: number, id?: string): void;
-    scrollToTop(id?: string): void;
-    scrollToBottom(id?: string): void;
+    viewport(): TerminalViewport;
     start(): void;
-    setFocus(component: PiTuiComponentPort | null): void;
-    showOverlay(component: PiTuiComponentPort, options?: PiTuiOverlayOptions): PiTuiOverlayHandle;
+    showOverlay(component: TerminalComponentPort, options?: TerminalOverlayOptions): TerminalOverlayHandle;
     hasOverlay(): boolean;
     /** Keyboard capture is independent of a passive overlay's visible pointer region. */
     hasFocusedOverlay(): boolean;
@@ -44,30 +39,25 @@ export declare class PiTuiRuntimeAdapter {
      * renderer keeps scheduling but nothing it paints reaches the terminal.
      */
     freezePresentation(): void;
-    get presentationFrozen(): boolean;
     /**
      * Keeps asynchronous replacement-surface construction atomic at the terminal. Renderers may
      * compose while held, but their writes are dropped until the final forced repaint on release.
      */
     beginPresentationHold(): () => void;
     get presentationHeld(): boolean;
-    addPreInputListener(listener: PiTuiPreInputListener): () => void;
-    addInputListener(listener: PiTuiInputListener): () => void;
+    addPreInputListener(listener: TerminalPreInputListener): () => void;
+    addInputListener(listener: TerminalInputListener): () => void;
     switchMode(mode: "regular" | "fullscreen"): boolean;
     setHardwareCursor(enabled: boolean): void;
-    getHardwareCursor(): boolean;
     setClearOnShrink(enabled: boolean): void;
     setWheelScrollLines(lines: WheelScrollLines): void;
-    getClearOnShrink(): boolean;
     setTerminalProgress(active: boolean): void;
     setProgramStatus(status: ProgramStatus): void;
     setTitle(title: string): void;
-    /** Shows a bounded fullscreen acknowledgement without changing root layout geometry. */
-    showFlash(message: string, durationMs?: number): void;
     writeAfterStop(text: string): void;
     invalidate(): void;
     requestRender(force?: boolean): void;
     renderNow(force?: boolean): void;
-    stop(options?: PiTuiStopOptions): Promise<void>;
-    dispose(options?: PiTuiStopOptions): Promise<void>;
+    stop(options?: TerminalStopOptions): Promise<void>;
+    dispose(options?: TerminalStopOptions): Promise<void>;
 }