@hanzo/build 0.2.78 → 0.2.80

package/README.md

@@ -226,10 +226,15 @@ are any member's.
 - Plugins: TypeScript connectors built on the platform, from source or from a
   description of an API; a failed build says why. Browse offers building one and
   lists what the deployment mounts.
-- Agents: Browse is the platform's presets whose tool calls run on the platform,
-  each a Use that opens a new agent written from it; Yours is the org's own —
-  model, instructions, tools, budget — created, edited (only what changed is
-  sent) and deleted.
+- Agents: Browse is every agent to start from — the host's default agents
+  (`cast`) and personas (`personas`), and the platform's presets whose tool
+  calls run on the platform — searched by name and filtered by category. Use
+  makes one agent of the org's own from one template (a name taken becomes
+  `-2`, `-3`), with its face, model and instructions, and opens its profile;
+  nothing is added in bulk. Start from scratch, Clone yourself (the person
+  signed in, with writing pasted or uploaded) and Create from a person make one
+  too. Yours is the org's own — model, instructions, tools, budget — created,
+  edited (only what changed is sent) and deleted.
 
 **New.** "What's up next?", and at the foot the composer: where the run runs
 (Cloud is the platform's sandbox with the codebase's environment; the org's

package/lib/api/agents.d.ts

@@ -1,6 +1,6 @@
 /**
- * Agents: the org's own — a model, instructions, the tools it may call and a
- * budget — and the presets one can start from.
+ * Agents: the org's own — a model, instructions, the tools it may call, a
+ * budget and a face — and the templates one is made from.
  *
  *   GET    /v1/agent                 {agents: [agent]}, without instructions
  *   POST   /v1/agent                 create → 201 agent
@@ -35,6 +35,8 @@ export interface Agent {
     task: number;
     spent: number;
     period: Period | '';
+    /** Its picture: an https link or a data URL; '' draws its emoji or initial. */
+    avatar: string;
     emoji: string;
 }
 export interface Preset {
@@ -52,6 +54,8 @@ export interface Draft {
     cap: string;
     task: string;
     period: Period;
+    /** Sent on create only: an https link or a data URL. */
+    avatar: string;
 }
 /** An agent's name, as the handler takes it. */
 export declare const NAME: RegExp;
@@ -86,29 +90,45 @@ export declare function profile(t: Target, ref: string): Promise<{
     agent: Agent;
     runs: Run[];
 }>;
-/** A default agent a host offers: a name, its line, its model and its instructions. */
+/** An agent to start from: a default agent, a persona or a preset. */
 export interface Cast {
+    /** The name it is made under. */
     name: string;
+    /** What Browse calls it. */
+    title: string;
     description: string;
+    /** What Browse lists it under. */
+    category: string;
     model: string;
     instructions: string;
-    /** Its face, an address of the host, when it has one. */
+    /** Reads the instructions, where they are a file the host serves. */
+    read?: () => Promise<string>;
+    /** Its face, an address of the host. */
     avatar?: string;
+    tools?: string[];
 }
-/** What a default agent may spend until its owner says otherwise, in dollars: each month, and one run. */
+/** What an agent made from a template may spend until its owner says otherwise, in dollars: each month, and one run. */
 export declare const CAST_CAP = "10";
 export declare const CAST_TASK = "1";
-/** The cast members the org has no agent for, by name in any case. */
-export declare const missing: (cast: readonly Cast[], have: readonly {
-    name: string;
-}[]) => Cast[];
-/** Create every cast member the org lacks, one at a time; the names made, and the first refusal, if any. */
-export declare function hire(t: Target, cast: readonly Cast[], have: readonly {
+/**
+ * A name the API takes: accents dropped, any other run of characters a dash,
+ * from a letter or digit, up to 64. "Spärck Jones" is Sparck-Jones.
+ */
+export declare const handle: (name: string) => string;
+/** `name`, or `name-2`, `name-3`… : the first the org has no agent called, in any case. */
+export declare function free(name: string, have: readonly {
     name: string;
-}[]): Promise<{
-    made: string[];
-    error: unknown;
-}>;
+}[]): string;
+/** An address of the page as an https link the API keeps, or '' (a page served over http has none). */
+export declare const link: (at: string | undefined, base: string) => string;
+/**
+ * Make the org's own agent from a template: under the first name the org has
+ * free (read now, so it is never one that exists), with its instructions read
+ * and its face linked. The template is not touched.
+ */
+export declare function use(t: Target, c: Cast, base: string): Promise<Agent>;
+/** Anyone as a template: their name, who they are, and writing of theirs to take the voice from. */
+export declare function person(name: string, about: string, writing: string, avatar?: string): Cast;
 export declare function create(t: Target, d: Draft): Promise<Agent>;
 /** The fields that differ from `was`, and nothing else: an omitted field keeps its value. */
 export declare function changes(was: Agent, d: Draft): Record<string, unknown>;
@@ -116,5 +136,5 @@ export declare function update(t: Target, was: Agent, d: Draft): Promise<Agent>;
 export declare function remove(t: Target, ref: string): Promise<void>;
 /** The presets that make a working agent. */
 export declare function presets(t: Target): Promise<Preset[]>;
-/** A new agent's draft from a preset. */
-export declare function fromPreset(p: Preset): Draft;
+/** A preset as a template. */
+export declare function fromPreset(p: Preset): Cast;

package/lib/api/agents.js

@@ -1,6 +1,6 @@
 /**
- * Agents: the org's own — a model, instructions, the tools it may call and a
- * budget — and the presets one can start from.
+ * Agents: the org's own — a model, instructions, the tools it may call, a
+ * budget and a face — and the templates one is made from.
  *
  *   GET    /v1/agent                 {agents: [agent]}, without instructions
  *   POST   /v1/agent                 create → 201 agent
@@ -47,6 +47,7 @@ export function agent(raw) {
         task: num(o.max_task_micro_usd),
         spent: num(o.consumed_micro_usd),
         period: PERIODS.includes(period) ? period : '',
+        avatar: str(o.avatar),
         emoji: str(o.emoji),
     };
 }
@@ -61,9 +62,10 @@ export function draft(a) {
         cap: dollars(a.cap),
         task: dollars(a.task),
         period: a.period || 'month',
+        avatar: a.avatar,
     };
 }
-export const EMPTY = { name: '', description: '', model: '', instructions: '', tools: [], cap: '', task: '', period: 'month' };
+export const EMPTY = { name: '', description: '', model: '', instructions: '', tools: [], cap: '', task: '', period: 'month', avatar: '' };
 /** Why a draft cannot be saved as it stands, or '' when it can. */
 export function refuse(d) {
     if (!NAME.test(d.name))
@@ -95,27 +97,52 @@ export async function profile(t, ref) {
     const raw = await call(t, 'GET', `/v1/agent/${seg(ref)}`);
     return { agent: agent(raw), runs: rows(obj(raw).recentRuns).map(run).filter((r) => r.id) };
 }
-/** What a default agent may spend until its owner says otherwise, in dollars: each month, and one run. */
+/** What an agent made from a template may spend until its owner says otherwise, in dollars: each month, and one run. */
 export const CAST_CAP = '10';
 export const CAST_TASK = '1';
-/** The cast members the org has no agent for, by name in any case. */
-export const missing = (cast, have) => {
-    const names = new Set(have.map((a) => a.name.toLowerCase()));
-    return cast.filter((c) => !names.has(c.name.toLowerCase()));
-};
-/** Create every cast member the org lacks, one at a time; the names made, and the first refusal, if any. */
-export async function hire(t, cast, have) {
-    const made = [];
-    for (const c of missing(cast, have)) {
-        try {
-            await create(t, { ...EMPTY, name: c.name, description: c.description, model: c.model, instructions: c.instructions, cap: CAST_CAP, task: CAST_TASK, period: 'month' });
-            made.push(c.name);
-        }
-        catch (error) {
-            return { made, error };
-        }
+/**
+ * A name the API takes: accents dropped, any other run of characters a dash,
+ * from a letter or digit, up to 64. "Spärck Jones" is Sparck-Jones.
+ */
+export const handle = (name) => name
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^A-Za-z0-9._-]+/g, '-')
+    .replace(/^[^A-Za-z0-9]+/, '')
+    .slice(0, 64)
+    .replace(/-+$/, '');
+/** `name`, or `name-2`, `name-3`… : the first the org has no agent called, in any case. */
+export function free(name, have) {
+    const taken = new Set(have.map((a) => a.name.toLowerCase()));
+    if (!taken.has(name.toLowerCase()))
+        return name;
+    for (let i = 2;; i++) {
+        const next = `${name.slice(0, 63 - String(i).length)}-${i}`;
+        if (!taken.has(next.toLowerCase()))
+            return next;
     }
-    return { made, error: null };
+}
+/** An address of the page as an https link the API keeps, or '' (a page served over http has none). */
+export const link = (at, base) => {
+    if (!at)
+        return '';
+    const url = new URL(at, base).href;
+    return url.startsWith('https://') || url.startsWith('data:') ? url : '';
+};
+/**
+ * Make the org's own agent from a template: under the first name the org has
+ * free (read now, so it is never one that exists), with its instructions read
+ * and its face linked. The template is not touched.
+ */
+export async function use(t, c, base) {
+    const [have, instructions] = await Promise.all([agents(t), c.read ? c.read() : c.instructions]);
+    return create(t, { ...EMPTY, name: free(handle(c.name), have), description: c.description, model: c.model, instructions, tools: c.tools ?? [], cap: CAST_CAP, task: CAST_TASK, avatar: link(c.avatar, base) });
+}
+/** Anyone as a template: their name, who they are, and writing of theirs to take the voice from. */
+export function person(name, about, writing, avatar = '') {
+    const who = name.trim();
+    const lines = [`You are ${who}.`, about.trim(), writing.trim() && `Writing by ${who}:\n\n${writing.trim()}`];
+    return { name: who, title: who, description: about.trim(), category: 'Person', model: '', instructions: lines.filter(Boolean).join('\n\n'), avatar };
 }
 export async function create(t, d) {
     const why = refuse(d);
@@ -132,6 +159,8 @@ export async function create(t, d) {
     };
     if (d.model)
         body.model = d.model;
+    if (d.avatar)
+        body.avatar = d.avatar;
     return agent(await call(t, 'POST', '/v1/agent', body));
 }
 /** The fields that differ from `was`, and nothing else: an omitted field keeps its value. */
@@ -173,7 +202,7 @@ export async function presets(t) {
         .map((p) => ({ id: str(p.id), title: str(p.title), prompt: str(p.systemPrompt) }))
         .filter((p) => p.id);
 }
-/** A new agent's draft from a preset. */
+/** A preset as a template. */
 export function fromPreset(p) {
-    return { ...EMPTY, name: p.id, description: p.title, instructions: p.prompt };
+    return { name: p.id, title: p.title || p.id, description: p.title, category: 'Preset', model: '', instructions: p.prompt };
 }

package/lib/customize/agents.d.ts

@@ -1,4 +1,7 @@
+import { type Cast } from '../api/agents.ts';
 import { type Pane } from './ui.tsx';
+/** Categories as Browse offers them: the default agents' and presets' first, as listed, then the rest by how many each holds. */
+export declare function kinds(first: readonly Cast[], rest: readonly Cast[]): string[];
 export declare function Agents({ view, q, adding, onAdding, onView, onCount }: Pane): import("react").JSX.Element;
 /** One agent's page: who it is, what it runs on and reads, what it may call and spend, and what it has done. */
 export declare function Profile({ name }: {

package/lib/customize/agents.js

@@ -3,10 +3,12 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
  * Agents: the org's own — a model, instructions, the tools it may call, and
  * what it may spend.
  *
- * Browse is the platform's presets whose tool calls run on the platform;
- * starting from one opens a new agent written from it. Yours lists the org's
- * agents, and Add default agents makes every member of the host's cast the org
- * has none for (an org starts with none). Opening one is its profile page
+ * Browse is every agent there is to start from: the host's default agents
+ * (`cast`) and personas (`personas`), and the platform's presets whose tool
+ * calls run on the platform, by name and category. Use makes the org's own
+ * agent from one and opens it; nothing is added any other way, so an org starts
+ * with none. An agent is also made from scratch, from the person signed in
+ * (Clone yourself) or from anyone named. Yours lists the org's agents. Opening one is its profile page
  * (`-/customize/agents/<name>`): its face, part, model, instructions, tools,
  * budget and runs, edited in place, and only what changed is sent. An
  * agent calls only the tools it names, and only those that are on for the org,
@@ -15,11 +17,11 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
  * spend each period, and in one run.
  */
 import { SizableText, XStack, YStack } from '@hanzo/gui';
-import { ArrowLeft, Bot, Users } from '@hanzogui/lucide-icons-2';
+import { ArrowLeft, Upload } from '@hanzogui/lucide-icons-2';
 import { Button, Input, Switch, Textarea } from '@hanzo/ui';
 import { ModelPicker } from '@hanzo/ui/models';
-import { useEffect, useMemo, useState } from 'react';
-import { agents, ALL, create, draft, EMPTY, fromPreset, hire, missing, one, PERIODS, presets, profile, remove, update } from '../api/agents.js';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { agents, ALL, create, draft, EMPTY, fromPreset, one, PERIODS, person, presets, profile, remove, update, use } from '../api/agents.js';
 import { models } from '../api/models.js';
 import { tools } from '../api/tools.js';
 import { useHost, useTarget } from '../host.js';
@@ -27,58 +29,106 @@ import { path } from '../route.js';
 import { useLoad } from './load.js';
 import { say } from './say.js';
 import { Add, Choice, Confirm, Empty, Failed, Field, Grid, Line, Mark, matches, mono, Part, Sheet, Soft, Tile, useCount, Visitor } from './ui.js';
+/** How many cards Browse draws at a time. */
+const PAGE = 60;
+const ANY = 'All';
+/** Categories as Browse offers them: the default agents' and presets' first, as listed, then the rest by how many each holds. */
+export function kinds(first, rest) {
+    const lead = [...new Set(first.map((c) => c.category))];
+    const count = new Map();
+    for (const c of rest)
+        if (!lead.includes(c.category))
+            count.set(c.category, (count.get(c.category) ?? 0) + 1);
+    return [ANY, ...lead, ...[...count.keys()].sort((a, b) => count.get(b) - count.get(a) || a.localeCompare(b))];
+}
 const money = (m) => `$${(m / 1_000_000).toFixed(m % 10_000 ? 4 : 2).replace(/\.?0+$/, '')}`;
 export function Agents({ view, q, adding, onAdding, onView, onCount }) {
     const host = useHost();
     const t = useTarget();
     const signed = Boolean(host.person);
+    const browsing = view === 'discover';
     const mine = useLoad(signed ? () => agents(t) : null, [], [t, signed]);
-    const offered = useLoad(view === 'discover' ? () => presets(t) : null, [], [t, view]);
+    const offered = useLoad(browsing ? () => presets(t) : null, [], [t, view]);
+    const figures = useLoad(browsing && host.personas ? host.personas : null, [], [view]);
     useCount(mine.value.length, onCount);
-    const [start, setStart] = useState(null);
     const [note, setNote] = useState('');
-    const [hiring, setHiring] = useState(false);
-    const cast = host.cast ?? [];
-    const lacking = missing(cast, mine.value);
-    // The host's cast, made in one press: each member the org has no agent for.
-    const addCast = async () => {
-        setHiring(true);
+    const [kind, setKind] = useState(ANY);
+    const [more, setMore] = useState(PAGE);
+    const [using, setUsing] = useState(null);
+    const [making, setMaking] = useState(null);
+    useEffect(() => setMore(PAGE), [q, kind]);
+    const opened = (a) => host.go(path({ kind: 'agent', name: a.name }));
+    const take = async (c) => {
+        setUsing(c);
         setNote('');
-        const { made, error } = await hire(t, cast, mine.value);
-        setHiring(false);
-        mine.reload();
-        setNote(error ? `${made.length ? `Added ${made.length}. ` : ''}${say(error)}` : `Added ${made.length} default ${made.length === 1 ? 'agent' : 'agents'}`);
-    };
-    const castButton = signed && lacking.length ? (_jsxs(Button, { size: "sm", variant: "outline", disabled: hiring, onPress: () => void addCast(), children: [_jsx(Users, { size: 14 }), " ", hiring ? 'Adding…' : lacking.length === cast.length ? 'Add default agents' : `Add ${lacking.length} default ${lacking.length === 1 ? 'agent' : 'agents'}`] })) : null;
-    const closeNew = () => {
-        setStart(null);
-        onAdding(false);
+        try {
+            opened(await use(t, c, window.location.href));
+        }
+        catch (e) {
+            setNote(say(e));
+        }
+        finally {
+            setUsing(null);
+        }
     };
-    const editor = adding || start ? (_jsx(Editor, { start: start ?? EMPTY, onClose: closeNew, onSaved: (a) => {
-            closeNew();
+    const editor = adding ? (_jsx(Editor, { onClose: () => onAdding(false), onSaved: (a) => {
+            onAdding(false);
             onView('yours');
             mine.reload();
             setNote(`${a.name} is saved`);
         } })) : null;
-    if (view === 'discover') {
-        const names = new Set(mine.value.map((a) => a.name));
-        const shown = offered.value.filter((p) => matches(q, p.id, p.title, p.prompt));
-        return (_jsxs(YStack, { gap: "$3", children: [_jsx(Line, { children: note }), _jsx(Part, { title: "Start from a preset", detail: "A ready agent from Hanzo. You can change it before you save it.", children: offered.error && !offered.value.length ? (_jsx(Failed, { error: offered.error, onRetry: offered.reload })) : offered.loading && !offered.value.length ? (_jsx(Soft, { children: "Loading presets\u2026" })) : !shown.length ? (_jsx(Soft, { children: offered.value.length ? `No preset matches “${q.trim()}”.` : 'There are no presets yet. Start from a blank agent with New agent.' })) : (_jsx(Grid, { label: "Presets", children: shown.map((p) => (_jsx(Tile, { title: p.title || p.id, detail: p.prompt, meta: `Preset ${p.id}`, mark: _jsx(Mark, { name: p.title || p.id, icon: _jsx(Bot, { size: 15 }) }), action: signed ? _jsx(Add, { name: p.title || p.id, label: "Use", added: names.has(p.id), onPress: () => setStart(fromPreset(p)) }) : undefined }, p.id))) })) }), editor] }));
+    if (browsing) {
+        const first = [...(host.cast ?? []), ...offered.value.map(fromPreset)];
+        const all = [...first, ...figures.value];
+        const shown = all.filter((c) => (kind === ANY || c.category === kind) && matches(q, c.title, c.name, c.description, c.category));
+        const failed = figures.error ?? offered.error;
+        return (_jsxs(YStack, { gap: "$3", children: [signed ? (_jsxs(XStack, { gap: "$2", flexWrap: "wrap", children: [_jsx(Button, { size: "sm", variant: "outline", onPress: () => onAdding(true), children: "Start from scratch" }), _jsx(Button, { size: "sm", variant: "outline", onPress: () => setMaking('self'), children: "Clone yourself" }), _jsx(Button, { size: "sm", variant: "outline", onPress: () => setMaking('person'), children: "Create from a person" })] })) : null, _jsx(XStack, { overflowX: "auto", overflowY: "hidden", pb: "$1", children: _jsx(Choice, { label: "Category", value: kind, options: kinds(first, figures.value).map((id) => ({ id, label: id })), onChange: setKind }) }), _jsx(Line, { children: note }), shown.length ? (_jsx(Grid, { label: "Agents to start from", children: shown.slice(0, more).map((c) => (_jsx(Tile, { title: c.title, detail: c.description === c.title || c.description === c.category ? undefined : c.description, meta: c.category, mark: _jsx(Mark, { name: c.title, size: 40, logo: c.avatar }), action: signed ? _jsx(Add, { name: c.title, label: "Use", added: false, busy: using !== null, onPress: () => void take(c) }) : undefined }, `${c.category}/${c.name}/${c.title}`))) })) : figures.loading || offered.loading ? null : (_jsx(Soft, { children: `No agent matches “${q.trim()}”.` })), shown.length > more ? (_jsx(XStack, { children: _jsx(Button, { size: "sm", variant: "ghost", onPress: () => setMore(more + PAGE), children: "More" }) })) : null, failed ? _jsx(Failed, { error: failed, onRetry: figures.error ? figures.reload : offered.reload }) : figures.loading || offered.loading ? _jsx(Soft, { children: "Loading\u2026" }) : null, editor, making ? _jsx(Person, { self: making === 'self', onClose: () => setMaking(null), onMade: opened }) : null] }));
     }
     if (!signed) {
         return _jsx(Visitor, { children: "Sign in to see your agents." });
     }
     const shown = mine.value.filter((a) => matches(q, a.name, a.description, a.model));
-    return (_jsxs(YStack, { gap: "$3", children: [_jsx(Line, { children: note }), mine.error && !mine.value.length ? (_jsx(Failed, { error: mine.error, onRetry: mine.reload })) : mine.loading && !mine.value.length ? (_jsx(Soft, { children: "Loading your agents\u2026" })) : !mine.value.length ? (_jsxs(Empty, { title: "No agents yet", detail: cast.length ? 'Add the default team, start from a preset, or give a new one a model, instructions and tools.' : 'Start from a preset, or give a new one a model, instructions and tools.', children: [castButton, _jsx(Button, { size: "sm", variant: "outline", onPress: () => onView('discover'), children: "Browse presets" }), _jsx(Button, { size: "sm", onPress: () => onAdding(true), children: "New agent" })] })) : !shown.length ? (_jsx(Soft, { children: `No agent of yours matches “${q.trim()}”.` })) : (_jsxs(_Fragment, { children: [castButton ? _jsx(XStack, { children: castButton }) : null, _jsx(Grid, { label: "Your agents", children: shown.map((a) => (_jsx(Tile, { title: a.name, detail: a.description || 'No description.', meta: [a.model, `${a.runs} ${a.runs === 1 ? 'run' : 'runs'}`, reach(a), a.cap ? `${money(a.spent)} of ${money(a.cap)} this ${a.period || 'period'}` : ''].filter(Boolean).join(' · '), mark: _jsx(Face, { agent: a, cast: cast }), onOpen: () => host.go(path({ kind: 'agent', name: a.name })) }, a.id || a.name))) })] })), editor] }));
+    return (_jsxs(YStack, { gap: "$3", children: [_jsx(Line, { children: note }), mine.error && !mine.value.length ? (_jsx(Failed, { error: mine.error, onRetry: mine.reload })) : mine.loading && !mine.value.length ? (_jsx(Soft, { children: "Loading your agents\u2026" })) : !mine.value.length ? (_jsxs(Empty, { title: "No agents yet", detail: "", children: [_jsx(Button, { size: "sm", variant: "outline", onPress: () => onView('discover'), children: "Browse agents" }), _jsx(Button, { size: "sm", onPress: () => onAdding(true), children: "New agent" })] })) : !shown.length ? (_jsx(Soft, { children: `No agent of yours matches “${q.trim()}”.` })) : (_jsx(Grid, { label: "Your agents", children: shown.map((a) => (_jsx(Tile, { title: a.name, detail: a.description || 'No description.', meta: [a.model, `${a.runs} ${a.runs === 1 ? 'run' : 'runs'}`, reach(a), a.cap ? `${money(a.spent)} of ${money(a.cap)} this ${a.period || 'period'}` : ''].filter(Boolean).join(' · '), mark: _jsx(Face, { agent: a, cast: host.cast ?? [] }), onOpen: () => opened(a) }, a.id || a.name))) })), editor] }));
+}
+/** Clone yourself, or anyone named: a name, who they are, and writing of theirs, pasted or uploaded. */
+function Person({ self, onClose, onMade }) {
+    const host = useHost();
+    const t = useTarget();
+    const me = self ? host.person : null;
+    const [name, setName] = useState(me?.name ?? '');
+    const [about, setAbout] = useState('');
+    const [writing, setWriting] = useState('');
+    const [working, setWorking] = useState(false);
+    const [note, setNote] = useState('');
+    const file = useRef(null);
+    const read = async (files) => {
+        const texts = await Promise.all([...(files ?? [])].map((f) => f.text()));
+        setWriting((w) => [w.trim(), ...texts.map((x) => x.trim())].filter(Boolean).join('\n\n'));
+    };
+    const save = async () => {
+        setWorking(true);
+        setNote('');
+        try {
+            onMade(await use(t, person(name, about, writing, me?.avatar), window.location.href));
+        }
+        catch (e) {
+            setNote(say(e));
+            setWorking(false);
+        }
+    };
+    return (_jsxs(Sheet, { title: self ? 'Clone yourself' : 'Create from a person', open: true, onOpenChange: (o) => !o && onClose(), children: [_jsx(Field, { label: "Name", children: _jsx(Input, { value: name, onChangeText: setName, "aria-label": "Name" }) }), _jsx(Field, { label: "Description", children: _jsx(Textarea, { value: about, onChangeText: setAbout, "aria-label": "Description", rows: 3 }) }), _jsx(Field, { label: "Writing", children: _jsx(Textarea, { value: writing, onChangeText: setWriting, "aria-label": "Writing", rows: 6 }) }), _jsxs(XStack, { children: [_jsxs(Button, { size: "sm", variant: "ghost", onPress: () => file.current?.click(), children: [_jsx(Upload, { size: 14 }), " Upload"] }), _jsx("input", { ref: file, type: "file", multiple: true, accept: ".txt,.md,.markdown,.csv,.json,.html,text/*", hidden: true, "aria-label": "Upload writing", onChange: (e) => {
+                            void read(e.currentTarget.files);
+                            e.currentTarget.value = '';
+                        } })] }), _jsx(Line, { children: note }), _jsxs(XStack, { gap: "$2", items: "center", children: [_jsx(XStack, { flex: 1 }), _jsx(Button, { size: "sm", variant: "ghost", onPress: onClose, children: "Cancel" }), _jsx(Button, { size: "sm", disabled: working || !name.trim(), onPress: () => void save(), children: "Create" })] })] }));
 }
 function reach(a) {
     if (a.tools.includes(ALL))
         return 'every tool';
     return a.tools.length === 1 ? '1 tool' : `${a.tools.length} tools`;
 }
-/** An agent's face: the cast member's picture, its emoji, or its initial. */
+/** An agent's face: its picture, the default agent's of its name, its emoji, or its initial. */
 function Face({ agent: a, cast, size = 32 }) {
-    const avatar = cast.find((c) => c.name.toLowerCase() === a.name.toLowerCase())?.avatar;
+    const avatar = a.avatar || cast.find((c) => c.name.toLowerCase() === a.name.toLowerCase())?.avatar;
     return _jsx(Mark, { name: a.name, size: size, logo: avatar, icon: a.emoji ? _jsx(SizableText, { size: size > 40 ? '$8' : '$4', children: a.emoji }) : undefined });
 }
 /** One agent's page: who it is, what it runs on and reads, what it may call and spend, and what it has done. */
@@ -95,12 +145,12 @@ export function Profile({ name }) {
                 }, onDeleted: back })) : null] }));
 }
 /** Write a new agent, or change one; an existing agent is read whole first, for its instructions. */
-function Editor({ agent, start, onClose, onSaved, onDeleted, }) {
+function Editor({ agent, onClose, onSaved, onDeleted, }) {
     const t = useTarget();
     const full = useLoad(agent ? () => one(t, agent.id || agent.name) : null, null, [t, agent?.id]);
     const catalog = useLoad(() => models(t), [], [t]);
     const on = useLoad(() => tools(t, { activated: true }), [], [t]);
-    const [d, setD] = useState(start ?? EMPTY);
+    const [d, setD] = useState(EMPTY);
     const [ready, setReady] = useState(!agent);
     const [working, setWorking] = useState(false);
     const [note, setNote] = useState('');

package/lib/customize/index.js

@@ -29,11 +29,9 @@ const LABEL = {
     plugins: { title: 'Plugins', says: 'Connectors you build in TypeScript.', add: 'Build plugin', find: 'Search plugins', icon: _jsx(Puzzle, { size: 15 }) },
     agents: { title: 'Agents', says: 'Agents with their own model, instructions and budget.', add: 'New agent', find: 'Search agents', icon: _jsx(Bot, { size: 15 }) },
 };
-/** Where a tab opens: an org's own agents (and the cast to add) for Agents; Browse for the rest, what there is to add being the page. */
-const opens = (tab) => (tab === 'agents' ? 'yours' : 'discover');
 export function Customize({ tab, view: first }) {
     const host = useHost();
-    const [view, setView] = useState(first ?? opens(tab));
+    const [view, setView] = useState(first ?? 'discover');
     const [q, setQ] = useState('');
     const [adding, setAdding] = useState(false);
     const [count, setCount] = useState(0);
@@ -41,7 +39,7 @@ export function Customize({ tab, view: first }) {
     const pick = (next) => {
         setQ('');
         setAdding(false);
-        setView(opens(next));
+        setView('discover');
         setCount(0);
         host.go(path({ kind: 'customize', tab: next }));
     };

package/lib/host.d.ts

@@ -107,8 +107,10 @@ export interface Host {
     browser?: Browser;
     /** The host's sidebar lists Settings' sections and Customize's tabs, so the pages draw neither. */
     sections?: boolean;
-    /** The default agents an org may add in one press (Customize › Agents). Absent, none are offered. */
+    /** The default agents Customize › Agents offers to start from. Absent, none. */
     cast?: readonly Cast[];
+    /** Every persona Customize › Agents offers to start from, read when Browse opens. Absent, none. */
+    personas?: () => Promise<readonly Cast[]>;
 }
 export declare function HostProvider({ host, children }: {
     host: Host;

package/lib/index.d.ts

@@ -74,5 +74,5 @@ export { address, destination, located, name, PAGE, SEARCH, useDeck, useKey, use
  * 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';
+export { book, hand, Suggestions, taken, useSuggestions, type Suggested, type SuggestionsProps } from './suggestions.tsx';
+export type { Act, Suggestion as Hint } from './suggest.ts';

package/lib/index.js

@@ -68,4 +68,4 @@ export { address, destination, located, name, PAGE, SEARCH, useDeck, useKey, use
  * 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';
+export { book, hand, Suggestions, taken, useSuggestions } from './suggestions.js';

package/lib/landing.js

@@ -37,7 +37,8 @@ import { Publish } from './publish.js';
 import { path } from './route.js';
 import { useCarry } from './carry.js';
 import { DEV_MODES } from './gear.js';
-import { Suggestions, useSuggestions } from './suggestions.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';
@@ -175,9 +176,9 @@ export function Landing({ onStarted }) {
         return { branches: names.map((name) => ({ name })), next: null };
     }, [t, codebase, home]);
     // The composer sends only a draft with words in it, and not while a send is out.
-    const send = async () => {
+    const send = async (said = draft) => {
         if (!signed) {
-            hold({ draft, files, sent: true });
+            hold({ draft: said, files, sent: true });
             host.signIn?.();
             return;
         }
@@ -203,7 +204,7 @@ export function Landing({ onStarted }) {
         setNote('');
         try {
             // What the plugins that are on add: words for the run, or an answer of their own.
-            const prepped = carry.preparing ? await carry.prep({ text: draft.trim(), files: [], thread: '' }, new AbortController().signal) : {};
+            const prepped = carry.preparing ? await carry.prep({ text: said.trim(), files: [], thread: '' }, new AbortController().signal) : {};
             // An answer of a plugin's own (a deck) is the answer: no run is started for it.
             if (prepped.reply) {
                 // Its words, without the page it drew (Chat shows that in the side panel).
@@ -216,7 +217,7 @@ export function Landing({ onStarted }) {
                 return;
             }
             const run = await start(t, {
-                prompt: compose([draft.trim(), carry.text, prepped.system ?? ''].filter(Boolean).join('\n\n---\n'), files),
+                prompt: compose([said.trim(), carry.text, prepped.system ?? ''].filter(Boolean).join('\n\n---\n'), files),
                 // The name alone. The org rides the request, and a slash is not a repo name.
                 // An empty base or place is not sent: the default branch, and the sandbox.
                 repo: repo?.name ?? hub?.full_name,
@@ -249,6 +250,45 @@ export function Landing({ onStarted }) {
         // Sent once, on the sign-in that it waited for.
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [signed]);
+    // A run a suggestion in Chat left for Dev starts on arrival, once its person is known.
+    const [handed] = useState(() => ({ prompt: taken('task') }));
+    useEffect(() => {
+        if (!signed || !handed.prompt)
+            return;
+        const p = handed.prompt;
+        handed.prompt = '';
+        setDraft(p);
+        void send(p);
+        // Started once, on the sign-in that it waited for.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [signed]);
+    /** What pressing a suggestion does: open what it names, chat its prompt, start its run, or make its scheduled task. */
+    const act = (a) => {
+        switch (a.kind) {
+            case 'open':
+                if (a.item)
+                    want(a.item);
+                if (/^https:\/\//.test(a.to))
+                    window.open(a.to, '_blank', 'noopener,noreferrer');
+                else if (a.to.startsWith('/'))
+                    host.open(a.to);
+                else
+                    host.go(a.to);
+                return;
+            case 'send':
+                hand('send', a.prompt);
+                host.open('/chat');
+                return;
+            case 'task':
+                setDraft(a.prompt);
+                void send(a.prompt);
+                return;
+            case 'schedule':
+                setNote('');
+                void book(t, a, 'dev').then((made) => host.go(path({ kind: 'automation', id: made.id })), (e) => setNote(e instanceof Error && e.message ? e.message : 'The scheduled task could not be made.'));
+                return;
+        }
+    };
     /** 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(t, { prompt: SETUP, repo, mode: 'setup', model: mind.model, effort: mind.effort });
@@ -319,7 +359,7 @@ export function Landing({ onStarted }) {
                                     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, onPick: setDraft, 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: () => {
+                                }, 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: () => {
                     setOffering(false);
                     env.reload();
                 } })) : null] }));

package/lib/mic.js

@@ -119,7 +119,10 @@ export function Dictation({ voice, disabled = false, narrow = false, language =
     const { inputs, allowed, using } = useInputs(open);
     const [device, setDevice] = useState(() => (typeof window === 'undefined' ? null : kept()));
     const spoken = LANGUAGES.find((l) => l.id === language);
-    return (_jsxs(XStack, { "data-slot": "dictation", items: "center", rounded: 8, borderWidth: 1, borderColor: open ? '$borderColor' : 'transparent', hoverStyle: { borderColor: '$borderColor' }, shrink: 0, children: [_jsx(Control, { asChild: true, size: narrow ? 44 : 30, ...PLAIN, children: _jsx(Voice, { voice: voice, disabled: disabled, says: { idle: 'Dictate', listening: 'Dictating — click to stop' }, children: (state) => _jsx(MicIcon, { size: 16, color: "var(--foreground)", fill: state === 'idle' ? 'none' : 'var(--foreground)' }) }) }), _jsxs(DropdownMenu, { open: open, onOpenChange: setOpen, children: [_jsx(DropdownMenuTrigger, { asChild: true, disabled: disabled, children: _jsx(XStack, { render: "button", "aria-label": "Dictation settings", "data-slot": "dictation-menu", width: 16, height: 30, items: "center", justify: "center", rounded: 6, cursor: "pointer", bg: open ? '$hover' : 'transparent', hoverStyle: { bg: '$hover' }, ...(narrow ? { width: 44, height: 44 } : null), children: _jsx(ChevronDown, { size: 14, color: "$aside" }) }) }), _jsxs(DropdownMenuContent, { align: "end", minW: 200, "data-slot": "dictation-panel", children: [_jsx(Meter, { device: device, on: open && allowed }), inputs.length === 0 ? (_jsx(DropdownMenuLabel, { children: _jsx(SizableText, { fontSize: 14, color: "$hint", children: "No devices found" }) })) : (inputs.map((d, i) => {
+    // The chevron is drawn while the mic is reached for (pointer, keyboard, menu open); at rest the row is the mic alone.
+    const [near, setNear] = useState(false);
+    const shown = open || near;
+    return (_jsxs(XStack, { "data-slot": "dictation", items: "center", rounded: 8, borderWidth: 1, borderColor: open ? '$borderColor' : 'transparent', hoverStyle: { borderColor: '$borderColor' }, shrink: 0, onPointerEnter: () => setNear(true), onPointerLeave: () => setNear(false), onFocus: () => setNear(true), onBlur: () => setNear(false), children: [_jsx(Control, { asChild: true, size: narrow ? 44 : 30, ...PLAIN, children: _jsx(Voice, { voice: voice, disabled: disabled, says: { idle: 'Dictate', listening: 'Dictating — click to stop' }, children: (state) => _jsx(MicIcon, { size: 16, color: "var(--foreground)", fill: state === 'idle' ? 'none' : 'var(--foreground)' }) }) }), _jsxs(DropdownMenu, { open: open, onOpenChange: setOpen, children: [_jsx(DropdownMenuTrigger, { asChild: true, disabled: disabled, children: _jsx(XStack, { render: "button", "aria-label": "Dictation settings", "data-slot": "dictation-menu", width: 16, height: 30, items: "center", justify: "center", rounded: 6, cursor: "pointer", bg: open ? '$hover' : 'transparent', hoverStyle: { bg: '$hover' }, ...(narrow ? { width: 44, height: 44 } : null), children: _jsx(ChevronDown, { size: 14, color: "$soft", opacity: shown || narrow ? 1 : 0 }) }) }), _jsxs(DropdownMenuContent, { align: "end", minW: 200, "data-slot": "dictation-panel", children: [_jsx(Meter, { device: device, on: open && allowed }), inputs.length === 0 ? (_jsx(DropdownMenuLabel, { children: _jsx(SizableText, { fontSize: 14, color: "$hint", children: "No devices found" }) })) : (inputs.map((d, i) => {
                                 const on = device ? d.deviceId === device : d.groupId === using;
                                 return (_jsx(DropdownMenuItem, { preventCloseOnSelect: true, onSelect: () => {
                                         setDevice(d.deviceId);

package/lib/prompt.js

@@ -168,14 +168,16 @@ export function prompt(o, state) {
         disabled,
         placeholder: o.placeholder ?? ASK,
         ...(o.label ? { label: o.label } : {}),
-        rows: 2,
+        // At rest two rows: one line of text, then the tools. It grows with the text to the kit's ceiling, then scrolls.
+        rows: 1,
         field: {
             ...o.field,
             fontSize: 16,
             lineHeight: 24,
             px: 8,
             pt: 2,
-            minH: 48,
+            pb: 0,
+            minH: 26,
             bg: 'transparent',
         },
         head,

package/lib/suggest.d.ts

@@ -1,7 +1,8 @@
 /**
- * Up to three suggestions under the composer, each one person's own: what
- * happened in their recent work, linked to where it happened, and the next step
- * as a prompt the composer takes.
+ * Three suggestions under the composer, each one person's own and each a thing
+ * done at once when pressed (`Act`): open what it names (a conversation, a run,
+ * a Studio creation, an item, an issue), send a new chat, start a Dev run, or
+ * schedule a task. None only fills the composer.
  *
  * Nothing here is written by hand. The rows are generated by Hanzo's own model
  * (`MODEL`, POST /v1/chat/completions with the person's bearer, so the call is
@@ -24,28 +25,49 @@
  * This file is the pure half: inputs to a request, an answer to validated rows,
  * the fingerprint and the policy. suggestions.tsx reads the sources and draws them.
  */
-import type { Automation } from './api/auto.ts';
+import type { Automation, Schedule } from './api/auto.ts';
 import type { Conversation } from './api/conversations.ts';
 import type { Item } from './api/library.ts';
 import type { Session } from './api/sessions.ts';
 import type { Issue } from './merge.ts';
 export type Icon = 'github' | 'agent' | 'chat' | 'file' | 'task';
 export declare const ICONS: readonly Icon[];
-/** One row: where it came from, what happened, and what to do next. */
+/**
+ * What pressing a row does, at once:
+ *
+ *   open      the thing it names: `to` is an app address (`/chat/<id>`,
+ *             `/studio/c/<id>`), a builder path (`sess_…`, `-/automations/<id>`,
+ *             `-/artifacts` with `item`), or another site's (a new tab)
+ *   send      a new chat, asked `prompt`
+ *   task      a new Dev run on `prompt`
+ *   schedule  a scheduled task, made and shown
+ */
+export type Act = {
+    kind: 'open';
+    to: string;
+    item?: string;
+} | {
+    kind: 'send';
+    prompt: string;
+} | {
+    kind: 'task';
+    prompt: string;
+} | {
+    kind: 'schedule';
+    name: string;
+    prompt: string;
+    schedule: Schedule;
+};
+/** One row: one short action in plain words, and what pressing it does. */
 export interface Suggestion {
-    /** Stable across generations: the source's address, or the title for a row with none. */
+    /** Stable across generations: what it opens, or its words. */
     id: string;
     icon: Icon;
-    /** What happened, a few words: "Hanzo app login fixes landed". */
+    /** The action, a few plain words: "Review poster.png in Studio". */
     title: string;
-    /** The source's own https address, copied from an input, or '' for none. */
-    href: string;
     /** What the source says, a sentence or three: the hover card. */
     summary: string;
-    /** The next step, a few words: "Verify the user flow". */
-    action: string;
-    /** What the composer is given when the row is chosen. */
-    prompt: string;
+    act: Act;
 }
 /** One piece of the person's activity, as the model is shown it. */
 export interface Input {
@@ -59,6 +81,10 @@ export interface Input {
     text: string;
     /** Its own https address, or ''. */
     href: string;
+    /** Where opening it goes (`Act` open's `to`), or '' when nothing opens it. */
+    to: string;
+    /** A Library item's id, for an item the Library opens at. */
+    item?: string;
     /** RFC 3339, or ''. */
     updated: string;
 }
@@ -142,6 +168,8 @@ export declare function due(kept: Kept | null, fingerprint: string, now: number)
 export declare function stale(kept: Kept | null, now: number): boolean;
 /** The icon a row about `i` carries: GitHub's mark only for GitHub's own address. */
 export declare function iconOf(i: Input): Icon;
+/** What a row does, as the model names it. */
+export declare const ACTIONS: readonly ['open', 'send', 'task', 'schedule'];
 /** The answer's shape, decoded strictly by the model. */
 export declare const SCHEMA: {
     readonly type: 'object';
@@ -154,7 +182,7 @@ export declare const SCHEMA: {
             readonly items: {
                 readonly type: 'object';
                 readonly additionalProperties: false;
-                readonly required: readonly ['icon', 'title', 'href', 'summary', 'action', 'prompt'];
+                readonly required: readonly ['icon', 'title', 'summary', 'action', 'source', 'prompt', 'every'];
                 readonly properties: {
                     readonly icon: {
                         readonly type: 'string';
@@ -163,18 +191,22 @@ export declare const SCHEMA: {
                     readonly title: {
                         readonly type: 'string';
                     };
-                    readonly href: {
-                        readonly type: 'string';
-                    };
                     readonly summary: {
                         readonly type: 'string';
                     };
                     readonly action: {
                         readonly type: 'string';
+                        readonly enum: readonly ["open", "send", "task", "schedule"];
+                    };
+                    readonly source: {
+                        readonly type: 'string';
                     };
                     readonly prompt: {
                         readonly type: 'string';
                     };
+                    readonly every: {
+                        readonly type: 'string';
+                    };
                 };
             };
         };
@@ -182,21 +214,24 @@ export declare const SCHEMA: {
 };
 /** The chat completion that asks for rows, or null when there is nothing to make them from. */
 export declare function request(inputs: Input[], seed: Seed, skip: string[], now: Date): Record<string, unknown> | null;
+/** `every` as a schedule, or null for words that are not one. */
+export declare function every(v: string): Schedule | null;
 /** The text of a chat completion's first choice, or ''. */
 export declare function content(raw: unknown): string;
-/** A row's id: its address, or for a row without one, its title. */
-export declare const idOf: (href: string, title: string) => string;
+/** A row's id: what it opens, or its words. */
+export declare const idOf: (to: string, title: string) => string;
 /**
- * The rows of a chat completion, validated: each with every field, an address
- * that is one of the inputs' own (or none), its icon from that input, one row
- * per source, at most `MOST`. Anything else is dropped, never repaired.
+ * The rows of a chat completion, validated: each with words and an action that
+ * binds (an open names an input's key; a send, a task or a schedule carries its
+ * prompt, and a schedule a time it reads), one row per thing, at most `MOST`.
+ * Anything else is dropped, never repaired.
  */
 export declare function answer(raw: unknown, inputs: Input[]): Suggestion[];
 /** The `suggest` key of the preference document, or undefined when it holds none. */
 export declare function kept(raw: unknown): Kept | undefined;
 /** The rows to draw: those not dismissed. */
 export declare const shown: (k: Kept | null | undefined) => Suggestion[];
-/** What Hanzo does, three ways in: what fills the rows a person's activity and signup do not. */
+/** What Hanzo does, three ways in, each done at once: what fills the rows a person's activity and signup do not. */
 export declare const STARTERS: readonly Suggestion[];
 /** The kept rows, filled to `MOST` with the starters not dismissed: never one lonely row. */
 export declare const fill: (k: Kept | null | undefined) => Suggestion[];

package/lib/suggest.js

@@ -51,7 +51,7 @@ const first = (s) => s.split('\n').find((l) => l.trim()) ?? '';
 /** The person's activity as inputs: their own runs only, each kind's newest `TAKE`. */
 export function inputs(a) {
     const all = [
-        ...a.conversations.map((c) => ({ kind: 'conversation', key: c.id, title: c.title, state: '', text: '', href: '', updated: c.updated })),
+        ...a.conversations.map((c) => ({ kind: 'conversation', key: c.id, title: c.title, state: '', text: '', href: '', to: `/chat/${encodeURIComponent(c.id)}`, updated: c.updated })),
         ...a.issues.map((i) => ({
             kind: i.pull ? 'pull' : 'issue',
             key: i.key,
@@ -59,6 +59,7 @@ export function inputs(a) {
             state: i.state === 'closed' ? 'closed' : i.status || 'open',
             text: [i.repo || i.forge || i.board, first(i.body)].filter(Boolean).join(': '),
             href: https(i.url),
+            to: https(i.url),
             updated: i.updated,
         })),
         ...a.runs
@@ -70,6 +71,7 @@ export function inputs(a) {
             state: r.status,
             text: [r.repo, r.branch].filter(Boolean).join(' @ '),
             href: https(r.pr),
+            to: r.id,
             updated: r.updatedAt || r.createdAt,
         })),
         ...a.automations
@@ -81,9 +83,11 @@ export function inputs(a) {
             state: x.last?.status || (x.enabled ? 'on' : 'off'),
             text: x.last?.summary || first(x.instructions),
             href: '',
+            to: `-/automations/${x.id}`,
             updated: x.last?.at || x.updated,
         })),
-        ...a.files.map((f) => ({ kind: 'file', key: f.id, title: f.name, state: f.kind, text: f.source, href: '', updated: f.updated || f.created })),
+        // An item opens where it was made when that has an address (a Studio creation), else in the Library at it.
+        ...a.files.map((f) => ({ kind: 'file', key: f.id, title: f.name, state: f.kind, text: f.source, href: '', ...(f.origin.startsWith('/') ? { to: f.origin } : { to: '-/artifacts', item: f.id }), updated: f.updated || f.created })),
     ];
     return pick(all);
 }
@@ -155,6 +159,8 @@ export function iconOf(i) {
             return 'file';
     }
 }
+/** What a row does, as the model names it. */
+export const ACTIONS = ['open', 'send', 'task', 'schedule'];
 /** The answer's shape, decoded strictly by the model. */
 export const SCHEMA = {
     type: 'object',
@@ -167,32 +173,35 @@ export const SCHEMA = {
             items: {
                 type: 'object',
                 additionalProperties: false,
-                required: ['icon', 'title', 'href', 'summary', 'action', 'prompt'],
+                required: ['icon', 'title', 'summary', 'action', 'source', 'prompt', 'every'],
                 properties: {
                     icon: { type: 'string', enum: [...ICONS] },
                     title: { type: 'string' },
-                    href: { type: 'string' },
                     summary: { type: 'string' },
-                    action: { type: 'string' },
+                    action: { type: 'string', enum: [...ACTIONS] },
+                    source: { type: 'string' },
                     prompt: { type: 'string' },
+                    every: { type: 'string' },
                 },
             },
         },
     },
 };
 const SYSTEM = [
-    'You choose up to three next steps for one person, from their own recent activity, to show under the box where they type to Hanzo.',
-    'Each row names something that happened and the step it calls for. Pick what is most worth their attention now: something that landed and needs checking, something open and urgent, something they were in the middle of.',
+    'You choose three things for one person to do next with Hanzo, from their own recent activity, shown under the box where they type. Pressing a row DOES it at once, so every row is an action, never a draft.',
+    'Each row has one action:',
+    '- open: open the thing an activity item names (a conversation to pick up, a run to check, a creation or file to review, an issue to read). source is that item\'s key, copied exactly.',
+    '- send: start a new chat and ask prompt. Use it for a question or a piece of work a chat answers (a summary, a draft, research).',
+    '- task: start a Dev coding run on prompt, in the person\'s current project. Use it for a change to code.',
+    '- schedule: make a scheduled task that runs prompt every `every`. every is one of: hourly · daily HH:MM · weekdays HH:MM · weekly mon|tue|wed|thu|fri|sat|sun HH:MM (24-hour).',
     'Fields:',
-    '- title: what happened, at most 6 words, naming the thing ("Hanzo app login fixes landed", "Kai P0 mapping bug is open").',
-    '- action: the next step, imperative, at most 6 words ("Verify the user flow").',
-    '- summary: one to three plain sentences of what the source says. Only facts from the input; never invent numbers, names or dates.',
-    '- prompt: the message the person would send Hanzo to do the step, first person, complete on its own, naming the source and its address when it has one.',
-    '- href: copied exactly from the input the row is about, or "" when that input has none. Never write an address that is not in the input.',
-    '- icon: github for a github.com address, agent for a run or an automation, chat for a conversation, file for a file, task for any other issue or task.',
-    'Answer three rows. Take them from the activity first; fill the rest from what the person told us at signup (their role, their work): first things to ask Hanzo, with href "".',
-    'Never repeat an item listed under skip. Never suggest the same item twice.',
-    'With neither activity nor anything from signup worth a row, answer fewer; never pad with a weak one.',
+    '- title: the action itself, plain words, at most 7, naming the thing: "Review poster.png in Studio", "Continue the physics chat", "Pick up the Oct 10 hello thread". Never a label and an action glued together.',
+    '- summary: one or two plain sentences of what the source says, for the hover card. Only facts from the input; never invent numbers, names or dates.',
+    '- source: for open, the key of the activity item; else "".',
+    '- prompt: for send, task and schedule, the complete message, first person, naming its source; for open, "".',
+    '- every: for schedule; else "".',
+    '- icon: github for a github.com issue or pull request, agent for a run, a task or a schedule, chat for a conversation or a send, file for a file or creation, task for any other issue.',
+    'Answer three rows: the activity first, then from what the person told us at signup (their role, their work). A row you cannot bind to one of the actions is no row. Never repeat an item under skip, and never the same item twice.',
 ].join('\n');
 /** The chat completion that asks for rows, or null when there is nothing to make them from. */
 export function request(inputs, seed, skip, now) {
@@ -200,11 +209,11 @@ export function request(inputs, seed, skip, now) {
     if (!inputs.length && !Object.keys(person).length)
         return null;
     const activity = inputs.map((i) => ({
+        key: i.key,
         kind: i.kind,
         title: line(i.title, 140),
         ...(i.state ? { state: i.state } : {}),
         ...(i.text ? { text: line(i.text, 240) } : {}),
-        href: i.href,
         ...(i.updated ? { updated: i.updated.slice(0, 10) } : {}),
     }));
     return {
@@ -218,6 +227,19 @@ export function request(inputs, seed, skip, now) {
         temperature: 0.3,
     };
 }
+const DAYS = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+const HHMM = /^([01]\d|2[0-3]):[0-5]\d$/;
+/** `every` as a schedule, or null for words that are not one. */
+export function every(v) {
+    const [kind, a, b] = v.trim().toLowerCase().split(/\s+/);
+    if (kind === 'hourly' && !a)
+        return { kind: 'hourly', at: '00:00' };
+    if ((kind === 'daily' || kind === 'weekdays') && a && HHMM.test(a) && !b)
+        return { kind, at: a };
+    if (kind === 'weekly' && a && DAYS.includes(a) && b && HHMM.test(b))
+        return { kind: 'weekly', day: a, at: b };
+    return null;
+}
 /** The first JSON object in a model's text: all of it, or from its first `{` to its last `}`. */
 function json(text) {
     try {
@@ -242,57 +264,89 @@ export function content(raw) {
     const first = obj(Array.isArray(choices) ? choices[0] : null);
     return str(obj(first.message).content);
 }
-/** A row's id: its address, or for a row without one, its title. */
-export const idOf = (href, title) => hash(href || title.toLowerCase());
+/** A row's id: what it opens, or its words. */
+export const idOf = (to, title) => hash(to || title.toLowerCase());
+/** A model's row bound to what pressing it does, or null for one that binds to nothing. */
+function bind(o, inputs) {
+    const prompt = str(o.prompt).trim().slice(0, 2000);
+    switch (str(o.action)) {
+        case 'open': {
+            const i = inputs.find((x) => x.key === str(o.source).trim());
+            if (!i?.to)
+                return null;
+            return i.item ? { kind: 'open', to: i.to, item: i.item } : { kind: 'open', to: i.to };
+        }
+        case 'send':
+        case 'task':
+            return prompt ? { kind: str(o.action), prompt } : null;
+        case 'schedule': {
+            const when = every(str(o.every));
+            return prompt && when ? { kind: 'schedule', name: line(o.title, 80), prompt, schedule: when } : null;
+        }
+    }
+    return null;
+}
+/** What a row is about, for its mark: the input it opens, if it opens one. */
+const about = (act, inputs) => (act.kind === 'open' ? inputs.find((i) => i.to === act.to && i.item === act.item) : undefined);
 /**
- * The rows of a chat completion, validated: each with every field, an address
- * that is one of the inputs' own (or none), its icon from that input, one row
- * per source, at most `MOST`. Anything else is dropped, never repaired.
+ * The rows of a chat completion, validated: each with words and an action that
+ * binds (an open names an input's key; a send, a task or a schedule carries its
+ * prompt, and a schedule a time it reads), one row per thing, at most `MOST`.
+ * Anything else is dropped, never repaired.
  */
 export function answer(raw, inputs) {
-    const by = new Map(inputs.filter((i) => i.href).map((i) => [i.href, i]));
     const rows = obj(json(content(raw))).rows;
     const out = [];
     for (const r of Array.isArray(rows) ? rows : []) {
         const o = obj(r);
-        const title = line(o.title, 80);
-        const action = line(o.action, 80).replace(/\.$/, '');
-        const prompt = str(o.prompt).trim().slice(0, 2000);
-        if (!title || !action || !prompt)
-            continue;
-        const said = str(o.href).trim();
-        const source = said ? by.get(said) : undefined;
-        if (said && !source)
+        const title = line(o.title, 80).replace(/\.$/, '');
+        const act = bind(o, inputs);
+        if (!title || !act)
             continue;
-        // GitHub's mark only beside GitHub's own address: a row without one is a task at most.
+        const source = about(act, inputs);
+        // GitHub's mark only beside GitHub's own address: anything else is a task at most.
         const named = ICONS.includes(o.icon) ? o.icon : 'chat';
         const icon = source ? iconOf(source) : named === 'github' ? 'task' : named;
-        const id = idOf(said, title);
+        const id = idOf(act.kind === 'open' ? `${act.to}${act.item ?? ''}` : '', title);
         if (out.some((x) => x.id === id))
             continue;
-        out.push({ id, icon, title: title.replace(/\.$/, ''), href: said, summary: line(o.summary, 600), action, prompt });
+        out.push({ id, icon, title, summary: line(o.summary, 600), act });
         if (out.length === MOST)
             break;
     }
     return out;
 }
-/** One kept row, or null for one that does not read as a row. */
+/** A kept action, or null for one that does not read as one. */
+function actOf(raw) {
+    const o = obj(raw);
+    const prompt = str(o.prompt);
+    switch (str(o.kind)) {
+        case 'open':
+            return str(o.to) ? { kind: 'open', to: str(o.to), ...(str(o.item) ? { item: str(o.item) } : {}) } : null;
+        case 'send':
+        case 'task':
+            return prompt ? { kind: str(o.kind), prompt } : null;
+        case 'schedule': {
+            const sc = obj(o.schedule);
+            const kind = str(sc.kind);
+            return prompt && kind ? { kind: 'schedule', name: str(o.name), prompt, schedule: { kind, ...(str(sc.at) ? { at: str(sc.at) } : {}), ...(str(sc.day) ? { day: str(sc.day) } : {}) } } : null;
+        }
+    }
+    return null;
+}
+/** One kept row, or null for one that does not read as a row (a row from before rows were actions, among them). */
 function row(raw) {
     const o = obj(raw);
     const title = str(o.title);
-    const action = str(o.action);
-    const prompt = str(o.prompt);
-    const href = str(o.href);
-    if (!title || !action || !prompt || (href && https(href) !== href))
+    const act = actOf(o.act);
+    if (!title || !act)
         return null;
     return {
-        id: str(o.id) || idOf(href, title),
+        id: str(o.id) || idOf(act.kind === 'open' ? act.to : '', title),
         icon: ICONS.includes(o.icon) ? o.icon : 'chat',
         title,
-        href,
         summary: str(o.summary),
-        action,
-        prompt,
+        act,
     };
 }
 /** The `suggest` key of the preference document, or undefined when it holds none. */
@@ -309,11 +363,11 @@ export function kept(raw) {
 }
 /** The rows to draw: those not dismissed. */
 export const shown = (k) => (k ? k.rows.filter((r) => !k.dismissed.includes(r.id)).slice(0, MOST) : []);
-/** What Hanzo does, three ways in: what fills the rows a person's activity and signup do not. */
+/** What Hanzo does, three ways in, each done at once: what fills the rows a person's activity and signup do not. */
 export const STARTERS = [
-    { id: 'start:chat', icon: 'chat', title: 'Think something through', href: '', summary: '', action: 'Ask Hanzo', prompt: 'Help me think through ' },
-    { id: 'start:dev', icon: 'agent', title: 'Build an app or a site', href: '', summary: '', action: 'Describe it', prompt: 'Build me ' },
-    { id: 'start:research', icon: 'file', title: 'Research a topic', href: '', summary: '', action: 'Get a cited brief', prompt: 'Research this and give me a short brief with sources: ' },
+    { id: 'start:chat', icon: 'chat', title: 'Ask what Hanzo can do for you', summary: '', act: { kind: 'send', prompt: 'What can you do for me? Give me three concrete things to try today.' } },
+    { id: 'start:dev', icon: 'agent', title: 'Build a landing page with Dev', summary: '', act: { kind: 'task', prompt: 'Build a one-page landing site for my project and give me the preview link.' } },
+    { id: 'start:research', icon: 'file', title: 'Get a cited brief on AI agents', summary: '', act: { kind: 'send', prompt: 'Research the state of AI coding agents this month and give me a short brief with sources.' } },
 ];
 /** The kept rows, filled to `MOST` with the starters not dismissed: never one lonely row. */
 export const fill = (k) => {
@@ -333,10 +387,10 @@ export function skip(k, inputs) {
     const gone = new Set(k.dismissed);
     const out = new Set();
     for (const i of inputs)
-        if (i.href && gone.has(idOf(i.href, '')))
-            out.add(i.href);
+        if (i.to && gone.has(idOf(`${i.to}${i.item ?? ''}`, '')))
+            out.add(i.key);
     for (const r of k.rows)
         if (gone.has(r.id))
-            out.add(r.href || r.title);
+            out.add(r.title);
     return [...out];
 }

package/lib/suggestions.d.ts

@@ -1,5 +1,6 @@
+import { type Automation, type Source } from './api/auto.ts';
 import { type Target } from './api/call.ts';
-import { type Suggestion } from './suggest.ts';
+import { type Act, type Suggestion } from './suggest.ts';
 export interface Suggested {
     /** The rows to draw: three when any are, none dismissed. */
     rows: Suggestion[];
@@ -10,11 +11,24 @@ export interface Suggested {
 }
 /** The person's suggestions. Signed out, or with nothing worth saying, there are none. */
 export declare function useSuggestions(t: Target): Suggested;
+/**
+ * Leave `prompt` for the product `kind` names, which does it on arrival, once:
+ * Chat sends a `send` as a new chat, Dev starts a `task` as a run. Same-tab
+ * session storage, written by the person's own press, so an address can never
+ * carry one (a link is not consent to spend).
+ */
+export declare function hand(kind: 'send' | 'task', prompt: string): void;
+/** The prompt left for `kind`, taken so it is done once, or ''. */
+export declare function taken(kind: 'send' | 'task'): string;
+/** Make a `schedule` row's task: on, asking before it acts, and notifying its person. */
+export declare function book(t: Target, act: Extract<Act, {
+    kind: 'schedule';
+}>, source: Source): Promise<Automation>;
 export interface SuggestionsProps {
     rows: readonly Suggestion[];
-    /** A row was chosen: its prompt, for the composer. */
-    onPick: (prompt: string) => void;
+    /** A row was pressed: do what it says. */
+    onAct: (act: Act, row: Suggestion) => void;
     onDismiss: (id: string) => void;
 }
 /** The rows, or nothing when there are none. */
-export declare function Suggestions({ rows, onPick, onDismiss }: SuggestionsProps): import("react").JSX.Element | null;
+export declare function Suggestions({ rows, onAct, onDismiss }: SuggestionsProps): import("react").JSX.Element | null;

package/lib/suggestions.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * The suggestions under the composer (above it on a phone): up to three rows,
- * each the source's mark, what happened linked to where it happened (its
- * summary on hover or focus), then the next step. Choosing a row puts its
- * prompt in the composer; its × dismisses it, and the account remembers.
+ * each the source's mark and one short action, its summary on hover. Pressing
+ * a row DOES it (suggest.ts `Act`): it opens what it names, sends its prompt as
+ * a new chat, starts its run, or makes its scheduled task. Nothing only fills
+ * the composer. Its × dismisses it, and the account remembers.
  *
  * `useSuggestions` reads the kept rows from the account (`suggest` in /v1/pref)
  * and, when they are due (suggest.ts `due`), reads the person's activity and
@@ -19,12 +20,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  *   POST /v1/iam/preferences {}           what signup kept (`onboarding`)
  *   POST /v1/chat/completions             the rows, as `MODEL` writes them
  *   PATCH /v1/pref {suggest}              the rows kept, and each dismissal
+ *   POST /v1/auto/automations             a `schedule` row's task
  */
 import { SizableText, useMedia, XStack, YStack } from '@hanzo/gui';
-import { ArrowUpRight, Bot, CalendarClock, FileText, Github, MessageSquare, X } from '@hanzogui/lucide-icons-2';
+import { Bot, CalendarClock, FileText, Github, MessageSquare, X } from '@hanzogui/lucide-icons-2';
 import { HoverCard, HoverCardContent, HoverCardTrigger } from '@hanzo/ui';
 import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from 'react';
-import { automations } from './api/auto.js';
+import { automations, create } from './api/auto.js';
 import { call, Refusal, unwrap } from './api/call.js';
 import { conversations } from './api/conversations.js';
 import { items } from './api/library.js';
@@ -32,7 +34,6 @@ import { read, save } from './api/pref.js';
 import { list } from './api/sessions.js';
 import { everything } from './api/work.js';
 import { claims } from './claims.js';
-import { Out } from './out.js';
 import { answer, dismissed, due, fill, inputs, request, seed, sig, skip, stale, TAKE } from './suggest.js';
 /** A source that refuses this person (a 4xx other than an expired sign-in or a rate) has nothing for them; any other failure leaves it unknown. */
 function soft(p, none) {
@@ -132,6 +133,49 @@ export function useSuggestions(t) {
     }, [t]);
     return useMemo(() => ({ rows, dismiss, error }), [rows, dismiss, error]);
 }
+/** Where a row leaves its act for the product that does it. */
+const HAND = 'hanzo.suggest.hand';
+/**
+ * Leave `prompt` for the product `kind` names, which does it on arrival, once:
+ * Chat sends a `send` as a new chat, Dev starts a `task` as a run. Same-tab
+ * session storage, written by the person's own press, so an address can never
+ * carry one (a link is not consent to spend).
+ */
+export function hand(kind, prompt) {
+    try {
+        window.sessionStorage.setItem(HAND, JSON.stringify({ kind, prompt }));
+    }
+    catch {
+        // Without storage the product opens without it.
+    }
+}
+/** The prompt left for `kind`, taken so it is done once, or ''. */
+export function taken(kind) {
+    try {
+        const v = JSON.parse(window.sessionStorage.getItem(HAND) ?? 'null');
+        if (v?.kind !== kind || typeof v.prompt !== 'string')
+            return '';
+        window.sessionStorage.removeItem(HAND);
+        return v.prompt.trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** Make a `schedule` row's task: on, asking before it acts, and notifying its person. */
+export function book(t, act, source) {
+    return create(t, {
+        name: act.name || act.prompt.slice(0, 80),
+        instructions: act.prompt,
+        model: null,
+        schedule: { ...act.schedule, tz: Intl.DateTimeFormat().resolvedOptions().timeZone },
+        permissions: 'ask',
+        notify: true,
+        postTo: [],
+        enabled: true,
+        source,
+    });
+}
 const MARKS = {
     github: Github,
     agent: Bot,
@@ -142,30 +186,17 @@ const MARKS = {
 /** The row's pitch, px: a finger's on a phone, and the same at a desk. */
 const PITCH = 44;
 /** The rows, or nothing when there are none. */
-export function Suggestions({ rows, onPick, onDismiss }) {
+export function Suggestions({ rows, onAct, onDismiss }) {
     // A phone has no hover: its × stays in sight.
     const touch = !useMedia().sm;
     if (!rows.length)
         return null;
-    return (_jsx(YStack, { role: "list", "aria-label": "Suggestions", "data-slot": "suggestions", children: rows.map((r) => (_jsx(Row, { row: r, touch: touch, onPick: onPick, onDismiss: onDismiss }, r.id))) }));
+    return (_jsx(YStack, { role: "list", "aria-label": "Suggestions", "data-slot": "suggestions", children: rows.map((r) => (_jsx(Row, { row: r, touch: touch, onAct: onAct, onDismiss: onDismiss }, r.id))) }));
 }
-/**
- * One row. The whole row is one button, laid under the row's content (which is
- * positioned after it, so it paints above, and lets presses through), and over
- * it the title's link and the × are their own: three stops for the keyboard,
- * none inside another.
- */
-function Row({ row, touch, onPick, onDismiss }) {
+/** One row: the whole of it one button that does the act, and its × beside it. Two stops for the keyboard, neither inside the other. */
+function Row({ row, touch, onAct, onDismiss }) {
     const [near, setNear] = useState(false);
     const Mark = MARKS[row.icon];
-    return (_jsxs(XStack, { role: "listitem", "data-slot": "suggestion", position: "relative", items: "center", gap: "$3", minH: PITCH, px: "$3", rounded: "$4", hoverStyle: { bg: '$hover' }, onPointerEnter: () => setNear(true), onPointerLeave: () => setNear(false), children: [_jsx(YStack, { render: "button", "aria-label": `${row.title}. ${row.action}`, onPress: () => onPick(row.prompt), position: "absolute", t: 0, r: 0, b: 0, l: 0, rounded: "$4", cursor: "pointer", focusVisibleStyle: { outlineWidth: 2, outlineStyle: 'solid', outlineColor: '$outlineColor' } }), _jsxs(XStack, { position: "relative", flex: 1, minW: 0, items: "center", gap: "$3", pointerEvents: "none", children: [_jsx(Mark, { size: 18, color: "$soft" }), _jsxs(XStack, { flex: 1, minW: 0, items: "center", children: [_jsx(Title, { row: row }), _jsx(SizableText, { fontSize: 15, color: "$soft", numberOfLines: 1, shrink: 1, minW: 0, children: `. ${row.action}` })] })] }), _jsx(XStack, { render: "button", "aria-label": `Dismiss ${row.title}`, position: "relative", onPress: () => onDismiss(row.id), p: "$1.5", rounded: "$2", cursor: "pointer", opacity: touch || near ? 1 : 0, hoverStyle: { bg: '$hover' }, focusVisibleStyle: { opacity: 1, outlineWidth: 2, outlineStyle: 'solid', outlineColor: '$outlineColor' }, children: _jsx(X, { size: 16, color: "$soft" }) })] }));
-}
-/** What happened, linked to its source with a ↗ when it has one, its summary in a card above it. It keeps its words before the step does, up to 70% of the line. */
-function Title({ row }) {
-    const words = (_jsx(SizableText, { fontSize: 15, color: "$soft", numberOfLines: 1, textDecorationLine: row.href ? 'underline' : 'none', textDecorationStyle: "dotted", children: row.title }));
-    const text = row.href ? (_jsxs(Out, { href: row.href, label: `${row.title}, opens the source`, children: [words, _jsx(ArrowUpRight, { size: 12, color: "$soft" })] })) : (words);
-    if (!row.summary) {
-        return (_jsx(XStack, { shrink: 0, maxW: "70%", minW: 0, pointerEvents: "auto", children: text }));
-    }
-    return (_jsxs(HoverCard, { openDelay: 300, closeDelay: 150, children: [_jsx(HoverCardTrigger, { shrink: 0, maxW: "70%", minW: 0, pointerEvents: "auto", children: text }), _jsx(HoverCardContent, { side: "top", align: "start", sideOffset: 8, width: 470, maxW: "calc(100vw - 32px)", rounded: "$6", p: "$4", children: _jsx(SizableText, { fontSize: 16, lineHeight: 26, color: "$ink", children: row.summary }) })] }));
+    const button = (_jsxs(XStack, { render: "button", "data-act": row.act.kind, "aria-label": row.title, onPress: () => onAct(row.act, row), flex: 1, minW: 0, self: "stretch", items: "center", gap: "$3", pl: "$3", rounded: "$4", cursor: "pointer", focusVisibleStyle: { outlineWidth: 2, outlineStyle: 'solid', outlineColor: '$outlineColor' }, children: [_jsx(Mark, { size: 18, color: "$soft" }), _jsx(SizableText, { fontSize: 15, color: "$soft", numberOfLines: 1, shrink: 1, minW: 0, children: row.title })] }));
+    return (_jsxs(XStack, { role: "listitem", "data-slot": "suggestion", items: "center", gap: "$1", minH: PITCH, pr: "$2", rounded: "$4", hoverStyle: { bg: '$hover' }, onPointerEnter: () => setNear(true), onPointerLeave: () => setNear(false), children: [row.summary ? (_jsxs(HoverCard, { openDelay: 300, closeDelay: 150, children: [_jsx(HoverCardTrigger, { flex: 1, minW: 0, self: "stretch", flexDirection: "row", children: button }), _jsx(HoverCardContent, { side: "top", align: "start", sideOffset: 8, width: 470, maxW: "calc(100vw - 32px)", rounded: "$6", p: "$4", children: _jsx(SizableText, { fontSize: 16, lineHeight: 26, color: "$ink", children: row.summary }) })] })) : (button), _jsx(XStack, { render: "button", "aria-label": `Dismiss ${row.title}`, onPress: () => onDismiss(row.id), p: "$1.5", rounded: "$2", cursor: "pointer", opacity: touch || near ? 1 : 0, hoverStyle: { bg: '$hover' }, focusVisibleStyle: { opacity: 1, outlineWidth: 2, outlineStyle: 'solid', outlineColor: '$outlineColor' }, children: _jsx(X, { size: 16, color: "$soft" }) })] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzo/build",
-  "version": "0.2.78",
+  "version": "0.2.80",
   "type": "module",
   "license": "Apache-2.0 OR MIT",
   "description": "Hanzo Build — say what you want, watch it built, deployed and running. The builder as a component, mounted by the Hanzo app at hanzo.ai.",