cli-jaw 2.17.72 → 2.17.73

package/public/manager/src/settings/pages/Memory.tsx

@@ -37,7 +37,7 @@ import {
     type MemoryBlock,
     type MemoryEntry,
 } from './components/memory-helpers';
-import { metaFor, selectableRuntimeOptions, isRetiredCliSelection, retiredRuntimeLabel } from './components/agent/agent-meta';
+import { metaFor, auxiliaryRuntimeOptions, isRetiredCliSelection, retiredRuntimeLabel } from './components/agent/agent-meta';
 
 // Re-export pure helpers for unit tests (Heartbeat pattern).
 export {
@@ -125,6 +125,7 @@ export default function Memory({ port, client, dirty, registerSave }: SettingsPa
             if (isMemorySettingsKey(key)) filtered[key] = value;
         }
         if (Object.keys(filtered).length === 0) return;
+        if (filtered['memory.cli'] === 'aside' || (filtered['memory.cli'] === '' && settingsSnap.state.kind === 'ready' && settingsSnap.state.data['cli'] === 'aside')) throw new Error('Aside cannot run memory flush.');
         const patch = expandPatch(filtered);
         const updated = await client.put<SettingsSnapshot>('/api/settings', patch);
         const fresh = (updated && typeof updated === 'object' && 'data' in updated
@@ -211,12 +212,13 @@ export default function Memory({ port, client, dirty, registerSave }: SettingsPa
     const retentionError = validatePositiveInt(retentionDays, 'Retention days');
 
     const perCli = settingsSnap.state.data.perCli || {};
-    const cliKeys = selectableRuntimeOptions(Object.keys(perCli));
+    const cliKeys = auxiliaryRuntimeOptions(Object.keys(perCli));
+    const asideInherited = !cli && settingsSnap.state.data['cli'] === 'aside';
     const cliOptions = [
-        { value: '', label: '(profile default)' },
+        ...(settingsSnap.state.data['cli'] === 'aside' ? [] : [{ value: '', label: '(profile default)' }]),
         ...cliKeys.map((c) => ({ value: c, label: metaFor(c).label || c })),
     ];
-    if (cli && !isRetiredCliSelection(cli) && !cliOptions.some((opt) => opt.value === cli)) {
+    if (cli && cli !== 'aside' && !isRetiredCliSelection(cli) && !cliOptions.some((opt) => opt.value === cli)) {
         cliOptions.push({ value: cli, label: `${metaFor(cli).label || cli} (legacy)` });
     }
 
@@ -276,8 +278,8 @@ export default function Memory({ port, client, dirty, registerSave }: SettingsPa
                     id="memory-cli"
                     label="Flush CLI"
                     value={cli}
-                    missingValueLabel={isRetiredCliSelection(cli) ? retiredRuntimeLabel(cli) : undefined}
-                    error={isRetiredCliSelection(cli) ? 'The saved runtime is retired. Choose an available runtime.' : null}
+                    missingValueLabel={asideInherited ? '(profile default unavailable)' : cli === 'aside' ? 'Aside (main-only)' : isRetiredCliSelection(cli) ? retiredRuntimeLabel(cli) : undefined}
+                    error={asideInherited || cli === 'aside' ? 'Aside cannot run memory flush. Choose a separate runtime.' : isRetiredCliSelection(cli) ? 'The saved runtime is retired. Choose an available runtime.' : null}
                     options={cliOptions}
                     onChange={(next) => {
                         setCli(next);

package/public/manager/src/settings/pages/ModelProvider.tsx

@@ -16,6 +16,7 @@ import {
     usePageSnapshot,
     type SnapshotState,
 } from './page-shell';
+import { useAsideModels, asideSelectionError } from './components/aside-models';
 import { PerCliRow, type PiRegistration } from './components/PerCliRow';
 import { metaFor, normalizeCliMetaRegistry, selectableRuntimeOptions, isRetiredCliSelection, retiredRuntimeLabel } from './components/agent/agent-meta';
 import type { CliMeta, PerCliEntry } from './components/agent/agent-meta';
@@ -29,9 +30,9 @@ type ModelSnapshot = {
     pi?: PiSettingsView;
     [key: string]: unknown;
 };
-type ModelInstance = Pick<SettingsPageProps, 'client' | 'port' | 'dirty'>;
+type ModelInstance = Pick<SettingsPageProps, 'client' | 'port' | 'instanceUrl' | 'dirty'>;
 type BoundSnapshot = { instance: ModelInstance; value: ModelSnapshot };
-const ownsModelKey = (key: string) => key === 'fallbackOrder' || key.startsWith('perCli.');
+const ownsModelKey = (key: string) => key === 'fallbackOrder' || key.startsWith('perCli.') || key === 'activeOverrides.aside.model' || key === 'activeOverrides.aside.effort';
 
 function savedModelSnapshot(updated: unknown): ModelSnapshot {
     const value = updated && typeof updated === 'object' && 'data' in updated ? updated.data : updated;
@@ -62,8 +63,8 @@ export function buildResetOverridesPatch(snapshot: ModelSnapshot): {
     return { activeOverrides };
 }
 
-export default function ModelProvider({ port, client, dirty, registerSave }: SettingsPageProps) {
-    const instance = useMemo<ModelInstance>(() => ({ client, port, dirty }), [client, port, dirty]);
+export default function ModelProvider({ port, instanceUrl, client, dirty, registerSave }: SettingsPageProps) {
+    const instance = useMemo<ModelInstance>(() => ({ client, port, instanceUrl, dirty }), [client, port, instanceUrl, dirty]);
     const activeInstance = useRef<ModelInstance | null>(null);
     const activeOperation = useRef<{ instance: ModelInstance; kind: 'save' | 'reset'; promise: Promise<void> } | null>(null);
     const metadataGeneration = useRef(0);
@@ -88,6 +89,20 @@ export default function ModelProvider({ port, client, dirty, registerSave }: Set
     const [saving, setSaving] = useState(false);
     const [cliMeta, setCliMeta] = useState<Record<string, CliMeta> | null>(null);
 
+    const asideDraft = perCliDraft['aside'];
+    const aside = useAsideModels(client, instanceUrl, port, asideDraft?.account || '', !!asideDraft);
+    const asideSaveError = asideDraft ? asideDraft.host !== 'local' ? 'Aside requires the local host.'
+        : asideSelectionError(aside.inventory, asideDraft.model || '', asideDraft.effort || '') : null;
+
+    useEffect(() => {
+        for (const [key, entry] of dirty.pending) {
+            if (key.startsWith('perCli.aside.') || key.startsWith('activeOverrides.aside.')) {
+                const valid = !asideSaveError;
+                if (entry.valid !== valid) dirty.set(key, { ...entry, valid });
+            }
+        }
+    }, [asideSaveError, dirty]);
+
     useLayoutEffect(() => {
         activeInstance.current = instance; activeOperation.current = null; ++metadataGeneration.current;
         setSaving(false); setResetting(false); setSaveError(null); setResetError(null); setCliMeta(null);
@@ -159,8 +174,15 @@ export default function ModelProvider({ port, client, dirty, registerSave }: Set
         const pending = activeOperation.current;
         if (pending) return pending.kind === 'save' ? pending.promise
             : Promise.reject(new Error('Wait for the active override reset before saving.'));
+        if ([...dirty.pending.keys()].some(key => key.startsWith('perCli.aside.') || key.startsWith('activeOverrides.aside.')) && asideSaveError) return Promise.reject(new Error(asideSaveError));
         const bundle = Object.fromEntries(Object.entries(dirty.saveBundle()).filter(([key]) => ownsModelKey(key)));
         if (Object.keys(bundle).length === 0) return Promise.resolve();
+        if (Object.keys(bundle).some(key => key.startsWith('perCli.aside.') || key.startsWith('activeOverrides.aside.')) && asideSaveError) return Promise.reject(new Error(asideSaveError));
+        if (bundle['fallbackOrder'] && (bundle['fallbackOrder'] as string[]).includes('aside')) return Promise.reject(new Error('Aside cannot be used as a fallback.'));
+        if (Object.hasOwn(bundle, 'perCli.aside.account')) {
+            bundle['activeOverrides.aside.model'] = '';
+            bundle['activeOverrides.aside.effort'] = '';
+        }
         const patch = expandPatch(bundle);
         const submitted = new Map([...dirty.pending].filter(([key]) => Object.hasOwn(bundle, key)));
         setSaving(true); setSaveError(null);
@@ -182,7 +204,7 @@ export default function ModelProvider({ port, client, dirty, registerSave }: Set
         });
         activeOperation.current = operation;
         return operation.promise;
-    }, [client, dirty, instance, loadCliMeta, refresh, setData]);
+    }, [client, dirty, instance, loadCliMeta, refresh, setData, asideSaveError]);
 
     useEffect(() => {
         if (!registerSave) return;
@@ -254,6 +276,8 @@ export default function ModelProvider({ port, client, dirty, registerSave }: Set
                             setValue={(next) => { if (canEdit()) setPerCliDraft({ ...perCliDraft, [cli]: next }); }}
                             setEntry={setEntry}
                             client={client}
+                            aside={aside}
+                            asideOverride={overrides[cli] || {}}
                             pi={piDraft}
                             setPi={(next) => { if (canEdit()) setPiDraft(next); }}
                             onPiRegistered={onPiRegistered}
@@ -270,6 +294,7 @@ export default function ModelProvider({ port, client, dirty, registerSave }: Set
                     id="model-fallbackOrder"
                     label="Fallback order"
                     error={(() => {
+                        if (fallback.includes('aside')) return 'Aside is main-only. Remove it from the fallback order.';
                         const retired = fallback.find(isRetiredCliSelection);
                         if (!retired) return null;
                         const name = retiredRuntimeLabel(retired).replace(' (retired)', '');
@@ -283,7 +308,7 @@ export default function ModelProvider({ port, client, dirty, registerSave }: Set
                         setEntry('fallbackOrder', {
                             value: next,
                             original: data.fallbackOrder || [],
-                            valid: !next.some(isRetiredCliSelection),
+                            valid: !next.includes('aside') && !next.some(isRetiredCliSelection),
                         });
                     }}
                     placeholder="cli name"

package/public/manager/src/settings/pages/Profile.tsx

@@ -118,8 +118,8 @@ export default function Profile({ port, client, dirty, registerSave }: SettingsP
             </SettingsSection>
 
             <SettingsSection title="Avatars" hint="Uploads write to the instance's home folder.">
-                <AvatarCard kind="agent" port={port} />
-                <AvatarCard kind="user" port={port} />
+                <AvatarCard kind="agent" client={client} />
+                <AvatarCard kind="user" client={client} />
             </SettingsSection>
         </form>
     );

package/public/manager/src/settings/pages/components/AsideSelectionFields.tsx

@@ -0,0 +1,33 @@
+import { SelectField, TextField } from '../../fields';
+import { asideEffortChoices, asideModelChoices, asideSelectionError, isAsideAccount, type AsideInventory } from './aside-models';
+
+type Props = {
+    id: string; account: string; host?: string | undefined; model: string; effort: string;
+    inventory: AsideInventory; disabled?: boolean;
+    onAccountChange(value: string): void; onModelChange(value: string): void; onEffortChange(value: string): void;
+    refresh(): void;
+};
+
+export function AsideSelectionFields({ id, account, host, model, effort, inventory, disabled = false,
+    onAccountChange, onModelChange, onEffortChange, refresh }: Props) {
+    const models = asideModelChoices(inventory);
+    const efforts = asideEffortChoices(inventory, model);
+    const error = asideSelectionError(inventory, model, effort);
+    return <>
+        <p className="settings-percli-note">Experimental · local main agent only. Scheduled heartbeat runs are unsupported with Aside as the main runtime and will be rejected. Account selection does not confirm sign-in or model access.</p>
+        <TextField id={`${id}-account`} label="Aside account" value={account} placeholder="uN" disabled={disabled}
+            error={isAsideAccount(account) ? null : 'Enter an explicit account (uN).'} onChange={onAccountChange} />
+        <TextField id={`${id}-host`} label="Host" value={host || 'local'} disabled
+            error={host && host !== 'local' ? 'Only the local host is supported. Edit the account to use local.' : null} onChange={() => {}} />
+        <SelectField id={`${id}-model`} label="Model" value={model || 'default'} options={models}
+            missingValueLabel={`${model || 'default'} (unavailable)`} disabled={disabled || inventory.kind !== 'ready' || models.length === 0}
+            error={error} onChange={onModelChange} />
+        <SelectField id={`${id}-effort`} label="Effort" value={effort === 'default' ? '' : effort}
+            options={[{ value: '', label: '(default)' }, ...efforts.map(value => ({ value, label: value }))]}
+            missingValueLabel={`${effort} (unavailable)`} disabled={disabled || inventory.kind !== 'ready' || (efforts.length === 0 && !effort)}
+            error={error?.includes('effort') ? error : null} onChange={onEffortChange} />
+        {inventory.kind === 'ready' && inventory.catalog.status !== 'available'
+            ? <p className="settings-percli-note" role="status">Catalog {inventory.catalog.status}{inventory.catalog.diagnostics.map(d => ` · ${d.code}`).join('')}</p> : null}
+        <button type="button" className="settings-action" disabled={disabled || !isAsideAccount(account)} onClick={refresh}>Refresh Aside models</button>
+    </>;
+}

package/public/manager/src/settings/pages/components/AvatarCard.tsx

@@ -1,12 +1,11 @@
 // Phase 2 — avatar upload card.
 //
-// Avatar upload bypasses the JSON settings client because the route expects a
-// raw image body (`Content-Type: image/*` or `application/octet-stream`) plus
-// `X-Filename`. We mount our own fetch + state instead of registering with the
-// page-level dirty store: uploads are atomic side-effects, not pending edits.
+// Avatar uploads use the configured settings transport with a raw image body.
+// They remain atomic side-effects outside the page-level dirty store.
 
 import { useEffect, useRef, useState } from 'react';
 import { icon } from '../../../../../js/icons';
+import type { SettingsClient } from '../../types';
 
 type AvatarKind = 'agent' | 'user';
 
@@ -20,12 +19,12 @@ type EnvelopeMeta =
 
 type Props = {
     kind: AvatarKind;
-    port: number;
+    client: SettingsClient;
 };
 
 const ACCEPTED_TYPES = 'image/png,image/jpeg,image/webp,image/gif';
 
-export function AvatarCard({ kind, port }: Props) {
+export function AvatarCard({ kind, client }: Props) {
     const [meta, setMeta] = useState<AvatarMeta | null>(null);
     const [busy, setBusy] = useState(false);
     const [error, setError] = useState<string | null>(null);
@@ -35,9 +34,8 @@ export function AvatarCard({ kind, port }: Props) {
         let cancelled = false;
         setError(null);
         setMeta(null);
-        fetch(`/i/${port}/api/avatar`)
-            .then((r) => (r.ok ? r.json() : Promise.reject(new Error(`avatar HTTP ${r.status}`))))
-            .then((envelope: EnvelopeMeta) => {
+        client.get<EnvelopeMeta>('/api/avatar')
+            .then((envelope) => {
                 if (cancelled) return;
                 const inner = 'data' in envelope && envelope.data ? envelope.data : envelope;
                 const got = (inner as { agent?: AvatarMeta; user?: AvatarMeta })[kind] || null;
@@ -50,7 +48,7 @@ export function AvatarCard({ kind, port }: Props) {
         return () => {
             cancelled = true;
         };
-    }, [kind, port]);
+    }, [kind, client]);
 
     const onPick = () => inputRef.current?.click();
 
@@ -60,21 +58,17 @@ export function AvatarCard({ kind, port }: Props) {
         try {
             const buf = await file.arrayBuffer();
             const ct = file.type || 'application/octet-stream';
-            const response = await fetch(`/i/${port}/api/avatar/${kind}/upload`, {
-                method: 'POST',
-                headers: {
-                    'content-type': ct,
-                    'x-filename': encodeURIComponent(file.name),
+            const envelope = await client.post<{ ok?: boolean; data?: AvatarMeta } | AvatarMeta>(
+                `/api/avatar/${kind}/upload`, undefined, {
+                    headers: {
+                        'content-type': ct,
+                        'x-filename': encodeURIComponent(file.name),
+                    },
+                    body: buf,
+                    // Image transfers may exceed the client's JSON request timeout.
+                    signal: new AbortController().signal,
                 },
-                body: buf,
-            });
-            if (!response.ok) {
-                const text = await response.text().catch(() => '');
-                throw new Error(`upload failed: ${response.status} ${text}`);
-            }
-            const envelope = (await response.json()) as
-                | { ok?: boolean; data?: AvatarMeta }
-                | AvatarMeta;
+            );
             const next: AvatarMeta = 'data' in envelope && envelope.data
                 ? (envelope.data as AvatarMeta)
                 : (envelope as AvatarMeta);
@@ -91,15 +85,9 @@ export function AvatarCard({ kind, port }: Props) {
         setBusy(true);
         setError(null);
         try {
-            const response = await fetch(`/i/${port}/api/avatar/${kind}/image`, {
-                method: 'DELETE',
-            });
-            if (!response.ok) {
-                throw new Error(`clear failed: ${response.status}`);
-            }
-            const envelope = (await response.json()) as
-                | { ok?: boolean; data?: AvatarMeta }
-                | AvatarMeta;
+            const envelope = await client.delete<{ ok?: boolean; data?: AvatarMeta } | AvatarMeta>(
+                `/api/avatar/${kind}/image`,
+            );
             const next: AvatarMeta = 'data' in envelope && envelope.data
                 ? (envelope.data as AvatarMeta)
                 : (envelope as AvatarMeta);
@@ -112,7 +100,7 @@ export function AvatarCard({ kind, port }: Props) {
     };
 
     const imageUrl = meta && meta.kind === 'image'
-        ? `/i/${port}${meta.imageUrl}`
+        ? client.url(meta.imageUrl)
         : null;
     const label = kind === 'agent' ? 'Agent avatar' : 'User avatar';
 

package/public/manager/src/settings/pages/components/PerCliRow.tsx

@@ -10,6 +10,8 @@ import { coerceEffortForModel, effortChoicesForModel } from './agent/agent-meta'
 import type { CliMeta, PerCliEntry } from './agent/agent-meta';
 import { PiProfileDialog } from './PiProfileDialog';
 import { piModelOptions, piProfileOptions, type PiSettingsView } from './pi-profile';
+import { AsideSelectionFields } from './AsideSelectionFields';
+import { type AsideInventory, isAsideAccount } from './aside-models';
 import { hasRuntimeTransportChoice, RuntimeTransportField } from './runtime-transport-field';
 export type PiRegistration = Parameters<ComponentProps<typeof PiProfileDialog>['onRegistered']>[0];
 
@@ -23,6 +25,8 @@ type Props = {
     dirty: DirtyStore;
     disabled?: boolean;
     client?: SettingsClient;
+    aside?: { inventory: AsideInventory; refresh(): void };
+    asideOverride?: { model?: string; effort?: string };
     pi?: PiSettingsView | undefined;
     setPi?: (next: PiSettingsView) => void;
     onPiRegistered?: (next: PiRegistration) => void;
@@ -32,7 +36,7 @@ function entryFor(value: unknown, original: unknown, valid = true): DirtyEntry {
     return { value, original, valid };
 }
 
-export function PerCliRow({ cli, meta, original, value, setValue, setEntry, dirty, disabled = false, client, pi, setPi, onPiRegistered }: Props) {
+export function PerCliRow({ cli, meta, original, value, setValue, setEntry, dirty, disabled = false, client, aside, asideOverride, pi, setPi, onPiRegistered }: Props) {
     const modelDatalistId = `percli-${cli}-models`;
     const isPi = cli === 'pi';
     const [piDialogOpen, setPiDialogOpen] = useState(false);
@@ -43,6 +47,30 @@ export function PerCliRow({ cli, meta, original, value, setValue, setEntry, dirt
         blocked.current = disabled;
         return () => { blocked.current = true; };
     }, [disabled]);
+    if (cli === 'aside' && aside) return <div className="settings-percli-row" data-cli={cli}>
+        <SettingsToolbar><strong className="settings-percli-title">Aside</strong></SettingsToolbar>
+        <AsideSelectionFields id="percli-aside" account={value.account || ''} host={value.host}
+            model={value.model || ''} effort={value.effort || ''} inventory={aside.inventory} disabled={disabled}
+            refresh={aside.refresh}
+            onAccountChange={next => {
+                if (blocked.current) return;
+                setValue({ ...value, account: next, host: 'local' });
+                setEntry('perCli.aside.account', entryFor(next, original.account || '', isAsideAccount(next)));
+                setEntry('perCli.aside.host', entryFor('local', original.host || ''));
+                setEntry('activeOverrides.aside.model', entryFor('', asideOverride?.model || ''));
+                setEntry('activeOverrides.aside.effort', entryFor('', asideOverride?.effort || ''));
+            }}
+            onModelChange={next => {
+                if (blocked.current) return;
+                setValue({ ...value, model: next });
+                setEntry('perCli.aside.model', entryFor(next, original.model || ''));
+            }}
+            onEffortChange={next => {
+                if (blocked.current) return;
+                setValue({ ...value, effort: next });
+                setEntry('perCli.aside.effort', entryFor(next, original.effort || ''));
+            }} />
+    </div>;
     const provider = value.provider || meta.defaultProvider || meta.providers?.[0] || 'claude';
     const piModels = isPi ? piModelOptions(pi, provider, value.model || '') : [];
     const hasProviders = !isPi && (meta.providers?.length ?? 0) > 0;

package/public/manager/src/settings/pages/components/agent/FlushAgentSection.tsx

@@ -1,6 +1,6 @@
 import { SelectField } from '../../../fields';
 import { SettingsSection } from '../../page-shell';
-import { metaFor, selectableRuntimeOptions, isRetiredCliSelection, retiredRuntimeLabel, type CliMeta } from './agent-meta';
+import { metaFor, auxiliaryRuntimeOptions, isRetiredCliSelection, retiredRuntimeLabel, type CliMeta } from './agent-meta';
 
 type FlushAgentSectionProps = {
     activeCli: string;
@@ -28,6 +28,7 @@ export function FlushAgentSection({
     onFlushModelChange,
 }: FlushAgentSectionProps) {
     const effectiveCli = flushCli || activeCli;
+    const unsupported = effectiveCli === 'aside';
     const effectiveCliLabel = effectiveCli ? metaFor(effectiveCli, cliMeta).label || effectiveCli : 'active';
     return (
         <SettingsSection
@@ -46,11 +47,11 @@ export function FlushAgentSection({
                         id="agent-flush-cli"
                         label="Flush CLI"
                         value={flushCli}
-                        missingValueLabel={isRetiredCliSelection(flushCli) ? retiredRuntimeLabel(flushCli) : undefined}
-                        error={isRetiredCliSelection(effectiveCli) ? 'The saved flush runtime is retired. Choose an available runtime.' : null}
+                        missingValueLabel={!flushCli && activeCli === 'aside' ? '(active CLI unavailable)' : flushCli === 'aside' ? 'Aside (main-only)' : isRetiredCliSelection(flushCli) ? retiredRuntimeLabel(flushCli) : undefined}
+                        error={unsupported ? 'Aside cannot run memory flush. Choose a separate runtime.' : isRetiredCliSelection(effectiveCli) ? 'The saved flush runtime is retired. Choose an available runtime.' : null}
                         options={[
-                            { value: '', label: '(active CLI)' },
-                            ...selectableRuntimeOptions(cliOptions).map((value) => ({ value, label: metaFor(value, cliMeta).label || value })),
+                            ...(activeCli === 'aside' ? [] : [{ value: '', label: '(active CLI)' }]),
+                            ...auxiliaryRuntimeOptions(cliOptions).map((value) => ({ value, label: metaFor(value, cliMeta).label || value })),
                         ]}
                         onChange={onFlushCliChange}
                     />
@@ -58,7 +59,7 @@ export function FlushAgentSection({
                         id="agent-flush-model"
                         label="Flush model"
                         value={flushModel}
-                        disabled={isRetiredCliSelection(effectiveCli)}
+                        disabled={unsupported || isRetiredCliSelection(effectiveCli)}
                         options={[{ value: '', label: '(default)' }, ...modelOptions]}
                         onChange={onFlushModelChange}
                     />

package/public/manager/src/settings/pages/components/agent/RuntimeEmployeeRow.tsx

@@ -1,6 +1,6 @@
 import { SelectField, TextField } from '../../../fields';
 import { SettingsActions, StatusBadge } from '../../page-shell';
-import { metaFor, optionList, selectableRuntimeOptions, isRetiredCliSelection, retiredRuntimeLabel, type CliMeta } from './agent-meta';
+import { metaFor, optionList, auxiliaryRuntimeOptions, isRetiredCliSelection, retiredRuntimeLabel, type CliMeta } from './agent-meta';
 import {
     isStaticEmployee,
     runtimeEmployeeError,
@@ -28,8 +28,8 @@ export function RuntimeEmployeeRow({
     const meta = metaFor(employee.cli, cliMeta);
     const modelOptions = optionList(meta.models, employee.model);
     const error = runtimeEmployeeError(employee);
-    const retired = isRetiredCliSelection(employee.cli);
-    const cliChoices = selectableRuntimeOptions(Array.from(new Set([...cliOptions, employee.cli, 'claude'])).filter(Boolean));
+    const retired = isRetiredCliSelection(employee.cli) || employee.cli === 'aside';
+    const cliChoices = auxiliaryRuntimeOptions(Array.from(new Set([...cliOptions, employee.cli, 'claude'])).filter(Boolean));
 
     const employeeName = employee.name || `Employee ${index + 1}`;
     return (
@@ -51,7 +51,7 @@ export function RuntimeEmployeeRow({
                     id={`runtime-employee-${employee.id}-cli`}
                     label="CLI"
                     value={employee.cli}
-                    missingValueLabel={isRetiredCliSelection(employee.cli) ? retiredRuntimeLabel(employee.cli) : undefined}
+                    missingValueLabel={employee.cli === 'aside' ? 'Aside (main-only)' : isRetiredCliSelection(employee.cli) ? retiredRuntimeLabel(employee.cli) : undefined}
                     error={retired ? 'This saved runtime cannot execute. Choose an available runtime.' : null}
                     disabled={locked}
                     options={cliChoices.map((value) => ({ value, label: metaFor(value, cliMeta).label || value }))}

package/public/manager/src/settings/pages/components/agent/RuntimeHeader.tsx

@@ -1,8 +1,10 @@
+import type { ReactNode } from 'react';
 import { SelectField, TextField } from '../../../fields';
 import { SettingsSection } from '../../page-shell';
 import { metaFor, orderRuntimeCliOptions, PRIMARY_CLIS, isRetiredCliSelection, retiredRuntimeLabel, type CliMeta } from './agent-meta';
 
 type RuntimeHeaderProps = {
+    asideFields?: ReactNode;
     cli: string;
     cliOptions: ReadonlyArray<string>;
     provider?: string;
@@ -22,6 +24,7 @@ type RuntimeHeaderProps = {
 };
 
 export function RuntimeHeader({
+    asideFields,
     cli,
     cliOptions,
     provider = '',
@@ -58,6 +61,7 @@ export function RuntimeHeader({
                     collapsedAfter={orderedPrimaryCliCount}
                     onChange={onCliChange}
                 />
+                {asideFields || <>
                 {providerOptions.length > 0 ? (
                     <SelectField
                         id={`agent-${cli}-provider`}
@@ -86,6 +90,7 @@ export function RuntimeHeader({
                     disabled={retired || effortOptions.length === 0}
                     onChange={onEffortChange}
                 />
+                </>}
                 <TextField
                     id="agent-workingDir"
                     label="Working directory"

package/public/manager/src/settings/pages/components/agent/agent-meta.ts

@@ -31,6 +31,8 @@ export type CliMeta = {
 };
 
 export type PerCliEntry = {
+    account?: string;
+    host?: string;
     transport?: RuntimeTransport;
     provider?: string;
     model?: string;
@@ -50,6 +52,7 @@ const CODEX_MODELS: ReadonlyArray<string> = ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini
 export const PRIMARY_CLIS: ReadonlyArray<string> = ['pi', 'claude', 'agy', 'codex', 'cursor', 'kiro-code', 'gemini'];
 
 export const CLI_META: Record<string, CliMeta> = {
+    aside: { label: 'Aside (experimental)', models: [], efforts: [] },
     agy: {
         label: 'Antigravity',
         // Label form is what `agy --model` accepts when no --effort is sent
@@ -316,6 +319,10 @@ export function selectableRuntimeOptions(cliOptions: ReadonlyArray<string>): str
     return cliOptions.filter(value => !isRetiredCliSelection(value));
 }
 
+export function auxiliaryRuntimeOptions(cliOptions: ReadonlyArray<string>): string[] {
+    return selectableRuntimeOptions(cliOptions).filter(cli => cli !== 'aside');
+}
+
 export function orderRuntimeCliOptions(input: ReadonlyArray<string>): string[] {
     const cliOptions = selectableRuntimeOptions(input);
     const primary = PRIMARY_CLIS.filter((value) => cliOptions.includes(value));

package/public/manager/src/settings/pages/components/agent/runtime-employees-helpers.ts

@@ -1,5 +1,5 @@
 import type { SettingsClient } from '../../../types';
-import { selectableRuntimeOptions, type CliMeta } from './agent-meta';
+import { auxiliaryRuntimeOptions, type CliMeta } from './agent-meta';
 
 export type RuntimeEmployeeSource = 'static' | 'db';
 
@@ -42,7 +42,7 @@ export function makeDefaultRuntimeEmployee(
     cliOptions: ReadonlyArray<string>,
     cliMeta?: Record<string, CliMeta> | null,
 ): RuntimeEmployeeRecord {
-    const cli = selectableRuntimeOptions(cliOptions)[0] || 'claude';
+    const cli = auxiliaryRuntimeOptions(cliOptions)[0] || 'claude';
     const model = cliMeta?.[cli]?.models?.[0] || 'default';
     return {
         id: newRuntimeEmployeeId(),
@@ -81,6 +81,7 @@ export function normalizeRuntimeEmployee(value: unknown): RuntimeEmployeeRecord
 
 export function runtimeEmployeeError(row: RuntimeEmployeeRecord): string | null {
     if (!row.name.trim()) return 'Name is required';
+    if (row.cli === 'aside') return 'Aside supports the main agent only';
     if (!row.cli.trim()) return 'CLI is required';
     if (!row.model.trim()) return 'Model is required';
     return null;

package/public/manager/src/settings/pages/components/aside-models.ts

@@ -0,0 +1,104 @@
+import { useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import type { SettingsClient } from '../../types';
+import type { AsideCatalog, AsideModelEntry, AsideThinkingLevel } from '../../../../../../src/shared/aside-contract';
+
+export const isAsideAccount = (account: string) => /^u(?:0|[1-9][0-9]{0,8})$/.test(account);
+const levels: readonly string[] = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+const record = (value: unknown): value is Record<string, unknown> => !!value && typeof value === 'object' && !Array.isArray(value);
+const qualified = (value: unknown): value is string => typeof value === 'string' && /^[^/\s]+\/.+/.test(value);
+
+/** SettingsClient returns raw JSON. Reject mismatched context and malformed wire data. */
+export function unwrapAsideCatalog(raw: unknown, account: string): AsideCatalog {
+    if (!record(raw) || raw['ok'] !== true || !record(raw['data'])) throw new Error('Aside catalog response is unavailable.');
+    const data = raw['data'];
+    const context = data['context'];
+    if (!record(context) || context['account'] !== account || context['host'] !== 'local'
+        || data['source'] !== 'local-files' || !['available', 'partial', 'unavailable'].includes(String(data['status']))
+        || !Array.isArray(data['entries']) || !Array.isArray(data['cachedIds']) || !Array.isArray(data['diagnostics'])
+        || (data['defaultModel'] !== null && !qualified(data['defaultModel']))) throw new Error('Invalid Aside catalog response.');
+    const seen = new Set<string>();
+    for (const entry of data['entries']) {
+        if (!record(entry) || !qualified(entry['id']) || typeof entry['provider'] !== 'string'
+            || typeof entry['modelId'] !== 'string' || entry['id'] !== `${entry['provider']}/${entry['modelId']}`
+            || typeof entry['name'] !== 'string' || !['registered', 'unknown'].includes(String(entry['capability']))
+            || !Array.isArray(entry['efforts']) || !entry['efforts'].every(e => typeof e === 'string' && levels.includes(e))
+            || !record(entry['thinkingLevelMap']) || seen.has(entry['id'])) throw new Error('Invalid Aside model catalog.');
+        seen.add(entry['id']);
+    }
+    const preference = data['configuredDefault'];
+    if (preference !== null && (!record(preference) || typeof preference['provider'] !== 'string'
+        || typeof preference['modelId'] !== 'string'
+        || (preference['thinkingLevel'] !== undefined && !levels.includes(String(preference['thinkingLevel'])))))
+        throw new Error('Invalid Aside default model.');
+    if (data['defaultModel'] !== null && (!record(preference)
+        || data['defaultModel'] !== `${preference['provider']}/${preference['modelId']}`)) throw new Error('Invalid Aside default model.');
+    for (const diagnostic of data['diagnostics']) {
+        if (!record(diagnostic) || !['context', 'models', 'settings'].includes(String(diagnostic['source']))
+            || typeof diagnostic['code'] !== 'string' || typeof diagnostic['message'] !== 'string') throw new Error('Invalid Aside diagnostics.');
+    }
+    return data as unknown as AsideCatalog;
+}
+
+export type AsideInventory = { kind: 'loading' } | { kind: 'error'; message: string } | { kind: 'ready'; catalog: AsideCatalog };
+type Context = { client: SettingsClient; instanceUrl: string; port: number; account: string; enabled: boolean; revision: number };
+
+export function useAsideModels(client: SettingsClient, instanceUrl: string, port: number, account: string, enabled = true) {
+    const [revision, setRevision] = useState(0);
+    const context = useMemo<Context>(() => ({ client, instanceUrl, port, account, enabled, revision }), [client, instanceUrl, port, account, enabled, revision]);
+    const generation = useRef(0);
+    const [result, setResult] = useState<{ context: Context; value: AsideInventory } | null>(null);
+    useLayoutEffect(() => {
+        const epoch = ++generation.current;
+        let live = true;
+        if (enabled && isAsideAccount(account)) {
+            void client.get<unknown>(`/api/aside/models?account=${encodeURIComponent(account)}&host=local`).then(raw => {
+                if (!live || epoch !== generation.current) return;
+                setResult({ context, value: { kind: 'ready', catalog: unwrapAsideCatalog(raw, account) } });
+            }).catch(() => {
+                if (live && epoch === generation.current) setResult({ context, value: { kind: 'error', message: 'Could not read the local Aside catalog. Refresh to try again.' } });
+            });
+        }
+        return () => { live = false; ++generation.current; };
+    }, [context, client, account, enabled]);
+    // Hide old inventory in the first render of a changed context, before effects.
+    const inventory: AsideInventory = !isAsideAccount(account)
+        ? { kind: 'error', message: 'Enter an explicit Aside account (uN).' }
+        : result?.context === context ? result.value : { kind: 'loading' };
+    const refresh = useCallback(() => setRevision(value => value + 1), []);
+    return { inventory, refresh };
+}
+
+export function asideModelChoices(inventory: AsideInventory): Array<{ value: string; label: string }> {
+    if (inventory.kind !== 'ready') return [];
+    const catalog = inventory.catalog;
+    if (catalog.status === 'unavailable' || catalog.diagnostics.some(d => d.source === 'models' || d.source === 'context')) return [];
+    const ids = new Set(catalog.entries.map(e => e.id));
+    if (catalog.defaultModel) ids.add(catalog.defaultModel);
+    const defaultEntry = catalog.entries.find(e => e.id === catalog.defaultModel);
+    const level = catalog.configuredDefault?.thinkingLevel;
+    const defaultReady = !!catalog.defaultModel && (!level || defaultEntry?.capability !== 'registered' || defaultEntry.efforts.includes(level));
+    return [
+        ...(defaultReady ? [{ value: 'default', label: `Default (${catalog.defaultModel})` }] : []),
+        ...Array.from(ids, value => ({ value, label: value })),
+    ];
+}
+
+export function asideEffortChoices(inventory: AsideInventory, model: string): readonly string[] {
+    if (inventory.kind !== 'ready' || !asideModelChoices(inventory).some(e => e.value === (model || 'default'))) return [];
+    const catalog = inventory.catalog;
+    const concrete = !model || model === 'default' ? catalog.defaultModel : model;
+    const entry: AsideModelEntry | undefined = catalog.entries.find(e => e.id === concrete && e.capability === 'registered');
+    if (entry) return entry.efforts;
+    return concrete === catalog.defaultModel && catalog.configuredDefault?.thinkingLevel ? [catalog.configuredDefault.thinkingLevel] : [];
+}
+
+export function asideSelectionError(inventory: AsideInventory, model: string, effort: string): string | null {
+    if (inventory.kind === 'loading') return 'Loading Aside models…';
+    if (inventory.kind === 'error') return inventory.message;
+    if (!asideModelChoices(inventory).some(e => e.value === (model || 'default'))) return 'This model is unavailable for the selected Aside account.';
+    const concrete = !model || model === 'default' ? inventory.catalog.defaultModel : model;
+    const effectiveEffort = effort && effort !== 'default' ? effort
+        : concrete === inventory.catalog.defaultModel ? inventory.catalog.configuredDefault?.thinkingLevel : undefined;
+    if (effectiveEffort && !asideEffortChoices(inventory, model).includes(effectiveEffort as AsideThinkingLevel)) return 'This effort is unavailable for the selected Aside model.';
+    return null;
+}