@hanzo/build 0.2.80 → 0.2.82

package/lib/api/turn.d.ts

@@ -1,26 +1,4 @@
-/**
- * What a run's events SAY, as text a person reads.
- *
- * A curated projection, never a dump: an event carries the machinery a run
- * happened on — hosts, paths, whole file bodies — and printing it would put
- * someone's filesystem in front of anyone who can read the run. Each kind gets a
- * sentence built from the few fields that describe the outcome; the rest is
- * dropped by omission, because a projection cannot leak a field it never reads.
- *
- * Every string here is rendered as TEXT by the transcript. Nothing is HTML.
- *
- * The coding plane's vocabulary (apps/coding): `status` for a lifecycle move
- * (started, routed, done, error, stopped, paused), `tool-call` for a step of the
- * run itself, `event` for one line of the agent's own structured narration (the
- * harness's JSON stream: its messages, reasoning, commands, edits, tool calls and
- * plan), and `log` for raw output, which only the Terminal's log shows. A
- * person's steering is a `control` {command, message}. A run on a project with a
- * site ends `done` with `live` when it published what it pushed, or `unpublished`
- * saying why it did not.
- *
- * `cards` is the transcript as it is drawn: the run's steps and the agent's
- * items, never its log.
- */
+import type { Say } from '@hanzo/i18n/react';
 import type { Event } from './sessions.ts';
 /** The payload as an object. A live frame may carry it as a JSON string. */
 export declare function decode(payload: unknown): Record<string, unknown> | string | null;
@@ -32,17 +10,17 @@ export declare function decode(payload: unknown): Record<string, unknown> | stri
  */
 export declare function vendor(error: string): boolean;
 /** An error as the run page may show it: its own words, or the plain line when they are a vendor's. */
-export declare const scrub: (error: string) => string;
+export declare const scrub: (error: string, t?: Say) => string;
 /**
  * A run's error as one plain line with what to do, never the log it came from:
  * that goes in the Error step beside it (cards), unless it is a vendor's.
  */
-export declare function plain(error: string): string;
+export declare function plain(error: string, t?: Say): string;
 /**
  * One event's sentence, or '' when it says nothing a person needs. `mode` is
  * the run's, from its record: a plan run's final status says the plan.
  */
-export declare function said(e: Pick<Event, 'kind' | 'payload'>, mode?: string): string;
+export declare function said(e: Pick<Event, 'kind' | 'payload'>, mode?: string, t?: Say): string;
 /** One line of the shell: a command the run started, or output that followed it. */
 export interface ShellLine {
     role: 'cmd' | 'out';
@@ -89,7 +67,7 @@ export interface Outcome {
  */
 export declare function outcome(events: Pick<Event, 'kind' | 'payload' | 'seq'>[]): Outcome;
 /** Why the run failed, as its last status says it, or '' when that status is not a failure. */
-export declare function failure(events: Pick<Event, 'kind' | 'payload' | 'seq'>[]): string;
+export declare function failure(events: Pick<Event, 'kind' | 'payload' | 'seq'>[], t?: Say): string;
 /** The turns, ordered and deduped: a recorded read and the live feed overlap. */
 export declare function merge<T extends Pick<Event, 'id' | 'seq'>>(...lists: T[][]): T[];
 /** The actor, short enough to label a block: `hanzo/2d4d67ab`, not the whole subject. */
@@ -176,7 +154,7 @@ export type Card = {
  * is drawn only if the turn then fails. The final status carries the agent's
  * answer, drawn once. `log` is never drawn here.
  */
-export declare function cards(events: Pick<Event, 'kind' | 'payload' | 'seq'>[], mode?: string): Card[];
+export declare function cards(events: Pick<Event, 'kind' | 'payload' | 'seq'>[], mode?: string, t?: Say): Card[];
 /** The plan a plan run answered with, from its final status, or ''. */
 export declare function answer(events: Pick<Event, 'kind' | 'payload' | 'seq'>[]): string;
 export interface Settled {

package/lib/api/turn.js

@@ -1,3 +1,34 @@
+/**
+ * What a run's events SAY, as text a person reads.
+ *
+ * A curated projection, never a dump: an event carries the machinery a run
+ * happened on — hosts, paths, whole file bodies — and printing it would put
+ * someone's filesystem in front of anyone who can read the run. Each kind gets a
+ * sentence built from the few fields that describe the outcome; the rest is
+ * dropped by omission, because a projection cannot leak a field it never reads.
+ *
+ * Every string here is rendered as TEXT by the transcript. Nothing is HTML.
+ *
+ * The coding plane's vocabulary (apps/coding): `status` for a lifecycle move
+ * (started, routed, done, error, stopped, paused), `tool-call` for a step of the
+ * run itself, `event` for one line of the agent's own structured narration (the
+ * harness's JSON stream: its messages, reasoning, commands, edits, tool calls and
+ * plan), and `log` for raw output, which only the Terminal's log shows. A
+ * person's steering is a `control` {command, message}. A run on a project with a
+ * site ends `done` with `live` when it published what it pushed, or `unpublished`
+ * saying why it did not.
+ *
+ * `cards` is the transcript as it is drawn: the run's steps and the agent's
+ * items, never its log.
+ *
+ * The sentences are this client's, said in the language of the `t` a caller
+ * hands (@hanzo/i18n; English without one); what the run and the agent said
+ * is drawn as given. A step's name is a name the transcript keys on (`Error`
+ * opens itself), so it stays English, marked (`phrase`), and the transcript
+ * draws it through `t`.
+ */
+import { phrase } from '@hanzo/i18n';
+import { english } from '../say.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const obj = (v) => (v && typeof v === 'object' ? v : {});
 /** The payload as an object. A live frame may carry it as a JSON string. */
@@ -22,40 +53,65 @@ const base = (path) => {
     const cut = path.replace(/\/+$/, '');
     return cut.slice(cut.lastIndexOf('/') + 1);
 };
-function status(b, mode) {
+/**
+ * A finished run's line, by whether it pushed a branch (Done when it did not),
+ * its pull request (none, one that could not be opened, its address) and its
+ * site (none, not published and why, published): each a whole line, so a
+ * language puts the parts in its own order.
+ */
+const FINISHED = {
+    pushed: {
+        none: { none: phrase('Pushed {branch}'), out: phrase('Pushed {branch} — not published: {why}'), live: phrase('Pushed {branch} — published') },
+        broke: {
+            none: phrase('Pushed {branch} — the pull request could not be opened'),
+            out: phrase('Pushed {branch} — the pull request could not be opened — not published: {why}'),
+            live: phrase('Pushed {branch} — the pull request could not be opened — published'),
+        },
+        pr: { none: phrase('Pushed {branch} — {pr}'), out: phrase('Pushed {branch} — {pr} — not published: {why}'), live: phrase('Pushed {branch} — {pr} — published') },
+    },
+    done: {
+        none: { none: phrase('Done'), out: phrase('Done — not published: {why}'), live: phrase('Done — published') },
+        broke: {
+            none: phrase('Done — the pull request could not be opened'),
+            out: phrase('Done — the pull request could not be opened — not published: {why}'),
+            live: phrase('Done — the pull request could not be opened — published'),
+        },
+        pr: { none: phrase('Done — {pr}'), out: phrase('Done — {pr} — not published: {why}'), live: phrase('Done — {pr} — published') },
+    },
+};
+function status(b, mode, t) {
     const branch = str(b.branch);
     switch (str(b.status)) {
         case 'started':
-            return branch ? `Started on ${branch}` : 'Started';
+            return branch ? t('Started on {branch}', { branch }) : t('Started');
         case 'routed':
-            return 'Sent to a machine';
+            return t('Sent to a machine');
         case 'done': {
             // A plan's answer IS its final status: the run read and wrote nothing.
             // Whether the run planned is the RECORD's word — any member of the org
             // can append an event saying `mode: plan`, and its text is not an answer.
             // A setup is a plan put to one question, and answers the same way.
             if (mode === 'plan')
-                return str(b.plan) || 'Planned — the run answered with no plan';
+                return str(b.plan) || t('Planned — the run answered with no plan');
             if (mode === 'setup')
-                return str(b.plan) || 'Set up — the run answered with no environment';
+                return str(b.plan) || t('Set up — the run answered with no environment');
             if (b.changed === false)
-                return 'Done — nothing to change';
+                return t('Done — nothing to change');
             const pr = str(b.pr);
-            const tail = str(b.prError) ? ' — the pull request could not be opened' : pr ? ` — ${pr}` : '';
             // A run on a project with a site publishes what it pushed, or says why not.
             const why = str(b.unpublished);
-            const site = why ? ` — not published: ${why}` : str(b.live) ? ' — published' : '';
-            return branch ? `Pushed ${branch}${tail}${site}` : `Done${tail}${site}`;
+            const line = FINISHED[branch ? 'pushed' : 'done'][str(b.prError) ? 'broke' : pr ? 'pr' : 'none'][why ? 'out' : str(b.live) ? 'live' : 'none'];
+            return t(line, { branch, pr, why });
         }
         case 'error':
-            return plain(str(b.error));
+            return plain(str(b.error), t);
         case 'stopped':
-            return branch && b.changed ? `Stopped — work kept on ${branch}` : 'Stopped';
+            return branch && b.changed ? t('Stopped — work kept on {branch}', { branch }) : t('Stopped');
         case 'paused':
-            return branch && b.changed ? `Paused — work kept on ${branch}` : 'Paused';
+            return branch && b.changed ? t('Paused — work kept on {branch}', { branch }) : t('Paused');
         case 'followed':
             // A run redirected from a chat thread is carried on by a follow-up (apps/coding steer.go).
-            return str(b.next) ? 'Continued in a follow-up run' : 'The follow-up run could not start';
+            return str(b.next) ? t('Continued in a follow-up run') : t('The follow-up run could not start');
     }
     return str(b.status);
 }
@@ -69,35 +125,35 @@ export function vendor(error) {
     return /open\s?router|anthropic|openai|azure|bedrock|vertex|gemini|mistral|cohere|deepinfra|fireworks|together\.ai|groq|x-ratelimit|upstream|\bprovider\b|\bsk-[A-Za-z0-9_-]{6,}|"(error|code|message)"\s*:/i.test(error);
 }
 /** An error as the run page may show it: its own words, or the plain line when they are a vendor's. */
-export const scrub = (error) => (vendor(error) ? plain(error) : error);
+export const scrub = (error, t = english) => (vendor(error) ? plain(error, t) : error);
 /**
  * A run's error as one plain line with what to do, never the log it came from:
  * that goes in the Error step beside it (cards), unless it is a vendor's.
  */
-export function plain(error) {
+export function plain(error, t = english) {
     if (!error)
-        return 'The run hit an error';
+        return t('The run hit an error');
     const ours = /providers_exhausted|every provider refused|temporarily unavailable/i.test(error);
     if (/free sandboxes .*are used/i.test(error))
-        return 'This plan’s free sandboxes are used for now. Add credit to keep building, or try again later.';
+        return t('This plan’s free sandboxes are used for now. Add credit to keep building, or try again later.');
     if (!ours && /\b402 Payment Required|insufficient (credit|balance)|top up/i.test(error))
-        return 'Your balance is out of credit. Add credit, then try again.';
+        return t('Your balance is out of credit. Add credit, then try again.');
     if (ours || /\b(429 Too Many Requests|503 Service Unavailable)|stream disconnected|retries exhausted|rate limit/i.test(error))
-        return 'The model did not answer. Try again in a moment, or pick another model.';
-    return 'The run stopped with an error. Try again, or follow up with what to change.';
+        return t('The model did not answer. Try again in a moment, or pick another model.');
+    return t('The run stopped with an error. Try again, or follow up with what to change.');
 }
 /**
  * One event's sentence, or '' when it says nothing a person needs. `mode` is
  * the run's, from its record: a plan run's final status says the plan.
  */
-export function said(e, mode = '') {
+export function said(e, mode = '', t = english) {
     const body = decode(e.payload);
     if (typeof body === 'string')
         return body;
     if (!body)
         return '';
     if (e.kind === 'status')
-        return status(body, mode);
+        return status(body, mode, t);
     for (const key of ['message', 'text', 'content', 'result', 'command']) {
         const v = body[key];
         if (typeof v === 'string' && v)
@@ -106,13 +162,13 @@ export function said(e, mode = '') {
     if (str(body.type) === 'done' && Array.isArray(body.changed)) {
         const names = body.changed.map((f) => base(str(f))).filter(Boolean);
         return names.length === 0
-            ? 'Done — no files changed'
+            ? t('Done — no files changed')
             : names.length <= 3
-                ? `Done — changed ${names.join(', ')}`
-                : `Done — changed ${names.length} files`;
+                ? t('Done — changed {files}', { files: names.join(', ') })
+                : t('Done — changed {n} files', { n: names.length });
     }
     if (str(body.type) === 'error')
-        return scrub(str(body.error)) || 'The run hit an error';
+        return scrub(str(body.error), t) || t('The run hit an error');
     return str(body.step) || str(body.name);
 }
 /**
@@ -200,7 +256,7 @@ export function outcome(events) {
     return out;
 }
 /** Why the run failed, as its last status says it, or '' when that status is not a failure. */
-export function failure(events) {
+export function failure(events, t = english) {
     let out = '';
     for (const e of [...events].sort((a, b) => a.seq - b.seq)) {
         if (e.kind !== 'status')
@@ -208,7 +264,7 @@ export function failure(events) {
         const b = decode(e.payload);
         if (!b || typeof b === 'string' || !str(b.status))
             continue;
-        out = str(b.status) === 'error' ? scrub(str(b.error)) || 'The run hit an error' : '';
+        out = str(b.status) === 'error' ? scrub(str(b.error), t) || t('The run hit an error') : '';
     }
     return out;
 }
@@ -242,19 +298,19 @@ export function pull(url, repo) {
         return { href: '', label: '' };
     return { href: url, label: `#${m[3]}` };
 }
-/** What the run's own steps are called on a card. */
+/** What the run's own steps are called on a card: English, marked (`phrase`); the transcript draws them through `t`. */
 const NAMES = {
-    lease: 'Sandbox',
-    workspace: 'Workspace',
-    clone: 'Clone',
-    branch: 'Branch',
-    secrets: 'Secrets',
-    install: 'Install',
-    start: 'Start',
-    skills: 'Skills',
-    artifacts: 'Save artifacts',
-    push: 'Push',
-    kept: 'Keep the sandbox',
+    lease: phrase('Sandbox'),
+    workspace: phrase('Workspace'),
+    clone: phrase('Clone'),
+    branch: phrase('Branch'),
+    secrets: phrase('Secrets'),
+    install: phrase('Install'),
+    start: phrase('Start'),
+    skills: phrase('Skills'),
+    artifacts: phrase('Save artifacts'),
+    push: phrase('Push'),
+    kept: phrase('Keep the sandbox'),
 };
 /** Steps another card already says: `leased` finishes the lease, `done` is the final status, `ended` and `exit` are housekeeping. */
 const QUIET = new Set(['leased', 'done', 'ended', 'exit']);
@@ -290,9 +346,9 @@ function item(it, key) {
             return { kind: 'edit', key, files: changes.map((c) => rel(str(obj(c).path))).filter(Boolean), ran: itemRan(it) };
         }
         case 'mcp_tool_call':
-            return { kind: 'step', key, name: str(it.tool) || 'Tool', detail: str(it.server), output: '', ran: itemRan(it) };
+            return { kind: 'step', key, name: str(it.tool) || phrase('Tool'), detail: str(it.server), output: '', ran: itemRan(it) };
         case 'web_search':
-            return { kind: 'step', key, name: 'Search', detail: str(it.query), output: '', ran: 'done' };
+            return { kind: 'step', key, name: phrase('Search'), detail: str(it.query), output: '', ran: 'done' };
         case 'todo_list': {
             const items = Array.isArray(it.items) ? it.items : [];
             return { kind: 'todo', key, items: items.map((x) => ({ text: str(obj(x).text), done: obj(x).completed === true })).filter((x) => x.text) };
@@ -313,7 +369,7 @@ function item(it, key) {
  * is drawn only if the turn then fails. The final status carries the agent's
  * answer, drawn once. `log` is never drawn here.
  */
-export function cards(events, mode = '') {
+export function cards(events, mode = '', t = english) {
     const out = [];
     let seq = 0;
     let n = 0;
@@ -334,10 +390,10 @@ export function cards(events, mode = '') {
         if (failures.has(message))
             return;
         failures.add(message);
-        out.push({ kind: 'note', key: mint(), text: plain(message) });
+        out.push({ kind: 'note', key: mint(), text: plain(message, t) });
         // The reason, read whole, when it is the run's own; a vendor's words stay off the page.
         if (message && !vendor(message))
-            out.push({ kind: 'step', key: mint(), name: 'Error', detail: '', output: message, ran: 'error' });
+            out.push({ kind: 'step', key: mint(), name: phrase('Error'), detail: '', output: message, ran: 'error' });
     };
     for (const e of [...events].sort((a, b) => a.seq - b.seq)) {
         seq = e.seq;
@@ -421,7 +477,7 @@ export function cards(events, mode = '') {
                     failed(str(b.error));
                     break;
                 }
-                const line = status(b, mode);
+                const line = status(b, mode, t);
                 if (line)
                     out.push({ kind: 'note', key: mint(), text: line });
                 break;
@@ -434,11 +490,11 @@ export function cards(events, mode = '') {
                 if (command === 'message' && said)
                     steered.add(person(said));
                 else if (command === 'pause')
-                    out.push({ kind: 'note', key: mint(), text: 'Pause asked' });
+                    out.push({ kind: 'note', key: mint(), text: t('Pause asked') });
                 else if (command === 'resume')
-                    out.push({ kind: 'note', key: mint(), text: 'Resume asked' });
+                    out.push({ kind: 'note', key: mint(), text: t('Resume asked') });
                 else if (command === 'stop')
-                    out.push({ kind: 'note', key: mint(), text: 'Stop asked' });
+                    out.push({ kind: 'note', key: mint(), text: t('Stop asked') });
                 break;
             }
             case 'message': {

package/lib/api/verdict.d.ts

@@ -1,12 +1,3 @@
-/**
- * A person's verdict on what a run said, recorded on the platform's own event
- * bus in the org it was said in.
- *
- *   POST /v1/event {type: 'track', event: 'build.verdict', sessionId, properties}
- *
- * The receipt says whether it landed; a verdict that did not is reported, not
- * shown as recorded.
- */
 import { type Target } from './call.ts';
 export type Verdict = 'up' | 'down' | null;
 export declare function verdict(t: Target, session: string, project: string, v: Verdict): Promise<void>;

package/lib/api/verdict.js

@@ -7,6 +7,7 @@
  * The receipt says whether it landed; a verdict that did not is reported, not
  * shown as recorded.
  */
+import { phrase } from '@hanzo/i18n';
 import { call } from './call.js';
 export async function verdict(t, session, project, v) {
     const out = await call(t, 'POST', '/v1/event', {
@@ -16,5 +17,5 @@ export async function verdict(t, session, project, v) {
         properties: { verdict: v ?? 'cleared', project },
     });
     if (!out || !out.accepted)
-        throw new Error('The verdict was not recorded');
+        throw new Error(phrase('The verdict was not recorded'));
 }

package/lib/api/webhooks.d.ts

@@ -1,16 +1,3 @@
-/**
- * The organization's webhooks: https endpoints that each matching platform event
- * is POSTed to, signed.
- *
- *   GET    /v1/webhook                    {data: [endpoint]}, newest first, secrets withheld
- *   POST   /v1/webhook                    {url, events, description} → 201, the secret shown this once
- *   DELETE /v1/webhook/{id}               204
- *   POST   /v1/webhook/{id}/test          one signed test event, sent now → {delivered, httpStatus, durationMs, error}
- *   GET    /v1/webhook/{id}/deliveries    {data: [attempt]}, newest first
- *
- * The org is the caller's; an endpoint another org owns reads as not found.
- * Events are subject patterns (`commerce.order.>`); none means every event.
- */
 import { type Target } from './call.ts';
 export interface Endpoint {
     id: string;
@@ -36,7 +23,7 @@ export interface Draft {
     events: string[];
     description: string;
 }
-/** Why a draft cannot be sent, or ''. The platform refuses the same things. */
+/** Why a draft cannot be sent, or ''. The platform refuses the same things. English, marked (`phrase`): a screen says it through `t`. */
 export declare function refuse(d: Draft): string;
 export declare function add(t: Target, d: Draft): Promise<Endpoint>;
 export declare function remove(t: Target, id: string): Promise<void>;

package/lib/api/webhooks.js

@@ -11,6 +11,7 @@
  * The org is the caller's; an endpoint another org owns reads as not found.
  * Events are subject patterns (`commerce.order.>`); none means every event.
  */
+import { phrase } from '@hanzo/i18n';
 import { call, query, seg } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
@@ -38,19 +39,19 @@ export async function endpoints(t) {
 export function patterns(typed) {
     return [...new Set(typed.split(/[\s,]+/).map((s) => s.trim()).filter(Boolean))];
 }
-/** Why a draft cannot be sent, or ''. The platform refuses the same things. */
+/** Why a draft cannot be sent, or ''. The platform refuses the same things. English, marked (`phrase`): a screen says it through `t`. */
 export function refuse(d) {
     let u;
     try {
         u = new URL(d.url.trim());
     }
     catch {
-        return 'Enter the https address to deliver to';
+        return phrase('Enter the https address to deliver to');
     }
     if (u.protocol !== 'https:')
-        return 'A webhook is delivered over https only';
+        return phrase('A webhook is delivered over https only');
     if (d.events.length > 64)
-        return 'At most 64 event patterns';
+        return phrase('At most 64 event patterns');
     return '';
 }
 export async function add(t, d) {

package/lib/ask.js

@@ -5,6 +5,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * the reason is read where the act was asked for.
  */
 import { SizableText, XStack } from '@hanzo/gui';
+import { useI18n } from '@hanzo/i18n/react';
 import { Button, Dialog, DialogContent, DialogTitle, Input } from '@hanzo/ui';
 import { useEffect, useState } from 'react';
 /** One act in flight, and what refused it. */
@@ -32,6 +33,7 @@ function Said({ note }) {
     return (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note }));
 }
 export function Confirm({ open, onOpenChange, title, says, act, run, }) {
+    const { t } = useI18n();
     const { working, note, setNote, go } = useAct(() => onOpenChange(false));
     const close = (o) => {
         if (working)
@@ -39,9 +41,10 @@ export function Confirm({ open, onOpenChange, title, says, act, run, }) {
         setNote('');
         onOpenChange(o);
     };
-    return (_jsx(Dialog, { open: open, onOpenChange: close, children: _jsxs(DialogContent, { maxW: 420, showCloseButton: false, children: [_jsx(DialogTitle, { children: title }), _jsx(SizableText, { size: "$2", color: "$soft", children: says }), _jsx(Said, { note: note }), _jsxs(XStack, { gap: "$2", justify: "flex-end", children: [_jsx(Button, { size: "sm", variant: "ghost", disabled: working, onPress: () => close(false), children: "Cancel" }), _jsx(Button, { size: "sm", variant: "destructive", disabled: working, onPress: () => void go(run), children: act })] })] }) }));
+    return (_jsx(Dialog, { open: open, onOpenChange: close, children: _jsxs(DialogContent, { maxW: 420, showCloseButton: false, children: [_jsx(DialogTitle, { children: title }), _jsx(SizableText, { size: "$2", color: "$soft", children: says }), _jsx(Said, { note: note }), _jsxs(XStack, { gap: "$2", justify: "flex-end", children: [_jsx(Button, { size: "sm", variant: "ghost", disabled: working, onPress: () => close(false), children: t('Cancel') }), _jsx(Button, { size: "sm", variant: "destructive", disabled: working, onPress: () => void go(run), children: act })] })] }) }));
 }
 export function Rename({ open, onOpenChange, title, name, run, }) {
+    const { t } = useI18n();
     const [value, setValue] = useState(name);
     const { working, note, setNote, go } = useAct(() => onOpenChange(false));
     useEffect(() => {
@@ -57,13 +60,13 @@ export function Rename({ open, onOpenChange, title, name, run, }) {
     const save = () => {
         const next = value.trim();
         if (!next)
-            return setNote('It needs a name');
+            return setNote(t('It needs a name'));
         if (next === name)
             return close(false);
         void go(() => run(next));
     };
-    return (_jsx(Dialog, { open: open, onOpenChange: close, children: _jsxs(DialogContent, { maxW: 420, showCloseButton: false, children: [_jsx(DialogTitle, { children: title }), _jsx(Input, { autoFocus: true, value: value, onChangeText: setValue, "aria-label": "Name", onKeyDown: (e) => {
+    return (_jsx(Dialog, { open: open, onOpenChange: close, children: _jsxs(DialogContent, { maxW: 420, showCloseButton: false, children: [_jsx(DialogTitle, { children: title }), _jsx(Input, { autoFocus: true, value: value, onChangeText: setValue, "aria-label": t('Name'), onKeyDown: (e) => {
                         if (e.key === 'Enter')
                             save();
-                    } }), _jsx(Said, { note: note }), _jsxs(XStack, { gap: "$2", justify: "flex-end", children: [_jsx(Button, { size: "sm", variant: "ghost", disabled: working, onPress: () => close(false), children: "Cancel" }), _jsx(Button, { size: "sm", disabled: working, onPress: save, children: "Save" })] })] }) }));
+                    } }), _jsx(Said, { note: note }), _jsxs(XStack, { gap: "$2", justify: "flex-end", children: [_jsx(Button, { size: "sm", variant: "ghost", disabled: working, onPress: () => close(false), children: t('Cancel') }), _jsx(Button, { size: "sm", disabled: working, onPress: save, children: t('Save') })] })] }) }));
 }

package/lib/automations.d.ts

@@ -1,25 +1,26 @@
 import { type SessionStatus } from '@hanzo/ui/chat';
 import { type Draft, type Kind, type Schedule } from './api/auto.ts';
 export declare const zone: () => string;
+/** The lists' words are English, marked (`phrase`), and drawn through `t`. */
 export declare const KINDS: readonly {
     id: Kind;
     label: string;
 }[];
-/** A run's status as the rail's dot draws it. */
+/** A run's status as the rail's dot draws it, and in words (marked, drawn through `t`). */
 export declare const DOT: Record<string, SessionStatus>;
 export declare const WORD: Record<string, string>;
 export declare const live: (s: string) => boolean;
 /** The schedule a kind starts from, keeping whatever of `was` still applies. */
 export declare function shaped(kind: Kind, was: Schedule): Schedule;
-/** What is wrong with a schedule before it is sent, or ''. */
+/** What is wrong with a schedule before it is sent, or '': English, marked (`phrase`), so a screen says it through `t`. */
 export declare function unready(s: Schedule): string;
 /** A schedule as the platform reads it: an hourly minute in two digits. */
 export declare function tidy(d: Draft): Draft;
 /** A local time and date for an RFC 3339 instant. */
 export declare const local: (iso: string) => string;
-/** A run the platform refused for want of a plan: a free org with no credit for the run fee. */
+/** A run the platform refused for want of a plan: a free org with no credit for the run fee. `PLAN` says so, marked, drawn through `t`. */
 export declare const unplanned: (e: unknown) => boolean;
-export declare const PLAN = "Automations run on a paid plan; on Free each run needs $1 of credit, and this organization has none. Upgrade to run it.";
+export declare const PLAN: string;
 /** When a task runs, chosen: how often, the day and time, and the zone it is read in. */
 export declare function When({ s, onChange, disabled }: {
     s: Schedule;