@hanzo/build 0.2.77 → 0.2.79

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.d.ts

@@ -94,11 +94,12 @@ export interface PromptOptions {
     narrow?: boolean;
 }
 /** The row under the frame: where (Dev), then the model, the effort and the mode. */
-export declare function Tune({ mind, mode, where, onUpgrade }: {
+export declare function Tune({ mind, mode, where, onUpgrade, limits }: {
     mind?: Mind | null;
     mode?: PromptOptions['mode'];
     where?: ReactNode;
     onUpgrade?: (model: string) => void;
+    limits?: PauseSource | null;
 }): import("react").JSX.Element;
 /** The `/` or `@` the caret ends on, and the words typed after it. */
 export declare function trigger(value: string): {

package/lib/prompt.js

@@ -23,7 +23,7 @@ import { ArrowUp, AudioLines, Check, Square, X } from '@hanzogui/lucide-icons-2'
 import { Control } from '@hanzo/composer';
 import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSearch, DropdownMenuTrigger, Popover, PopoverContent, PopoverTrigger } from '@hanzo/ui';
 import { Composer } from '@hanzo/ui/chat';
-import { groupModels, matchesModel } from '@hanzo/ui/models';
+import { groupModels, isPaused, matchesModel } from '@hanzo/ui/models';
 import { speech, Voice } from '@hanzo/voice';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { ENSO } from './api/models.js';
@@ -81,7 +81,7 @@ function Opens({ label, word, dim, children }) {
     return (_jsxs(Popover, { open: open, onOpenChange: setOpen, allowFlip: true, placement: "top-end", children: [_jsx(PopoverTrigger, { asChild: true, children: _jsx(XStack, { children: _jsx(Word, { label: label, dim: dim, open: open, children: word }) }) }), _jsx(PopoverContent, { solid: true, p: 6, width: 288, maxW: "calc(100vw - 24px)", children: children(() => setOpen(false)) })] }));
 }
 /** The model's name, and the catalog behind it: Free's lane to pick from, the rest an upgrade. */
-function Model({ mind, onUpgrade }) {
+function Model({ mind, onUpgrade, limits }) {
     const [open, setOpen] = useState(false);
     const [q, setQ] = useState('');
     // The catalog is hundreds long, and drawing all of it is what made the menu slow
@@ -103,14 +103,16 @@ function Model({ mind, onUpgrade }) {
     const routed = mind.model === ENSO;
     return (_jsxs(DropdownMenu, { open: open, onOpenChange: setOpen, placement: "top-end", children: [_jsx(DropdownMenuTrigger, { asChild: true, children: _jsx(XStack, { "data-slot": "mind", children: _jsx(Word, { label: `Model: ${nameOf(mind.model, mind.models)}`, open: open, children: nameOf(mind.model, mind.models) }) }) }), _jsxs(DropdownMenuContent, { align: "end", minW: 280, "data-slot": "model-menu", children: [_jsx(DropdownMenuSearch, { value: q, onValueChange: setQ, placeholder: "Search models" }), _jsxs(YStack, { maxH: "min(420px, 60vh)", overflowY: "auto", overflowX: "hidden", "data-slot": "model-rows", children: [!mind.free && !q.trim() ? (_jsx(DropdownMenuItem, { onSelect: () => mind.pick(ENSO), children: _jsxs(XStack, { flex: 1, items: "center", gap: 8, children: [_jsxs(YStack, { flex: 1, children: [_jsx(SizableText, { fontSize: 14, color: "$ink", children: "Enso" }), _jsx(SizableText, { fontSize: 12, color: "$hint", children: "Picks the model for each message and step" })] }), routed ? _jsx(Check, { size: 14, color: "var(--primary)", "aria-hidden": true }) : null] }) })) : null, groups.map((g) => (_jsxs(YStack, { role: "group", "aria-label": g.label, children: [_jsx(SizableText, { fontSize: 12, color: "$hint", px: 8, pt: 8, pb: 2, children: g.label }), g.models.map((m) => {
                                         const ok = grants(mind.free, m.id, mind.models);
-                                        return (_jsx(DropdownMenuItem, { "data-slot": "model-row", onSelect: () => (ok ? mind.pick(m.id) : onUpgrade?.(m.id)), children: _jsxs(XStack, { flex: 1, items: "center", gap: 8, children: [_jsx(SizableText, { fontSize: 14, color: ok ? '$ink' : '$hint', numberOfLines: 1, flex: 1, children: nameOf(m.id, mind.models) }), ok ? null : (_jsx(SizableText, { fontSize: 12, color: "$hint", px: 6, py: 1, rounded: 6, borderWidth: 1, borderColor: "$borderColor", children: "Upgrade" })), m.id === mind.model ? _jsx(Check, { size: 14, color: "var(--primary)", "aria-hidden": true }) : null] }) }, m.id));
+                                        // Paused by the plan's usage: still listed and still picked; the gateway answers from Enso.
+                                        const paused = isPaused(m, limits);
+                                        return (_jsx(DropdownMenuItem, { "data-slot": "model-row", "data-model": m.id, "data-paused": paused ? 'true' : undefined, onSelect: () => (ok ? mind.pick(m.id) : onUpgrade?.(m.id)), children: _jsxs(XStack, { flex: 1, items: "center", gap: 8, children: [_jsx(SizableText, { fontSize: 14, color: ok ? '$ink' : '$hint', numberOfLines: 1, flex: 1, children: nameOf(m.id, mind.models) }), ok ? null : (_jsx(SizableText, { fontSize: 12, color: "$hint", px: 6, py: 1, rounded: 6, borderWidth: 1, borderColor: "$borderColor", children: "Upgrade" })), ok && paused ? (_jsx(SizableText, { fontSize: 12, color: "$hint", children: "Paused" })) : null, m.id === mind.model ? _jsx(Check, { size: 14, color: "var(--primary)", "aria-hidden": true }) : null] }) }, m.id));
                                     })] }, g.key))), more > 0 ? (_jsx(SizableText, { fontSize: 12, color: "$hint", px: 8, py: 8, children: `Type to search ${more} more models` })) : null] })] })] }));
 }
 /** The row under the frame: where (Dev), then the model, the effort and the mode. */
-export function Tune({ mind, mode, where, onUpgrade }) {
+export function Tune({ mind, mode, where, onUpgrade, limits }) {
     const thinks = mind ? reasons(mind.model, mind.models) : false;
     const pace = mind ? EFFORTS.find((e) => e.id === mind.effort) : null;
-    return (_jsxs(XStack, { "data-slot": "tune", width: "100%", items: "center", gap: 2, flexWrap: "wrap", rowGap: 4, children: [where ? (_jsx(XStack, { items: "center", gap: 2, flexWrap: "wrap", minW: 0, "$max-sm": { width: '100%' }, children: where })) : null, _jsx(XStack, { flex: 1, "$max-sm": { display: 'none' } }), _jsxs(XStack, { items: "center", gap: 2, ml: "auto", shrink: 0, children: [mind ? _jsx(Model, { mind: mind, onUpgrade: onUpgrade }) : null, mind && thinks && pace ? (_jsx(Opens, { label: `Effort: ${pace.label}`, word: pace.label, dim: true, children: (close) => (_jsx(Choices, { title: "Effort", items: EFFORTS, value: mind.effort, onPick: (e) => {
+    return (_jsxs(XStack, { "data-slot": "tune", width: "100%", items: "center", gap: 2, flexWrap: "wrap", rowGap: 4, children: [where ? (_jsx(XStack, { items: "center", gap: 2, flexWrap: "wrap", minW: 0, "$max-sm": { width: '100%' }, children: where })) : null, _jsx(XStack, { flex: 1, "$max-sm": { display: 'none' } }), _jsxs(XStack, { items: "center", gap: 2, ml: "auto", shrink: 0, children: [mind ? _jsx(Model, { mind: mind, onUpgrade: onUpgrade, limits: limits }) : null, mind && thinks && pace ? (_jsx(Opens, { label: `Effort: ${pace.label}`, word: pace.label, dim: true, children: (close) => (_jsx(Choices, { title: "Effort", items: EFFORTS, value: mind.effort, onPick: (e) => {
                                 mind.pace(e);
                                 close();
                             } })) })) : null, mode ? (_jsxs(Popover, { allowFlip: true, placement: "top-end", children: [_jsx(PopoverTrigger, { asChild: true, children: _jsx(XStack, { render: "button", "data-slot": "mode", "aria-label": `Mode: ${MODES.find((m) => m.id === mode.value)?.label}`, items: "center", height: 24, px: 8, ml: 4, rounded: 6, bg: "$hover", cursor: "pointer", hoverStyle: { bg: '$raised' }, focusVisibleStyle: { outlineColor: '$outlineColor', outlineWidth: 2, outlineStyle: 'solid' }, "$max-sm": { height: 44, px: 12 }, children: _jsx(SizableText, { fontSize: 14, color: "$ink", children: MODES.find((m) => m.id === mode.value)?.label }) }) }), _jsx(PopoverContent, { solid: true, p: 6, width: 288, maxW: "calc(100vw - 24px)", children: _jsx(Choices, { title: "Mode", items: mode.items ? MODES.filter((m) => mode.items.includes(m.id)) : MODES, value: mode.value, onPick: mode.set }) })] })) : null] })] }));
@@ -144,7 +146,7 @@ export function prompt(o, state) {
     };
     const mention = listed && shelf && typed ? (_jsx(Mention, { shelf: shelf, rows: listed, index: index, onPick: choose, tag: typed.char === '/' ? 'Skill' : 'Plugin', name: typed.char === '/' ? 'Skills' : 'Plugins' })) : null;
     const head = o.head || o.note || mention || (narrow && o.below) ? (_jsxs(YStack, { ...measure, gap: "$1.5", "data-slot": "prompt-head", children: [narrow ? o.below : null, o.head, mention, o.note ? (_jsx(SizableText, { "data-slot": "prompt-note", fontSize: 12, color: "$soft", text: "center", self: "center", children: o.note })) : null] })) : undefined;
-    const foot = o.mind || o.mode || o.where || (!narrow && o.below) ? (_jsxs(YStack, { ...measure, gap: 10, "data-slot": "prompt-foot", children: [_jsx(Tune, { mind: o.mind, mode: o.mode, where: o.where, onUpgrade: o.onUpgrade }), narrow ? null : o.below] })) : undefined;
+    const foot = o.mind || o.mode || o.where || (!narrow && o.below) ? (_jsxs(YStack, { ...measure, gap: 10, "data-slot": "prompt-foot", children: [_jsx(Tune, { mind: o.mind, mode: o.mode, where: o.where, onUpgrade: o.onUpgrade, limits: o.limits }), narrow ? null : o.below] })) : undefined;
     const round = (_jsx(Control, { type: "button", size: narrow ? TAP : ROUND, fill: true, rounded: 999, "data-slot": "composer-send", "aria-label": busy ? 'Stop' : 'Send', "aria-disabled": !live || undefined, opacity: live ? 1 : 0.4, onClick: () => {
             if (!live)
                 return;
@@ -166,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.77",
+  "version": "0.2.79",
   "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.",