@hanzo/build 0.2.29 → 0.2.31

package/lib/door.js

@@ -1,7 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * One door into a run's sandbox — its screen or its shell — framed from cloud's
- * own page with a fresh ticket in its address.
+ * own page with a fresh ticket in its address, while the sandbox runs. A
+ * suspended sandbox is resumed from the pane's bar, never by looking at it.
  *
  * The page says when its socket is up. A page that says it failed, or silence
  * past the deadline, is a failed connection, and Retry mints a new ticket: a
@@ -17,14 +18,18 @@ import { useTarget } from './host.js';
 const SOURCE = { screen: 'hanzo-screen', terminal: 'hanzo-term' };
 const WHAT = { screen: 'desktop', terminal: 'terminal' };
 const DEADLINE = 20_000;
-export function Door({ which, sandbox, live, session }) {
+/**
+ * `held` is where the run's sandbox is in its life, '' until it has been read. Only
+ * a running sandbox has an open door.
+ */
+export function Door({ which, sandbox, held, session }) {
     const t = useTarget();
     const frame = useRef(null);
     const [src, setSrc] = useState('');
     const [state, setState] = useState('opening');
     const [why, setWhy] = useState('');
     const [attempt, setAttempt] = useState(0);
-    const up = live && Boolean(sandbox);
+    const up = Boolean(sandbox) && held === 'running';
     useEffect(() => {
         if (!up)
             return;
@@ -73,12 +78,18 @@ export function Door({ which, sandbox, live, session }) {
             clearTimeout(late);
         };
     }, [src, which]);
-    if (!live) {
-        return _jsx(Shut, { title: "Not running", body: `This run’s ${WHAT[which]} closed when the run stopped.` });
-    }
-    if (!sandbox) {
+    if (!sandbox || held === '' || held === 'pending') {
         return _jsx(Shut, { title: "Starting", body: `The ${WHAT[which]} opens once the run’s sandbox is up.` });
     }
+    if (held === 'parked') {
+        return _jsx(Shut, { title: "Suspended", body: `This run’s sandbox is suspended with its files kept. Resume it from the bar above to open its ${WHAT[which]}.` });
+    }
+    if (held === 'gone') {
+        return _jsx(Shut, { title: "Ended", body: "This run\u2019s sandbox has ended. Its work is on its branch and in its artifacts." });
+    }
+    if (held === 'error') {
+        return _jsx(Shut, { title: "Unavailable", body: `This run’s sandbox could not start, so it has no ${WHAT[which]}.` });
+    }
     if (state === 'failed') {
         return (_jsx(Shut, { title: "Failed to connect", body: why || `Unable to reach the ${WHAT[which]}. The run may have stopped.`, children: _jsx(Button, { size: "sm", variant: "outline", onPress: () => setAttempt((a) => a + 1), children: "Retry" }) }));
     }

package/lib/files.d.ts

@@ -5,7 +5,10 @@ export declare function Files({ session, repo, branch, sandbox, live, }: {
     sandbox: string;
     live: boolean;
 }): import("react").JSX.Element;
-export declare function Artifacts({ repo, branch, mode, project, site, pr, onEnvironment, }: {
+export declare function Artifacts({ session, sandbox, repo, branch, mode, project, site, pr, onEnvironment, }: {
+    session: string;
+    /** The run's sandbox, which serves its previews while it is kept. */
+    sandbox: string;
     repo: string;
     branch: string;
     mode: string;

package/lib/files.js

@@ -2,22 +2,26 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * A run's Files tab: its working tree, live from the sandbox while the run holds
  * one — every edit the agent has made, committed or not — and its branch on the
- * forge otherwise. And its Artifacts tab: what the run produced — its published
- * site, its pull request, its branch, its environment proposal and its project.
+ * forge otherwise. And its Artifacts tab: what the run left — every file it added
+ * or changed and the whole change as a patch, kept after its sandbox is gone; its
+ * previews, pull request and deployments — then its published site, its branch,
+ * its environment proposal and its project.
  */
 import { SizableText, XStack, YStack } from '@hanzo/gui';
-import { ExternalLink, File, Folder, Globe, GitBranch, GitPullRequest, Layers, Settings2 } from '@hanzogui/lucide-icons-2';
+import { Download, ExternalLink, File, FileDiff, Folder, Globe, GitBranch, GitPullRequest, Layers, MonitorPlay, Rocket, Settings2 } from '@hanzogui/lucide-icons-2';
 import { useState } from 'react';
 import { blob, tree } from './api/changes.js';
-import { read as look } from './api/sandbox.js';
+import { artifact, artifacts } from './api/coding.js';
+import { preview, read as look } from './api/sandbox.js';
 import { useRead } from './data.js';
 import { useHost, useTarget } from './host.js';
-import { Out } from './out.js';
+import { away, Out } from './out.js';
 const monoWrap = { whiteSpace: 'pre-wrap', fontFamily: 'var(--f-mono, ui-monospace, monospace)' };
 export function Files({ session, repo, branch, sandbox, live, }) {
     const reachable = live && Boolean(sandbox);
-    const [source, setSource] = useState(reachable ? 'live' : 'branch');
-    const from = reachable ? source : 'branch';
+    // Live once the sandbox is reachable, unless the branch was picked.
+    const [source, setSource] = useState(null);
+    const from = reachable ? (source ?? 'live') : 'branch';
     return (_jsxs(YStack, { gap: "$3", children: [reachable ? (_jsxs(XStack, { gap: "$1", items: "center", flexWrap: "wrap", children: [_jsx(Pick, { on: from === 'live', onPress: () => setSource('live'), children: "Live" }), _jsx(Pick, { on: from === 'branch', onPress: () => setSource('branch'), children: "Branch" })] })) : null, from === 'live' ? _jsx(Live, { sandbox: sandbox }) : _jsx(Branch, { session: session, label: `${repo}${branch ? `@${branch}` : ''}` })] }));
 }
 /** The sandbox's working tree, as it is right now. */
@@ -84,9 +88,53 @@ function Branch({ session, label }) {
 function Listing({ where, up, error, loading, rows, file, body, }) {
     return (_jsxs(YStack, { gap: "$2", children: [_jsxs(XStack, { gap: "$2", items: "center", children: [up ? (_jsx(XStack, { render: "button", "aria-label": "Up one directory", onPress: up, px: "$1", py: "$1", children: _jsx(SizableText, { size: "$1", color: "$soft", children: "Up" }) })) : null, _jsx(SizableText, { size: "$1", color: "$soft", numberOfLines: 1, children: where })] }), error ? (_jsx(SizableText, { size: "$2", color: "$soft", children: error })) : loading ? (_jsx(SizableText, { size: "$2", color: "$soft", children: "Reading\u2026" })) : rows.length === 0 ? (_jsx(SizableText, { size: "$2", color: "$soft", children: "This directory is empty." })) : (rows.map((r) => (_jsxs(XStack, { render: "button", "aria-label": r.dir === false ? `Read ${r.name}` : `Open ${r.name}`, onPress: r.onPress, items: "center", gap: "$2", py: "$1", hoverStyle: { bg: '$hover' }, children: [r.dir === false ? _jsx(File, { size: 14 }) : r.dir ? _jsx(Folder, { size: 14 }) : _jsx(File, { size: 14, opacity: 0.6 }), _jsx(SizableText, { size: "$2", color: "$ink", numberOfLines: 1, style: { textAlign: 'left' }, children: r.name })] }, r.key)))), file && body ? (_jsxs(YStack, { gap: "$1", pt: "$2", borderTopWidth: 1, borderColor: "$borderColor", children: [_jsx(SizableText, { size: "$1", color: "$soft", children: file }), _jsx(SizableText, { size: "$1", color: "$ink", style: monoWrap, children: body })] })) : null] }));
 }
-export function Artifacts({ repo, branch, mode, project, site, pr, onEnvironment, }) {
+/** A stored artifact's size, as a person reads it. */
+const size = (n) => (n < 1024 ? `${n} B` : n < 1 << 20 ? `${(n / 1024).toFixed(1)} KB` : `${(n / (1 << 20)).toFixed(1)} MB`);
+/** What each kind of artifact is drawn with, and says it is. */
+const KIND = {
+    file: { icon: _jsx(File, { size: 16 }), note: (a) => `Changed file · ${size(a.size)}` },
+    patch: { icon: _jsx(FileDiff, { size: 16 }), note: (a) => `The whole change as a patch · ${size(a.size)}` },
+    preview: { icon: _jsx(MonitorPlay, { size: 16 }), note: (a) => `What the run served on port ${a.port}` },
+    pull: { icon: _jsx(GitPullRequest, { size: 16 }), note: () => 'Pull request' },
+    deploy: { icon: _jsx(Rocket, { size: 16 }), note: () => 'Deployment' },
+};
+export function Artifacts({ session, sandbox, repo, branch, mode, project, site, pr, onEnvironment, }) {
     const host = useHost();
+    const t = useTarget();
+    const left = useRead(host.person ? () => artifacts(t, session) : null, { saved: '', artifacts: [] }, [t, session, host.person]);
+    const [note, setNote] = useState('');
+    // Bytes come with the person's bearer, so a stored artifact is fetched, then saved.
+    const save = async (a) => {
+        try {
+            const url = URL.createObjectURL(await artifact(t, session, a.name));
+            const link = document.createElement('a');
+            link.href = url;
+            link.download = a.name.split('/').pop() || a.name;
+            link.click();
+            setTimeout(() => URL.revokeObjectURL(url), 10_000);
+        }
+        catch (e) {
+            setNote(e.message);
+        }
+    };
+    // A preview is opened with a fresh ticket, in a tab of its own.
+    const open = (a) => away(preview(t, sandbox, a.port)).catch((e) => setNote(e.message));
     const items = [];
+    for (const a of left.value.artifacts) {
+        const stored = a.kind === 'file' || a.kind === 'patch';
+        const link = a.kind === 'pull' || a.kind === 'deploy';
+        if ((a.kind === 'preview' && !sandbox) || (link && !/^https:\/\//.test(a.url)))
+            continue;
+        items.push({
+            key: `${a.kind}:${a.name}`,
+            icon: KIND[a.kind].icon,
+            title: link ? a.url.replace(/^https:\/\//, '') : a.name,
+            note: KIND[a.kind].note(a),
+            href: link ? a.url : undefined,
+            onPress: stored ? () => void save(a) : a.kind === 'preview' ? () => void open(a) : undefined,
+            action: stored ? _jsx(Download, { size: 14 }) : a.kind === 'preview' ? _jsx(ExternalLink, { size: 14 }) : undefined,
+        });
+    }
     if (site)
         items.push({ key: 'site', icon: _jsx(Globe, { size: 16 }), title: site.replace(/^https:\/\//, ''), note: 'Where this run is published', href: site });
     if (pr.href)
@@ -98,11 +146,11 @@ export function Artifacts({ repo, branch, mode, project, site, pr, onEnvironment
     if (project)
         items.push({ key: 'project', icon: _jsx(Layers, { size: 16 }), title: project, note: 'The project this run builds', onPress: () => host.go(project) });
     if (!items.length)
-        return _jsx(Soft, { children: "This run has produced no artifacts yet." });
-    return (_jsx(YStack, { borderWidth: 1, borderColor: "$borderColor", rounded: "$3", overflow: "hidden", children: items.map((a, i) => {
-            const row = (_jsxs(XStack, { items: "center", gap: "$3", px: "$3", py: "$2.5", borderTopWidth: i ? 1 : 0, borderColor: "$borderColor", hoverStyle: a.href || a.onPress ? { bg: '$hover' } : undefined, children: [a.icon, _jsxs(YStack, { flex: 1, minW: 0, style: { textAlign: 'left' }, children: [_jsx(SizableText, { size: "$2", color: "$ink", numberOfLines: 1, children: a.title }), _jsx(SizableText, { size: "$1", color: "$soft", numberOfLines: 1, children: a.note })] }), a.href ? _jsx(ExternalLink, { size: 14 }) : null] }));
-            return a.href ? (_jsx(Out, { href: a.href, label: a.title, children: _jsx(YStack, { width: "100%", children: row }) }, a.key)) : a.onPress ? (_jsx(YStack, { render: "button", "aria-label": a.title, onPress: a.onPress, children: row }, a.key)) : (_jsx(YStack, { children: row }, a.key));
-        }) }));
+        return _jsx(Soft, { children: left.error?.message || (left.loading ? 'Reading what this run left…' : 'This run has produced no artifacts yet.') });
+    return (_jsxs(YStack, { gap: "$2", children: [note ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note })) : null, _jsx(YStack, { borderWidth: 1, borderColor: "$borderColor", rounded: "$3", overflow: "hidden", children: items.map((a, i) => {
+                    const row = (_jsxs(XStack, { items: "center", gap: "$3", px: "$3", py: "$2.5", borderTopWidth: i ? 1 : 0, borderColor: "$borderColor", hoverStyle: a.href || a.onPress ? { bg: '$hover' } : undefined, children: [a.icon, _jsxs(YStack, { flex: 1, minW: 0, style: { textAlign: 'left' }, children: [_jsx(SizableText, { size: "$2", color: "$ink", numberOfLines: 1, children: a.title }), _jsx(SizableText, { size: "$1", color: "$soft", numberOfLines: 1, children: a.note })] }), a.action ?? (a.href ? _jsx(ExternalLink, { size: 14 }) : null)] }));
+                    return a.href ? (_jsx(Out, { href: a.href, label: a.title, children: _jsx(YStack, { width: "100%", children: row }) }, a.key)) : a.onPress ? (_jsx(YStack, { render: "button", "aria-label": a.title, onPress: a.onPress, children: row }, a.key)) : (_jsx(YStack, { children: row }, a.key));
+                }) })] }));
 }
 function Pick({ on, onPress, children }) {
     return (_jsx(XStack, { render: "button", "aria-label": children, onPress: onPress, px: "$2.5", py: "$1", rounded: "$2", bg: on ? '$hover' : 'transparent', children: _jsx(SizableText, { size: "$2", color: on ? '$ink' : '$soft', children: children }) }));

package/lib/out.d.ts

@@ -1,6 +1,7 @@
 /**
  * A link out of the builder: a new tab, no handle back to this page, no
  * referrer. Only ever handed an https address the caller has already checked.
+ * `away` is the same for an address that has to be minted first.
  */
 import type { ReactNode } from 'react';
 export declare function Out({ href, label, children }: {
@@ -8,3 +9,8 @@ export declare function Out({ href, label, children }: {
     label?: string;
     children: ReactNode;
 }): import("react").JSX.Element;
+/**
+ * Opens a tab for an address that takes a moment to mint: the tab opens now, while
+ * the press still counts, and goes to the address once it comes. A refusal closes it.
+ */
+export declare function away(url: Promise<string>): Promise<void>;

package/lib/out.js

@@ -2,3 +2,23 @@ import { jsx as _jsx } from "react/jsx-runtime";
 export function Out({ href, label, children }) {
     return (_jsx("a", { href: href, target: "_blank", rel: "noopener noreferrer", "aria-label": label, style: { color: 'inherit', textDecoration: 'none', display: 'inline-flex', alignItems: 'center', gap: 6 }, children: children }));
 }
+/**
+ * Opens a tab for an address that takes a moment to mint: the tab opens now, while
+ * the press still counts, and goes to the address once it comes. A refusal closes it.
+ */
+export async function away(url) {
+    const w = window.open('about:blank', '_blank');
+    if (w)
+        w.opener = null;
+    try {
+        const to = await url;
+        if (w)
+            w.location.replace(to);
+        else
+            window.open(to, '_blank', 'noopener');
+    }
+    catch (e) {
+        w?.close();
+        throw e;
+    }
+}

package/lib/project.js

@@ -43,7 +43,7 @@ import { start } from './api/coding.js';
 import { blob, tree } from './api/git.js';
 import { deployments, name as repoName, ours, templates } from './api/projects.js';
 import { list, message, stop } from './api/sessions.js';
-import { outcome, pull, said, who } from './api/turn.js';
+import { decode, outcome, pull, said, who } from './api/turn.js';
 import { verdict as record } from './api/verdict.js';
 import { useKept, useProjects, useRead, useRun } from './data.js';
 import { Merge } from './git.js';
@@ -213,12 +213,17 @@ export function Project({ slug }) {
     const lines = useMemo(() => [
         ...run.events
             .filter((e) => e.kind === 'log' || e.kind === 'tool-call' || e.kind === 'status')
-            .map((e) => ({
-            id: `r${e.seq || e.id}`,
-            level: e.kind === 'status' && /error/.test(said(e, run.record?.mode).toLowerCase()) ? 'error' : e.kind === 'tool-call' ? 'info' : 'log',
-            text: said(e, run.record?.mode),
-            source: e.kind === 'status' ? 'run' : who(e.actor),
-        }))
+            .map((e) => {
+            // The console is where a run's error is read whole; the chat says it in one plain line.
+            const body = decode(e.payload);
+            const error = e.kind === 'status' && body && typeof body === 'object' && typeof body.error === 'string' ? body.error : '';
+            return {
+                id: `r${e.seq || e.id}`,
+                level: error || (e.kind === 'status' && /error/.test(said(e, run.record?.mode).toLowerCase())) ? 'error' : e.kind === 'tool-call' ? 'info' : 'log',
+                text: error || said(e, run.record?.mode),
+                source: e.kind === 'status' ? 'run' : who(e.actor),
+            };
+        })
             .filter((l) => l.text),
         ...pageLines,
     ], [run.events, run.record?.mode, pageLines]);

package/lib/run.js

@@ -30,7 +30,7 @@ import { Steer } from '@hanzo/ui/agents';
 import { Composer } from '@hanzo/ui/chat';
 import { ChipSelect } from '@hanzo/ui/product';
 import { useEffect, useMemo, useState } from 'react';
-import { approve, followUp, start } from './api/coding.js';
+import { approve, followUp, headline, retry, start } from './api/coding.js';
 import { ENSO, label as named, models } from './api/models.js';
 import { list, message, pause, publish, rename, resume, stop, story, took } from './api/sessions.js';
 import { answer, cards, outcome, pull, settled, steps } from './api/turn.js';
@@ -69,7 +69,13 @@ export function Run({ id }) {
     const pace = EFFORTS.find((e) => e.id === chose?.effort) ?? EFFORTS.find((e) => e.id === prefs.code?.effort) ?? EFFORTS[1];
     const catalog = useRead(signed ? () => models(t) : null, [], [t, signed]);
     const mode = record?.mode ?? '';
-    const shown = useMemo(() => cards(events, mode), [events, mode]);
+    // A run that narrated no ask of its own opens with the one its title records, once it has said anything.
+    const shown = useMemo(() => {
+        const drawn = cards(events, mode);
+        const ask = record ? headline(record.title, record.repo) : '';
+        const opens = drawn[0]?.kind === 'said' && drawn[0].who === 'person';
+        return ask && drawn.length && !opens ? [{ kind: 'said', key: 'ask', who: 'person', text: ask }, ...drawn] : drawn;
+    }, [events, mode, record]);
     const end = outcome(events);
     const plan = useMemo(() => steps(events), [events]);
     const kept = useMemo(() => settled(events), [events]);
@@ -115,6 +121,10 @@ export function Run({ id }) {
         }
         : null;
     const planned = mode === 'plan' && finished && state === 'done' ? answer(events) : '';
+    // A failed run is tried again with the person's words as it recorded them.
+    const failed = finished && state === 'error';
+    const asked = shown.find((c) => c.kind === 'said' && c.who === 'person');
+    const again = asked && asked.kind === 'said' ? asked.text : '';
     // What the recorded read left out: it carries the latest fifty turns.
     const hidden = Math.max(0, (detail.value?.events ?? 0) - (detail.value?.recent.length ?? 0));
     // Only a run still working is on a step.
@@ -159,13 +169,17 @@ export function Run({ id }) {
     };
     /** A new run's ask with the model and effort the foot shows. The router is the platform's default, so it is not named. */
     const tuned = (a) => ({ ...a, model: model === ENSO ? undefined : model, effort: pace.id });
-    /** A new run from this one's work, opened. A paused run it carries on is let go once the new one is admitted. */
+    /**
+     * A new run from this one's work, opened. A paused run it carries on is let go
+     * first: the new run works in the same sandbox, where nothing else may be at work.
+     */
     const carry = async (said, how = 'follow') => {
         if (!earlier)
             throw new Error('This run is still being read');
-        const run = await start(t, tuned(how === 'approve' ? approve(earlier, said) : followUp(earlier, said)));
         if (paused)
             await stop(t, id, 'Continued in a follow-up run').catch(() => undefined);
+        const ask = how === 'approve' ? approve(earlier, said) : how === 'retry' ? retry(earlier, said) : followUp(earlier, said);
+        const run = await start(t, tuned(ask));
         setDraft('');
         host.go(run.session);
         return '';
@@ -283,7 +297,7 @@ export function Run({ id }) {
                                         ? setup
                                             ? 'Setting up environment'
                                             : 'Starting…'
-                                        : 'Waiting for the run’s first step…' })) : (_jsxs(YStack, { gap: "$3", items: "flex-start", children: [_jsx(SizableText, { size: "$2", color: "$soft", children: "Sign in to follow this run." }), _jsx(Button, { size: "sm", onPress: () => host.signIn?.(), children: "Sign in" })] })) }), _jsxs(YStack, { pb: "$3", pt: "$2", gap: "$2", children: [end.problem ? (_jsx(SizableText, { size: "$1", color: "$soft", children: "The branch is pushed, and the pull request could not be opened." })) : null, note || (signed && refused) ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note || refused })) : null, plan.length ? (_jsxs(YStack, { borderWidth: 1, borderColor: "$borderColor", rounded: "$3", overflow: "hidden", children: [_jsxs(XStack, { render: "button", "aria-label": `Steps · ${plan.length}`, "aria-expanded": unfolded, onPress: () => setUnfolded(!unfolded), px: "$3", py: "$1.5", gap: "$2", items: "center", hoverStyle: { bg: '$hover' }, children: [unfolded ? _jsx(ChevronDown, { size: 14 }) : _jsx(ChevronRight, { size: 14 }), _jsx(SizableText, { size: "$2", color: "$ink", children: `Steps · ${plan.length}` }), current && !unfolded ? (_jsx(SizableText, { flex: 1, minW: 0, size: "$1", color: "$soft", numberOfLines: 1, style: { textAlign: 'right' }, children: current.name })) : null] }), unfolded
+                                        : 'Waiting for the run’s first step…' })) : (_jsxs(YStack, { gap: "$3", items: "flex-start", children: [_jsx(SizableText, { size: "$2", color: "$soft", children: "Sign in to follow this run." }), _jsx(Button, { size: "sm", onPress: () => host.signIn?.(), children: "Sign in" })] })) }), _jsxs(YStack, { pb: "$3", pt: "$2", gap: "$2", children: [end.problem ? (_jsx(SizableText, { size: "$1", color: "$soft", children: "The branch is pushed, and the pull request could not be opened." })) : null, note || (signed && refused) ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note || refused })) : null, failed ? (_jsx(XStack, { items: "center", gap: "$2", children: _jsx(Button, { size: "sm", disabled: busy, onPress: () => void act(() => carry(again, 'retry')), children: busy ? 'Starting…' : 'Try again' }) })) : null, plan.length ? (_jsxs(YStack, { borderWidth: 1, borderColor: "$borderColor", rounded: "$3", overflow: "hidden", children: [_jsxs(XStack, { render: "button", "aria-label": `Steps · ${plan.length}`, "aria-expanded": unfolded, onPress: () => setUnfolded(!unfolded), px: "$3", py: "$1.5", gap: "$2", items: "center", hoverStyle: { bg: '$hover' }, children: [unfolded ? _jsx(ChevronDown, { size: 14 }) : _jsx(ChevronRight, { size: 14 }), _jsx(SizableText, { size: "$2", color: "$ink", children: `Steps · ${plan.length}` }), current && !unfolded ? (_jsx(SizableText, { flex: 1, minW: 0, size: "$1", color: "$soft", numberOfLines: 1, style: { textAlign: 'right' }, children: current.name })) : null] }), unfolded
                                         ? plan.map((s) => {
                                             const on = s === current;
                                             return (_jsxs(XStack, { items: "center", gap: "$2", px: "$3", py: "$1.5", borderTopWidth: 1, borderColor: "$borderColor", children: [_jsx(SizableText, { size: "$2", color: s.done || on ? '$ink' : '$soft', children: s.done ? '✓' : on ? '●' : '○' }), _jsx(SizableText, { size: "$2", color: s.done ? '$soft' : '$ink', numberOfLines: 1, children: s.name })] }, s.name));

package/lib/transcript.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * A run's transcript, drawn by what each part is (turn.ts `cards`): what the
- * agent said as markdown, each command it ran as a card that opens onto its
- * output, the files it changed with their diff, the files it read as chips,
- * the run's own steps, and a plan run's plan with the button that builds it.
+ * agent said as markdown, its reasoning folded, each command it ran as a card
+ * that opens onto its output, the files it changed, its plan as a checklist, the
+ * run's own steps, and a plan run's plan with the button that builds it.
  * What the agent said, and its plan, can be copied and judged, as a reply on
  * claude.ai can: a thumb pressed again takes the verdict back.
  *
@@ -11,46 +11,34 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * scrolls up (Thread). Everything drawn is text.
  */
 import { SizableText, XStack, YStack } from '@hanzo/gui';
-import { FileText } from '@hanzogui/lucide-icons-2';
 import { Button } from '@hanzo/ui';
 import { Feedback } from '@hanzo/ui/agents';
 import { Code, Message, Step, Thread } from '@hanzo/ui/chat';
 import { useState } from 'react';
-import { Patch } from './git.js';
 import { Prose } from './prose.js';
 /** A card's output, its tail: what a command said last is why it stopped. */
 const TAIL = 6000;
 const tail = (s) => (s.length > TAIL ? `…${s.slice(-TAIL)}` : s);
 const mono = { fontFamily: 'var(--f-mono, ui-monospace, monospace)' };
-/** Consecutive reads draw as one row of chips. */
-function rows(cards) {
-    const out = [];
-    for (const c of cards) {
-        const last = out[out.length - 1];
-        if (c.kind === 'read' && Array.isArray(last))
-            last.push(c);
-        else
-            out.push(c.kind === 'read' ? [c] : c);
-    }
-    return out;
-}
+/** What a thought is about: its first line, without the markdown that bolds it. */
+const firstLine = (text) => text.trim().split('\n')[0].replace(/[*_#`]/g, '').slice(0, 120);
 export function Transcript({ cards, live, empty, header, onApprove, approving = false, onVerdict, }) {
     // A card the run never finished is cut off once the run has ended, not still going.
     const state = (ran) => (ran === 'running' && !live ? 'cancelled' : ran);
-    return (_jsxs(Thread, { maxWidth: 0, gap: 14, column: { px: 0 }, "aria-label": "Transcript", children: [header, cards.length === 0 ? _jsx(YStack, { py: "$2", children: empty }) : null, rows(cards).map((row) => {
-                if (Array.isArray(row)) {
-                    return (_jsx(XStack, { gap: "$1.5", flexWrap: "wrap", children: row.map((r) => (_jsxs(XStack, { "aria-label": `Read ${r.file}`, items: "center", gap: "$1.5", px: "$2", py: "$1", rounded: "$10", borderWidth: 1, borderColor: "$borderColor", maxW: "100%", children: [_jsx(FileText, { size: 12, color: "$soft" }), _jsx(SizableText, { size: "$1", color: "$soft", children: "Read" }), _jsx(SizableText, { size: "$1", color: "$ink", numberOfLines: 1, style: mono, children: r.file })] }, r.key))) }, row[0].key));
-                }
-                const c = row;
+    return (_jsxs(Thread, { maxWidth: 0, gap: 14, column: { px: 0 }, "aria-label": "Transcript", children: [header, cards.length === 0 ? _jsx(YStack, { py: "$2", children: empty }) : null, cards.map((c) => {
                 switch (c.kind) {
                     case 'said':
                         return c.who === 'person' ? (_jsx(Message, { role: "user", children: _jsx(SizableText, { size: "$3", color: "$ink", style: { whiteSpace: 'pre-wrap' }, children: c.text }) }, c.key)) : (_jsx(Message, { role: "assistant", actions: _jsx(Judge, { text: c.text, onVerdict: onVerdict }), children: _jsx(Prose, { text: c.text }) }, c.key));
+                    case 'think':
+                        return (_jsx(Step, { name: "Thought", detail: firstLine(c.text), status: "done", "aria-label": "Thought", children: _jsx(Prose, { text: c.text }) }, c.key));
+                    case 'todo':
+                        return (_jsx(YStack, { gap: "$1", px: "$3", py: "$2", rounded: "$3", borderWidth: 1, borderColor: "$borderColor", "aria-label": "Plan checklist", children: c.items.map((x, i) => (_jsxs(XStack, { gap: "$2", items: "flex-start", children: [_jsx(SizableText, { size: "$2", color: x.done ? '$ink' : '$soft', children: x.done ? '✓' : '○' }), _jsx(SizableText, { flex: 1, size: "$2", color: x.done ? '$soft' : '$ink', children: x.text })] }, i))) }, c.key));
                     case 'shell':
                         return (_jsx(Step, { name: "Shell", detail: c.command, status: state(c.ran), "aria-label": `Command ${c.command}`, children: _jsx(Code, { language: "shell", value: c.output ? `$ ${c.command}\n${c.output}` : `$ ${c.command}`, children: c.output ? `$ ${c.command}\n${tail(c.output)}` : `$ ${c.command}` }) }, c.key));
                     case 'edit':
-                        return (_jsx(Step, { name: c.files.length === 1 ? 'Edited' : c.files.length ? `Edited ${c.files.length} files` : 'Edited files', detail: c.files.join(', '), status: state(c.ran), "aria-label": `Edited ${c.files.join(', ') || 'files'}`, children: c.patch ? (_jsx(YStack, { overflow: "scroll", maxH: 480, children: _jsx(Patch, { text: c.patch }) })) : (_jsx(SizableText, { size: "$1", color: "$soft", children: c.files.length ? c.files.join('\n') : 'The harness named no files.' })) }, c.key));
+                        return (_jsx(Step, { name: c.files.length === 1 ? 'Edited' : c.files.length ? `Edited ${c.files.length} files` : 'Edited files', detail: c.files.join(', '), status: state(c.ran), "aria-label": `Edited ${c.files.join(', ') || 'files'}`, children: _jsx(SizableText, { size: "$1", color: "$soft", children: c.files.length ? `${c.files.join('\n')}\n\nThe diff is in the run’s Git tab.` : 'The agent named no files.' }) }, c.key));
                     case 'step':
-                        return (_jsx(Step, { name: c.name, detail: c.detail, status: state(c.ran), "aria-label": `${c.name} ${c.detail}`.trim(), children: c.output.trim() ? (_jsx(Code, { language: "output", value: c.output, children: tail(c.output.replace(/\n+$/, '')) })) : undefined }, c.key));
+                        return (_jsx(Step, { name: c.name, detail: c.detail, status: state(c.ran), defaultOpen: c.name === 'Error', "aria-label": `${c.name} ${c.detail}`.trim(), children: c.name === 'Error' ? (_jsx(SizableText, { size: "$2", color: "$ink", style: { ...mono, whiteSpace: 'pre-wrap', overflowWrap: 'anywhere' }, children: c.output })) : c.output.trim() ? (_jsx(Code, { language: "output", value: c.output, children: tail(c.output.replace(/\n+$/, '')) })) : undefined }, c.key));
                     case 'note':
                         return (_jsx(SizableText, { size: "$1", color: "$soft", role: "note", children: c.text }, c.key));
                     case 'plan':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzo/build",
-  "version": "0.2.29",
+  "version": "0.2.31",
   "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.",

package/lib/api/harness.d.ts

@@ -1,62 +0,0 @@
-/**
- * The agent's own output, read as cards.
- *
- * A sandbox run's agent is `dev exec`, and everything it prints reaches the
- * run's session as `log` chunks (apps/sandbox work.go). It prints each item of
- * its turn under a header line (hanzo dev, exec/src/event_processor_with_human_output.rs):
- *
- *   user / <task>                        what the agent was asked
- *   exec / <command> in <dir>            a command started
- *    succeeded in 12ms: / <output>       …how it ended, then what it printed
- *   codex / <text>                        the agent said something
- *   apply patch / patch: completed / <paths>, then the turn's diff
- *   mcp: server/tool (completed)          a tool call
- *   web search: <query>
- *     ✓ step / → step / • step            its plan
- *   tokens used / <n>                     the end; the final message follows once more, bare
- *
- * The sandbox's older harness (dev 0.6.94) prints another grammar: it stamps
- * each item `[2026-09-29T16:07:35] ` and spells its headers its own way —
- * `User instructions:`, `dev`, `thinking`, `exec <command> in <dir>`,
- * `<command> succeeded in 1m 05s:`, `tool <call>`, `🌐 Search: <query>`,
- * `apply_patch auto_approved=true:`, `turn diff:`, `tokens used: <n>`. A stamped
- * line starts an item and says where the unstamped lines after it belong
- * (`stamped`). Every stamped line no header owns is the harness's diagnostics.
- *
- * Warnings, errors, retries and diagnostics are the agent's log, one collapsed
- * step, never the conversation; token counts are dropped.
- *
- * The chunks are cut by a clock, not by line, so a line is read only once it
- * is whole. Lines no header owns — reasoning, or the tail of output from before
- * the recorded events begin — are prose. Everything here becomes TEXT on the
- * screen; nothing is markup.
- *
- * The task under `user` is what the person asked, with what the platform told
- * the agent ahead of it and what a follow-up said after it taken off (`asked`),
- * so it opens the transcript as the person's own words.
- */
-import type { Card } from './turn.ts';
-/**
- * A shell command's words, as `sh` splits them: quotes grouped, `'"'"'`
- * joined, a backslash escaping the next character outside single quotes.
- */
-export declare function words(line: string): string[];
-/** The command a harness ran, out of the `bash -lc '…'` it wraps each one in. */
-export declare function unwrap(command: string): string;
-/**
- * The file a command only reads, or ''. `cat f`, `nl -ba f`, `sed -n '1,80p' f`,
- * `head -n 40 f`, `tail f` — one file, and nothing piped, chained or redirected.
- */
-export declare function reads(command: string): string;
-/** A path to show: a relative one as it is, an absolute one by its name — never the sandbox's layout. */
-export declare const shown: (path: string) => string;
-/** What the person asked, out of the task the agent was given. A follow-up with nothing said keeps its own line. */
-export declare function asked(task: string): string;
-/** A unified diff's sections, by the path each changes, from its first hunk on. */
-export declare function sections(diff: string): Map<string, string>;
-/** A reader that appends the cards it finds to `out`, keyed by `mint`. */
-export declare function harness(out: Card[], mint: () => string): {
-    feed(chunk: string): void;
-    /** The last line even without its newline, and what only the whole output can decide. */
-    end(): void;
-};