@hanzo/build 0.2.82 → 0.2.84

package/README.md

@@ -118,10 +118,14 @@ French and right to left in Arabic.
 One of each, shared with Chat (@hanzo/rooms imports them):
 
 - `useMind` — the model and effort: `GET /v1/models` read once per platform,
-  and the choice kept in this browser (`hanzo.mind`, Enso and Medium until
-  changed). `Tune` is the chip that changes it; Settings → Code writes the same
-  choice. `@hanzo/build/mind` serves the store alone, without the builder.
-- `prompt` / `Prompt` — the composer, as wide as the text above it (`measure`).
+  and the choice kept in this browser (`hanzo.mind`, Enso and Auto until
+  changed). The composer's row changes it: the effort (Auto, High, XHigh,
+  Max) always, the model chip only where the person turned the model selector
+  on (Settings → Appearance, `@hanzo/appearance` `composing`). Settings → Code
+  writes the same choice. `@hanzo/build/mind` serves the store alone, without
+  the builder. `pacing(mind)` is the effort as the composer reads it.
+- The composer is `@hanzo/ui/chat`'s `Composer`, once for Chat, Dev and Studio;
+  `useEar` is the platform's ear it dictates through.
 - `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
@@ -253,10 +257,12 @@ are any member's.
 (Cloud is the platform's sandbox with the codebase's environment; the org's
 machines follow under remote control, each linked with `hanzo link`), the
 codebase and the branch — the forge's repositories, filtered as you type, read
-again with Refresh list, and a way to Sync for a GitHub repository that is not
-there yet — then the ask, in the composer Chat draws too (`prompt`): the paperclip
-and Build or Plan at its start; the model and effort (`Tune`), dictation and
-send at its end. A codebase can be added to a project. Opening a codebase or an
+again each time the list opens, and a way to bring a GitHub repository that is
+not there yet — then the ask, in the composer Chat draws too (`@hanzo/ui/chat`): the
+paperclip and Build or Plan at its start; the effort, the model where the person
+turned the selector on, dictation and send at its end. The three pills sit above
+the field (environment, repository with its All / Organization / GitHub tabs, branch),
+and Repos, Branches, Issues and Templates under it, each a press to its list. A codebase can be added to a project. Opening a codebase or an
 issue from its own screen lands here with that choice already made.
 
 **A run.** The transcript as it streams, drawn by what each part is: what the
@@ -351,7 +357,8 @@ picker and open-in-tab; Share and Publish; the console dock under it.
 `mode`, `model` and `effort` are sent with a run as asked — Enso as
 `enso-auto`, never left out — and `issue`, the number a run started from an
 issue closes; the platform honours them where it does and nothing here
-simulates them.
+simulates them. A run takes `low`, `medium` or `high`, so Auto names `medium`
+and High, XHigh and Max name `high` (`level`).
 
 ## Layout
 
@@ -369,7 +376,7 @@ src/
   prose.tsx     markdown, drawn as text (markdown.ts reads it)
   desk.tsx      the pane beside a run
   mind.ts       the model and effort, one choice with Chat
-  prompt.tsx    the composer, and Tune, the model and effort chip
+  voice.ts      the language dictation listens in, and the platform's ear
   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

package/lib/carry.d.ts

@@ -2,8 +2,7 @@ import { type ReactNode } from 'react';
 import { type Target } from './api/call.ts';
 import { type GearState, type Mode } from './gear.ts';
 import type { Composer, Prep, Turn } from './plugin.ts';
-import type { Shelf } from './plus.tsx';
-import type { Chip, PromptOptions } from './prompt.tsx';
+import type { Carried, Modes, Shelf } from '@hanzo/ui/chat';
 /** What the surface lends the plugins: its draft, its files, its way about. */
 export type Lent = Omit<Composer, 'target' | 'show'>;
 export interface Carry {
@@ -20,9 +19,9 @@ export interface Carry {
     /** What the plugins that are on add to the message about to go. */
     prep: (turn: Omit<Turn, 'design'>, signal: AbortSignal) => Promise<Prep>;
     /** The chips after `+`: the skills on, Research, and Plan. */
-    on: Chip[];
+    on: Carried[];
     /** The mode pill: this surface's modes, the conversation's choice among them. */
-    mode: NonNullable<PromptOptions['mode']>;
+    mode: Modes<Mode>;
     /** Whether `what` may run: in Manual the person is asked (once, always in this conversation, or not); else yes. */
     allow: (what: Asked) => Promise<boolean>;
     /** The words the gear adds to every message, '' when none. */

package/lib/carry.js

@@ -26,7 +26,7 @@ import { active, authored, document, nameOf as skillOf } from './api/skills.js';
 import { brand, brands } from './api/studio.js';
 import { useRead } from './data.js';
 import { said as designSaid } from './design.js';
-import { DEV_MODES, useGear } from './gear.js';
+import { DEV_MODES, MODES, useGear } from './gear.js';
 import { active as lighted, prep, shelf as pluginShelf, usePlugins } from './plugins/index.js';
 /** The most of each skill a message carries. */
 const SKILL_MAX = 16_000;
@@ -171,7 +171,7 @@ export function useCarry(t, key, customize, lent, modes = DEV_MODES) {
     };
     return {
         gear,
-        mode: { value: mode, set: (m) => gear.set({ mode: m }), items: modes },
+        mode: { value: mode, set: (m) => gear.set({ mode: m }), items: MODES.filter((x) => modes.includes(x.id)) },
         allow,
         skills: shelf,
         plugins,

package/lib/index.d.ts

@@ -45,16 +45,14 @@ export type { Read } from './data.ts';
 export { href, parse, path, PLACES, route, SESSION, SLUG, type Route, type Screen } from './route.ts';
 /**
  * What Chat draws the same way (@hanzo/rooms imports these): the model and
- * effort (`useMind`, one choice kept for both, changed by `Tune`), the composer
- * (`prompt`), the row under an answer (`Reply`), and the side panel (`Panel`
- * over a `Deck` of tabs).
+ * effort (`useMind`, one choice kept for both), the row under an answer
+ * (`Reply`), and the side panel (`Panel` over a `Deck` of tabs). The composer is
+ * @hanzo/ui/chat's, for Chat and Dev alike.
  */
-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 { catalog, EFFORTS, FIRST, FREE, grants, isFree, keep, kept, level, nameOf, pacing, useCatalog, useChoice, useMind, type Choice, type Effort, type Mind } from './mind.ts';
+export { useEar } from './voice.ts';
 export { BARE, CHAT_MODES, DEV_MODES, 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 { 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';

package/lib/index.js

@@ -40,16 +40,14 @@ export { kind, label, said, share, spent, ways, when } from './plan.js';
 export { href, parse, path, PLACES, route, SESSION, SLUG } from './route.js';
 /**
  * What Chat draws the same way (@hanzo/rooms imports these): the model and
- * effort (`useMind`, one choice kept for both, changed by `Tune`), the composer
- * (`prompt`), the row under an answer (`Reply`), and the side panel (`Panel`
- * over a `Deck` of tabs).
+ * effort (`useMind`, one choice kept for both), the row under an answer
+ * (`Reply`), and the side panel (`Panel` over a `Deck` of tabs). The composer is
+ * @hanzo/ui/chat's, for Chat and Dev alike.
  */
-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 { catalog, EFFORTS, FIRST, FREE, grants, isFree, keep, kept, level, nameOf, pacing, useCatalog, useChoice, useMind } from './mind.js';
+export { useEar } from './voice.js';
 export { BARE, CHAT_MODES, DEV_MODES, 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';

package/lib/landing.js

@@ -1,11 +1,11 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * New: the empty state. A heading at the top of the column, and at the foot of
  * the pane the composer — where the run goes (Cloud: the sandbox with the
  * codebase's environment; or one of the org's machines, under remote control),
  * which repository and branch it starts from, and the ask itself — the one
- * composer Chat draws too (prompt.tsx): attach and the mode at its start, the
- * model and effort, dictation and send at its end.
+ * composer Chat draws too (@hanzo/ui/chat): Dev hands it the three pills, the
+ * chips that go to its repositories, issues and templates, and its commands.
  *
  * Sending starts a coding run on a project and opens it. A project is a
  * repository — the org's on the forge, or one its GitHub grants — so a run
@@ -19,8 +19,9 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { SizableText, XStack, YStack } from '@hanzo/gui';
 import { phrase } from '@hanzo/i18n';
 import { useI18n } from '@hanzo/i18n/react';
-import { Cloud, Monitor } from '@hanzogui/lucide-icons-2';
+import { CircleDot, Cloud, Code, GitBranch, LayoutTemplate, Monitor, Play } from '@hanzogui/lucide-icons-2';
 import { Button } from '@hanzo/ui';
+import { Composer, MEASURE } from '@hanzo/ui/chat';
 import { BranchSelect, ChipSelect, FooterLink, RepoSelect } from '@hanzo/ui/product';
 import { useLimits } from '@hanzo/ui/product/useLimits';
 import { useDictation, useTalk, useVoice } from '@hanzo/voice';
@@ -36,7 +37,7 @@ import { ready, SANDBOX } from './api/places.js';
 import { asHub, isForge, isHub, settle } from './choice.js';
 import { useCached, useKept, usePlaces, useRead } from './data.js';
 import { useHost, useTarget } from './host.js';
-import { useMind } from './mind.js';
+import { level, pacing, useMind } from './mind.js';
 import { usePrefs } from './prefs.js';
 import { Publish } from './publish.js';
 import { path } from './route.js';
@@ -44,10 +45,8 @@ import { useCarry } from './carry.js';
 import { DEV_MODES } from './gear.js';
 import { book, hand, Suggestions, taken, useSuggestions } from './suggestions.js';
 import { want } from './library.js';
-import { MEASURE, Prompt, useEar } from './prompt.js';
-import { Monitor as Device } from '@hanzogui/lucide-icons-2';
-import { compose, Files, pick, read as readFiles } from './tools.js';
-import { useSpoken } from './voice.js';
+import { carrying, compose, pick, read as readFiles } from './tools.js';
+import { useEar, useSpoken } from './voice.js';
 /** One vocabulary for the mode, on New and in a workspace: English, marked (`phrase`), drawn through `t`. */
 export const MODES = [
     { id: 'build', label: phrase('Build'), hint: phrase('Edits, commits and pushes a branch') },
@@ -104,9 +103,9 @@ export function Landing({ onStarted }) {
     const [note, setNote] = useState('');
     const [adding, setAdding] = useState(null);
     const [offering, setOffering] = useState(false);
-    // The repository list is read again each time it opens; Refresh reads it again while open.
+    // The repository and branch lists are read again each time they open.
     const [picking, setPicking] = useState(false);
-    const [round, setRound] = useState(0);
+    const [branching, setBranching] = useState(false);
     // A codebase or an issue hands its words over once. Left in the kept choice,
     // every later visit to New would put them back.
     useEffect(() => {
@@ -171,7 +170,7 @@ export function Landing({ onStarted }) {
         const github = (hub?.repos ?? []).map(asHub);
         for (const r of github)
             hubs.current.set(r.full_name.toLowerCase(), r);
-        return { repos: [...repos, ...github], next: null };
+        return { repos: [...repos.map((r) => ({ ...r, source: 'forge' })), ...github.map((r) => ({ ...r, source: 'github' }))], next: null };
     }, [target]);
     // Drawn only once a forge codebase is chosen; one the forge no longer lists offers its default branch.
     const home = kept.repo?.default_branch || 'main';
@@ -231,7 +230,7 @@ export function Landing({ onStarted }) {
                 targetId: place.id,
                 mode,
                 model: mind.model,
-                effort: mind.effort,
+                effort: level(mind.effort),
                 issue,
             });
             setDraft('');
@@ -297,7 +296,7 @@ export function Landing({ onStarted }) {
     };
     /** Start the agent that finds a codebase's environment, and open it: its run is the progress. A refusal is the dialog's to say. */
     const setup = async (repo) => {
-        const run = await start(target, { prompt: SETUP, repo, mode: 'setup', model: mind.model, effort: mind.effort });
+        const run = await start(target, { prompt: SETUP, repo, mode: 'setup', model: mind.model, effort: level(mind.effort) });
         onStarted(run.session);
     };
     /** The codebase a dialog chose, chosen here too. */
@@ -306,27 +305,20 @@ export function Landing({ onStarted }) {
         setIssue(0);
         set({ repo: row, branch: row.default_branch });
     };
-    // Cloud is the sandbox, set up by the chosen codebase's environment.
-    const setUp = codebase && env.value
-        ? env.value.state === 'ready'
-            ? t('{repo} environment', { repo: codebase })
-            : env.value.state === 'proposed'
-                ? t('{repo} environment proposed', { repo: codebase })
-                : unset(env.value)
-                    ? t('no {repo} environment yet', { repo: codebase })
-                    : t('{repo} environment, empty', { repo: codebase })
-        : '';
+    // Cloud is the sandbox, set up by the chosen codebase's environment; the rest are the org's machines.
     const placeItems = useMemo(() => (places.value.length ? places.value : [SANDBOX]).map((p) => ({
         id: p.id || 'sandbox',
         label: p.id ? p.label : t('Cloud'),
-        hint: p.id ? [t('Remote control'), p.status, p.capacity].filter(Boolean).join(' · ') : [t('Hanzo sandbox'), setUp].filter(Boolean).join(' · '),
+        hint: p.id ? [p.status, p.capacity].filter(Boolean).join(' · ') : '',
+        icon: p.id ? _jsx(Monitor, { size: 13, color: "$soft" }) : _jsx(Cloud, { size: 13, color: "$soft" }),
         disabled: !ready(p),
         place: p,
-    })), [places.value, setUp, t]);
+    })), [places.value, t]);
     const branch = kept.branch || kept.repo?.default_branch || 'main';
-    const where = (_jsxs(XStack, { gap: 6, items: "center", flexWrap: "wrap", children: [_jsx(ChipSelect, { name: t('Where the run runs'), icon: place.id ? _jsx(Monitor, { size: 13 }) : _jsx(Cloud, { size: 13 }), label: place.id ? place.label : t('Cloud'), chosen: placeItems.find((i) => i.place.id === place.id), items: placeItems, onChange: (i) => set({ place: i.place.id }), placeholder: t('Search machines…'), loading: places.loading, error: places.error?.message ?? null, footer: _jsxs(YStack, { gap: "$0.5", children: [_jsx(SizableText, { size: "$1", color: "$ink", children: t('Set up remote control') }), _jsx(SizableText, { size: "$1", color: "$soft", children: t('Run {command} on a machine: it joins this list, and a run there uses its checkout and credentials.', {
-                                command: (_jsx(SizableText, { size: "$1", color: "$ink", fontFamily: "$mono", 'data-i18n-ltr': '', children: "hanzo link" })),
-                            }) })] }) }), _jsx(RepoSelect, { open: picking, onOpenChange: setPicking, value: isForge(kept.repo) || isHub(kept.repo) ? kept.repo : null, onChange: (r) => {
+    const forge = isForge(kept.repo);
+    const screen = (to) => () => host.go(path({ kind: 'screen', screen: to }));
+    // The composer's pills: where the run goes, which repository, which branch.
+    const pills = (_jsxs(_Fragment, { children: [_jsx(ChipSelect, { name: t('Where the run runs'), icon: place.id ? _jsx(Monitor, { size: 13, color: "$soft" }) : _jsx(Cloud, { size: 13, color: "$soft" }), label: place.id ? place.label : t('Cloud'), chosen: placeItems.find((i) => i.place.id === place.id), items: placeItems, onChange: (i) => set({ place: i.place.id }), placeholder: t('Search machines…'), placement: "top-start", loading: places.loading, error: places.error?.message ?? null, footer: _jsx(FooterLink, { label: t('Manage…'), onPress: () => host.go(path({ kind: 'settings', section: 'machines' })) }) }), _jsx(RepoSelect, { open: picking, onOpenChange: setPicking, value: isForge(kept.repo) ? { ...kept.repo, source: 'forge' } : isHub(kept.repo) ? { ...kept.repo, source: 'github' } : null, onChange: (r) => {
                     const hub = r.github ? hubs.current.get((r.full_name ?? "").toLowerCase()) : undefined;
                     setIssue(0);
                     if (hub) {
@@ -335,10 +327,11 @@ export function Landing({ onStarted }) {
                     }
                     const row = known.current.get(r.name) ?? chosen(r);
                     set({ repo: row, branch: row.default_branch });
-                }, load: loadRepos, troubleshoot: {
-                    label: t('Missing a GitHub repository? Bring it onto the forge'),
-                    onPress: () => host.go(path({ kind: 'screen', screen: 'sync' })),
-                }, connect: _jsx(XStack, { justify: "flex-end", children: _jsx(FooterLink, { label: t('Refresh list'), onPress: () => setRound((n) => n + 1) }) }), note: t("Repositories on the forge and on your organization's GitHub. Type to search."), action: {
+                }, load: loadRepos, tabs: [
+                    { id: 'all', label: t('All') },
+                    { id: 'forge', label: t('Organization') },
+                    { id: 'github', label: 'GitHub' },
+                ], troubleshoot: { label: t('Bring a repository from GitHub'), onPress: screen('sync') }, action: {
                     label: t('Add to project'),
                     onPress: (r) => {
                         const row = known.current.get(r.name);
@@ -349,25 +342,38 @@ export function Landing({ onStarted }) {
                             name: r.name,
                         });
                     },
-                }, placeholder: t('Choose a project'), disabled: !signed }, round), isForge(kept.repo) ? _jsx(BranchSelect, { value: branch, onChange: (b) => set({ branch: b }), load: loadBranches }) : null] }));
-    const head = files.length ? (_jsx(XStack, { gap: 6, items: "center", flexWrap: "wrap", children: _jsx(Files, { files: files, onFiles: setFiles }) })) : undefined;
-    // The machines a run can go to, as the `+` menu's Devices: the same choice as `where`'s.
+                }, placeholder: t('Repository'), placement: "top-start", disabled: !signed }), forge ? _jsx(BranchSelect, { open: branching, onOpenChange: setBranching, value: branch, onChange: (b) => set({ branch: b }), load: loadBranches, placement: "top-start" }) : null] }));
+    // Where a run goes from here: its repositories, branches, issues and templates, each one press away.
+    const chips = [
+        { id: 'repos', label: t('Repos'), icon: _jsx(Code, { size: 13, color: "$soft" }), onPress: () => setPicking(true) },
+        ...(forge ? [{ id: 'branches', label: t('Branches'), icon: _jsx(GitBranch, { size: 13, color: "$soft" }), onPress: () => setBranching(true) }] : []),
+        { id: 'issues', label: t('Issues'), icon: _jsx(CircleDot, { size: 13, color: "$soft" }), onPress: screen('issues') },
+        { id: 'templates', label: t('Templates'), icon: _jsx(LayoutTemplate, { size: 13, color: "$soft" }), onPress: screen('templates') },
+    ];
+    const commands = [
+        { id: 'run', label: t('Run'), keys: 'Ctrl+↵', icon: _jsx(Play, { size: 14, color: "$soft" }), disabled: !draft.trim(), run: () => void send() },
+        { id: 'issues', label: t('View issues'), icon: _jsx(CircleDot, { size: 14, color: "$soft" }), run: screen('issues') },
+        { id: 'templates', label: t('Browse templates'), icon: _jsx(LayoutTemplate, { size: 14, color: "$soft" }), run: screen('templates') },
+        { id: 'projects', label: t('Open projects'), icon: _jsx(Code, { size: 14, color: "$soft" }), run: screen('projects') },
+        { id: 'sync', label: t('Bring a repository from GitHub'), icon: _jsx(GitBranch, { size: 14, color: "$soft" }), run: screen('sync') },
+    ];
+    // The machines a run can go to, as the `+` menu's Devices: the same choice as the pill's.
     const devices = {
-        rows: placeItems.map((i) => ({ id: i.place.id || 'sandbox', label: i.label, note: i.hint, icon: _jsx(Device, { size: 16 }), on: i.place.id === place.id })),
+        rows: placeItems.map((i) => ({ id: i.place.id || 'sandbox', label: i.label, note: i.hint, icon: _jsx(Monitor, { size: 16 }), on: i.place.id === place.id })),
         pick: (id) => set({ place: id === 'sandbox' ? '' : id }),
         loading: places.loading,
         error: places.error?.message ?? null,
     };
-    return (_jsxs(YStack, { flex: 1, minH: 0, minW: 0, items: "center", justify: "center", pb: "$10", overflowY: "auto", overflowX: "hidden", children: [_jsxs(YStack, { width: "100%", maxW: MEASURE, gap: "$3", children: [_jsx(SizableText, { render: "h1", fontSize: "$7", lineHeight: "$7", fontWeight: "700", color: "$ink", style: { textAlign: 'center' }, children: t('Build what’s next.') }), _jsxs(YStack, { gap: "$2", children: [stranger ? (_jsxs(XStack, { items: "center", justify: "space-between", gap: "$3", px: "$3", py: "$2", rounded: "$10", borderWidth: 1, borderColor: "$borderColor", role: "alert", children: [_jsx(SizableText, { size: "$2", color: "$ink", flex: 1, minW: 0, children: t('{repo} is not one of this organization’s repositories.', { repo: codebase }) }), _jsx(Button, { size: "sm", variant: "outline", onPress: () => setPicking(true), children: t('Choose a repository') })] })) : env.value && (env.value.state === 'proposed' || unset(env.value)) && !place.id ? (_jsxs(XStack, { items: "center", justify: "space-between", gap: "$3", px: "$3", py: "$2", rounded: "$10", borderWidth: 1, borderColor: "$borderColor", children: [_jsx(SizableText, { size: "$2", color: "$ink", flex: 1, minW: 0, children: env.value.state === 'proposed'
-                                            ? t('A proposed environment for {repo} is waiting for review.', { repo: codebase })
-                                            : t('{repo} has no environment yet, so every run starts it bare.', { repo: codebase }) }), env.value.state === 'proposed' && env.value.session ? (_jsx(Button, { size: "sm", variant: "outline", onPress: () => host.go(env.value.session), children: t('Review') })) : (_jsx(Button, { size: "sm", onPress: () => setOffering(true), children: t('Set up environment') }))] })) : null, note || unhonoured(mode, place.id, t) || mind.note ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note || unhonoured(mode, place.id, t) || mind.note })) : null, _jsx(Prompt, { framed: true, value: draft, onChange: setDraft, onSend: () => void send(), busy: busy, label: t('Describe a task or ask a question'), head: head, plus: {
-                                    upload: () => pick(files, setFiles, setNote, t),
-                                    skills: carry.skills,
-                                    design: carry.design,
-                                    plugins: carry.plugins,
-                                    devices,
-                                    memory: { on: carry.gear.gear.memory, set: (on) => carry.gear.set({ memory: on }) },
-                                }, on: carry.on, slash: carry.skills, at: carry.plugins, mode: carry.mode, where: where, below: _jsx(Suggestions, { rows: hints.rows, onAct: act, onDismiss: hints.dismiss }), mind: mind, limits: limits, onUpgrade: () => host.go(path({ kind: 'screen', screen: 'plans' })), voice: voice, language: prefs.language ?? null, onLanguage: (id) => void savePrefs({ language: id }), talk: talk })] })] }), _jsx(Publish, { source: adding, onClose: () => setAdding(null) }), carry.dialog, codebase ? (_jsx(SetupDialog, { repo: codebase, homes: homes, open: offering, onOpenChange: setOffering, onStart: setup, onRepo: choose, onSaved: () => {
+    return (_jsxs(YStack, { flex: 1, minH: 0, minW: 0, items: "center", overflowX: "hidden", "data-slot": "new", children: [_jsx(YStack, { flex: 1, minH: 0, width: "100%", maxW: MEASURE, justify: "flex-end", pb: "$3", overflowY: "auto", children: _jsx(SizableText, { render: "h1", fontSize: "$7", lineHeight: "$7", fontWeight: "700", color: "$ink", style: { textAlign: 'center' }, children: t('Build what’s next.') }) }), _jsx(YStack, { width: "100%", maxW: MEASURE, gap: "$2", pb: 12, shrink: 0, children: _jsxs(YStack, { gap: "$2", children: [stranger ? (_jsxs(XStack, { items: "center", justify: "space-between", gap: "$3", px: "$3", py: "$2", rounded: "$10", borderWidth: 1, borderColor: "$borderColor", role: "alert", children: [_jsx(SizableText, { size: "$2", color: "$ink", flex: 1, minW: 0, children: t('{repo} is not one of this organization’s repositories.', { repo: codebase }) }), _jsx(Button, { size: "sm", variant: "outline", onPress: () => setPicking(true), children: t('Choose a repository') })] })) : env.value && (env.value.state === 'proposed' || unset(env.value)) && !place.id ? (_jsxs(XStack, { items: "center", justify: "space-between", gap: "$3", px: "$3", py: "$2", rounded: "$10", borderWidth: 1, borderColor: "$borderColor", children: [_jsx(SizableText, { size: "$2", color: "$ink", flex: 1, minW: 0, children: env.value.state === 'proposed'
+                                        ? t('A proposed environment for {repo} is waiting for review.', { repo: codebase })
+                                        : t('{repo} has no environment yet, so every run starts it bare.', { repo: codebase }) }), env.value.state === 'proposed' && env.value.session ? (_jsx(Button, { size: "sm", variant: "outline", onPress: () => host.go(env.value.session), children: t('Review') })) : (_jsx(Button, { size: "sm", onPress: () => setOffering(true), children: t('Set up environment') }))] })) : null, note || unhonoured(mode, place.id, t) || mind.note ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note || unhonoured(mode, place.id, t) || mind.note })) : null, _jsx(Composer, { column: true, framed: true, value: draft, onChange: setDraft, onSend: () => void send(), busy: busy, placeholder: t('Ask, build, or run anything…'), label: t('Describe a task or ask a question'), plus: {
+                                upload: () => pick(files, setFiles, setNote, t),
+                                skills: carry.skills,
+                                design: carry.design,
+                                plugins: carry.plugins,
+                                devices,
+                                memory: { on: carry.gear.gear.memory, set: (on) => carry.gear.set({ memory: on }) },
+                            }, carried: [...carry.on, ...carrying(files, setFiles)], slash: carry.skills, at: carry.plugins, pills: pills, chips: chips, commands: commands, starters: _jsx(Suggestions, { rows: hints.rows, onAct: act, onDismiss: hints.dismiss }), mind: mind, effort: pacing(mind), limits: limits, onUpgrade: () => host.go(path({ kind: 'screen', screen: 'plans' })), voice: voice, language: prefs.language ?? null, onLanguage: (id) => void savePrefs({ language: id }), talk: talk })] }) }), _jsx(Publish, { source: adding, onClose: () => setAdding(null) }), carry.dialog, codebase ? (_jsx(SetupDialog, { repo: codebase, homes: homes, open: offering, onOpenChange: setOffering, onStart: setup, onRepo: choose, onSaved: () => {
                     setOffering(false);
                     env.reload();
                 } })) : null] }));

package/lib/mind.d.ts

@@ -1,12 +1,35 @@
+/**
+ * Which model answers, and how hard it thinks: one store for Chat and Dev, and
+ * the catalog both offer. The composer (@hanzo/ui/chat) changes it.
+ *
+ *   GET /v1/models   the catalog, read once per platform and shared
+ *   hanzo.mind       the person's choice, in this browser: {model, effort}
+ *
+ * The effort is always under the composer; the model chip only where the person
+ * turned it on (Settings → Appearance › Model in composer). Enso
+ * routes every ask — a message in Chat, a step in Dev — so naming a model is an
+ * override, and the panel says so before it offers one. A premium model is
+ * picked for the screen it was picked on (`usePick`) and never kept, so the next
+ * conversation or run opens on what was kept, Enso until something else is.
+ *
+ * The efforts are Auto, High, XHigh and Max, Chat's words (Hanzo's
+ * ThinkingEffort), Auto until another is chosen. A coding run takes low, medium
+ * or high (apps/coding `efforts`), so `level` is what a run names: medium for
+ * Auto, what a run took before anyone chose, and high for the rest, the most it
+ * takes. Auto names one rather than none, because a run that names none takes
+ * an effort the person saved to their account once (apps/coding start.go) and
+ * no screen shows any more.
+ */
+import type { Modes } from '@hanzo/ui/chat';
 import { type Target } from './api/call.ts';
 import { type Model } from './api/models.ts';
-export type Effort = 'low' | 'medium' | 'high';
-/** The efforts, in English and marked (`phrase`): the composer draws each word through `t`. */
-export declare const EFFORTS: readonly {
+export type Effort = 'auto' | 'high' | 'xhigh' | 'max';
+/** The efforts a Dev run offers, in order: the composer's own list (Chat offers every one), less Low and Medium. Marked English, drawn through `t`. */
+export declare const EFFORTS: (import("@hanzo/ui/chat").Way<import("@hanzo/ui/chat").Effort> & {
     id: Effort;
-    label: string;
-    note: string;
-}[];
+})[];
+/** The effort a coding run names (apps/coding takes low, medium or high): medium for Auto, high for the rest. */
+export declare const level: (effort: Effort) => 'medium' | 'high';
 /** What a person chose: the model (Enso routes) and the effort. */
 export interface Choice {
     model: string;
@@ -17,14 +40,12 @@ export declare const FIRST: Choice;
 export declare const FREE = "enso-free";
 /** Whether a plan grants only the free lane. An unknown plan is not taken for Free. */
 export declare const isFree: (plan: string | null | undefined) => boolean;
-/** The kept choice, Enso and Medium where nothing is kept. Stable while the stored text is. */
+/** The kept choice, Enso and Auto where nothing is kept. Stable while the stored text is. Low and Medium, offered once, read as Auto. */
 export declare function kept(): Choice;
 /** Keep a change, in this browser, for every surface that reads it. */
 export declare function keep(patch: Partial<Choice>): void;
 /** The kept choice and the way to change it. The server and the first render read the default. */
 export declare function useChoice(): readonly [Choice, (patch: Partial<Choice>) => void];
-/** Whether `model` takes an effort: the router and an undescribed model do, a listed one only if it reasons. */
-export declare function reasons(model: string, catalog: readonly Model[]): boolean;
 /** A model's name as the catalog spells it; Enso for the router. */
 export declare function nameOf(model: string, catalog: readonly Model[]): string;
 /** An id said as a name: its last path part, each word capitalised (`enso-flash` → Enso Flash). */
@@ -55,6 +76,8 @@ export interface Catalog {
 export declare function useCatalog(t: Target): Catalog;
 /** Whether `model` is one this plan may send: on Free, the catalog's free class alone. */
 export declare function grants(free: boolean, model: string, catalog: readonly Model[]): boolean;
+/** The effort as the composer reads it: the one in force, its list, and the way to change it. */
+export declare const pacing: (m: Pick<Mind, 'effort' | 'pace'>) => Modes<Effort>;
 /** The chip's whole state: the catalog, what answers next, and how to change either. */
 export interface Mind {
     model: string;

package/lib/mind.js

@@ -1,34 +1,14 @@
-/**
- * Which model answers, and how hard it thinks: one store for Chat and Dev, and
- * the catalog both offer. The chip that changes it is `Tune` (prompt.tsx).
- *
- *   GET /v1/models   the catalog, read once per platform and shared
- *   hanzo.mind       the person's choice, in this browser: {model, effort}
- *
- * Effort is on the chip and the model is one press in. Enso routes every ask —
- * a message in Chat, a step in Dev — so naming a model is an override, and the
- * panel says so before it offers one. A premium model is picked for the screen
- * it was picked on (`usePick`) and never kept, so the next conversation or run
- * opens on what was kept, Enso until something else is.
- *
- * The efforts are the set both planes take: `reasoning_effort` on a completion
- * and `effort` on a coding run (apps/coding `efforts`). A model the catalog
- * lists as not reasoning offers none; Enso and a model the catalog does not
- * describe offer all three.
- */
-import { phrase } from '@hanzo/i18n';
+import { EFFORTS as EVERY } from '@hanzo/ui/chat/pure';
 import { parseModels } from '@hanzo/ui/models/catalog';
 import { useEffect, useState, useSyncExternalStore } from 'react';
 import { Refusal } from './api/call.js';
 import { ENSO, models as read } from './api/models.js';
 import { usePick } from './pick.js';
-/** The efforts, in English and marked (`phrase`): the composer draws each word through `t`. */
-export const EFFORTS = [
-    { id: 'low', label: phrase('Low'), note: phrase('A quick pass') },
-    { id: 'medium', label: phrase('Medium'), note: phrase('Thinks before it answers') },
-    { id: 'high', label: phrase('High'), note: phrase('Slow and careful, for hard problems') },
-];
-export const FIRST = { model: ENSO, effort: 'medium' };
+/** The efforts a Dev run offers, in order: the composer's own list (Chat offers every one), less Low and Medium. Marked English, drawn through `t`. */
+export const EFFORTS = EVERY.filter((e) => ['auto', 'high', 'xhigh', 'max'].includes(e.id));
+/** The effort a coding run names (apps/coding takes low, medium or high): medium for Auto, high for the rest. */
+export const level = (effort) => (effort === 'auto' ? 'medium' : 'high');
+export const FIRST = { model: ENSO, effort: 'auto' };
 /** What Free answers on: the catalog's free lane, Enso's first. `free` is an alias of it. */
 export const FREE = 'enso-free';
 /** Whether a plan grants only the free lane. An unknown plan is not taken for Free. */
@@ -49,7 +29,7 @@ let raw;
 let held = FIRST;
 /** A choice the browser would not store, held for the page. */
 let memo = null;
-/** The kept choice, Enso and Medium where nothing is kept. Stable while the stored text is. */
+/** The kept choice, Enso and Auto where nothing is kept. Stable while the stored text is. Low and Medium, offered once, read as Auto. */
 export function kept() {
     if (memo)
         return memo;
@@ -74,7 +54,8 @@ export function kept() {
 }
 /** Keep a change, in this browser, for every surface that reads it. */
 export function keep(patch) {
-    const next = { ...kept(), ...patch };
+    const was = kept();
+    const next = { ...was, ...patch, effort: patch.effort === undefined ? was.effort : effortOf(patch.effort) };
     try {
         store()?.setItem(KEY, JSON.stringify(next));
         memo = null;
@@ -98,13 +79,6 @@ function subscribe(change) {
 export function useChoice() {
     return [useSyncExternalStore(subscribe, kept, () => FIRST), keep];
 }
-/** Whether `model` takes an effort: the router and an undescribed model do, a listed one only if it reasons. */
-export function reasons(model, catalog) {
-    if (model === ENSO)
-        return true;
-    const row = catalog.find((m) => m.id === model);
-    return !row || row.supports_reasoning === true;
-}
 /** A model's name as the catalog spells it; Enso for the router. */
 export function nameOf(model, catalog) {
     if (model === ENSO)
@@ -204,6 +178,8 @@ export function grants(free, model, catalog) {
         return true;
     return catalog.find((m) => m.id === model)?.class === 'free';
 }
+/** The effort as the composer reads it: the one in force, its list, and the way to change it. */
+export const pacing = (m) => ({ value: m.effort, set: m.pace, items: EFFORTS });
 /**
  * The model and effort for the plan `plan` names (`GET /v1/ai/limits` `plan`).
  * On Free the default is `FREE` and a kept pick outside the free lane is set

package/lib/plugins/index.d.ts

@@ -19,7 +19,7 @@ import type { Say } from '@hanzo/i18n/react';
 import type { Target } from '../api/call.ts';
 import type { Gear, GearState } from '../gear.ts';
 import type { Composer, Plugin, Prep, Turn } from '../plugin.ts';
-import type { Shelf } from '../plus.tsx';
+import type { Shelf } from '@hanzo/ui/chat';
 export { research } from './research.tsx';
 export interface Plugins {
     plugins: Plugin[];

package/lib/project.js

@@ -46,7 +46,7 @@ import { SizableText, useMedia, XStack, YStack } from '@hanzo/gui';
 import { useI18n } from '@hanzo/i18n/react';
 import { Clock, ExternalLink, MousePointerClick, PanelLeft, RefreshCcw, Share2, Upload, } from '@hanzogui/lucide-icons-2';
 import { Attachments, CHAT, Console, DEVICES, Feedback, FileTabs, FileTree, PageSelect, PreviewFrame, ProjectChip, VIEWS, Views, Workspace, fold, } from '@hanzo/ui/agents';
-import { Message } from '@hanzo/ui/chat';
+import { Composer, Message } from '@hanzo/ui/chat';
 import { Button, Dialog, DialogContent, DialogTitle } from '@hanzo/ui';
 import { HanzoMark } from '@hanzo/ui/product';
 import { useDictation, useVoice } from '@hanzo/voice';
@@ -64,13 +64,13 @@ import { useKept, useProjects, useRead, useRun } from './data.js';
 import { Merge } from './git.js';
 import { Gutter } from './gutter.js';
 import { useHost, useTarget } from './host.js';
-import { useMind } from './mind.js';
+import { MODES } from './gear.js';
+import { level, pacing, useMind } from './mind.js';
 import { Out } from './out.js';
-import { Prompt, useEar } from './prompt.js';
-import { useSpoken } from './voice.js';
+import { useEar, useSpoken } from './voice.js';
 import { Publish } from './publish.js';
 import { path } from './route.js';
-import { compose, Files, pick } from './tools.js';
+import { carrying, compose, pick } from './tools.js';
 const LIVE = new Set(['running', 'paused']);
 /** How often a project being published is read again, ms. */
 const AGAIN = 5000;
@@ -353,7 +353,7 @@ export function Project({ at }) {
                 mode,
                 // Enso named as itself: a run that names none takes the person's saved coding default.
                 model: mind.model,
-                effort: mind.effort,
+                effort: level(mind.effort),
             });
             setDraft('');
             setPicked([]);
@@ -422,9 +422,9 @@ export function Project({ at }) {
                                                 ? t('{name} is loaded and nothing is published yet. Say what to change and it gets built.', { name: project.name })
                                                 : named
                                                     ? t('{repo} is open on {branch}. Say what to change and it gets built there.', { repo: `${named.org}/${named.name}`, branch: home })
-                                                    : t('{name} is loaded. Say what to change and it gets built.', { name: slug }) })) : (ordered.map((r) => (_jsxs(YStack, { gap: "$2", children: [_jsx(Turn, { run: r, open: r.id === current, onOpen: () => setChosen(r.id), project: slug }), r.id === current ? (_jsxs(YStack, { gap: "$1", paddingInlineStart: "$2", borderInlineStartWidth: 1, borderColor: "$borderColor", children: [fold(run.events.map((e) => ({ kind: e.kind, actor: who(e.actor), seq: e.seq, id: e.id, text: said(e, run.record?.mode, t) })).filter((b) => b.text)).map((b) => (_jsx(SizableText, { size: "$1", color: "$soft", children: b.text }, b.key))), pr.href ? (_jsxs(XStack, { items: "center", gap: "$2", flexWrap: "wrap", children: [_jsxs(Out, { href: pr.href, label: t('Open pull request {pr}', { pr: pr.label }), children: [_jsx(SizableText, { size: "$1", color: "$ink", textDecorationLine: "underline", children: t('Pull request {pr}', { pr: pr.label }) }), _jsx(ExternalLink, { size: 11 })] }), _jsx(Merge, { session: r.id, open: proposing, onMerged: merged })] })) : null] })) : null] }, r.id)))) }), _jsxs(YStack, { "data-slot": "project-ask", px: "$3", pb: "$3", gap: "$2", minW: 0, $md: { pr: 0 }, children: [note ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note })) : null, picked.length ? _jsx(Attachments, { items: picked, onRemove: () => setPicked([]) }) : null, attached.length ? (_jsx(XStack, { gap: 6, flexWrap: "wrap", children: _jsx(Files, { files: attached, onFiles: setAttached }) })) : null, _jsx(Prompt, { framed: true, value: draft, onChange: setDraft, onSend: () => void (current && running ? steer(current) : send()), onStop: current
+                                                    : t('{name} is loaded. Say what to change and it gets built.', { name: slug }) })) : (ordered.map((r) => (_jsxs(YStack, { gap: "$2", children: [_jsx(Turn, { run: r, open: r.id === current, onOpen: () => setChosen(r.id), project: slug }), r.id === current ? (_jsxs(YStack, { gap: "$1", paddingInlineStart: "$2", borderInlineStartWidth: 1, borderColor: "$borderColor", children: [fold(run.events.map((e) => ({ kind: e.kind, actor: who(e.actor), seq: e.seq, id: e.id, text: said(e, run.record?.mode, t) })).filter((b) => b.text)).map((b) => (_jsx(SizableText, { size: "$1", color: "$soft", children: b.text }, b.key))), pr.href ? (_jsxs(XStack, { items: "center", gap: "$2", flexWrap: "wrap", children: [_jsxs(Out, { href: pr.href, label: t('Open pull request {pr}', { pr: pr.label }), children: [_jsx(SizableText, { size: "$1", color: "$ink", textDecorationLine: "underline", children: t('Pull request {pr}', { pr: pr.label }) }), _jsx(ExternalLink, { size: 11 })] }), _jsx(Merge, { session: r.id, open: proposing, onMerged: merged })] })) : null] })) : null] }, r.id)))) }), _jsxs(YStack, { "data-slot": "project-ask", px: "$3", pb: "$3", gap: "$2", minW: 0, $md: { pr: 0 }, children: [note ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note })) : null, picked.length ? _jsx(Attachments, { items: picked, onRemove: () => setPicked([]) }) : null, _jsx(Composer, { column: true, framed: true, value: draft, onChange: setDraft, onSend: () => void (current && running ? steer(current) : send()), onStop: current
                             ? () => void stop(target, current).then(() => setNote(t('Stop requested — the run keeps its work on its branch')), (e) => setNote(e.message))
-                            : undefined, busy: busy || (running && !draft.trim()), placeholder: running ? t('Steer this run') : t('Ask Hanzo for edits'), label: t('Ask Hanzo for edits'), plus: { upload: () => pick(attached, setAttached, setNote, t) }, mode: running ? null : { value: mode === 'plan' ? 'plan' : 'auto', set: (m) => setMode(m === 'plan' ? 'plan' : 'build'), items: ['auto', 'plan'] }, mind: running ? null : mind, voice: voice })] }), wide && !shut ? (_jsx(Gutter, { side: "left", span: across, floor: CHAT_FLOOR, ceil: most, reset: CHAT_WIDTH, onSpan: setSplit, label: t('Resize the chat'), gap: GUTTER })) : null] }));
+                            : undefined, busy: busy || (running && !draft.trim()), placeholder: running ? t('Steer this run') : t('Ask Hanzo for edits'), label: t('Ask Hanzo for edits'), plus: { upload: () => pick(attached, setAttached, setNote, t) }, carried: carrying(attached, setAttached), mode: running ? null : { value: mode === 'plan' ? 'plan' : 'auto', set: (m) => setMode(m === 'plan' ? 'plan' : 'build'), items: MODES.filter((m) => m.id !== 'manual') }, mind: running ? null : mind, effort: running ? null : pacing(mind), voice: voice })] }), wide && !shut ? (_jsx(Gutter, { side: "left", span: across, floor: CHAT_FLOOR, ceil: most, reset: CHAT_WIDTH, onSpan: setSplit, label: t('Resize the chat'), gap: GUTTER })) : null] }));
     // The preview stays loaded while another view is open, so coming back to it
     // is the page as it was left.
     const preview = (_jsxs(YStack, { "data-slot": "preview", flex: 1, minH: 0, minW: 0, gap: "$2", display: view === 'preview' ? 'flex' : 'none', children: [_jsxs(XStack, { "data-slot": "preview-bar", items: "center", gap: "$1.5", minW: 0, shrink: 0, "$max-md": { px: '$2' }, children: [_jsx(XStack, { render: "button", "aria-label": t('Reload the preview'), onPress: () => frame.current?.reload(), p: "$1.5", rounded: "$3", hoverStyle: { bg: '$hover' }, children: _jsx(RefreshCcw, { size: 16 }) }), _jsx(PageSelect, { pages: pages, value: page, onChange: setPage, shrink: 1 }), _jsx(XStack, { flex: 1 }), _jsx(Views, { views: DEVICES, value: device, onChange: (d) => setDevice(d), label: t('Device'), labels: "none" }), src ? (_jsx(Out, { href: src, label: t('Open in a new tab'), children: _jsx(XStack, { p: "$1.5", rounded: "$3", hoverStyle: { bg: '$hover' }, children: _jsx(ExternalLink, { size: 16 }) }) })) : null] }), _jsx(PreviewFrame, { ref: frame, src: src, title: t('{title} preview', { title }), device: device, onBridge: onBridge, empty: _jsxs(YStack, { items: "center", gap: "$2", p: "$6", children: [_jsx(SizableText, { size: "$3", color: "$ink", children: stalled