@hydraharness/harness-client-ui-agent-preset 0.1.1-rc.6

package/lib/index.js

@@ -0,0 +1,11 @@
+//#region lib/types/index.js
+/**
+* Agent-preset surface plugin, node half. The empty apply exists so the plugin
+* appears in the host cordis.yml / Loader; the browser half ships the
+* General-settings row through exports["./client"], discovered from the
+* package.json hydra.client declaration.
+*/
+/** Host plugin body — no host-side behavior for this surface plugin. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@hydraharness/harness-client-ui-agent-preset`.
+* @module @hydraharness/harness-client-ui-agent-preset/invariant
+*/
+const PACKAGE_NAME = "@hydraharness/harness-client-ui-agent-preset";
+/** Cordis companion plugin name. */
+const name = "client-ui-agent-preset-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: this is a browser-side surface plugin whose node half owns no event stream
+* or mutable runtime data; the roster and the settings write are host contracts covered there.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/client/AgentPresetLabel.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The session header's agent-preset label.
+ *
+ * Read-only by construction: a session's composition is fixed once its
+ * conversation starts, and a header is only worth reading after that. Offering
+ * a control here would promise a switch the host refuses; naming what the
+ * session runs is the honest affordance, and the choice itself lives on the
+ * new-session screen ({@link AgentPresetSeat}).
+ */
+import type { SnapshotStore } from '@hydraharness/harness-client-runtime/client';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@hydraharness/harness-client-ui-slots';
+import type { AgentPresetSettingsState } from './settings-store.ts';
+/** Registration-side business face for the header label. */
+export interface AgentPresetLabelInjected {
+    hooks: {
+        /** Roster snapshot bound by the renderer as useAgentPresets. */
+        agentPresets: SnapshotStore<AgentPresetSettingsState>;
+    };
+    /** Read the roster, so the label can show a name rather than an id. */
+    load: () => Promise<void>;
+}
+/** Full component props. */
+export type AgentPresetLabelProps = PropsRuntime<'conversation.session.header.actions'> & PropsLocale<'settings.agentPreset'> & InjectFace<AgentPresetLabelInjected>;
+/**
+ * Render this session's agent-preset name beside its title.
+ * @param props - composed slot props.
+ * @returns the label, or null when the session records no preset.
+ */
+export declare function AgentPresetLabel({ sessionId, useSessions, useAgentPresets, load, t, }: AgentPresetLabelProps): import("react").JSX.Element | null;
+//# sourceMappingURL=AgentPresetLabel.d.ts.map

package/lib/types/client/AgentPresetRow.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Agent-preset preference row: the preset new sessions are composed from.
+ * A running session keeps the composition it began with, so this row never
+ * disturbs work in progress.
+ */
+import type { SnapshotStore } from '@hydraharness/harness-client-runtime/client';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@hydraharness/harness-client-ui-slots';
+import type { AgentPresetSettingsState } from './settings-store.ts';
+import { type AgentPresetSettingsKey } from './locales.ts';
+/** Registration-side business face for the host-backed preference. */
+export interface AgentPresetRowInjected {
+    hooks: {
+        /** Agent-preset settings snapshot bound by the renderer as useAgentPreset. */
+        agentPreset: SnapshotStore<AgentPresetSettingsState>;
+    };
+    /** Load the roster when the row first renders. */
+    load: () => Promise<void>;
+    /** Persist one preset as the default for later sessions. */
+    select: (id: string) => Promise<void>;
+}
+/** Full component props. */
+export type AgentPresetRowProps = PropsRuntime<'settings.general.item'> & PropsLocale<'settings.agentPreset'> & InjectFace<AgentPresetRowInjected>;
+/**
+ * Render the new-session agent-preset selector.
+ * @param props - composed slot props.
+ * @returns the row, or null when the deployment composes no presets.
+ */
+export declare function AgentPresetRow({ load, select, useAgentPreset, t }: AgentPresetRowProps): import("react").JSX.Element | null;
+declare module '@hydraharness/harness-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Agent-preset row copy. */
+        'settings.agentPreset': AgentPresetSettingsKey;
+    }
+}
+//# sourceMappingURL=AgentPresetRow.d.ts.map

package/lib/types/client/AgentPresetSeat.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The agent-preset chip on the new-session screen, beside the workspace
+ * picker.
+ *
+ * It lives here rather than in the composer because the choice is only
+ * available before a conversation starts: once a turn has run, the session's
+ * history was produced under that preset's tools and the host refuses to swap
+ * them. A control that spends most of its life disabled belongs on the screen
+ * where it still works.
+ *
+ * The menu opens on the staged choice, which starts as the deployment default.
+ * Picking stages; the choice reaches a session when one becomes current.
+ */
+import type { SnapshotStore } from '@hydraharness/harness-client-runtime/client';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@hydraharness/harness-client-ui-slots';
+import type { AgentPresetSeatState } from './seat-store.ts';
+/** Registration-side business face for the hero chip. */
+export interface AgentPresetSeatInjected {
+    hooks: {
+        /** Seat snapshot bound by the renderer as useAgentPresetSeat. */
+        agentPresetSeat: SnapshotStore<AgentPresetSeatState>;
+    };
+    /** Read the roster when the chip first renders. */
+    load: () => Promise<void>;
+    /** Stage one preset for the next session. */
+    select: (id: string) => Promise<void>;
+    /** Clear the one-shot introduce cue once the chip has played it. */
+    introduced: () => void;
+}
+/** Full component props. */
+export type AgentPresetSeatProps = PropsRuntime<'conversation.hero.agentPreset'> & PropsLocale<'settings.agentPreset'> & InjectFace<AgentPresetSeatInjected>;
+/**
+ * Render the new-session agent-preset chip.
+ * @param props - composed slot props.
+ * @returns the chip, or null when the deployment composes no presets.
+ */
+export declare function AgentPresetSeat({ load, select, introduced, useAgentPresetSeat, t }: AgentPresetSeatProps): import("react").JSX.Element | null;
+//# sourceMappingURL=AgentPresetSeat.d.ts.map

package/lib/types/client/AgentPresetSection.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Agent-presets settings section: the roster as cards, a copy dialog as the
+ * only way a preset is created, and a read-only viewer over the shipped
+ * compositions.
+ *
+ * The browser edits no composition text — a shipped preset opens read-only to
+ * be READ (it is the known-good composition a copy starts from), and a custom
+ * preset is edited in its own files, which is what the location action leads
+ * to. Deleting a preset leaves running sessions alone: a composition is
+ * mounted once at session creation and nothing re-reads the file.
+ */
+import type { ReactNode } from 'react';
+import type { SnapshotStore } from '@hydraharness/harness-client-runtime/client';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@hydraharness/harness-client-ui-slots';
+import { type AgentPresetSectionState } from './section-store.ts';
+/** Registration-side business face for the management section. */
+export interface AgentPresetSectionInjected {
+    hooks: {
+        /** Page snapshot bound by the renderer as useAgentPresetSection. */
+        agentPresetSection: SnapshotStore<AgentPresetSectionState>;
+    };
+    /** Read the roster; called once when the section first renders. */
+    load: () => Promise<void>;
+    /** Open one shipped preset's composition in the read-only viewer. */
+    view: (id: string) => Promise<void>;
+    /** Close the read-only viewer. */
+    closeView: () => void;
+    /** Open the copy dialog over one preset. */
+    beginCopy: (from: string) => void;
+    /** Close the copy dialog, discarding the draft. */
+    cancelCopy: () => void;
+    /** Name the preset the copy creates. */
+    setCopyId: (id: string) => void;
+    /** Name the copy's display name. */
+    setCopyName: (name: string) => void;
+    /** Submit the copy. */
+    confirmCopy: () => Promise<void>;
+    /** Open one preset's directory, or reveal its path where there is no desktop. */
+    openLocation: (id: string) => Promise<void>;
+    /**
+     * Stage the self-referential preset and start a new session on it — the
+     * guided way to author a preset, beside copying. Absent when the surface
+     * is composed without the conversation flow to land the session in.
+     */
+    startCreatorDraft?: () => void;
+    /** Ask for delete confirmation, or dismiss it with null. */
+    confirmDelete: (id: string | null) => void;
+    /** Delete the preset awaiting confirmation. */
+    remove: () => Promise<void>;
+    /** Make one preset the default for sessions created later. */
+    makeDefault: (id: string) => Promise<void>;
+}
+/** Full component props. */
+export type AgentPresetSectionProps = PropsRuntime<'settings.section'> & PropsLocale<'settings.agentPreset'> & InjectFace<AgentPresetSectionInjected>;
+/**
+ * Render the Agent presets section content column.
+ * @param props - composed slot props.
+ * @returns the section, or null when the deployment composes no presets.
+ */
+export declare function AgentPresetSection(props: AgentPresetSectionProps): ReactNode;
+//# sourceMappingURL=AgentPresetSection.d.ts.map

package/lib/types/client/PresetMenu.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The preset picker both surfaces render: a menu of presets over a button
+ * naming the current one.
+ *
+ * The settings row and the composer seat differ in where they sit, what they
+ * call the current value, and when they refuse a pick — not in how the picker
+ * itself behaves. Trust is the one thing the list always says: a locally
+ * authored preset is exactly as privileged as the plugins it names, so the
+ * label marks it rather than presenting every preset as shipped and vetted.
+ */
+import type { AgentPresetOption } from './settings-store.ts';
+import { type AgentPresetSettingsKey } from './locales.ts';
+/** What one surface passes to the shared picker. */
+export interface PresetMenuProps {
+    /** Presets to offer, in roster order. */
+    options: readonly AgentPresetOption[];
+    /** The preset the button names and the menu marks selected. */
+    selectedId: string;
+    /** Text on the button; the surfaces word a pending roster differently. */
+    label: string;
+    /** Active Web locale lookup. */
+    t: (key: AgentPresetSettingsKey) => string;
+    /** Class for the trigger button, owned by the calling surface. */
+    buttonClassName: string | undefined;
+    /** Class for the chevron, owned by the calling surface. */
+    chevronClassName: string | undefined;
+    /** Whether the trigger refuses interaction. */
+    disabled: boolean;
+    /** Whether the menu is open — the surface owns this so it can force it shut. */
+    open: boolean;
+    /** Report the menu's next open state. */
+    onOpenChange: (open: boolean) => void;
+    /** Called with the picked preset once the menu has closed. */
+    onSelect: (id: string) => void;
+}
+/**
+ * Render the preset picker.
+ * @param props - the calling surface's copy, styling, and handlers.
+ * @returns the menu and its trigger.
+ */
+export declare function PresetMenu({ options, selectedId, label, t, buttonClassName, chevronClassName, disabled, open, onOpenChange, onSelect, }: PresetMenuProps): import("react").JSX.Element;
+//# sourceMappingURL=PresetMenu.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Agent-preset surface plugin, browser half — four surfaces over one roster:
+ * a General-settings row for the default preset, a chip on the new-session
+ * screen for the session about to start, a read-only label in the session
+ * header, and a settings section that manages the roster (copy, delete,
+ * default, and the way into a preset's own files).
+ *
+ * A running session keeps the composition it began with (the host refuses to
+ * adopt an existing session under a different preset). That is what splits
+ * the choice from the display: the General row and the hero chip are both
+ * before-the-fact, while the header only reports what a session already runs.
+ */
+import type { ClientContext } from '@hydraharness/harness-client-runtime/client';
+export type { AgentPresetLabelInjected, AgentPresetLabelProps } from './AgentPresetLabel.tsx';
+export type { AgentPresetRowInjected, AgentPresetRowProps } from './AgentPresetRow.tsx';
+export type { AgentPresetSeatInjected, AgentPresetSeatProps } from './AgentPresetSeat.tsx';
+export type { AgentPresetSectionInjected, AgentPresetSectionProps } from './AgentPresetSection.tsx';
+export type { AgentPresetSeatState, SeatSessionSummary } from './seat-store.ts';
+export { draftBlocker, type AgentPresetSectionState, type CopyDraft, type PresetRow, type PresetView, } from './section-store.ts';
+export type { AgentPresetOption, AgentPresetSettingsState } from './settings-store.ts';
+export { AGENT_PRESET_SETTINGS_NS, writeDefaultPreset } from './settings-store.ts';
+/** Required services (cordis fiber inject). */
+export declare const inject: string[];
+/**
+ * Mount the General-settings row.
+ * @param ctx - the browser plugin context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/locales.d.ts

@@ -0,0 +1,31 @@
+/** Locale bundles for the agent-preset settings row, hero chip, header label, and management section. */
+/** Locale keys these surfaces render. */
+export type AgentPresetSettingsKey = 'title' | 'description' | 'loading' | 'error' | 'userTrust' | 'seatHint' | 'headerHint' | 'nav' | 'sectionIntro' | 'builtIn' | 'setDefault' | 'view' | 'presetStandardName' | 'presetStandardDescription' | 'presetCodeName' | 'presetCodeDescription' | 'presetMinimalName' | 'presetMinimalDescription' | 'presetCordisName' | 'presetCordisDescription' | 'duplicate' | 'duplicateUnavailable' | 'delete' | 'presetId' | 'presetIdPlaceholder' | 'copyOf' | 'displayName' | 'displayNamePlaceholder' | 'inUse' | 'noDescription' | 'builtInGroup' | 'customGroup' | 'brokenBadge' | 'brokenNoCopy' | 'composition' | 'cancel' | 'close' | 'retry' | 'copyTitle' | 'copyIntro' | 'create' | 'creating' | 'creatorDraft' | 'openLocation' | 'showLocation' | 'revealedPathLabel' | 'idRequired' | 'idInvalid' | 'idTaken' | 'deleteTitle' | 'deleteDescription' | 'deleteConfirm' | 'deleting';
+/** English copy. */
+export declare const en: Record<AgentPresetSettingsKey, string>;
+/** Preset roster fields needed to resolve Web display copy. */
+export interface PresetDisplaySource {
+    /** Stable preset id. */
+    readonly id: string;
+    /** Whether the deployment ships the preset or the user owns it. */
+    readonly trust: 'system' | 'user';
+    /** Unlocalized name published by the preset. */
+    readonly name?: string;
+    /** Unlocalized description published by the preset. */
+    readonly description?: string;
+}
+/** Display copy resolved for the active Web locale. */
+export interface PresetDisplayText {
+    /** Localized built-in name or the preset's own fallback name. */
+    readonly name: string;
+    /** Localized built-in description or the preset's own description. */
+    readonly description?: string;
+}
+/**
+ * Resolve preset display copy without making user-authored metadata translatable.
+ * @param preset - roster row whose copy is being rendered.
+ * @param t - active Web locale lookup.
+ * @returns localized copy for a known shipped preset, otherwise file metadata.
+ */
+export declare function presetDisplayText(preset: PresetDisplaySource, t: (key: AgentPresetSettingsKey) => string): PresetDisplayText;
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/seat-store.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Hero-chip controller: which preset the NEXT session gets.
+ *
+ * The new-session screen has no session, so a pick is staged rather than
+ * applied. It reaches a session when one becomes current and is still blank —
+ * whether the workspace connect created it or reused an existing blank one,
+ * which is why staging cannot simply ride along on `sessions.create`.
+ *
+ * The stage is forgotten once applied: the next new session starts from the
+ * deployment default again, matching the workspace picker beside it.
+ */
+import type { IApiClient } from '@hydraharness/harness-api-remotes/client';
+import { type SessionId, type SnapshotStore } from '@hydraharness/harness-client-runtime/client';
+import type { AgentPresetOption } from './settings-store.ts';
+/** Hero-chip snapshot. */
+export interface AgentPresetSeatState {
+    /** Presets the deployment supplies; empty means the chip renders nothing. */
+    options: readonly AgentPresetOption[];
+    /** The staged choice, empty until the roster loads. */
+    current: string;
+    /** A rejected apply's message, cleared by the next attempt. */
+    error: string | null;
+    busy: boolean;
+    /**
+     * One-shot cue that the chip should introduce itself (the creator-draft
+     * entry staged the pick from another screen, so the user never touched the
+     * chip); the renderer clears it via `introduced()` once played.
+     */
+    introduce: boolean;
+}
+/** One session's identity and whether it has started. */
+export interface SeatSessionSummary {
+    /** The session the chip would apply its staged choice to. */
+    id: SessionId;
+    /** False once a turn has run — applying is refused from then on. */
+    blank: boolean;
+    /** The preset the session already runs, when the summary reports one. */
+    agentPreset?: string;
+}
+/** Stages the next session's preset and applies it when one appears. */
+export declare class AgentPresetSeatController {
+    private readonly api;
+    /** The session the hero is about to hand over to, when there is one. */
+    private readonly currentSession;
+    /**
+     * Publish an applied switch into the session list, so the header label
+     * moves with the composition instead of waiting for the next full list
+     * refresh. Optional: a harness that renders no list omits it.
+     */
+    private readonly onApplied?;
+    /** Chip snapshot the renderer subscribes to. */
+    readonly store: SnapshotStore<AgentPresetSeatState>;
+    /**
+     * The deployment default, so a consumed stage can fall back to it without
+     * re-reading the roster.
+     */
+    private fallback;
+    /** Set while a pick is waiting for a session; cleared once applied. */
+    private staged;
+    constructor(api: Pick<IApiClient, 'agentPresets'>, 
+    /** The session the hero is about to hand over to, when there is one. */
+    currentSession: () => SeatSessionSummary | undefined, 
+    /**
+     * Publish an applied switch into the session list, so the header label
+     * moves with the composition instead of waiting for the next full list
+     * refresh. Optional: a harness that renders no list omits it.
+     */
+    onApplied?: ((sessionId: string, agentPreset: string) => void) | undefined);
+    private set;
+    /**
+     * Read the roster and open the chip on the deployment default.
+     * @returns once the snapshot reflects the host.
+     */
+    load(): Promise<void>;
+    /**
+     * Stage one preset for the next session, applying it immediately when a
+     * blank session is already current.
+     * @param id - the preset to stage.
+     * @returns once the stage settled, and the apply too when one happened.
+     */
+    select(id: string): Promise<void>;
+    /**
+     * Stage a pick WITHOUT the immediate apply, for a flow that starts the
+     * receiving session after the pick (the settings section's creator entry).
+     * `select()`'s immediate apply would meet the still-current running session
+     * and drop the stage as unservable; staging alone leaves it for the
+     * list-change applier, which fires when the started session becomes
+     * current.
+     * @param id - the preset to stage.
+     * @param introduce - true when the stage came from another screen and the
+     * chip should announce itself on the session it lands on.
+     */
+    stage(id: string, introduce?: boolean): void;
+    /** Acknowledge the introduction cue once the chip has played it. */
+    introduced(): void;
+    /**
+     * Hand the staged choice to the current session, if there is one to take it.
+     *
+     * Called both by `select()` and by whoever observes the current session
+     * changing, because the session may appear either before or after the pick.
+     * @returns once the switch settled, or immediately when there is nothing to do.
+     */
+    apply(): Promise<void>;
+}
+//# sourceMappingURL=seat-store.d.ts.map

package/lib/types/client/section-store.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Agent-preset management controller: the roster as a list, a copy dialog as
+ * the only way a preset is created, and a read-only viewer over the shipped
+ * compositions.
+ *
+ * The browser edits no composition text. A new preset is a host-side copy of
+ * an existing one (`{ from, id, name? }` is all that crosses the wire), and
+ * everything after creation happens in the preset's own files — which is why
+ * the page's other job is getting the user TO those files: open the directory
+ * where the host has a desktop, show its path where it does not.
+ *
+ * The host stays the single fact source. Every mutation writes through the
+ * wire and the page re-reads the roster afterwards, because a copy changes
+ * more than the row it targeted.
+ */
+import type { IApiClient } from '@hydraharness/harness-api-remotes/client';
+import { type SnapshotStore } from '@hydraharness/harness-client-runtime/client';
+/** One preset row the page renders. */
+export interface PresetRow {
+    /** Preset id and directory name; the display name falls back to it. */
+    id: string;
+    /** Display name the preset published, absent when it published none. */
+    name?: string;
+    /** One sentence on what the preset is for. */
+    description?: string;
+    /** Whether the preset ships with the deployment or was authored locally. */
+    trust: 'system' | 'user';
+    /** Whether a session that names no preset gets this one. */
+    isDefault: boolean;
+    /**
+     * Why the preset cannot compose a session, absent when it can. A broken
+     * row renders marked and unselectable — its directory still occupies the
+     * id, so deleting it (or fixing the files) is the way out, and this page
+     * is where both of those live.
+     */
+    broken?: string;
+}
+/** The copy dialog: a new id and optional display name over a fixed source. */
+export interface CopyDraft {
+    /** The preset being copied. */
+    from: string;
+    /** Display name of the source, for the dialog title. */
+    fromTitle: string;
+    /** New preset id being typed; the directory name, so it is required. */
+    id: string;
+    /** Display name being typed; empty falls back to the id. */
+    name: string;
+    /** Whether the copy is in flight. */
+    saving: boolean;
+    /** The last copy failure, cleared by the next edit. */
+    error: string | null;
+}
+/** The read-only composition viewer over one shipped preset. */
+export interface PresetView {
+    /** The preset whose composition is shown. */
+    id: string;
+    /** Display name, for the dialog title. */
+    title: string;
+    /** Composition text exactly as stored. */
+    content: string;
+}
+/** Page snapshot. */
+export interface AgentPresetSectionState {
+    status: 'idle' | 'loading' | 'ready' | 'unavailable' | 'error';
+    /** Whole-load failure text; a copy failure stays on the dialog. */
+    error: string | null;
+    /** Whether the deployment configures a root new presets can be written to. */
+    authorable: boolean;
+    /** Whether the host can open a preset directory on a native desktop. */
+    hasDocument: boolean;
+    /** Every preset the deployment currently supplies. */
+    rows: readonly PresetRow[];
+    /** The open copy dialog, or null. */
+    copy: CopyDraft | null;
+    /** The open read-only viewer, or null. */
+    view: PresetView | null;
+    /** The preset awaiting delete confirmation. */
+    pendingDelete: string | null;
+    /** Whether a delete is in flight. */
+    deleting: boolean;
+    /**
+     * Preset directories shown as text because the host has no desktop opener
+     * — the answer `openDocument` gives instead of opening.
+     */
+    revealedPaths: Readonly<Record<string, string>>;
+}
+/**
+ * Why this copy cannot be submitted yet, as a locale key, or undefined when
+ * it can. Client-side only: the host re-checks the id and its answer is what
+ * the dialog reports on failure.
+ * @param draft - the open copy dialog.
+ * @param rows - the roster, for the collision check.
+ * @returns the blocking reason's locale key, or undefined when submittable.
+ */
+export declare function draftBlocker(draft: CopyDraft, rows: readonly PresetRow[]): 'idRequired' | 'idInvalid' | 'idTaken' | undefined;
+/** Reads the roster and drives the copy dialog, viewer, and location reveals. */
+export declare class AgentPresetSectionController {
+    private readonly api;
+    /**
+     * Called after this page changes the roster DIRECTORY, so the other
+     * surfaces reading the same roster re-read it. A settings field moving is
+     * already announced by the host through the forwarded
+     * `settings/document-updated`; a directory copied or deleted here is not,
+     * and the new-session chip has no other way to learn a preset it should
+     * offer now exists.
+     */
+    private readonly rosterChanged;
+    /** Page snapshot the renderer subscribes to. */
+    readonly store: SnapshotStore<AgentPresetSectionState>;
+    private readonly refresh;
+    constructor(api: Pick<IApiClient, 'agentPresets' | 'settings'>, 
+    /**
+     * Called after this page changes the roster DIRECTORY, so the other
+     * surfaces reading the same roster re-read it. A settings field moving is
+     * already announced by the host through the forwarded
+     * `settings/document-updated`; a directory copied or deleted here is not,
+     * and the new-session chip has no other way to learn a preset it should
+     * offer now exists.
+     */
+    rosterChanged?: () => void);
+    private set;
+    private patchCopy;
+    /**
+     * Load the roster. An empty roster means the deployment composes no
+     * presets, which is a valid deployment rather than a failure — the section
+     * reports `unavailable` and renders nothing.
+     * @returns once the snapshot reflects the host.
+     */
+    load(): Promise<void>;
+    private acceptRoster;
+    /**
+     * Open one shipped preset's composition in the read-only viewer.
+     * @param id - the preset to view.
+     * @returns once the composition loaded or the failure is on the page.
+     */
+    view(id: string): Promise<void>;
+    /** Close the read-only viewer. */
+    closeView(): void;
+    /**
+     * Open the copy dialog over one preset.
+     * @param from - the preset the copy will start from.
+     */
+    beginCopy(from: string): void;
+    /** Close the copy dialog, discarding whatever was typed. */
+    cancelCopy(): void;
+    /**
+     * Name the preset the copy creates.
+     * @param id - the id typed into the dialog.
+     */
+    setCopyId(id: string): void;
+    /**
+     * Name the copy's display name.
+     * @param name - the display name typed into the dialog.
+     */
+    setCopyName(name: string): void;
+    /**
+     * Submit the copy, re-read the roster, then take the user to the new
+     * preset's files — the directory opens where the host has a desktop, and
+     * its path appears on the new row where it does not.
+     * @returns once the copy settled and the page reflects it.
+     */
+    confirmCopy(): Promise<void>;
+    /**
+     * Open one preset's directory on the host desktop, or reveal its path on
+     * the row where the deployment has no opener to hand it to.
+     * @param id - the preset whose files the user wants.
+     * @returns once the host answered and the page reflects it.
+     */
+    openLocation(id: string): Promise<void>;
+    /**
+     * Ask for confirmation before deleting one preset.
+     * @param id - the preset to delete, or null to dismiss the confirmation.
+     */
+    confirmDelete(id: string | null): void;
+    /**
+     * Delete the preset awaiting confirmation, then re-read the roster.
+     *
+     * A session already composed from it keeps running: its composition was
+     * mounted at creation and nothing re-reads the file.
+     * @returns once the delete settled and the page reflects it.
+     */
+    remove(): Promise<void>;
+    /**
+     * Make one preset the default for sessions created later. Running sessions
+     * keep the composition they began with, so this never disturbs work.
+     * @param id - the preset to make default.
+     * @returns once the write settled and the roster was re-read.
+     */
+    makeDefault(id: string): Promise<void>;
+}
+//# sourceMappingURL=section-store.d.ts.map