@plurnk/plurnk 0.71.4 → 0.72.0

package/dist/tui.js

@@ -21,11 +21,16 @@ import { extractOpenPaths } from "./openpaths.js";
 import { pathPartial, completePath, dslOpPartial, completeOps } from "./completion.js";
 import { renderLogEntry, renderSummary, isPromptEntry, coordLabel, progressLabel, entryTarget, isEntryMaterialization } from "./render.js";
 import { renderProposalMenu, keyToResolution, isServerResolved, questionFromProposal, renderQuestionMenu, answerForLine } from "./proposal.js";
-import { RunAckError } from "./transport.js";
-import { renderTelemetryEvent, report, clientSubcommandUnknownVerb, NO_MODEL_HINT } from "./telemetry.js";
+import { ProblemError, renderDiagnostic, report, clientSubcommandUnknownVerb, NO_MODEL_HINT } from "./diagnostics.js";
 import StreamTrace, { inlineable, renderInline } from "./stream.js";
-import { runOAuth } from "./auth.js";
 import { runModels, runWorkspaceList, runWorkspaceWorkers, runLogRead } from "./subcommands.js";
+export const renderTuiFailure = (cause) => {
+    if (cause instanceof ProblemError) {
+        return renderDiagnostic(cause.problem)
+            + (cause.problem.status === 501 ? NO_MODEL_HINT : "");
+    }
+    return `  \x1b[31merror: ${cause instanceof Error ? cause.message : String(cause)}\x1b[0m`;
+};
 // One verb vocabulary across nvim's :AI/, the TUI, and (where they exist)
 // the argv subcommands. Convergence is policy: divergence needs a reason.
 // Singular = CREATE, plural = LIST: /workspace makes a new workspace, /workspaces
@@ -33,14 +38,14 @@ import { runModels, runWorkspaceList, runWorkspaceWorkers, runLogRead } from "./
 // ambiguous (workspace or worker?) and is gone. /rename retargets the current
 // workspace's mutable handle (a worker's name is immutable — no /rename for workers).
 export const VERBS = [
-    "help", "models", "workspaces", "workers", "log", "model",
+    "help", "models", "workspaces", "workers", "log", "model", "child",
     "yolo", "workspace", "rename", "worker", "stop", "quit",
-    "pick", "hide", "view", "repo", "drop", "members", "import", "script",
-    "auth", "accept", "reject", "cancel", "edit",
+    "pick", "hide", "view", "drop", "members", "import", "script",
+    "accept", "reject", "cancel", "edit",
 ];
 export const TUI_HELP = [
-    "  /models /workspaces /runs /log [n]   inspect",
-    "  /model <alias>                     model for subsequent loops",
+    "  /models /workspaces /workers /log [n]   inspect",
+    "  /model <alias> · /child <alias|inherit>   parent and child models",
     "  /yolo                              toggle local auto-accept",
     "  /workspace [name]                    new workspace",
     "  /rename <name>                     rename this workspace (a mutable handle)",
@@ -48,12 +53,10 @@ export const TUI_HELP = [
     "  /pick <glob>                       membership: track file(s) in manifest",
     "  /hide <glob>                       membership: block file(s) from manifest",
     "  /view <glob>                       membership: track file(s) in manifest (read-only)",
-    "  /repo <glob>                       membership: track a git repo folder",
-    "  /drop <glob>                       membership: remove tracking rules for file(s), remove git tracking for folder",
+    "  /drop <glob>                       membership: remove a matching rule",
     "  /members                           the model's resolved file universe (+ rules)",
     "  /import <path>                     dump a local file's content into the prompt",
     "  /script <path>                     run a .plk file (its DSL → op.parse)",
-    "  /auth <target>                     OAuth an auth-protected exec (e.g. notion) via device code",
     "  /accept /reject /cancel /edit      resolve a pending proposal (or keys a/e/r/c)",
     "  /stop                              cancel the running loop",
     "  /quit                              exit",
@@ -86,7 +89,7 @@ export const expandNewlines = (line) => line.replaceAll(NL_MARK, "\n");
 // doesn't change a control code), Ctrl-s is XOFF, Ctrl-i is Tab, and readline
 // owns a/e/n/p/u/w/k/l. Alt-b/f/d are skipped (readline word-ops).
 export const ALT_SHORTCUTS = Object.freeze({
-    m: "/models", s: "/workspaces", R: "/runs", L: "/log",
+    m: "/models", s: "/workspaces", R: "/workers", L: "/log",
     Y: "/yolo", N: "/workspace", M: "/members", x: "/stop", h: "/help",
 });
 // An Alt-<letter> keypress (ESC then a single letter, no `[`/`O` → not an arrow
@@ -96,14 +99,9 @@ export const altShortcut = (forward) => {
     const m = forward.match(/^\x1b([a-zA-Z])$/);
     return m ? (ALT_SHORTCUTS[m[1]] ?? null) : null;
 };
-// `<<LOOK…::LOOK` is a CLIENT pseudo-op — "READ, but for me instead of the model".
-// The grammar (plurnk-grammar plurnk.md §Operations) terminates a statement with its
-// own op name (`<<OP…:body:OP`), so a faithful rewrite swaps BOTH ends LOOK→READ and passes
-// [signal](target)<sel>:body through untouched — the daemon only ever sees a real
-// READ. `\b` keeps `<<LOOKUP` from matching. null when the line isn't a LOOK.
-export const lookRewrite = (line) => /^<<LOOK\b/i.test(line)
-    ? line.replace(/^<<LOOK\b/i, "<<READ").replace(/:LOOK(\s*)$/i, ":READ$1")
-    : null;
+// Recognize the client-only LOOK surface so it can be routed to `op.look`.
+// The AG-UI observation action owns validation and the single LOOK→READ rewrite.
+export const lookStatement = (line) => /^<<LOOK\b/i.test(line) ? line : null;
 // §2.0 prompt prefixes (converged with nvim's :AI ? / :AI :): `? ` puts mode:"ask"
 // on the wire flags, `: ` forces act, both overriding a --flags base mode; `...`
 // (injection) strips without minting flags. Mode is a per-line habit, never --ask.
@@ -135,7 +133,7 @@ export const parseSlash = (line) => {
     const m = line.match(/^\/(\S*)\s*(.*)$/);
     return { verb: m?.[1] ?? "", rest: (m?.[2] ?? "").trim() };
 };
-// readline completer — verbs after `/`, model aliases after `/model `.
+// readline completer — verbs after `/`, model aliases after `/model ` or `/child `.
 // Plain readline machinery only; no screen takeover, no terminal hell.
 // readline's async completer form (arity 2 → async). Verb/alias completion
 // answers synchronously; path positions read the local fs (co-location law)
@@ -146,9 +144,12 @@ export const makeCompleter = (getAliases, cwd) => (line, callback) => {
         callback(null, [VERBS.map((v) => `/${v}`).filter((v) => v.startsWith(line)), line]);
         return;
     }
-    const aliasFrag = line.match(/^\/model\s+(\S*)$/);
+    const aliasFrag = line.match(/^\/(model|child)\s+(\S*)$/);
     if (aliasFrag) {
-        callback(null, [getAliases().filter((a) => a.startsWith(aliasFrag[1])), aliasFrag[1]]);
+        const candidates = aliasFrag[1] === "child"
+            ? ["inherit", ...getAliases().filter((alias) => alias !== "inherit")]
+            : getAliases();
+        callback(null, [candidates.filter((a) => a.startsWith(aliasFrag[2])), aliasFrag[2]]);
         return;
     }
     const op = dslOpPartial(line);
@@ -223,6 +224,21 @@ export const handleVerb = async (line, ctx) => {
             opts.model = ctx.resolveModel?.(rest);
             write(`  model: ${rest}\n`);
             return;
+        case "child":
+            if (rest.length === 0) {
+                write(`  child: ${opts.childAlias ?? "inherit"}\n`);
+                return;
+            }
+            if (rest === "inherit") {
+                opts.childAlias = null;
+                opts.childModel = undefined;
+            }
+            else {
+                opts.childAlias = rest;
+                opts.childModel = ctx.resolveModel?.(rest);
+            }
+            write(`  child: ${rest}\n`);
+            return;
         case "yolo":
             opts.yolo = !opts.yolo;
             write(`  yolo: ${opts.yolo ? "ON" : "OFF"}\n`);
@@ -260,9 +276,8 @@ export const handleVerb = async (line, ctx) => {
         }
         case "pick":
         case "hide":
-        case "view":
-        case "repo": {
-            // Membership overlay (svc#200/#242) — service vocabulary, live via
+        case "view": {
+            // Membership overlay — service vocabulary, live via
             // workspace.constrain (workspace-scoped, re-resolved immediately).
             if (rest.length === 0) {
                 write(`  usage: /${verb} <glob>\n`);
@@ -298,7 +313,7 @@ export const handleVerb = async (line, ctx) => {
             const editable = members.filter((m) => m.effect === "member");
             const view = members.filter((m) => m.effect === "view");
             if (members.length === 0 && hidden.length === 0) {
-                write("  the model's universe is empty — no members (/pick a file or /repo a folder)\n");
+                write("  the model's universe is empty — no Git members or /pick rules\n");
             }
             else {
                 write(`  the model's universe: ${members.length} file${members.length === 1 ? "" : "s"}`
@@ -351,19 +366,6 @@ export const handleVerb = async (line, ctx) => {
             // Typed no-modifier fallback for the a/e/r/c proposal review keys.
             await ctx.resolveProposal(verb);
             return;
-        case "auth": {
-            // #116 — the OAuth device-grant leg: authorize → print URL + code →
-            // poll to authorized. Blocks the REPL while polling (Ctrl-C exits); the
-            // service half is stateless, we own the poll loop + expiry bound.
-            const target = rest.trim();
-            if (target.length === 0) {
-                write("  \x1b[2musage: /auth <target>  (the exec needing auth, e.g. notion)\x1b[0m");
-                return;
-            }
-            const r = await runOAuth(rpc, target, { print: write });
-            write(`  ${r.ok ? "✅" : "❌"} ${r.message}`);
-            return;
-        }
         case "stop":
             await rpc.call("loop.cancel", { reason: "user_stop" });
             return;
@@ -390,6 +392,7 @@ export const runTui = async (transport, workspace, opts) => {
     let embeddingPercent = null;
     let searchFetching = false;
     let searchPercent = null;
+    let branchBatch = null;
     let hibernating = false; // the loop parked on a SEND[202] (awaiting streams/workers)
     // <<LOOK off-run inspection: the REAL target URIs of prior operations the
     // waterfall has shown (oldest→newest, e.g. worker:///plan.md) feed the Alt-p/
@@ -448,13 +451,12 @@ export const runTui = async (transport, workspace, opts) => {
     // the row identity. 🐹 (U+1F439, the brand head — was the generic 👤
     // U+1F464) and ✅ (U+2705) are plain East-Asian-Wide single code points —
     // width 2 in node AND every major terminal, no VS16 — so they stay; the
-    // 201 is the contract constant (the prompt row is always a 201 EDIT);
+    // 201 is the input-affordance constant;
     // 💬 (U+1F4AC, stable-wide) fills the op slot the toxic ✉️ vacated.
     // Policy: VS16/ambiguous glyphs are banned from the ENTIRE palette
     // (render.ts) — stable widths are also what make columns align.
     // The prompt is the user's row, coordinate-prefixed like every other
-    // waterfall line (§5.1). The coordinate is the one the typed line will
-    // get: the prompt becomes the next loop's foist EDIT at <next>/01/01.
+    // waterfall line (§5.1). The coordinate is the next actionless prompt row.
     // lastLoopSeq tracks the highest loop the waterfall has shown; the next
     // prompt is one beyond it. Plain-ASCII coordinate — width-safe.
     // The prompt is the SAME whether or not a loop is running — kept alive above
@@ -474,11 +476,23 @@ export const runTui = async (transport, workspace, opts) => {
         // TWO lanes exactly, same as every waterfall row (identity · status), so the
         // prompt sits flush in the ladder. All glyphs are same-width palette members;
         // swapping in place keeps the columns and the readline cursor stable.
-        const busy = inFlight || embedding || searchFetching;
-        const origin = embedding ? "🧮" : searchFetching ? "🔎" : "🐹";
-        const status = busy ? (inFlight && hibernating ? "💤" : "⏳") : "  ";
+        const busy = inFlight || embedding || searchFetching || branchBatch !== null;
+        const origin = embedding ? "🧮" : searchFetching ? "🔎" : branchBatch !== null ? "🌿" : "🐹";
+        const status = branchBatch?.state === "recovery_required"
+            ? "❌"
+            : busy ? (inFlight && hibernating && branchBatch === null ? "💤" : "⏳") : "  ";
         const yolo = opts.yolo ? "🔥" : "  ";
-        const activePercent = embedding ? embeddingPercent : searchFetching ? searchPercent : null;
+        const branchCompleted = Number(branchBatch?.completed);
+        const branchTotal = Number(branchBatch?.total);
+        const branchPercent = branchBatch !== null
+            && Number.isFinite(branchCompleted)
+            && Number.isFinite(branchTotal)
+            && branchTotal > 0
+            ? Math.floor((branchCompleted / branchTotal) * 100)
+            : null;
+        const activePercent = embedding ? embeddingPercent
+            : searchFetching ? searchPercent
+                : branchPercent;
         const position = activePercent !== null
             ? progressLabel(activePercent)
             : coordLabel(lastLoopSeq + 1, 1, 1);
@@ -539,17 +553,14 @@ export const runTui = async (transport, workspace, opts) => {
             return;
         setLine(`<<LOOK(${priorTargets[lookCursor]})::LOOK`);
     };
-    // `<<LOOK(uri)` already rewritten (op token LOOK→READ) to a READ statement.
-    // LOOK is a PURE QUERY: op.look (plurnk-service#283, shipped v0.57.0) runs READ's
-    // full resolver but writes NO log entry — so the model never sees it and there's no
-    // run to manage. Run on the main connection (the conversation run, so log:/// resolves
-    // run-relative against the right run). Render the content; no op, no harvest. Trust
-    // the contract: status is required, content is `string | null` (svc ReadResult).
-    const runLook = async (readText) => {
-        const r = await transport.rpc("op.look", { text: readText });
+    // LOOK is a pure query: AG-UI validates and rewrites the original statement, then
+    // resolves READ without writing a log entry. Run it on the conversation connection
+    // so run-relative targets resolve against the right run.
+    const runLook = async (lookText) => {
+        const r = await transport.rpc("op.look", { text: lookText });
         const content = r.content ?? "";
         printAbove(content.length > 0 ? content : `  \x1b[2m(look ${r.status}: no content)\x1b[0m`);
-        return r.status;
+        return r;
     };
     // Multi-line composition. The non-submitting newline keys insert a single ↵
     // marker into readline's ONE line; Enter submits, expanding ↵→\n. Keeping it
@@ -625,7 +636,7 @@ export const runTui = async (transport, workspace, opts) => {
             await transport.resolve({ logEntryId: p.logEntryId, ...resolution });
         }
         catch (cause) {
-            process.stdout.write(`  \x1b[31mresolve failed: ${cause instanceof Error ? cause.message : String(cause)}\x1b[0m\n`);
+            process.stdout.write(`${renderTuiFailure(cause)}\n`);
         }
         showNextProposal();
         reprompt();
@@ -644,7 +655,7 @@ export const runTui = async (transport, workspace, opts) => {
             resolution = (await keyToResolution("e", p)) ?? { decision: "cancel", outcome: "edit_failed" };
         }
         catch (cause) {
-            process.stdout.write(`  \x1b[31medit failed: ${cause instanceof Error ? cause.message : String(cause)}\x1b[0m\n`);
+            process.stdout.write(`${renderTuiFailure(cause)}\n`);
             resolution = { decision: "cancel", outcome: "edit_error" };
         }
         finally {
@@ -668,19 +679,19 @@ export const runTui = async (transport, workspace, opts) => {
     // transport is live. Same bodies as the old inline rpc.onNotification handlers;
     // they render the shared workspace's activity whether this REPL started the loop
     // or a worker/second client did (multi-client observability).
-    const handleTelemetry = (event) => {
+    const handleNotice = (notice) => {
         // engine:turn liveness is the ⏳ gutter (inFlight), not a waterfall line.
-        if (event.source === "engine:turn")
+        if (notice.source === "engine:turn")
             return;
         // Indexing progress is ephemeral prompt state, not an append-only waterfall
         // record. The coordinate slot becomes a fixed-width percentage while warm,
         // then returns to the next real L/T/S coordinate on completion.
-        if (event.source === "engine:derivation" && event.kind === "embed_progress") {
-            const phase = typeof event.phase === "string" ? event.phase : null;
+        if (notice.source === "engine:derivation" && notice.kind === "embed_progress") {
+            const phase = typeof notice.phase === "string" ? notice.phase : null;
             embedding = phase === "preparing"
-                || (phase !== "complete" && phase !== "failed" && Number(event.completed) < Number(event.total));
-            const completed = Number(event.completed);
-            const total = Number(event.total);
+                || (phase !== "complete" && phase !== "failed" && Number(notice.completed) < Number(notice.total));
+            const completed = Number(notice.completed);
+            const total = Number(notice.total);
             embeddingPercent = embedding && Number.isFinite(completed) && Number.isFinite(total) && total > 0
                 ? Math.floor((completed / total) * 100)
                 : null;
@@ -688,15 +699,37 @@ export const runTui = async (transport, workspace, opts) => {
             return;
         }
         // Search acquisition is the same compact lifecycle shape: update the
-        // fixed-width prompt gauge, never append one telemetry line per tick.
-        if (event.kind === "search_progress" && typeof event.source === "string" && event.source.startsWith("exec:")) {
-            searchFetching = event.phase !== "complete" && event.phase !== "failed";
-            const percent = Number(event.percent);
+        // fixed-width prompt gauge, never append one notice line per tick.
+        if (notice.kind === "search_progress" && notice.source.startsWith("exec:")) {
+            searchFetching = notice.phase !== "complete" && notice.phase !== "failed";
+            const percent = Number(notice.percent);
             searchPercent = searchFetching && Number.isFinite(percent) ? percent : null;
             repromptPreserving();
             return;
         }
-        printAbove(renderTelemetryEvent(event));
+        printAbove(renderDiagnostic(notice));
+    };
+    const handleBranchBatch = (event) => {
+        let rendered = false;
+        if (event.state === "completed") {
+            branchBatch = null;
+            printAbove(`  🌿 branch batch ${event.batchId} complete (${event.completed ?? event.total ?? 0}/${event.total ?? event.completed ?? 0})`);
+            rendered = true;
+        }
+        else if (event.state === "failed") {
+            branchBatch = null;
+            printAbove(`  \x1b[31m❌ branch batch ${event.batchId} failed: ${event.problem?.detail ?? "branch preflight failed"}\x1b[0m`);
+            rendered = true;
+        }
+        else {
+            branchBatch = event;
+            if (event.state === "recovery_required") {
+                printAbove(`  \x1b[31m❌ branch batch ${event.batchId} requires recovery: ${event.problem?.detail ?? "inspect the workspace Git state"}\x1b[0m`);
+                rendered = true;
+            }
+        }
+        if (!rendered)
+            repromptPreserving();
     };
     transport.subscribe({
         onEntry: (entry) => {
@@ -716,17 +749,16 @@ export const runTui = async (transport, workspace, opts) => {
             hibernating = entry.op === "SEND" && entry.signal === 202;
             printAbove(renderLogEntry(entry));
         },
-        onTelemetry: handleTelemetry,
+        onNotice: handleNotice,
+        onProblem: (problem) => printAbove(renderDiagnostic(problem)),
+        onBranchBatch: handleBranchBatch,
         onStream: (payload) => {
-            // One channel for the lifecycle: concluded carries closeStatus, a start
+            // One channel for the lifecycle: concluded carries its exact result, a start
             // event carries state. One start line, one conclusion line, tiny outputs inlined.
-            if (typeof payload.closeStatus === "number") {
+            if (typeof payload.result?.status === "number") {
                 const p = payload;
                 printAbove(streams.concluded(p));
-                // #116 — a 401 close offers the device-grant flow (run /auth <scheme>).
-                if (p.closeStatus === 401)
-                    printAbove(`  🔒 ${p.scheme} needs authorization — run \x1b[1m/auth ${p.scheme}\x1b[0m`);
-                void transport.rpc("entry.read", { target: p.target }).then((r) => {
+                void transport.rpc("entry.read", { target: p.target, workerId: p.workerId }).then((r) => {
                     const channels = r.entry?.channels ?? {};
                     for (const name of ["stdout", "stderr"]) {
                         const content = channels[name]?.content;
@@ -767,7 +799,7 @@ export const runTui = async (transport, workspace, opts) => {
     });
     // Startup warming begins while AG-UI is still establishing the workspace, before a
     // request-scoped SSE exists. Poll the engine's latest structured state until terminal;
-    // later /repo actions stay on their own SSE until warming completes and stream live events.
+    // Later membership actions stay on their own SSE while warming streams live events.
     let lastDerivationState = "";
     let derivationPoll = null;
     const pollDerivation = async () => {
@@ -782,7 +814,7 @@ export const runTui = async (transport, workspace, opts) => {
             const signature = JSON.stringify(status);
             if (signature !== lastDerivationState) {
                 lastDerivationState = signature;
-                handleTelemetry({ ...status, source: "engine:derivation", kind: "embed_progress" });
+                handleNotice({ ...status, source: "engine:derivation", kind: "embed_progress" });
             }
             if (status.phase === "complete" || status.phase === "failed") {
                 if (derivationPoll !== null)
@@ -807,7 +839,7 @@ export const runTui = async (transport, workspace, opts) => {
         rpc: verbRpc, opts, resolveModel: opts.resolveModel,
         getWorkspace: () => current,
         setWorkspace: (s) => { current = s; },
-        switchWorkspace: (name) => transport.useSession(name, { projectRoot: opts.projectRoot, client: opts.client, autoReadAgents: opts.autoReadAgents }),
+        switchWorkspace: (name) => transport.useSession(name, { projectRoot: opts.projectRoot, client: opts.client }),
         write: (text) => { process.stdout.write(text); },
         importFile: async (rest) => {
             const abs = isAbsolute(rest) ? rest : resolve(process.cwd(), rest);
@@ -846,7 +878,7 @@ export const runTui = async (transport, workspace, opts) => {
                 }
             }
             catch (cause) {
-                process.stdout.write(`  \x1b[31merror: ${cause instanceof Error ? cause.message : String(cause)}\x1b[0m\n`);
+                process.stdout.write(`${renderTuiFailure(cause)}\n`);
             }
             reprompt();
         })();
@@ -899,8 +931,7 @@ export const runTui = async (transport, workspace, opts) => {
                     }
                 }
                 catch (cause) {
-                    const msg = cause instanceof Error ? cause.message : String(cause);
-                    process.stdout.write(`  \x1b[31merror: ${msg}\x1b[0m\n`);
+                    process.stdout.write(`${renderTuiFailure(cause)}\n`);
                 }
                 reprompt();
                 return;
@@ -929,26 +960,25 @@ export const runTui = async (transport, workspace, opts) => {
             reprompt();
             const start = Date.now();
             let turnCount = 0;
-            let finalStatus = 0;
+            let terminalResult = { status: 0 };
             let hitMaxTurns = false;
             let usage;
             try {
-                const lookText = trimmed.startsWith("<<") ? lookRewrite(trimmed) : null;
+                const lookText = trimmed.startsWith("<<") ? lookStatement(trimmed) : null;
                 if (lookText !== null) {
                     // <<LOOK: off-run READ on the side connection — for me, not the model.
-                    finalStatus = await runLook(lookText);
+                    terminalResult = await runLook(lookText);
                 }
                 else if (trimmed.startsWith("<<")) {
                     // Raw DSL: send to op.parse
                     const result = await transport.rpc("op.parse", { text: trimmed });
-                    finalStatus = result.results[result.results.length - 1]?.status ?? 0;
+                    terminalResult = result.results[result.results.length - 1] ?? { status: 0 };
                 }
                 else if (trimmed.startsWith("!")) {
                     // `! cmd` — exec via the daemon (proposal-gated like any
                     // side effect; output streams as stream/event traces).
                     const command = trimmed.replace(/^!+\s*/, "");
-                    const result = await transport.rpc("op.exec", { command });
-                    finalStatus = result.status;
+                    terminalResult = await transport.rpc("op.exec", { command });
                 }
                 else {
                     // Prompt. `? ` = ask (read-only loop, flags.mode="ask");
@@ -959,6 +989,10 @@ export const runTui = async (transport, workspace, opts) => {
                         loopParams.alias = opts.modelAlias; // display label
                     if (opts.model !== undefined)
                         loopParams.model = opts.model; // #90 client-resolved routing (precedence)
+                    if (opts.childAlias !== undefined)
+                        loopParams.childAlias = opts.childAlias;
+                    if (opts.childModel !== undefined)
+                        loopParams.childModel = opts.childModel;
                     if (lineFlags !== undefined && Object.keys(lineFlags).length > 0)
                         loopParams.flags = lineFlags;
                     if (opts.maxTurns !== undefined)
@@ -967,22 +1001,19 @@ export const runTui = async (transport, workspace, opts) => {
                     if (openPaths.length > 0)
                         loopParams.openPaths = openPaths;
                     // The transport owns the ack→terminated bridge; done resolves
-                    // with the loop's outcome. A synchronous ACK failure surfaces as
-                    // RunAckError (caught below; 501 gets the .env pointer, #120).
+                    // with the loop's outcome. A pre-stream HTTP failure surfaces as
+                    // an exact ProblemError (caught below; 501 gets the .env pointer).
                     const t = await transport.run(promptText, loopParams).done;
-                    finalStatus = t.finalStatus;
+                    terminalResult = t.result;
                     hitMaxTurns = t.hitMaxTurns;
                     turnCount = t.turnIds?.length ?? 0;
                     usage = t.usage;
                 }
                 const wallMs = Date.now() - start;
-                printAbove(renderSummary(turnCount, wallMs, finalStatus, hitMaxTurns, usage, usage?.promptBudget));
+                printAbove(renderSummary(turnCount, wallMs, terminalResult, hitMaxTurns, usage, usage?.promptBudget));
             }
             catch (cause) {
-                const msg = cause instanceof RunAckError && cause.status === 501
-                    ? cause.message + NO_MODEL_HINT
-                    : cause instanceof Error ? cause.message : String(cause);
-                printAbove(`  \x1b[31merror: ${msg}\x1b[0m`);
+                printAbove(renderTuiFailure(cause));
             }
             finally {
                 inFlight = false;
@@ -999,6 +1030,7 @@ export const runTui = async (transport, workspace, opts) => {
             process.stdout.write("\x1b[?2004l");
             process.stdin.off("data", onStdin);
             process.stdin.setRawMode?.(false);
+            process.stdin.pause();
             // Steal pi's nicety: hand back the one-liner to pick this workspace up.
             process.stdout.write(`\n  \x1b[2mresume this workspace:  plurnk --workspace ${current.name}\x1b[0m\n`);
             resolve();