@timurproko/a1 0.1.8-dev.508 → 0.1.8-dev.510

package/dist/integrations/pi/components/skills-command.js

@@ -0,0 +1,118 @@
+/** The collapsed bare-A1 replacement for the per-skill command listing. */
+export const SKILLS_COMMAND_NAME = "skills";
+export const SKILLS_COMMAND_DESCRIPTION = "Browse, search, and apply a skill";
+/** Pi's own command prefix; the engine expands `/skill:<name>` regardless of how the menu presents it. */
+export const SKILL_COMMAND_PREFIX = "skill:";
+const SKILLS_TUNNEL_PREFIX = `${SKILLS_COMMAND_NAME}:`;
+/** The tunnel form follows v2: a name without whitespace right after the colon. */
+const SKILLS_TUNNEL_INPUT = /^\/skills:(\S*)$/u;
+const SKILLS_TUNNEL_SUBMISSION = /^\/skills:([A-Za-z0-9][A-Za-z0-9_-]*)(\s[\s\S]*)?$/u;
+/** One line of description, as the v2 extension shows it beside a row. */
+export function oneLineSkillDescription(description) {
+    return description.replace(/\s+/gu, " ").trim();
+}
+/** The skills the engine registered as `skill:<name>` commands, in its order. */
+export function skillsFromCommands(commands) {
+    return commands.flatMap(command => command.name.startsWith(SKILL_COMMAND_PREFIX) && command.name.length > SKILL_COMMAND_PREFIX.length
+        ? [{ name: command.name.slice(SKILL_COMMAND_PREFIX.length), description: oneLineSkillDescription(command.description ?? "") }]
+        : []);
+}
+/**
+ * Replace every `skill:<name>` entry with one `skills` command whose argument completions are the
+ * skill names. A list without skill entries (registration disabled, or no skills) is returned
+ * unchanged with no `skills` command, so the collapsed presentation never invents a command.
+ */
+export function collapseSkillCommands(commands) {
+    const skills = skillsFromCommands(commands);
+    if (skills.length === 0)
+        return { commands, skills };
+    const collapsed = [];
+    let inserted = false;
+    for (const command of commands) {
+        if (!command.name.startsWith(SKILL_COMMAND_PREFIX)) {
+            collapsed.push(command);
+            continue;
+        }
+        if (inserted)
+            continue;
+        inserted = true;
+        collapsed.push({
+            name: SKILLS_COMMAND_NAME,
+            description: SKILLS_COMMAND_DESCRIPTION,
+            argumentOptions: skills.map(skill => ({
+                id: skill.name,
+                label: skill.name,
+                ...(skill.description.length === 0 ? {} : { description: skill.description }),
+            })),
+        });
+    }
+    return { commands: collapsed, skills };
+}
+/** Case-insensitive substring match on the name or description; a leading `skill:`/`skills:` in the query is ignored for the name. */
+export function skillMatchesQuery(skill, query) {
+    const normalized = query.trim().toLowerCase();
+    if (normalized.length === 0)
+        return true;
+    const withoutPrefix = normalized.startsWith(SKILLS_TUNNEL_PREFIX)
+        ? normalized.slice(SKILLS_TUNNEL_PREFIX.length)
+        : normalized.startsWith(SKILL_COMMAND_PREFIX) ? normalized.slice(SKILL_COMMAND_PREFIX.length) : normalized;
+    return skill.name.toLowerCase().includes(withoutPrefix)
+        || `${SKILL_COMMAND_PREFIX}${skill.name}`.toLowerCase().includes(normalized)
+        || skill.description.toLowerCase().includes(normalized);
+}
+/** Resolve a `/skills` argument token to a skill, accepting the name with or without `skill:`. */
+export function findSkillByArgument(skills, token) {
+    const name = token.startsWith(SKILL_COMMAND_PREFIX) ? token.slice(SKILL_COMMAND_PREFIX.length) : token;
+    return skills.find(skill => skill.name === name);
+}
+/** The `/skill:<name>` prompt the engine expands, with any arguments after one space. */
+export function skillPrompt(name, args = "") {
+    const trimmed = args.trim();
+    return trimmed.length === 0 ? `/${SKILL_COMMAND_PREFIX}${name}` : `/${SKILL_COMMAND_PREFIX}${name} ${trimmed}`;
+}
+/**
+ * Rewrite a submitted tunnel form `/skills:<name> rest` to `/skill:<name> rest`; anything else is
+ * returned unchanged so ordinary prompts, `/skills <name>`, and `/skill:` input keep their text.
+ */
+export function rewriteSkillsTunnelSubmission(text) {
+    const match = SKILLS_TUNNEL_SUBMISSION.exec(text);
+    if (match === null)
+        return text;
+    return `/${SKILL_COMMAND_PREFIX}${match[1]}${match[2] ?? ""}`;
+}
+/** The tunnel query when single-line content before the cursor is exactly `/skills:<query>`. */
+export function skillsTunnelQuery(lines, cursorLine, cursorCol) {
+    if (cursorLine !== 0 || lines.length !== 1)
+        return null;
+    const match = SKILLS_TUNNEL_INPUT.exec((lines[0] ?? "").slice(0, cursorCol));
+    return match === null ? null : match[1] ?? "";
+}
+export function skillsTunnelItems(skills, query) {
+    return skills.filter(skill => skillMatchesQuery(skill, query)).map(skill => ({
+        value: `${SKILLS_TUNNEL_PREFIX}${skill.name}`,
+        label: `${SKILLS_TUNNEL_PREFIX}${skill.name}`,
+        ...(skill.description.length === 0 ? {} : { description: skill.description }),
+    }));
+}
+/**
+ * Wrap the pinned combined provider with the `skills` tunnel: `/skills:<query>` lists matching
+ * skills as `skills:<name>` rows and shows nothing when none match; every other request, the
+ * completion application, and the file-completion decision are delegated unchanged so extension
+ * wrappers registered over this provider see one ordinary provider.
+ */
+export function createSkillsTunnelProvider(base, skills) {
+    return {
+        ...(base.triggerCharacters === undefined ? {} : { triggerCharacters: base.triggerCharacters }),
+        async getSuggestions(lines, cursorLine, cursorCol, options) {
+            const query = skillsTunnelQuery(lines, cursorLine, cursorCol);
+            if (query === null)
+                return base.getSuggestions(lines, cursorLine, cursorCol, options);
+            const items = skillsTunnelItems(skills, query);
+            if (options.signal.aborted || items.length === 0)
+                return null;
+            return { prefix: (lines[cursorLine] ?? "").slice(0, cursorCol), items };
+        },
+        applyCompletion: (lines, cursorLine, cursorCol, item, prefix) => base.applyCompletion(lines, cursorLine, cursorCol, item, prefix),
+        shouldTriggerFileCompletion: (lines, cursorLine, cursorCol) => base.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true,
+    };
+}

package/dist/integrations/pi/components/skills-dialog.d.ts

@@ -0,0 +1,9 @@
+import { type PiShellComponentPort } from "./shell-shared-facade.js";
+import { type PiShellSkillSummary } from "./skills-command.js";
+export interface PiShellSkillsSelectorOptions {
+    /** The skills the engine registered, in its discovery order. */
+    readonly skills: readonly PiShellSkillSummary[];
+    readonly onSelect: (name: string) => void;
+    readonly onCancel: () => void;
+}
+export declare function createPiShellSkillsSelector(options: PiShellSkillsSelectorOptions): PiShellComponentPort;

package/dist/integrations/pi/components/skills-dialog.js

@@ -0,0 +1,112 @@
+import { DynamicBorder, keyHint, rawKeyHint } from "../startup-public.js";
+import { Container, getKeybindings, Input, Spacer, Text } from "@earendil-works/pi-tui";
+import { PINNED_PI_LAYOUT, piTheme } from "./theme.js";
+import { componentPort, ensureTheme } from "./shell-shared-facade.js";
+import { SKILL_COMMAND_PREFIX, skillMatchesQuery } from "./skills-command.js";
+/**
+ * The A1-owned searchable Skills dialog. Its composition is the model selector's (border, spacer,
+ * search input, spacer, list, spacer, hint footer, border) built from public pi-tui components; its
+ * content follows the v2 skills extension: an accent bold title, `skill:<name>` rows, the selected
+ * skill's one-line description under the rows, the pinned scroll counter on overflow, and the two
+ * empty states. Enter applies the selected skill with no arguments; the query is never appended.
+ */
+class SkillsSelectorComponent extends Container {
+    #searchInput = new Input();
+    #listContainer = new Container();
+    #skills;
+    #onSelect;
+    #onCancel;
+    #filtered;
+    #selectedIndex = 0;
+    #focused = false;
+    constructor(options) {
+        super();
+        this.#skills = options.skills;
+        this.#filtered = options.skills;
+        this.#onSelect = options.onSelect;
+        this.#onCancel = options.onCancel;
+        this.#searchInput.onSubmit = () => this.#selectCurrent();
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(piTheme().fg("accent", piTheme().bold("Skills")), 0, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(this.#searchInput);
+        this.addChild(new Spacer(1));
+        this.addChild(this.#listContainer);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(`  ${rawKeyHint("↑↓", "navigate")}  ${keyHint("tui.select.confirm", "select")}  ${keyHint("tui.select.cancel", "cancel")}`, 0, 0));
+        this.addChild(new DynamicBorder());
+        this.#updateList();
+    }
+    // Protocol: focus propagates to the search input so the terminal cursor follows the query.
+    get focused() { return this.#focused; }
+    set focused(value) {
+        this.#focused = value;
+        this.#searchInput.focused = value;
+    }
+    handleInput(data) {
+        const keybindings = getKeybindings();
+        if (keybindings.matches(data, "tui.select.up")) {
+            if (this.#filtered.length === 0)
+                return;
+            this.#selectedIndex = this.#selectedIndex === 0 ? this.#filtered.length - 1 : this.#selectedIndex - 1;
+            this.#updateList();
+        }
+        else if (keybindings.matches(data, "tui.select.down")) {
+            if (this.#filtered.length === 0)
+                return;
+            this.#selectedIndex = this.#selectedIndex === this.#filtered.length - 1 ? 0 : this.#selectedIndex + 1;
+            this.#updateList();
+        }
+        else if (keybindings.matches(data, "tui.select.confirm")) {
+            this.#selectCurrent();
+        }
+        else if (keybindings.matches(data, "tui.select.cancel")) {
+            this.#onCancel();
+        }
+        else {
+            const before = this.#searchInput.getValue();
+            this.#searchInput.handleInput(data);
+            const query = this.#searchInput.getValue();
+            if (query === before)
+                return;
+            this.#filtered = this.#skills.filter(skill => skillMatchesQuery(skill, query));
+            this.#selectedIndex = 0;
+            this.#updateList();
+        }
+    }
+    #selectCurrent() {
+        const selected = this.#filtered[this.#selectedIndex];
+        if (selected !== undefined)
+            this.#onSelect(selected.name);
+    }
+    #updateList() {
+        this.#listContainer.clear();
+        const theme = piTheme();
+        if (this.#filtered.length === 0) {
+            this.#listContainer.addChild(new Text(theme.fg("muted", this.#skills.length === 0 ? "  No skills yet" : "  No matching skills"), 0, 0));
+            return;
+        }
+        const maxVisible = PINNED_PI_LAYOUT.selectorMaxVisible;
+        const start = Math.max(0, Math.min(this.#selectedIndex - Math.floor(maxVisible / 2), this.#filtered.length - maxVisible));
+        const end = Math.min(start + maxVisible, this.#filtered.length);
+        for (let index = start; index < end; index++) {
+            const skill = this.#filtered[index];
+            const selected = index === this.#selectedIndex;
+            const label = `${SKILL_COMMAND_PREFIX}${skill.name}`;
+            this.#listContainer.addChild(new Text(`${selected ? theme.fg("accent", "→ ") : "  "}${selected ? theme.fg("accent", label) : label}`, 0, 0));
+        }
+        if (start > 0 || end < this.#filtered.length) {
+            this.#listContainer.addChild(new Text(theme.fg("muted", `  (${this.#selectedIndex + 1}/${this.#filtered.length})`), 0, 0));
+        }
+        const description = this.#filtered[this.#selectedIndex]?.description ?? "";
+        if (description.length > 0) {
+            this.#listContainer.addChild(new Spacer(1));
+            this.#listContainer.addChild(new Text(theme.fg("muted", `  ${description}`), 0, 0));
+        }
+    }
+}
+export function createPiShellSkillsSelector(options) {
+    ensureTheme();
+    return componentPort(new SkillsSelectorComponent(options));
+}

package/dist/integrations/pi/components/upstream/components/owned-editor.d.ts

@@ -4,9 +4,10 @@
  * Modifications: A1-owned class name and synchronized A1 keybinding contract replace the nominal
  * private upstream keybinding constructor dependency; bare A1 injects the shared Settings/agent input
  * frame, transient contextual-suggestion branch, and explicit body geometry for selection and
- * above-prompt autocomplete. Bare A1 also clears a sole top-level slash-command search on Escape.
+ * above-prompt autocomplete. Bare A1 also clears a sole top-level slash-command search on Escape. Bare
+ * A1 also completes a selected tunnel command with `:` and reopens the menu on its tunnel rows.
  * Deviations: owned-shared-input-frame, above-prompt-autocomplete-placement,
- * clear-command-search-on-escape.
+ * clear-command-search-on-escape, command-tunnel-colon-completion.
  */
 import { type EditorOptions, type EditorTheme, type TUI } from "@earendil-works/pi-tui";
 import type { AppKeybinding, KeybindingsManager } from "../adjacent/core/keybindings.js";
@@ -23,6 +24,11 @@ export interface OwnedEditorOptions extends EditorOptions {
     readonly getVisualLineCount?: (width: number) => number | undefined;
     /** Bare-A1 exception: Escape on a sole top-level slash-command search also clears the prompt. */
     readonly clearCommandSearchOnEscape?: boolean;
+    /**
+     * Bare-A1 exception: the slash commands that own a `:` tunnel. Typing `:` while one of them is
+     * the selected row of a sole top-level search completes to `/<command>:` and reopens the menu.
+     */
+    readonly commandTunnels?: () => readonly string[];
 }
 export interface ShellEditorInstance extends EditorSurface {
     readonly actionHandlers: Map<AppKeybinding, () => void>;

package/dist/integrations/pi/components/upstream/components/owned-editor.js

@@ -4,9 +4,10 @@
  * Modifications: A1-owned class name and synchronized A1 keybinding contract replace the nominal
  * private upstream keybinding constructor dependency; bare A1 injects the shared Settings/agent input
  * frame, transient contextual-suggestion branch, and explicit body geometry for selection and
- * above-prompt autocomplete. Bare A1 also clears a sole top-level slash-command search on Escape.
+ * above-prompt autocomplete. Bare A1 also clears a sole top-level slash-command search on Escape. Bare
+ * A1 also completes a selected tunnel command with `:` and reopens the menu on its tunnel rows.
  * Deviations: owned-shared-input-frame, above-prompt-autocomplete-placement,
- * clear-command-search-on-escape.
+ * clear-command-search-on-escape, command-tunnel-colon-completion.
  */
 import { CURSOR_MARKER, Editor, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
 const PROMPT_GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
@@ -25,6 +26,7 @@ export function createOwnedEditorClass(Base) {
         #terminalRows;
         #getVisualLineCount;
         #clearCommandSearchOnEscape;
+        #commandTunnels;
         #renderedBodyRowCount = 0;
         keybindings;
         constructor(tui, theme, keybindings, options = {}) {
@@ -36,6 +38,7 @@ export function createOwnedEditorClass(Base) {
             this.#terminalRows = options.terminalRows ?? (() => 24);
             this.#getVisualLineCount = options.getVisualLineCount;
             this.#clearCommandSearchOnEscape = options.clearCommandSearchOnEscape === true;
+            this.#commandTunnels = options.commandTunnels ?? (() => []);
         }
         getRenderedBodyRowCount() { return this.#renderedBodyRowCount; }
         setPromptSuggestion(text) {
@@ -58,11 +61,6 @@ export function createOwnedEditorClass(Base) {
             const cursor = this.getCursor();
             return cursor.line === 0 && cursor.col === text.length;
         }
-        setText(text) {
-            if (text.length > 0)
-                this.#promptSuggestion = null;
-            super.setText(text);
-        }
         render(width) {
             if (this.#inputPresentation === undefined) {
                 const rows = super.render(width);
@@ -80,6 +78,8 @@ export function createOwnedEditorClass(Base) {
         handleInput(data) {
             if (this.onExtensionShortcut?.(data))
                 return;
+            if (data === ":" && this.#completeSelectedCommandTunnel())
+                return;
             if (this.#promptSuggestion !== null
                 && !this.isShowingAutocomplete()
                 && this.canPresentPromptSuggestion()
@@ -134,6 +134,21 @@ export function createOwnedEditorClass(Base) {
             }
             super.handleInput(data);
         }
+        /**
+         * Replace a sole top-level slash search whose selected row is a tunnel command with `/<command>:`
+         * and reopen the menu on the tunnel rows. The replacement goes through the public setText, which
+         * records the undo snapshot; every other colon stays ordinary text.
+         */
+        #completeSelectedCommandTunnel() {
+            if (!this.isTopLevelCommandSearch())
+                return false;
+            const selected = selectedAutocompleteValue(this);
+            if (selected === undefined || !this.#commandTunnels().includes(selected))
+                return false;
+            this.setText(`/${selected}:`);
+            triggerAutocomplete(this);
+            return true;
+        }
         #renderSuggestion(width) {
             const presentation = this.#inputPresentation;
             const { paddingX, contentWidth, layoutWidth } = presentation.geometry(width, this.getPaddingX());
@@ -185,3 +200,23 @@ export function createOwnedEditorClass(Base) {
 }
 export class OwnedEditor extends createOwnedEditorClass(Editor) {
 }
+/** The value of the row the open autocomplete list highlights, read from either editor's list. */
+function selectedAutocompleteValue(editor) {
+    const list = Reflect.get(editor, "autocompleteList");
+    if (typeof list !== "object" || list === null)
+        return undefined;
+    const getSelectedItem = Reflect.get(list, "getSelectedItem");
+    if (typeof getSelectedItem !== "function")
+        return undefined;
+    const item = getSelectedItem.call(list);
+    if (typeof item !== "object" || item === null)
+        return undefined;
+    const value = Reflect.get(item, "value");
+    return typeof value === "string" ? value : undefined;
+}
+/** Request the slash-command menu for the current text, as typing a command character would. */
+function triggerAutocomplete(editor) {
+    const trigger = Reflect.get(editor, "tryTriggerAutocomplete");
+    if (typeof trigger === "function")
+        trigger.call(editor);
+}

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

@@ -1,6 +1,6 @@
 import { type AgentSession } from "../startup-public.js";
 import { type OwnedUiCommand, type OwnedUiImageAttachment, type OwnedUiPromptSuggestionGeneratorPort, type OwnedUiPromptSuggestionReasoning, type OwnedUiPromptSuggestionRequest, type OwnedUiPromptSuggestionResult, type OwnedUiEvent, type OwnedUiSessionViewModel, type OwnedUiSnapshot } from "../../../contracts/owned-ui/index.js";
-import type { PiAuthenticationProviderOption, PiBashWorkflowResult, PiPinnedSettingsCallback, PiPinnedSettingsSnapshot, PiProjectTrustContext, PiProjectTrustUpdate, PiScopedModelsContext, PiScopedModelsRefreshResult, PiSessionResumeMetadata, PiSessionSelectorContext, PiTreeSelectorContext, PiWorkflowAutocompleteCommand, PiWorkflowHost, PiWorkflowInteractionHost, PiWorkflowOption, PiWorkflowRequest, PiWorkflowResult } from "./workflows.js";
+import type { PiAuthenticationProviderOption, PiBashWorkflowResult, PiModelsContext, PiModelsRefreshResult, PiPinnedSettingsCallback, PiPinnedSettingsSnapshot, PiProjectTrustContext, PiProjectTrustUpdate, PiScopedModelsContext, PiScopedModelsRefreshResult, PiSessionResumeMetadata, PiSessionSelectorContext, PiTreeSelectorContext, PiWorkflowAutocompleteCommand, PiWorkflowHost, PiWorkflowInteractionHost, PiWorkflowOption, PiWorkflowRequest, PiWorkflowResult } from "./workflows.js";
 import type { PiSettingsBridge } from "./settings-bridge.js";
 import type { PiSettingOwnerHandlers } from "./settings-bridge.js";
 import type { PiProjectTrustPreflightPrompt } from "./project-trust-preflight.js";
@@ -91,6 +91,10 @@ export declare class PiEngineAdapter implements OwnedUiPromptSuggestionGenerator
     updateScopedModels(enabledModelIds: readonly string[] | null): void;
     persistScopedModels(enabledModelIds: readonly string[] | null): void;
     refreshScopedModels(signal: AbortSignal): Promise<PiScopedModelsRefreshResult>;
+    modelsContext(): PiModelsContext;
+    setSessionModelScope(scopeIds: readonly string[]): void;
+    persistModelScope(scopeIds: readonly string[]): void;
+    refreshModels(signal: AbortSignal): Promise<PiModelsRefreshResult>;
     pinnedLoginOptions(authType?: "oauth" | "api_key"): readonly PiAuthenticationProviderOption[];
     pinnedLoginMethodOptions(providerReference: string): {
         readonly title: string;

package/dist/integrations/pi/engine/adapter.js

@@ -193,7 +193,7 @@ export class PiEngineAdapter {
             emitView: () => { this.#emitView(); },
             diagnostic: (severity, code, message, recoverable) => { this.#addDiagnostic(severity, code, message, recoverable); },
         });
-        this.#resources = new PiResourceCatalog({ contexts: this.#contexts }, {
+        this.#resources = new PiResourceCatalog({ contexts: this.#contexts, productMode: options.settingsProductMode ?? "bare" }, {
             session: () => this.#engine.session,
             runtime: () => this.#engine.runtime,
         });
@@ -321,6 +321,18 @@ export class PiEngineAdapter {
     refreshScopedModels(signal) {
         return this.#contexts.refreshScopedModels(signal);
     }
+    modelsContext() {
+        return this.#contexts.modelsContext();
+    }
+    setSessionModelScope(scopeIds) {
+        this.#contexts.setSessionModelScope(scopeIds);
+    }
+    persistModelScope(scopeIds) {
+        this.#contexts.persistModelScope(scopeIds);
+    }
+    refreshModels(signal) {
+        return this.#contexts.refreshModels(signal);
+    }
     pinnedLoginOptions(authType) {
         return this.#contexts.loginOptions(authType);
     }

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

@@ -14,5 +14,5 @@ export { resolvePiProjectTrustPreflight } from "./project-trust-preflight.js";
 export type { PiProjectTrustPreflightPrompt, PiProjectTrustPreflightRequest, PiProjectTrustPreflightResult, ResolvePiProjectTrustPreflightOptions, } from "./project-trust-preflight.js";
 export { configureOwnedHttpDispatcher, configuredOwnedHttpIdleTimeoutMs } from "./http-dispatcher.js";
 export { createPiPackagesPort } from "./package-integration.js";
-export { PINNED_PI_HIDDEN_COMMAND_NAMES, PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES } from "./workflows.js";
-export type { PiAuthenticationProviderOption, PiAuthenticationProviderStatus, PiBashWorkflowResult, PiHiddenWorkflowCommandName, PiPinnedSettingsCallback, PiPinnedSettingsSnapshot, PiProjectTrustContext, PiProjectTrustUpdate, PiScopedModelDescriptor, PiScopedModelsContext, PiScopedModelsRefreshResult, PiSessionInfoPresentation, PiSessionResumeMetadata, PiSessionSelectorContext, PiTreeSelectorContext, PiWorkflowAutocompleteCommand, PiWorkflowCommandName, PiWorkflowHost, PiWorkflowInteractionHost, PiWorkflowInteractionRequest, PiWorkflowLoginNotification, PiWorkflowLoginStart, PiWorkflowMessage, PiWorkflowMessageKind, PiWorkflowOption, PiWorkflowOutcome, PiWorkflowPresentation, PiWorkflowRequest, PiWorkflowResult, PiWorkflowRoute, } from "./workflows.js";
+export { OWNED_MODELS_COMMAND_NAME, OWNED_WORKFLOW_COMMAND_NAMES, PINNED_PI_HIDDEN_COMMAND_NAMES, PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES, workflowCommandNames, } from "./workflows.js";
+export type { PiAuthenticationProviderOption, PiAuthenticationProviderStatus, PiBashWorkflowResult, PiHiddenWorkflowCommandName, PiModelsContext, PiModelsRefreshResult, PiPinnedSettingsCallback, PiPinnedSettingsSnapshot, PiProjectTrustContext, PiProductMode, PiProjectTrustUpdate, PiScopedModelDescriptor, PiScopedModelsContext, PiScopedModelsRefreshResult, PiSessionInfoPresentation, PiSessionResumeMetadata, PiSessionSelectorContext, PiTreeSelectorContext, PiWorkflowAutocompleteCommand, PiWorkflowCommandName, PiWorkflowHost, PiWorkflowInteractionHost, PiWorkflowInteractionRequest, PiWorkflowLoginNotification, PiWorkflowLoginStart, PiWorkflowMessage, PiWorkflowMessageKind, PiWorkflowOption, PiWorkflowOutcome, PiWorkflowPresentation, PiWorkflowRequest, PiWorkflowResult, PiWorkflowRoute, } from "./workflows.js";

package/dist/integrations/pi/engine/index.js

@@ -7,4 +7,4 @@ export { assertPiSettingsMetadata, loadPiSettingsMetadata, PI_SETTINGS_METADATA_
 export { resolvePiProjectTrustPreflight } from "./project-trust-preflight.js";
 export { configureOwnedHttpDispatcher, configuredOwnedHttpIdleTimeoutMs } from "./http-dispatcher.js";
 export { createPiPackagesPort } from "./package-integration.js";
-export { PINNED_PI_HIDDEN_COMMAND_NAMES, PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES } from "./workflows.js";
+export { OWNED_MODELS_COMMAND_NAME, OWNED_WORKFLOW_COMMAND_NAMES, PINNED_PI_HIDDEN_COMMAND_NAMES, PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES, workflowCommandNames, } from "./workflows.js";

package/dist/integrations/pi/engine/resource-catalog.d.ts

@@ -1,6 +1,6 @@
 import type { AgentSession, AgentSessionRuntime } from "../startup-public.js";
 import type { PiWorkflowContexts } from "./workflow-contexts.js";
-import { type PiWorkflowAutocompleteCommand } from "./workflows.js";
+import { type PiProductMode, type PiWorkflowAutocompleteCommand } from "./workflows.js";
 export interface OwnedPiResourceSummary {
     readonly kind: "skill" | "prompt-template" | "agent-context" | "system-prompt" | "theme";
     readonly id: string;
@@ -38,6 +38,7 @@ export declare class PiResourceCatalog {
     #private;
     constructor(options: {
         readonly contexts: PiWorkflowContexts;
+        readonly productMode?: PiProductMode;
     }, ports: PiResourceCatalogPorts);
     nonVisualResources(): readonly OwnedPiResourceSummary[];
     extensionResources(): readonly OwnedPiExtensionResourceSummary[];

package/dist/integrations/pi/engine/resource-catalog.js

@@ -1,5 +1,5 @@
 import { isRecord, stringProperty } from "./message-values.js";
-import { PINNED_PI_WORKFLOW_COMMAND_NAMES } from "./workflows.js";
+import { OWNED_MODELS_COMMAND_NAME, workflowCommandNames } from "./workflows.js";
 /**
  * The resources pinned Pi's loader discovered for the current runtime (skills, prompt templates,
  * agent context files, system prompts, themes, extensions) and the slash-command autocomplete
@@ -9,8 +9,10 @@ import { PINNED_PI_WORKFLOW_COMMAND_NAMES } from "./workflows.js";
 export class PiResourceCatalog {
     #ports;
     #contexts;
+    #productMode;
     constructor(options, ports) {
         this.#contexts = options.contexts;
+        this.#productMode = options.productMode ?? "bare";
         this.#ports = ports;
     }
     nonVisualResources() {
@@ -159,13 +161,20 @@ export class PiResourceCatalog {
     }
     workflowAutocompleteCommands() {
         const commands = [
-            {
-                name: "model",
-                description: "Select model (opens selector UI)",
-                argumentHint: "<provider/model>",
-                argumentOptions: this.#contexts.modelOptions(),
-                source: "builtin",
-            },
+            this.#productMode === "bare"
+                ? {
+                    name: OWNED_MODELS_COMMAND_NAME,
+                    description: "Switch models and manage scoped model cycling",
+                    argumentOptions: this.#contexts.modelOptions(),
+                    source: "builtin",
+                }
+                : {
+                    name: "model",
+                    description: "Select model (opens selector UI)",
+                    argumentHint: "<provider/model>",
+                    argumentOptions: this.#contexts.modelOptions(),
+                    source: "builtin",
+                },
             {
                 name: "login",
                 description: "Configure provider authentication",
@@ -174,7 +183,8 @@ export class PiResourceCatalog {
                 source: "builtin",
             },
         ];
-        const usedNames = new Set(PINNED_PI_WORKFLOW_COMMAND_NAMES);
+        // Invariant: only the active product mode's catalog reserves names; the other mode's replaced routes stay free for resources.
+        const usedNames = new Set(workflowCommandNames(this.#productMode));
         const loader = this.#ports.runtime()?.services.resourceLoader;
         if (!loader)
             return commands;

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

@@ -1,6 +1,6 @@
 import { type AgentSession, type AgentSessionRuntime } from "../startup-public.js";
 import type { OwnedUiModelInfo } from "../../../contracts/owned-ui/index.js";
-import type { PiAuthenticationProviderOption, PiProjectTrustContext, PiProjectTrustUpdate, PiScopedModelsContext, PiScopedModelsRefreshResult, PiSessionSelectorContext, PiTreeSelectorContext, PiWorkflowOption } from "./workflows.js";
+import type { PiAuthenticationProviderOption, PiModelsContext, PiModelsRefreshResult, PiProjectTrustContext, PiProjectTrustUpdate, PiScopedModelsContext, PiScopedModelsRefreshResult, PiSessionSelectorContext, PiTreeSelectorContext, PiWorkflowOption } from "./workflows.js";
 type PiSessionApi = AgentSession;
 type PiRuntimeApi = AgentSessionRuntime;
 export interface PiWorkflowContextPorts {
@@ -40,6 +40,13 @@ export declare class PiWorkflowContexts {
     updateScopedModels(enabledModelIds: readonly string[] | null): void;
     persistScopedModels(enabledModelIds: readonly string[] | null): void;
     refreshScopedModels(signal: AbortSignal): Promise<PiScopedModelsRefreshResult>;
+    /** The bare-A1 Models dialog's read: catalog, active model, and the session and persisted scopes kept separate. */
+    modelsContext(): PiModelsContext;
+    /** Replace the session's cycling scope with exactly these available models, in order; empty restores the all-model fallback. */
+    setSessionModelScope(scopeIds: readonly string[]): void;
+    /** Persist the explicit scope as `enabledModels`; an empty scope removes the setting so cycling falls back to every model. */
+    persistModelScope(scopeIds: readonly string[]): void;
+    refreshModels(signal: AbortSignal): Promise<PiModelsRefreshResult>;
     pinnedLoginMethodOptions(providerReference: string): {
         readonly title: string;
         readonly options: readonly PiWorkflowOption[];

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

@@ -156,23 +156,67 @@ export class PiWorkflowContexts {
         requireCapability(runtime.services.settingsManager?.setEnabledModels, "setEnabledModels").call(runtime.services.settingsManager, patterns === undefined ? undefined : [...patterns]);
     }
     async refreshScopedModels(signal) {
+        const outcome = await this.#refreshCatalogs(signal);
+        return { ...this.pinnedScopedModelsContext(), ...outcome };
+    }
+    /** The bare-A1 Models dialog's read: catalog, active model, and the session and persisted scopes kept separate. */
+    modelsContext() {
+        const session = this.#requireSession();
+        const runtime = this.#ports.runtime();
+        if (!runtime)
+            throw new Error("engine runtime is unavailable");
+        const models = scopedModelRecords(runtime.services.modelRuntime);
+        const scoped = session.scopedModels;
+        const active = this.#ports.activeModel();
+        const patterns = runtime.services.settingsManager?.getEnabledModels?.();
+        return {
+            models: models.map(item => item.descriptor),
+            activeModelId: active === null ? null : `${active.providerId}/${active.modelId}`,
+            sessionScopeIds: Array.isArray(scoped) ? scoped.map(scopedModelReference).filter((id) => id !== undefined) : [],
+            persistedScopeIds: Array.isArray(patterns)
+                ? resolveConfiguredModelIds(patterns.filter((value) => typeof value === "string"), models)
+                : [],
+        };
+    }
+    /** Replace the session's cycling scope with exactly these available models, in order; empty restores the all-model fallback. */
+    setSessionModelScope(scopeIds) {
+        const session = this.#requireSession();
+        const runtime = this.#ports.runtime();
+        if (!runtime)
+            throw new Error("engine runtime is unavailable");
+        const models = scopedModelRecords(runtime.services.modelRuntime);
+        const scoped = scopeIds.flatMap(id => {
+            const item = models.find(candidate => `${candidate.descriptor.provider}/${candidate.descriptor.id}` === id);
+            return item === undefined ? [] : [{ model: item.model }];
+        });
+        requireCapability(session.setScopedModels, "setScopedModels").call(session, scoped);
+        this.#ports.emitView();
+    }
+    /** Persist the explicit scope as `enabledModels`; an empty scope removes the setting so cycling falls back to every model. */
+    persistModelScope(scopeIds) {
+        const runtime = this.#ports.runtime();
+        if (!runtime)
+            throw new Error("engine runtime is unavailable");
+        requireCapability(runtime.services.settingsManager?.setEnabledModels, "setEnabledModels")
+            .call(runtime.services.settingsManager, scopeIds.length === 0 ? undefined : [...scopeIds]);
+    }
+    async refreshModels(signal) {
+        const outcome = await this.#refreshCatalogs(signal);
+        return { models: this.modelsContext().models, ...outcome };
+    }
+    async #refreshCatalogs(signal) {
         const runtime = this.#ports.runtime();
         if (!runtime)
             throw new Error("engine runtime is unavailable");
         const result = await runtime.services.modelRuntime.refresh?.({ signal });
-        const context = this.pinnedScopedModelsContext();
         if (isRecord(result) && result.aborted === true) {
-            return { ...context, status: "Model refresh timed out; showing cached models.", statusKind: "warning" };
+            return { status: "Model refresh timed out; showing cached models.", statusKind: "warning" };
         }
         const errors = isRecord(result) ? result.errors : undefined;
         if (errors instanceof Map && errors.size > 0) {
-            return {
-                ...context,
-                status: `Could not refresh ${[...errors.keys()].join(", ")}; showing cached models.`,
-                statusKind: "warning",
-            };
+            return { status: `Could not refresh ${[...errors.keys()].join(", ")}; showing cached models.`, statusKind: "warning" };
         }
-        return { ...context, status: "Model catalogs refreshed.", statusKind: "success" };
+        return { status: "Model catalogs refreshed.", statusKind: "success" };
     }
     pinnedLoginMethodOptions(providerReference) {
         const runtime = this.#ports.runtime();