@hanzo/build 0.2.60 → 0.2.62

package/README.md

@@ -111,6 +111,12 @@ One of each, shared with Chat (@hanzo/rooms imports them):
 - `prompt` / `Prompt` — the composer, as wide as the text above it (`measure`).
 - `Reply` — copy, Listen and Open under an answer.
 - `Panel` over `useDeck` — the side panel and its kept tabs.
+- `useSplit` / `SideProvider` — the column the panel stands in: its edge (the
+  kit's `Grip`), the width the person drags kept in their preferences
+  (`side.width`, `PATCH /v1/pref`), the middle column hidden when the panel is
+  pulled over it (Show chat brings it back), and full screen from the strip
+  (Escape returns). `PrefsProvider` above it keeps the width; without one it
+  lasts the page.
 
 ## Addresses
 
@@ -249,8 +255,11 @@ Files, Diff (Diff, Review, Commits) and Terminal (a shell in the working tree,
 reattached by the run's name, and the agent's log); `+` opens Desktop (the
 sandbox's screen), Environment and any page. Tabs are dragged to reorder (or
 moved with Ctrl/⌘+Shift+←/→), shut with their cross, and kept as left; the
-header's Panel button and ⌘. / Ctrl+. open and shut it, and a phone opens it as
-a sheet. An answer's Open shows what it wrote there, and a publish opens Preview.
+header's Panel button and ⌘. / Ctrl+. open and shut it, and a phone opens it
+over the whole window. Its edge sizes it, the width kept in the person's
+preferences; pulled over the run it takes the run's room until Show run or a
+pull back out, and its strip's button puts it full screen until Escape. An
+answer's Open shows what it wrote there, and a publish opens Preview.
 
 The desktop and the shell are the sandbox's, so they close when the run stops.
 The setup bar says how long setup runs here have taken, once there are three.
@@ -305,7 +314,7 @@ picker and open-in-tab; Share and Publish; the console dock under it.
 | `GET /v1/tool/plugins/authored` · `POST /v1/tool/plugins/build` · `DELETE …/authored/{id}` · `GET /v1/tool/plugins` | plugins, and what is mounted |
 | `GET`/`POST /v1/agent` · `GET`/`PATCH`/`DELETE /v1/agent/{ref}` · `GET /v1/agent/chat/presets` | agents, and presets |
 | `GET /v1/models` · `POST /v1/event` | the model list, a verdict |
-| `GET`/`PATCH /v1/pref` | the person's own settings: theme, text size, motion, dictation language, what to call them, their instructions, the coding defaults |
+| `GET`/`PATCH /v1/pref` | the person's own settings: theme, text size, motion, dictation language, what to call them, their instructions, the coding defaults, the side panel's width (`side`) |
 | `PUT /v1/iam/account` · `POST /v1/account/avatar` | the person's name and photo |
 | `GET`/`PUT /v1/iam/consent` | whether Hanzo may train on their data, and usage insights |
 | `GET /v1/tool` · `PUT /v1/tool/activation` | what the agent may use, per kind of tool |
@@ -345,6 +354,7 @@ src/
   prompt.tsx    the composer, and Tune, the model and effort chip
   reply.tsx     the row under an answer
   panel.tsx     the side panel; tabs.ts its kept tabs
+  side.tsx      the column it stands in: width, the middle column, full screen
   pane.ts       how a pane is cut, from the --pane-* tokens
   door.tsx      a run's desktop or shell, framed
   git.tsx       what a run pushed

package/lib/api/conversations.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The person's Chat conversations, as the agent service keeps them (the list
+ * @hanzo/ai `threads.list` and @hanzo/rooms read).
+ *
+ *   GET /v1/agents/chat/conversations → {conversations: [{id, title, updatedAt, pinned, archived}]}
+ *
+ * Pinned first, then most recently spoken in; archived ones are left out. Only
+ * the caller's own: another member's conversations are never listed.
+ */
+import { type Target } from './call.ts';
+export interface Conversation {
+    id: string;
+    /** Taken from the opening message until renamed. */
+    title: string;
+    /** RFC 3339: when it was last spoken in, or ''. */
+    updated: string;
+    pinned: boolean;
+}
+export declare function conversation(raw: unknown): Conversation | null;
+export declare function conversations(t: Target, signal?: AbortSignal): Promise<Conversation[]>;

package/lib/api/conversations.js

@@ -0,0 +1,23 @@
+/**
+ * The person's Chat conversations, as the agent service keeps them (the list
+ * @hanzo/ai `threads.list` and @hanzo/rooms read).
+ *
+ *   GET /v1/agents/chat/conversations → {conversations: [{id, title, updatedAt, pinned, archived}]}
+ *
+ * Pinned first, then most recently spoken in; archived ones are left out. Only
+ * the caller's own: another member's conversations are never listed.
+ */
+import { call } from './call.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+const obj = (v) => (v && typeof v === 'object' ? v : {});
+export function conversation(raw) {
+    const o = obj(raw);
+    const id = str(o.id);
+    if (!id)
+        return null;
+    return { id, title: str(o.title), updated: str(o.updatedAt), pinned: o.pinned === true };
+}
+export async function conversations(t, signal) {
+    const raw = obj(await call(t, 'GET', '/v1/agents/chat/conversations', undefined, { signal }));
+    return (Array.isArray(raw.conversations) ? raw.conversations : []).map(conversation).filter((c) => c !== null);
+}

package/lib/api/pref.d.ts

@@ -10,6 +10,7 @@
  * key another surface saved is left as it was. A value this version does not
  * recognise reads as unset rather than as a choice.
  */
+import { type Kept } from '../suggest.ts';
 import { type Target } from './call.ts';
 export type Theme = 'system' | 'light' | 'dark';
 export type Text = 'small' | 'medium' | 'large';
@@ -24,6 +25,11 @@ export interface Code {
     /** A machine's id, or '' for the sandbox. */
     place?: string;
 }
+/** The side panel beside Chat and Dev, once for both. */
+export interface Side {
+    /** How wide it is drawn, px, while the middle column shows. */
+    width?: number;
+}
 export interface Prefs {
     theme?: Theme;
     text?: Text;
@@ -37,12 +43,16 @@ export interface Prefs {
     /** What every coding run is told about how they like to work. */
     instructions?: string;
     code?: Code;
+    side?: Side;
+    /** The suggestions under the composer: when made, from what, the rows, and those dismissed (suggest.ts). */
+    suggest?: Kept;
 }
 /** A change: a key set to a value, or to null to delete it. */
 export type Patch = {
     [K in keyof Prefs]?: Prefs[K] | null;
 };
 export declare function code(raw: unknown): Code | undefined;
+export declare function side(raw: unknown): Side | undefined;
 /** The builder's keys from a whole preference document. */
 export declare function prefs(raw: unknown): Prefs;
 /** What a document reads as once `patch` is merged into it — the platform's own rule. */

package/lib/api/pref.js

@@ -10,6 +10,7 @@
  * key another surface saved is left as it was. A value this version does not
  * recognise reads as unset rather than as a choice.
  */
+import { kept } from '../suggest.js';
 import { call } from './call.js';
 const THEMES = ['system', 'light', 'dark'];
 const TEXTS = ['small', 'medium', 'large'];
@@ -30,6 +31,10 @@ export function code(raw) {
     });
     return Object.keys(out).length ? out : undefined;
 }
+export function side(raw) {
+    const w = obj(raw).width;
+    return typeof w === 'number' && Number.isFinite(w) && w > 0 ? { width: Math.round(w) } : undefined;
+}
 /** The builder's keys from a whole preference document. */
 export function prefs(raw) {
     const p = obj(raw);
@@ -42,6 +47,8 @@ export function prefs(raw) {
         work: text(p.work),
         instructions: text(p.instructions),
         code: code(p.code),
+        side: side(p.side),
+        suggest: kept(p.suggest),
     });
 }
 /** What a document reads as once `patch` is merged into it — the platform's own rule. */

package/lib/builder.js

@@ -41,7 +41,7 @@ import { Forge } from './forge.js';
 import { HostProvider, useHost, useTarget } from './host.js';
 import { Landing } from './landing.js';
 import { nav, NEW } from './nav.js';
-import { PrefsProvider } from './prefs.js';
+import { Look, PrefsProvider } from './prefs.js';
 import { Project } from './project.js';
 import { Plans } from './plans.js';
 import { path, route } from './route.js';
@@ -153,5 +153,5 @@ function Screens({ rail }) {
  * the builder is then a pane of the host's, and paints no background of its own.
  */
 export function Builder({ host, rail = true }) {
-    return (_jsx(HostProvider, { host: host, children: _jsx(PrefsProvider, { children: _jsx(YStack, { flex: 1, minH: 0, minW: 0, height: "100%", bg: rail ? '$background' : undefined, children: _jsx(Screens, { rail: rail }) }) }) }));
+    return (_jsx(HostProvider, { host: host, children: _jsxs(PrefsProvider, { children: [_jsx(Look, {}), _jsx(YStack, { flex: 1, minH: 0, minW: 0, height: "100%", bg: rail ? '$background' : undefined, children: _jsx(Screens, { rail: rail }) })] }) }));
 }

package/lib/carry.d.ts

@@ -0,0 +1,17 @@
+import { type Target } from './api/call.ts';
+import { type GearState } from './gear.ts';
+import type { Shelf } from './plus.tsx';
+import type { Chip } from './prompt.tsx';
+export interface Carry {
+    gear: GearState;
+    skills: Shelf;
+    /** The chips after `+`: the skills on, Research, and Plan. */
+    on: Chip[];
+    /** The words the gear adds to every message, '' when none. */
+    text: string;
+}
+/**
+ * The conversation `key` names (`''` for one not begun), for target `t`.
+ * `customize(tab)` opens Dev's Customize on that tab.
+ */
+export declare function useCarry(t: Target, key: string, customize: (tab: 'skills') => void): Carry;

package/lib/carry.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * What a message carries beside its words, assembled once for Chat and Dev:
+ * the conversation's gear (gear.ts) drawn as the `+` menu's shelves and the
+ * chips after `+`, and `text` — the words the gear adds to every message, read
+ * again whenever the gear changes.
+ *
+ *   skills    each picked skill's SKILL.md (the org's own, or the brand's
+ *             catalogue document): the platform's completion takes no skills
+ *             field, so the text rides the message
+ *   memory    what Hanzo remembers about the person (GET /v1/ai/memory/list):
+ *             the platform injects none itself
+ *   mode      Plan: lay the plan out and wait; Auto says nothing
+ *
+ * A shelf is offered only where its service answers; a surface adds its own
+ * (Chat its agents, Dev its devices) beside these.
+ */
+import { BookOpen, ListChecks, ScrollText } from '@hanzogui/lucide-icons-2';
+import { useEffect, useMemo, useState } from 'react';
+import { call, query, unwrap } from './api/call.js';
+import { active, authored, document, nameOf as skillOf } from './api/skills.js';
+import { useRead } from './data.js';
+import { useGear } from './gear.js';
+/** The most of each skill a message carries. */
+const SKILL_MAX = 16_000;
+/** The memories every message carries at most, newest first. */
+const RECALL = 20;
+/** What Hanzo remembers about the person, newest first, as lines. */
+async function remembered(t) {
+    const rows = unwrap(await call(t, 'GET', `/v1/ai/memory/list${query({ limit: RECALL })}`));
+    return (Array.isArray(rows) ? rows : [])
+        .map((r) => (r && typeof r === 'object' ? String(r.content ?? '') : ''))
+        .filter(Boolean);
+}
+/** The words `skills`, `memory` and `mode` add to a message. */
+async function said(t, skills, memory, mode) {
+    const parts = [];
+    if (skills.length) {
+        const own = await authored(t).catch(() => []);
+        for (const n of skills) {
+            const body = own.find((s) => s.name === n)?.content || (await document(t, n).catch(() => ''));
+            if (body)
+                parts.push(`Use the skill "${n}" where it applies:\n\n${body.slice(0, SKILL_MAX)}`);
+        }
+    }
+    if (memory) {
+        const lines = await remembered(t).catch(() => []);
+        if (lines.length)
+            parts.push(`What you remember about the person:\n${lines.map((l) => `- ${l}`).join('\n')}`);
+    }
+    if (mode === 'plan')
+        parts.push('Plan mode: lay out the plan — the steps, what each changes and why — and stop. Change nothing and produce no final work until the person says go.');
+    return parts.join('\n\n');
+}
+/**
+ * The conversation `key` names (`''` for one not begun), for target `t`.
+ * `customize(tab)` opens Dev's Customize on that tab.
+ */
+export function useCarry(t, key, customize) {
+    const gear = useGear(t, key);
+    const signed = Boolean(t.token());
+    const list = useRead(signed ? () => active(t) : null, [], [t, signed]);
+    const names = useMemo(() => list.value.map((s) => skillOf(s.name)).filter(Boolean), [list.value]);
+    const { skills, research, memory, mode } = gear.gear;
+    const shelf = {
+        rows: names.map((n) => ({ id: n, label: n, icon: _jsx(ScrollText, { size: 16 }), on: skills.includes(n) })),
+        pick: (id) => gear.toggle('skills', id),
+        loading: list.loading,
+        error: list.error ? 'The skills could not be read.' : null,
+        search: names.length > 8 ? 'Search skills' : undefined,
+        empty: 'No skills are on for this organization',
+        manage: { label: 'Manage skills', onPress: () => customize('skills') },
+        browse: { label: 'Browse skills', onPress: () => customize('skills') },
+    };
+    const on = [
+        ...skills.map((n) => ({ id: `skill:${n}`, label: n, icon: _jsx(ScrollText, { size: 14 }), onRemove: () => gear.toggle('skills', n) })),
+        ...(research ? [{ id: 'research', label: 'Research', icon: _jsx(BookOpen, { size: 14 }), onRemove: () => gear.set({ research: false }) }] : []),
+        ...(mode === 'plan' ? [{ id: 'plan', label: 'Plan', icon: _jsx(ListChecks, { size: 14 }), onRemove: () => gear.set({ mode: 'auto' }) }] : []),
+    ];
+    const signedIn = Boolean(t.token());
+    const [text, setText] = useState('');
+    const asked = skills.join('\n');
+    useEffect(() => {
+        if (!signedIn)
+            return setText(mode === 'plan' ? 'Plan mode: lay out the plan and stop until the person says go.' : '');
+        let live = true;
+        void said(t, skills, memory, mode).then((x) => live && setText(x));
+        return () => {
+            live = false;
+        };
+        // `skills` is read through `asked`, its contents.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [t, signedIn, asked, memory, mode]);
+    return { gear, skills: shelf, on, text };
+}

package/lib/gear.d.ts

@@ -0,0 +1,53 @@
+import { type Target } from './api/call.ts';
+/** What a run or a turn may do on its own: the permission mode. */
+export type Mode = 'auto' | 'plan';
+/**
+ * The modes the platform honours. Manual and Accept edits are not here: a cloud
+ * run takes `build` or `plan` (apps/coding) and a chat turn asks before nothing,
+ * so offering them would promise a pause that never comes.
+ */
+export declare const MODES: readonly {
+    id: Mode;
+    label: string;
+    note: string;
+}[];
+export interface Gear {
+    /** Skill names (`/v1/tool/skills`). */
+    skills: string[];
+    /** Connector ids (`/v1/tool/mcp/servers`). */
+    connectors: string[];
+    /** Plugin ids. */
+    plugins: string[];
+    /** A design system's id, or ''. */
+    design: string;
+    /** A machine's id, or '' for none (Chat) or the sandbox (Dev). */
+    device: string;
+    research: boolean;
+    memory: boolean;
+    mode: Mode;
+}
+export declare const BARE: Gear;
+/** How many conversations keep a choice of their own: the document holds 16 KiB in all. */
+export declare const KEEP = 30;
+/** A stored value as a Gear, a field the reader does not know read as unset. */
+export declare function gearOf(raw: unknown, base?: Gear): Gear;
+/** `gears` with `key`'s entry first, cut to `KEEP`. */
+export declare function shelve(gears: Record<string, Gear>, key: string, g: Gear): Record<string, Gear>;
+export interface GearState {
+    gear: Gear;
+    /** Change this conversation's choice. */
+    set: (patch: Partial<Gear>) => void;
+    /** Add or take out one id of a list. */
+    toggle: (field: 'skills' | 'connectors' | 'plugins', id: string) => void;
+    /** Make this conversation's choice the person's default. */
+    keep: () => void;
+    /** Whether a save was refused, in the platform's words. */
+    error: string | null;
+}
+/**
+ * The gear of the conversation `key` names (`''` for one not begun: it reads and
+ * writes the default until it has an id). Signed out, it lives for the page.
+ */
+export declare function useGear(t: Target, key?: string): GearState;
+/** The dictation language the person keeps, null for Auto, and how to change it. */
+export declare function useLanguage(t: Target): readonly [string | null, (id: string | null) => void];

package/lib/gear.js

@@ -0,0 +1,141 @@
+/**
+ * What a conversation carries beside its words: the skills, connectors and
+ * plugins picked from the composer's `+`, the design system, the device, the
+ * Research and Memory switches and the mode. Chat and Dev keep it the same way.
+ *
+ *   GET   /v1/pref   {prefs: {gear, gears}}
+ *   PATCH /v1/pref   {gear} — the person's default, what a new conversation opens with
+ *                    {gears: {<key>: Gear}} — each conversation's own, newest first, at most `KEEP`
+ *
+ * Both live in the account, so a choice follows the person to every device. A
+ * conversation that has none of its own reads the default; changing one writes
+ * that conversation's, and "Keep as default" writes the default.
+ */
+import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from 'react';
+import { call } from './api/call.js';
+/**
+ * The modes the platform honours. Manual and Accept edits are not here: a cloud
+ * run takes `build` or `plan` (apps/coding) and a chat turn asks before nothing,
+ * so offering them would promise a pause that never comes.
+ */
+export const MODES = [
+    { id: 'auto', label: 'Auto', note: 'Hanzo works on its own and stops to ask only if something looks unsafe.' },
+    { id: 'plan', label: 'Plan', note: 'Hanzo lays out the plan first and changes nothing until you say go.' },
+];
+export const BARE = {
+    skills: [],
+    connectors: [],
+    plugins: [],
+    design: '',
+    device: '',
+    research: false,
+    memory: true,
+    mode: 'auto',
+};
+/** How many conversations keep a choice of their own: the document holds 16 KiB in all. */
+export const KEEP = 30;
+const list = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string' && x !== '') : []);
+const text = (v) => (typeof v === 'string' ? v : '');
+/** A stored value as a Gear, a field the reader does not know read as unset. */
+export function gearOf(raw, base = BARE) {
+    const o = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+    return {
+        skills: 'skills' in o ? list(o.skills) : base.skills,
+        connectors: 'connectors' in o ? list(o.connectors) : base.connectors,
+        plugins: 'plugins' in o ? list(o.plugins) : base.plugins,
+        design: 'design' in o ? text(o.design) : base.design,
+        device: 'device' in o ? text(o.device) : base.device,
+        research: typeof o.research === 'boolean' ? o.research : base.research,
+        memory: typeof o.memory === 'boolean' ? o.memory : base.memory,
+        mode: MODES.some((m) => m.id === o.mode) ? o.mode : base.mode,
+    };
+}
+/** `gears` with `key`'s entry first, cut to `KEEP`. */
+export function shelve(gears, key, g) {
+    const out = { [key]: g };
+    for (const [k, v] of Object.entries(gears)) {
+        if (k === key)
+            continue;
+        if (Object.keys(out).length >= KEEP)
+            break;
+        out[k] = v;
+    }
+    return out;
+}
+let doc = { gear: BARE, gears: {}, language: null };
+let loaded = null;
+const listeners = new Set();
+const emit = () => listeners.forEach((f) => f());
+const subscribe = (f) => {
+    listeners.add(f);
+    return () => listeners.delete(f);
+};
+function load(t) {
+    const id = `${t.api}|${t.org ?? ''}|${t.token() ? 1 : 0}`;
+    if (loaded === id || !t.token())
+        return;
+    loaded = id;
+    void call(t, 'GET', '/v1/pref')
+        .then((r) => {
+        const raw = r?.prefs ?? {};
+        const gear = gearOf(raw.gear);
+        const all = raw.gears && typeof raw.gears === 'object' ? raw.gears : {};
+        const language = typeof raw.language === 'string' && raw.language ? raw.language : null;
+        doc = { gear, gears: Object.fromEntries(Object.entries(all).map(([k, v]) => [k, gearOf(v, gear)])), language };
+        emit();
+    })
+        .catch(() => {
+        loaded = null;
+    });
+}
+/**
+ * The gear of the conversation `key` names (`''` for one not begun: it reads and
+ * writes the default until it has an id). Signed out, it lives for the page.
+ */
+export function useGear(t, key = '') {
+    useEffect(() => load(t), [t]);
+    const now = useSyncExternalStore(subscribe, () => doc, () => doc);
+    const [error, setError] = useState(null);
+    const gear = key ? (now.gears[key] ?? now.gear) : now.gear;
+    const write = useCallback((g) => {
+        const fresh = key ? { ...doc, gears: shelve(doc.gears, key, g) } : { ...doc, gear: g };
+        doc = fresh;
+        emit();
+        if (!t.token())
+            return;
+        const patch = key ? { gears: fresh.gears } : { gear: g };
+        call(t, 'PATCH', '/v1/pref', patch).then(() => setError(null), (e) => setError(e instanceof Error ? e.message : 'Your choice was not saved.'));
+    }, [key, t]);
+    return useMemo(() => ({
+        gear,
+        error,
+        set: (patch) => write({ ...gear, ...patch }),
+        toggle: (field, id) => {
+            const has = gear[field].includes(id);
+            write({ ...gear, [field]: has ? gear[field].filter((x) => x !== id) : [...gear[field], id] });
+        },
+        keep: () => {
+            doc = { ...doc, gear };
+            emit();
+            if (t.token())
+                call(t, 'PATCH', '/v1/pref', { gear }).catch((e) => setError(e instanceof Error ? e.message : 'Not saved.'));
+        },
+    }), [gear, error, write, t]);
+}
+/** The dictation language the person keeps, null for Auto, and how to change it. */
+export function useLanguage(t) {
+    useEffect(() => load(t), [t]);
+    const now = useSyncExternalStore(subscribe, () => doc, () => doc);
+    const set = useCallback((id) => {
+        const was = doc.language;
+        doc = { ...doc, language: id };
+        emit();
+        // A refused save takes the choice back, so what is shown is what is kept.
+        if (t.token())
+            call(t, 'PATCH', '/v1/pref', { language: id }).catch(() => {
+                doc = { ...doc, language: was };
+                emit();
+            });
+    }, [t]);
+    return [now.language, set];
+}

package/lib/index.d.ts

@@ -7,8 +7,11 @@
  * of its own mounts it with `rail={false}` and draws the builder's parts in that
  * rail: its places (`nav`), its runs (`useSessions`, or `DevSection` for both),
  * and at the foot the Slack card and the account menu (`Slack`, `Who`), under
- * `HostProvider`. `Grip` sizes that rail: the edge the builder sizes its own
- * chat with.
+ * `HostProvider`. `Grip` (the kit's, passed on) sizes that rail.
+ *
+ * The side panel's column, for a host that draws it beside its own middle
+ * column (Chat): `useSplit`, `SideProvider` and `PrefsProvider` above both, so
+ * the width the person drags is kept in their preferences (side.tsx).
  *
  * The plan, once for every surface that shows one: `label` names it (`Max` with
  * `20x` beside it), `useStanding` reads where an account stands, `Meter` is the
@@ -26,7 +29,7 @@ export { nav, NEW, type Group } from './nav.tsx';
 export { DevSection, DOTS, useSessions } from './section.tsx';
 export { HostProvider } from './host.tsx';
 export { Slack, useWho, Who } from './foot.tsx';
-export { Grip, type GripProps } from './grip.tsx';
+export { Grip, type GripProps } from '@hanzo/ui';
 export { administers } from './claims.ts';
 export { Meter, Title } from './meter.tsx';
 export { Plan } from './settings/plan.tsx';
@@ -45,9 +48,23 @@ export { href, parse, path, PLACES, route, SESSION, SLUG, type Route, type Scree
  * (`prompt`), the row under an answer (`Reply`), and the side panel (`Panel`
  * over a `Deck` of tabs).
  */
-export { catalog, EFFORTS, FIRST, keep, kept, nameOf, reasons, useCatalog, useChoice, useMind, type Choice, type Effort, type Mind } from './mind.ts';
-export { cut, GAP, MEASURE, measure, Prompt, prompt, ROUND, Tune, useEar, type PromptOptions } from './prompt.tsx';
+export { catalog, EFFORTS, FIRST, FREE, grants, isFree, keep, kept, nameOf, reasons, useCatalog, useChoice, useMind, type Choice, type Effort, type Mind } from './mind.ts';
+export { ASK, cut, GAP, MEASURE, measure, Prompt, prompt, ROUND, trigger, Tune, useEar, useMention, useUpload, type Chip, type PromptOptions } from './prompt.tsx';
+export { Plus, type Link, type PlusProps, type Row as ShelfRow, type Shelf, type Switch } from './plus.tsx';
+export { BARE, gearOf, MODES, useGear, useLanguage, type Gear, type GearState, type Mode as GearMode } from './gear.ts';
+export { useCarry, type Carry } from './carry.tsx';
+export { Dictation } from './mic.tsx';
+export type { Composer as PluginComposer, Plugin, Prep, Turn } from './plugin.ts';
 export { artifacts, blob, lead, renders, Reply, Served, speakable, speaker, type Artifact, type Listen } from './reply.tsx';
 export { frames, Page, Panel, PanelToggle, type Kind, type PageProps, type PanelProps, type Suggestion } from './panel.tsx';
+export { SideProvider, useSplit, type Split } from './side.tsx';
+export { PrefsProvider } from './prefs.tsx';
 export { kinds, Summary, useKinds, type Entry, type Section } from './summary.tsx';
 export { address, destination, located, name, PAGE, SEARCH, useDeck, useKey, usePanel, useShown, type Deck, type Tab, type Tabs } from './tabs.ts';
+/**
+ * Up to three suggestions under the composer (above it on a phone), each from
+ * the person's own activity: `useSuggestions` reads and makes them, `Suggestions`
+ * draws them. The row is `Hint` here: `Suggestion` is the side panel's.
+ */
+export { Suggestions, useSuggestions, type Suggested, type SuggestionsProps } from './suggestions.tsx';
+export type { Suggestion as Hint } from './suggest.ts';

package/lib/index.js

@@ -7,8 +7,11 @@
  * of its own mounts it with `rail={false}` and draws the builder's parts in that
  * rail: its places (`nav`), its runs (`useSessions`, or `DevSection` for both),
  * and at the foot the Slack card and the account menu (`Slack`, `Who`), under
- * `HostProvider`. `Grip` sizes that rail: the edge the builder sizes its own
- * chat with.
+ * `HostProvider`. `Grip` (the kit's, passed on) sizes that rail.
+ *
+ * The side panel's column, for a host that draws it beside its own middle
+ * column (Chat): `useSplit`, `SideProvider` and `PrefsProvider` above both, so
+ * the width the person drags is kept in their preferences (side.tsx).
  *
  * The plan, once for every surface that shows one: `label` names it (`Max` with
  * `20x` beside it), `useStanding` reads where an account stands, `Meter` is the
@@ -26,7 +29,7 @@ export { nav, NEW } from './nav.js';
 export { DevSection, DOTS, useSessions } from './section.js';
 export { HostProvider } from './host.js';
 export { Slack, useWho, Who } from './foot.js';
-export { Grip } from './grip.js';
+export { Grip } from '@hanzo/ui';
 export { administers } from './claims.js';
 export { Meter, Title } from './meter.js';
 export { Plan } from './settings/plan.js';
@@ -40,9 +43,21 @@ export { href, parse, path, PLACES, route, SESSION, SLUG } from './route.js';
  * (`prompt`), the row under an answer (`Reply`), and the side panel (`Panel`
  * over a `Deck` of tabs).
  */
-export { catalog, EFFORTS, FIRST, keep, kept, nameOf, reasons, useCatalog, useChoice, useMind } from './mind.js';
-export { cut, GAP, MEASURE, measure, Prompt, prompt, ROUND, Tune, useEar } from './prompt.js';
+export { catalog, EFFORTS, FIRST, FREE, grants, isFree, keep, kept, nameOf, reasons, useCatalog, useChoice, useMind } from './mind.js';
+export { ASK, cut, GAP, MEASURE, measure, Prompt, prompt, ROUND, trigger, Tune, useEar, useMention, useUpload } from './prompt.js';
+export { Plus } from './plus.js';
+export { BARE, gearOf, MODES, useGear, useLanguage } from './gear.js';
+export { useCarry } from './carry.js';
+export { Dictation } from './mic.js';
 export { artifacts, blob, lead, renders, Reply, Served, speakable, speaker } from './reply.js';
 export { frames, Page, Panel, PanelToggle } from './panel.js';
+export { SideProvider, useSplit } from './side.js';
+export { PrefsProvider } from './prefs.js';
 export { kinds, Summary, useKinds } from './summary.js';
 export { address, destination, located, name, PAGE, SEARCH, useDeck, useKey, usePanel, useShown } from './tabs.js';
+/**
+ * Up to three suggestions under the composer (above it on a phone), each from
+ * the person's own activity: `useSuggestions` reads and makes them, `Suggestions`
+ * draws them. The row is `Hint` here: `Suggestion` is the side panel's.
+ */
+export { Suggestions, useSuggestions } from './suggestions.js';