@giovannijecha/jecode 0.8.6 → 0.8.7

package/dist/tui/app.js

@@ -34,7 +34,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     const state = appState();
     state.blocks.push(...session.conversation.transcript);
     state.committedNodeId = session.conversation.activeNodeId;
-    const permissions = sessionPermissions(session.tools, session.config.autoApprove);
+    const permissions = sessionPermissions(session.tools);
     let closed;
     let frameTimer;
     let motionTimer;
@@ -42,9 +42,10 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     let escapeTimer;
     let stopResize = () => { };
     let stopInput = () => { };
+    let stopOutput = () => { };
     let stopShutdown = () => { };
     let failure;
-    let activeWorkflow;
+    const activeWorkflows = new Set();
     // Timers outlive the teardown they were scheduled before. Painting after the
     // terminal has been handed back would write escapes into the user's shell.
     let live = true;
@@ -61,22 +62,25 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     };
     const view = () => {
         const now = Date.now();
+        const activity = state.command !== undefined && state.open === undefined && state.approval === undefined
+            ? state.command : state.activity ?? state.command;
         return {
             blocks: state.blocks,
             editor: state.editor,
             scroll: state.scroll,
             unseen: state.unseen,
             pal: session.palette,
-            footer: footerInfo(session, workspace),
-            status: state.activity === undefined
+            footer: state.turnFooter === undefined ? footerInfo(session, workspace) : { ...state.turnFooter, workspace },
+            status: activity === undefined
                 ? undefined
-                : activityStatus(state.activity, now),
-            steering: state.steering,
+                : activityStatus(activity, now),
+            turnActive: state.activity !== undefined,
+            steering: state.command === undefined ? state.steering : undefined,
             feedback: state.feedback,
             readiness: turnBlocker(session),
             now,
             reducedMotion: session.config.reducedMotion,
-            modal: overlay.shown(state.open),
+            modal: overlay.shown(state.approval ?? state.open),
             menu: completionOptions(state.completing),
             menuIndex: state.completing?.index,
         };
@@ -143,8 +147,8 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         if (state.follow)
             state.unseen = 0;
     };
-    const replaceTranscript = () => {
-        state.blocks.splice(0, state.blocks.length, ...session.conversation.transcript);
+    const replaceTranscript = (blocks = session.conversation.transcript) => {
+        state.blocks.splice(0, state.blocks.length, ...blocks);
         state.scroll = 0;
         state.follow = true;
         state.unseen = 0;
@@ -158,6 +162,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             return;
         live = false;
         safely(stopInput);
+        safely(stopOutput);
         safely(stopResize);
         safely(stopShutdown);
         if (activityTimer !== undefined)
@@ -183,35 +188,42 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     function fail(error) {
         failure ??= { error };
         state.open = overlay.cancel(state.open);
+        state.approval = overlay.cancel(state.approval);
         state.activity?.control.abort(error);
+        state.command?.control.abort(error);
         quit();
     }
     function track(work) {
         const tracked = work
             .catch((error) => fail(error))
             .finally(() => {
-            if (activeWorkflow === tracked)
-                activeWorkflow = undefined;
+            activeWorkflows.delete(tracked);
         });
-        activeWorkflow = tracked;
+        activeWorkflows.add(tracked);
         return tracked;
     }
     function requestQuit(reason = new Error("interrupted")) {
         state.open = overlay.cancel(state.open);
-        const activity = state.activity;
-        if (activity === undefined) {
+        state.approval = overlay.cancel(state.approval);
+        if (state.activity === undefined && state.command === undefined) {
             quit();
             return;
         }
         state.closeWhenIdle = true;
-        activity.control.abort(reason);
+        state.activity?.control.abort(reason);
+        state.command?.control.abort(reason);
     }
     function startActivity(kind, label) {
-        if (state.activity !== undefined)
+        if (state.closeWhenIdle)
+            return undefined;
+        if (state.command !== undefined || (kind === "turn" && state.activity !== undefined))
             return undefined;
         const activity = begin(kind, label);
-        state.activity = activity;
-        activityTimer = setInterval(() => guard(() => {
+        if (kind === "turn")
+            state.activity = activity;
+        else
+            state.command = activity;
+        activityTimer ??= setInterval(() => guard(() => {
             let activeTool;
             for (let index = state.blocks.length - 1; index >= 0; index--) {
                 const block = state.blocks[index];
@@ -226,14 +238,23 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         return activity;
     }
     function finishActivity(activity) {
-        if (state.activity !== activity)
+        if (state.activity === activity) {
+            state.activity = undefined;
+            state.turnFooter = undefined;
+            state.approval = overlay.cancel(state.approval);
+        }
+        else if (state.command === activity) {
+            state.command = undefined;
+            state.open = overlay.cancel(state.open);
+        }
+        else
             return;
-        if (activityTimer !== undefined)
+        const idle = state.activity === undefined && state.command === undefined;
+        if (idle && activityTimer !== undefined) {
             clearInterval(activityTimer);
-        activityTimer = undefined;
-        state.activity = undefined;
-        state.open = overlay.cancel(state.open);
-        if (state.closeWhenIdle)
+            activityTimer = undefined;
+        }
+        if (state.closeWhenIdle && idle)
             quit();
         else
             render();
@@ -273,9 +294,6 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         invalidate: () => paint.invalidate(),
         transcriptChanged: (block) => transcript.invalidate(block),
     });
-    const resumeAtLaunch = session.resume === undefined
-        ? undefined
-        : track(openResumedSession(session.resume));
     async function openResumedSession(launch) {
         while (live) {
             const index = await new Promise((resolve) => {
@@ -314,6 +332,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         shutdownSignal?.addEventListener("abort", onShutdown, { once: true });
         stopShutdown = () => shutdownSignal?.removeEventListener("abort", onShutdown);
         terminal.enter(session.config.reducedMotion);
+        stopOutput = paint.onReady?.(() => guard(() => render())) ?? (() => { });
         stopResize = terminal.onResize(() => guard(() => {
             paint.invalidate();
             render();
@@ -339,6 +358,9 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             }), ESCAPE_MS);
             render();
         }));
+        const resumeAtLaunch = session.resume === undefined
+            ? undefined
+            : track(openResumedSession(session.resume));
         draw();
         if (resumeAtLaunch !== undefined)
             await Promise.race([resumeAtLaunch, done]);
@@ -347,10 +369,15 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         if (failure !== undefined)
             throw failure.error;
     }
+    catch (error) {
+        // Startup failures must settle pending menus before teardown waits for work.
+        fail(error);
+        throw error;
+    }
     finally {
         try {
             quit();
-            await activeWorkflow;
+            await Promise.allSettled([...activeWorkflows]);
         }
         finally {
             await session.persistence?.close();

package/dist/tui/approve.js

@@ -16,10 +16,9 @@ export { scopeFor };
 export function promptFor(call, target, pal) {
     const scope = scopeFor(call);
     const options = [
-        { label: "Yes, once", hint: "y", key: "y", description: "Approve only this call. Ask again next time." },
-        { label: `Yes, ${scopeNoun(scope)} for the session`, hint: "a", key: "a",
-            description: `Reuse approval for ${scopeNoun(scope)} in this session.` },
-        { label: "No, and say why", hint: "n", key: "n", description: "Do not run this call. Return feedback to the model." },
+        { label: "Yes, once", hint: "y", key: "y" },
+        { label: `Yes, ${scopeNoun(scope)} for the session`, hint: "a", key: "a" },
+        { label: "No, and say why", hint: "n", key: "n" },
     ];
     return {
         title: [{ text: question(call.name), fg: pal.ink.attention, bold: true }],

package/dist/tui/blocks.js

@@ -2,24 +2,22 @@
 import { renderAnswer, renderReasoning, renderUser } from "./components/messages.js";
 import { renderNotice } from "./components/misc.js";
 import { renderTool } from "./components/tool.js";
-import { insetTranscript, modelTranscriptWidth } from "./transcript-grammar.js";
 export function render(block, width, pal, context = {}) {
-    const inner = modelTranscriptWidth(width);
     switch (block.kind) {
         case "user":
             return renderUser(block, width, pal);
         case "answer":
-            return insetTranscript(renderAnswer(block, inner, pal));
+            return renderAnswer(block, width, pal);
         case "reasoning":
-            return insetTranscript(renderReasoning(block, inner, pal, {
+            return renderReasoning(block, width, pal, {
                 continues: context.previous?.kind === "reasoning",
-            }));
+            });
         case "tool":
-            return insetTranscript(renderTool(block, inner, pal, {
+            return renderTool(block, width, pal, {
                 continues: context.previous?.kind === "reasoning",
                 now: context.now,
                 reducedMotion: context.reducedMotion,
-            }));
+            });
         case "notice":
             return renderNotice(block, width, pal);
     }

package/dist/tui/command-workflow.js

@@ -1,5 +1,5 @@
 // Foreground slash-command interactions and their session updates.
-import { handleCommand } from "../commands.js";
+import { commandNeedsIdle, handleCommand } from "../commands.js";
 import { compactSession } from "../context/manual.js";
 import { resetRequestIdentity } from "../request-identity.js";
 import { updateSettings } from "../settings.js";
@@ -7,13 +7,16 @@ import { selectTimeline } from "../timeline.js";
 import { saveTranscript } from "../transcript-export.js";
 import { transition } from "./activity.js";
 import { cancel as cancelOpen } from "./overlay.js";
-export function commandWorkflow(options, resetCompaction) {
+export function commandWorkflow(options, resetCompaction, resetInput) {
     const { session, state, permissions, feedback } = options;
     const choose = (picker) => new Promise((resolve) => {
+        state.command?.control.signal.throwIfAborted();
         state.open = { picker, settle: resolve };
         options.render();
     });
     async function command(text) {
+        if (state.activity !== undefined && commandNeedsIdle(text))
+            return;
         const activity = options.startActivity("command", `Running ${text.split(/\s+/)[0]}`);
         if (activity === undefined)
             return;
@@ -23,6 +26,7 @@ export function commandWorkflow(options, resetCompaction) {
                 emit: options.commandNotice,
                 signal: activity.control.signal,
                 showHelp: () => new Promise((resolve) => {
+                    activity.control.signal.throwIfAborted();
                     state.open = { help: true, settle: resolve };
                     options.render();
                 }),
@@ -32,6 +36,7 @@ export function commandWorkflow(options, resetCompaction) {
                     options.render();
                 },
                 type: (field) => new Promise((resolve) => {
+                    activity.control.signal.throwIfAborted();
                     state.open = { field, settle: resolve };
                     options.render();
                 }),
@@ -43,17 +48,13 @@ export function commandWorkflow(options, resetCompaction) {
                     await session.persistence?.reset();
                     resetRequestIdentity(session);
                     resetCompaction();
-                    state.blocks.splice(0);
                     state.past.length = 0;
                     permissions.reset();
-                    state.scroll = 0;
-                    state.follow = true;
-                    state.unseen = 0;
-                    state.lastMaxScroll = 0;
+                    options.replaceTranscript([]);
                     state.committedNodeId = 0;
                 },
                 permissions,
-                exportTranscript: () => saveTranscript(options.transcriptRoot, state.blocks),
+                exportTranscript: () => saveTranscript(options.transcriptRoot, structuredClone(state.blocks)),
                 saveSettings: async (patch) => {
                     await updateSettings(patch);
                 },
@@ -62,6 +63,7 @@ export function commandWorkflow(options, resetCompaction) {
                     const selected = await selectTimeline(session, choose);
                     if (!selected)
                         return "unchanged";
+                    resetCompaction();
                     options.replaceTranscript();
                     return session.conversation.activeNodeId === state.committedNodeId
                         ? "unchanged"
@@ -99,6 +101,10 @@ export function commandWorkflow(options, resetCompaction) {
             }
         }
         finally {
+            // Access can change while a turn is running. Discard even an observation
+            // from an in-flight response that used the previous connection.
+            if (text.trim().split(/\s+/)[0] === "/providers")
+                resetInput();
             options.finishActivity(activity);
         }
     }

package/dist/tui/components/command-menu.js

@@ -5,7 +5,7 @@ export function renderCommandMenu(commands, selected, width, pal) {
     if (commands.length === 0)
         return { rows: [], right: "" };
     const menu = renderMenu(commands.map((command, index) => ({
-        label: `/${command.name}`, description: command.blurb, selected: selectedIndex === index,
+        label: `/${command.name}`, selected: selectedIndex === index,
     })), width, pal, { maxRows: MAX_ROWS + 2, visible: MAX_ROWS });
     return {
         rows: menu.rows,

package/dist/tui/components/menu.js

@@ -1,4 +1,4 @@
-// Ribbon rows and a stable detail area shared by completion and selectors.
+// Ribbon rows and bounded overflow recovery shared by completion and selectors.
 import { row } from "../../ui/render.js";
 import { terminalText } from "../../ui/terminal-text.js";
 import { elide, textWidth, wrapText } from "../../ui/width.js";
@@ -16,10 +16,10 @@ export function renderMenu(entries, width, pal, options) {
     const room = Math.max(0, options.maxRows);
     if (room === 0)
         return { rows: [], first: 0, last: 0 };
-    const detailLimit = Math.min(2, room - 1);
+    const detailLimit = options.overflow === "truncate" ? 0 : Math.min(2, room - 1);
     let detailRows = 0;
-    // Measure every possible selection to keep the dock stable without reserving
-    // a second row when all details fit on one line at this width.
+    // Measure every possible selection so revealing clipped identity and values
+    // does not move the dock when the selected row changes.
     for (const entry of entries) {
         detailRows = Math.max(detailRows, detailLines(entry, width, detailLimit).length);
         if (detailRows === detailLimit)
@@ -47,11 +47,8 @@ export function renderMenu(entries, width, pal, options) {
 function detailLines(entry, width, maxRows) {
     if (entry === undefined || maxRows <= 0)
         return [];
-    // Complete identity and values take priority over explanatory copy.
     const room = Math.max(1, width - 2);
-    const lines = menuText(clippedParts(entry, width).join(" · "), room, maxRows);
-    lines.push(...menuText(entry.description ?? "", room, maxRows - lines.length));
-    return lines;
+    return menuText(clippedParts(entry, width).join(" · "), room, maxRows);
 }
 export function menuWindow(length, selected, visible) {
     const count = Math.max(0, length);
@@ -68,11 +65,22 @@ export function menuText(text, width, maxRows) {
     return lines.slice(0, maxRows).map((line, index) => index === maxRows - 1 && lines.length > maxRows ? elide(line + " …", width) : line);
 }
 function fullSummary(entry) {
-    const value = entry.value === undefined ? "" : entry.selected && entry.adjustable ? "‹ " + entry.value + " ›" : entry.value;
-    return [entry.hint, value].filter(Boolean).join(" · ");
+    return [entry.hint, displayedValue(entry)].filter(Boolean).join(" · ");
 }
 function summary(entry, width) {
-    return elide(terminalText(fullSummary(entry)), Math.max(1, Math.floor(width * 0.42)));
+    const room = Math.max(1, Math.floor(width * 0.42));
+    const value = terminalText(displayedValue(entry));
+    const hint = terminalText(entry.hint ?? "");
+    if (value === "" || hint === "")
+        return elide(value || hint, room);
+    // Keep the current policy visible even when its remembered-scope hint is long.
+    const hintRoom = room - textWidth(value) - 3;
+    return hintRoom <= 0 ? elide(value, room) : `${elide(hint, hintRoom)} · ${value}`;
+}
+function displayedValue(entry) {
+    if (entry.value === undefined)
+        return "";
+    return entry.selected && entry.adjustable ? `‹ ${entry.value} ›` : entry.value;
 }
 function clippedParts(entry, width) {
     // Reserve the stepper's width for every peer, so moving selection cannot

package/dist/tui/components/status.js

@@ -19,7 +19,7 @@ export function renderStatus(info, pal) {
             ];
         return withUnseen([
             ...active,
-            { text: " · esc to interrupt", fg: pal.ink.dim, optional: true },
+            ...(info.interruptible === false ? [] : [{ text: " · esc to interrupt", fg: pal.ink.dim, optional: true }]),
         ], info.unseen, pal);
     }
     if (info.feedback !== undefined) {

package/dist/tui/frame.js

@@ -5,11 +5,15 @@
 // writing it: a full repaint at streaming speed flickers and floods the pipe.
 // So the painter keeps the last frame and emits the difference.
 import { CSI } from "../ui/render.js";
-import { CURSOR, SYNC, write } from "./screen.js";
-export function painter() {
+import { CURSOR, SYNC, write, outputReady, onDrain } from "./screen.js";
+export function painter(output = { write, ready: outputReady, onReady: onDrain }) {
     let previous = [];
     return {
         paint(rows, cursor) {
+            // The last accepted frame remains the diff base. The host redraws current
+            // state on drain, so stale intermediate frames never form another queue.
+            if (!output.ready())
+                return;
             let out = SYNC.begin + CURSOR.hide;
             const height = Math.max(rows.length, previous.length);
             for (let i = 0; i < height; i++) {
@@ -24,10 +28,11 @@ export function painter() {
             previous = rows.slice();
             // One write, so a terminal that ignores the synchronization hint still
             // gets the frame as a single arrival rather than a row at a time.
-            write(out + SYNC.end);
+            output.write(out + SYNC.end);
         },
         invalidate() {
             previous = [];
         },
+        onReady: (handler) => output.onReady(handler),
     };
 }

package/dist/tui/help.js

@@ -3,6 +3,7 @@ import { row } from "../ui/render.js";
 import { textWidth } from "../ui/width.js";
 const CONTROL_WIDTH = 18;
 const CONTROLS = [
+    { key: "/", description: "open commands, also while working" },
     { key: "up / down", description: "move through menus or history" },
     { key: "left / right", description: "move cursor or change a value" },
     { key: "ctrl+left / right", description: "move cursor by word" },
@@ -10,7 +11,7 @@ const CONTROLS = [
     { key: "enter / tab", description: "select, send/steer · complete" },
     { key: "alt+enter", description: "insert a new line" },
     { key: "esc", description: "close UI or interrupt work" },
-    { key: "ctrl+c", description: "interrupt work or exit" },
+    { key: "ctrl+c", description: "cancel menu, interrupt work or exit" },
     { key: "ctrl+o", description: "expand/collapse reasoning or evidence" },
     { key: "wheel / pgup/dn", description: "scroll the transcript" },
     { key: "ctrl+l", description: "redraw the screen" },

package/dist/tui/picker-layout.js

@@ -12,7 +12,11 @@ export function layoutPicker(picker, found, width, pal, maxRows) {
     contextRoom -= target.length;
     const note = menuText(picker.description ?? picker.footer ?? "", width, Math.min(2, contextRoom));
     const prefix = titleRows + target.length + note.length + queryRows;
-    const menu = renderMenu(found.map(({ option, index }) => ({ ...option, selected: index === picker.index })), width, pal, { maxRows: budget - prefix - controlRows, visible: picker.visible ?? 6 });
+    const menu = renderMenu(found.map(({ option, index }) => ({ ...option, selected: index === picker.index })), width, pal, {
+        maxRows: budget - prefix - controlRows,
+        visible: picker.visible ?? 6,
+        overflow: picker.overflow,
+    });
     const progress = found.length > menu.last - menu.first || picker.searchable
         ? `${found.length === 0 ? "0" : `${menu.first + 1}–${menu.last}`} / ${found.length}` +
             (found.length === picker.options.length ? "" : ` · ${picker.options.length} total`)

package/dist/tui/screen.js

@@ -50,6 +50,13 @@ export function size() {
 export function write(text) {
     process.stdout.write(text);
 }
+export function outputReady() {
+    return !process.stdout.writableNeedDrain;
+}
+export function onDrain(handler) {
+    process.stdout.on("drain", handler);
+    return () => { process.stdout.off("drain", handler); };
+}
 export function enter(reducedMotion = false) {
     if (active)
         return;

package/dist/tui/session-view.js

@@ -14,7 +14,6 @@ export function controllerOptions(session, contextPolicy, tools = session.tools,
         contextPolicy,
         effort: session.config.effort,
         requestIdentity: requestIdentityForSession(session),
-        maxModelRequests: session.config.maxModelRequests,
         toolContext: { root: session.config.root },
         ...(steering === undefined ? {} : { steering }),
     };

package/dist/tui/transcript-grammar.js

@@ -1,12 +1,5 @@
-// Shared transcript inset and a bounded measure for model prose and tool records.
+// Content padding for user surfaces, notices, and tool evidence markers.
 const GUTTER = 2;
-const MODEL_MEASURE = 86;
-export function modelTranscriptWidth(width) {
-    return Math.max(8, Math.min(width - GUTTER * 2, MODEL_MEASURE));
-}
-export function insetTranscript(rows) {
-    return rows.map((line) => line === "" ? "" : `${" ".repeat(GUTTER)}${line}`);
-}
 export function transcriptGutter(_width) {
     return GUTTER;
 }

package/dist/tui/transcript-view.js

@@ -17,6 +17,10 @@ export function transcriptRenderer(draw = render, clock = Date.now) {
     const activeTools = new Set();
     return {
         viewport(blocks, width, height, scroll, palette, state = {}) {
+            if (blocks.length === 0 && layouts.some((layout) => layout.entries.length > 0)) {
+                layouts = [];
+                activeTools.clear();
+            }
             const layout = layoutFor(blocks, width, palette);
             state = { ...state, now: state.now ?? clock() };
             if (scroll === 0)