tokenmaw 0.4.0 → 0.4.1

package/README.md

@@ -31,7 +31,6 @@ Inside the TUI:
 - `F2` (or `/select`) optionally releases app mouse capture for the terminal's native selection. `F2` again restores app clicks, drag selection and wheel scrolling. `Ctrl+Y` and `PageUp` / `PageDown` also work without the mouse.
 - `Ctrl+X` or `/cancel` stops the current session's agents; send another message to continue.
 - `/compact` summarizes and archives older context of the main agent; an optional argument focuses the digest (e.g. `/compact file changes and pending work`).
-- `/aside <note>` queues a side note without starting a turn; it folds into the next message you send and is announced in the conversation stream.
 - `/btw <question>` opens a side conversation forked from the current session (full context included) and sends your question there. `/back` or `Ctrl+C` returns to the main conversation; side sessions are marked `[side]` in the status bar and the `/sessions` list.
 - `/fork` copies the current conversation into a new saved session. `/sessions` lists both; the original stays untouched.
 - `/goal <text>` sets a standing goal for the session: it is injected into every agent's prompt until cleared, shows in the status bar, and survives across sessions. `/goal clear` removes it.

package/dist/cli.js

@@ -9,6 +9,7 @@ import { AgentRuntime } from './runtime/agent-runtime.js';
 import { WorktreeManager } from './runtime/worktree.js';
 import { registerWorkspaceInstance } from './runtime/workspace-instances.js';
 import { runFullscreenTui } from './ui/fullscreen-tui.js';
+import { checkForUpdate, formatUpdateNotice, offerSelfUpdate } from './update-check.js';
 import { CODER_VERSION } from './version.js';
 async function main() {
     const program = new Command();
@@ -16,6 +17,18 @@ async function main() {
     program.allowExcessArguments(false).showSuggestionAfterError();
     program.option('--model <name>', 'default model name or .agentrc alias');
     program.option('--worktree [name]', 'start inside an isolated managed git worktree (.coder/worktrees/<name>)');
+    // Query npm for a newer release while the command runs; afterwards a y/N
+    // prompt offers a self-update (China mirror first) in interactive sessions.
+    const updateNotice = checkForUpdate().catch(() => null);
+    const showUpdateNotice = async () => {
+        const result = await updateNotice;
+        if (!result?.updateAvailable || !process.stderr.isTTY)
+            return;
+        process.stderr.write(`\n${formatUpdateNotice(result)}\n`);
+        const message = await offerSelfUpdate(result).catch(() => null);
+        if (message)
+            process.stderr.write(`\n${message}\n`);
+    };
     let config = await loadConfig();
     const selectedFromCli = () => program.opts().model;
     setToolPolicy(defaultPolicy(config.policyLevel ?? 'moderate', process.cwd()));
@@ -70,6 +83,7 @@ async function main() {
             const response = session.messages.slice(submitted + 1).reverse().find((message) => message.role === 'assistant');
             if (response)
                 process.stdout.write(`${response.content}\n`);
+            await showUpdateNotice();
         }
         finally {
             await runtime.shutdown();
@@ -83,6 +97,7 @@ async function main() {
         for (const spec of runtime.listAgentSpecs()) {
             process.stdout.write(`${spec.id}\t${spec.scope}\t${spec.model ?? 'inherit'}\t${spec.description}\n`);
         }
+        await showUpdateNotice();
         await runtime.shutdown();
     });
     program.action(async () => {
@@ -115,6 +130,7 @@ async function main() {
             },
             configManager,
         });
+        await showUpdateNotice();
         await runtime.shutdown();
     });
     const shutdown = async () => {

package/dist/runtime/agent-runtime.js

@@ -19,9 +19,6 @@ function mergeUsage(previous, next) {
     }
     return result;
 }
-function asidePrefix() {
-    return 'Additional context noted earlier (aside):';
-}
 function mergeAgentUsage(previous, usage, firstTokenMs, durationMs, requests = 1) {
     const merged = mergeUsage(previous, usage ?? {});
     return { ...merged, requests: (previous?.requests ?? 0) + requests, turns: (previous?.turns ?? 0) + 1, firstTokenMs, lastTurnMs: durationMs };
@@ -424,7 +421,6 @@ export class AgentRuntime {
         const session = this.sessions.get(sessionId);
         session.messages = [];
         session.timeline = [];
-        session.pendingAsides = [];
         session.goal = undefined;
         session.updatedAt = now();
         const main = this.instances.get(session.mainInstanceId);
@@ -461,24 +457,6 @@ export class AgentRuntime {
         await this.persistSession(sessionId);
         this.notifyIdleWaiters();
     }
-    /** Queue an aside (/aside): folds into the next submitted message without starting a turn. */
-    async addAside(sessionId, content) {
-        const text = content.trim();
-        if (!text)
-            throw new Error('Aside cannot be empty');
-        await this.requireSessionWrite(sessionId);
-        const session = this.sessions.get(sessionId);
-        const hadAsides = (session.pendingAsides?.length ?? 0) > 0;
-        (session.pendingAsides ??= []).push(text);
-        session.updatedAt = now();
-        await this.persistSession(sessionId);
-        this.emit({ type: 'system_message', sessionId, message: { messageId: randomUUID(), role: 'system', content: hadAsides
-                    ? `Noted — another aside is already queued; both will be included with your next message.`
-                    : `Noted. This will be included with your next message without starting a turn.`, createdAt: now() } });
-        return { queued: true, detail: hadAsides
-                ? 'Queued behind one earlier aside; both will be included with the next message.'
-                : 'Queued. It will be included with the next message without starting a turn.' };
-    }
     /** Set or clear the standing session goal (/goal). Injected into every agent's prompt until cleared. */
     async setSessionGoal(sessionId, goal) {
         const text = goal.trim();
@@ -527,15 +505,7 @@ export class AgentRuntime {
         const session = this.sessions.get(sessionId);
         const main = this.instances.get(session.mainInstanceId);
         const turnId = randomUUID();
-        const queuedAsides = session.pendingAsides ?? [];
-        session.pendingAsides = [];
-        const composed = queuedAsides.length
-            ? `${text}
-
-${asidePrefix()}
-${queuedAsides.map((aside, index) => `${index + 1}. ${aside}`).join('\n')}`
-            : text;
-        const message = { messageId: randomUUID(), role: 'user', content: composed, createdAt: now(), turnId };
+        const message = { messageId: randomUUID(), role: 'user', content: text, createdAt: now(), turnId };
         session.messages.push(message);
         session.updatedAt = message.createdAt;
         if (main.status === 'running' || main.status === 'waiting') {
@@ -543,20 +513,9 @@ ${queuedAsides.map((aside, index) => `${index + 1}. ${aside}`).join('\n')}`
         }
         if (main.status === 'cancelled')
             main.status = 'idle';
-        // The model must see the folded asides, so deliver the composed message.
-        // The TUI renders the asides as separate system entries from the emitted
-        // system_message events above, while this user message keeps them inline.
-        this.deliver(main, composed, undefined, turnId);
+        this.deliver(main, text, undefined, turnId);
         await this.persistSession(sessionId);
         this.emit({ type: 'user_message', sessionId, message: { ...message } });
-        if (queuedAsides.length) {
-            // Timeline-only notices; the user message itself already carries the
-            // asides inline for the model.
-            this.emit({ type: 'system_message', sessionId, message: { messageId: randomUUID(), role: 'system', content: `Aside${queuedAsides.length > 1 ? 's' : ''} included with your message:`, createdAt: now() } });
-            for (const aside of queuedAsides) {
-                this.emit({ type: 'system_message', sessionId, message: { messageId: randomUUID(), role: 'system', content: `· ${aside}`, createdAt: now() } });
-            }
-        }
         this.enqueue(main.instanceId);
         return turnId;
     }

package/dist/runtime/agent-store.js

@@ -26,6 +26,33 @@ async function replaceFile(temp, target) {
     }
     throw lastError;
 }
+/** First user message, flattened to one line and clipped for session-picker previews. */
+function firstUserPreview(messages) {
+    const first = messages.find((message) => message.role === 'user');
+    const text = first?.content.replace(/\s+/g, ' ').trim();
+    if (!text)
+        return undefined;
+    return text.length > 60 ? `${text.slice(0, 59)}…` : text;
+}
+/** Coarse relative timestamp for session pickers: just now / Nm ago / Nh ago / Nd ago / date. */
+function relativeTime(iso) {
+    const then = Date.parse(iso);
+    if (!Number.isFinite(then))
+        return iso;
+    const seconds = Math.max(0, Math.round((Date.now() - then) / 1000));
+    if (seconds < 60)
+        return 'just now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `${days}d ago`;
+    return new Date(then).toISOString().slice(0, 10);
+}
 export class AgentRuntimeStore {
     dir;
     constructor(baseDir = process.env.CODER_DATA_HOME?.trim() || resolve(homedir(), '.coder')) {
@@ -117,6 +144,8 @@ export class AgentRuntimeStore {
                     sessionId: parsed.session.sessionId,
                     messages: parsed.session.messages.length,
                     updatedAt: parsed.session.updatedAt,
+                    preview: firstUserPreview(parsed.session.messages),
+                    relativeUpdatedAt: relativeTime(parsed.session.updatedAt),
                 });
             }
             catch { /* skip invalid snapshots */ }

package/dist/ui/commands.js

@@ -1,7 +1,6 @@
 export const SLASH_COMMANDS = [
     { name: '/provider', description: 'Manage providers' },
     { name: '/model', description: 'Choose a model' },
-    { name: '/aside', description: 'Queue an aside to fold into the next message' },
     { name: '/btw', description: 'Ask in a side conversation forked from this one' },
     { name: '/back', description: 'Return from a side conversation to the parent session' },
     { name: '/fork', description: 'Copy this conversation into a new saved session' },

package/dist/ui/fullscreen-tui.js

@@ -75,10 +75,39 @@ export async function runFullscreenTui(runtime, options) {
     let welcomeTimer;
     let welcomeFrame = 0;
     let welcomeStartedAt = 0;
-    // Terminal focus lifecycle (DECSET 1004): while the window is unfocused the
-    // periodic repaints pause — otherwise 20fps of screen updates flood the PTY
-    // and the terminal replays the backlog the moment the window regains focus.
+    // Set between a committed theme change and the next renderConversation():
+    // the welcome clock is then rebased so the mark replays its one-second
+    // opening act under the new palette. Preview highlights and Esc/✕ rollbacks
+    // restore the previous palette without a change and never set this.
+    let themeIntroReplay = false;
+    // Terminal focus lifecycle (DECSET 1004). While the window is unfocused the
+    // app must be frugal with PTY writes: a refocusing terminal replays the
+    // bytes it did not render, and a backlog of pending updates is what users
+    // see as the "crazy scrolling" burst on focus regain. Two rules:
+    //  - Decorative animation (spinner glyphs, welcome shine, shell ellipsis) is
+    //    suppressed outright while blurred: it is invisible in an unfocused
+    //    window, and every frame is a multi-row byte burst.
+    //  - Streaming text keeps flowing on a ~400ms heartbeat so a background
+    //    window still shows the transcript growing. Event-driven repaints (tool
+    //    calls, finished messages) are never throttled.
+    // Frames skipped for blur set `blurredStale`; focus regain then issues
+    // exactly one full redraw (like a resize) instead of replaying a backlog.
     let windowFocused = true;
+    let blurredStale = false;
+    const BLURRED_STREAM_MS = 400;
+    let lastStreamFrame = 0;
+    // Heartbeat gate for the stream repaint timer: true at most once every
+    // BLURRED_STREAM_MS while unfocused, always while focused.
+    const throttledFrame = () => {
+        if (windowFocused)
+            return true;
+        const now = Date.now();
+        if (now - lastStreamFrame < BLURRED_STREAM_MS)
+            return false;
+        lastStreamFrame = now;
+        blurredStale = true;
+        return true;
+    };
     let streamTimer;
     let shellAbort;
     let shellAnimationFrame = 0;
@@ -397,6 +426,17 @@ export async function runFullscreenTui(runtime, options) {
             renderComposerFrame();
             return;
         }
+        // A bare Escape stops the running turn, same as Ctrl+X / `/cancel`. The
+        // completion menu and the screen-level bindings keep their Esc semantics
+        // (dismiss suggestions, leave a focused pane), so stop only when nothing
+        // else claims the key and something is actually running — a stray press
+        // while idle stays a no-op instead of wiping queued work.
+        if (key.name === 'escape') {
+            const active = instances().some((item) => ['running', 'waiting', 'queued'].includes(item.status));
+            if (active)
+                void command('/cancel').catch((error) => { notice = String(error); refresh(); });
+            return;
+        }
         if (matches.length && (key.name === 'tab' || ((!key.meta) && (key.name === 'enter' || key.name === 'return')))) {
             setComposerValue(matches[completionIndex].name + (key.name === 'tab' ? ' ' : ''));
             if (key.name === 'tab')
@@ -463,7 +503,12 @@ export async function runFullscreenTui(runtime, options) {
                 stopSpinner();
                 return;
             }
-            if (nativeSelection || hasSelection() || !windowFocused)
+            // Decoration only: frozen while blurred. Skipping a frame leaves the
+            // screen untouched and still valid, so it must not mark the frame stale
+            // — a quiet refocus after decoration-only blur is the whole point.
+            if (!windowFocused)
+                return;
+            if (nativeSelection || hasSelection())
                 return;
             spinnerFrame += 1;
             conversationDirty = true;
@@ -496,7 +541,11 @@ export async function runFullscreenTui(runtime, options) {
                 return;
             }
             // Native text selection owns the screen; never dirty or repaint under it.
-            if (nativeSelection || hasSelection() || !windowFocused)
+            if (nativeSelection || hasSelection())
+                return;
+            // Content heartbeat: while blurred, repaint live text at most once per
+            // BLURRED_STREAM_MS so the background window keeps up without flooding.
+            if (!throttledFrame())
                 return;
             const runningEntry = [...(session.timeline ?? [])].find((entry) => entry.status === 'running' && entry.kind !== 'tool' && entry.kind !== 'shell');
             if (streams.size > 0 || runningEntry) {
@@ -511,6 +560,10 @@ export async function runFullscreenTui(runtime, options) {
                 }
             }
             else {
+                // The waiting ellipsis is decoration: frozen while blurred. A skipped
+                // frame leaves the screen untouched, so it must not mark it stale.
+                if (!windowFocused)
+                    return;
                 waitingFrame = (waitingFrame + 1) % 24;
                 conversationDirty = true;
             }
@@ -851,16 +904,30 @@ export async function runFullscreenTui(runtime, options) {
         const markdownCols = Math.max(10, Math.min(120, metrics.conversationWidth - metrics.horizontalPadding * 2 - 2));
         thinkingBlockLines.clear();
         // The welcome screen yields to any conversation content — messages,
-        // streaming output, thinking, or transcript entries like shell runs and
-        // queued asides.
+        // streaming output, thinking, or transcript entries like shell runs.
         const welcomeVisible = !session.messages.length && !streams.size && thinkingBlocks.size === 0 && !(session.timeline?.length);
         if (welcomeVisible) {
+            // A committed theme change rebases the welcome clock so the mark replays
+            // its opening act under the new palette; preview highlights and Esc/✕
+            // rollbacks never set the flag, so they only recolor in place.
+            if (themeIntroReplay) {
+                themeIntroReplay = false;
+                // Rebase the welcome clock: the next timer tick derives frame 1 from
+                // this moment, and the loop's own shine phase restarts seamlessly
+                // because every intro lands on the settled frame-20 state.
+                welcomeStartedAt = performance.now();
+                welcomeFrame = 0;
+            }
             for (const line of renderWelcome(Number(conversation.width) - Number(conversation.iwidth) - 1, Number(conversation.height) - Number(conversation.iheight), Number(screen.height), welcomeFrame))
                 pushConversationLine(line);
             if (!welcomeTimer) {
                 welcomeStartedAt = performance.now();
                 welcomeTimer = setInterval(() => {
-                    if (!windowFocused || nativeSelection || hasSelection() || screen.focused !== composer)
+                    // Decoration only: frozen while blurred. A skipped frame leaves the
+                    // screen untouched, so it must not mark the frame stale.
+                    if (!windowFocused)
+                        return;
+                    if (nativeSelection || hasSelection() || screen.focused !== composer)
                         return;
                     // The frame derives from the monotonic clock instead of a counter:
                     // after sleep or background suspension the animation lands on the
@@ -874,9 +941,14 @@ export async function runFullscreenTui(runtime, options) {
                 welcomeTimer.unref?.();
             }
         }
-        else if (welcomeTimer) {
-            clearInterval(welcomeTimer);
-            welcomeTimer = undefined;
+        else {
+            // The welcome screen is hidden: a pending replay would otherwise fire
+            // stale months later (e.g. when /clear finally reveals the banner).
+            themeIntroReplay = false;
+            if (welcomeTimer) {
+                clearInterval(welcomeTimer);
+                welcomeTimer = undefined;
+            }
         }
         const renderedBlocks = new Set();
         if (session.timeline) {
@@ -1169,19 +1241,23 @@ export async function runFullscreenTui(runtime, options) {
     };
     const stickyHeaderLine = (block) => {
         const toggle = block.expanded ? '▼' : '▶';
-        const icon = block.status === 'active' ? spinnerGlyph(spinnerFrame) : toggle;
+        // Completed blocks reuse the toggle glyph as their icon; keep only one so
+        // the pinned header never shows "▼ ▼".
+        const icon = block.status === 'active' ? spinnerGlyph(spinnerFrame) : '';
         const color = block.status === 'active' ? COLOR().accent : COLOR().muted;
         const label = block.status === 'active'
             ? (block.thinking || block.content.length === 0 ? 'Thinking' : 'Working')
             : (block.thinking ? 'Thought' : 'Activity');
         const duration = elapsedLabel(block.startedAt, block.finishedAt);
         const durationText = duration ? `  ${duration}` : '';
-        return `{${color}-fg}${toggle} ${icon} ${label}${durationText}{/${color}-fg}`;
+        return `{${color}-fg}${toggle}${icon ? ` ${icon}` : ''} ${label}${durationText}{/${color}-fg}`;
     };
     const renderThinkingBlock = (block) => {
         const headerLine = lineCursor;
         const toggle = block.expanded ? '▼' : '▶';
-        const icon = block.status === 'active' ? spinnerGlyph(spinnerFrame) : toggle;
+        // Completed blocks reuse the toggle glyph as their icon; keep only one so
+        // the header never shows "▼ ▼" or "▶ ▶".
+        const icon = block.status === 'active' ? spinnerGlyph(spinnerFrame) : '';
         const color = block.status === 'active' ? COLOR().accent : COLOR().muted;
         // An active block with nothing to show yet is the pre-first-token state:
         // the model is reasoning, so label it Thinking, not Working.
@@ -1195,7 +1271,7 @@ export async function runFullscreenTui(runtime, options) {
             pushConversationLine(`{${color}-fg}${toggle} ${icon}{/${color}-fg} ${scanLabel}{${COLOR().subtle}-fg}${durationText}{/${COLOR().subtle}-fg}`);
         }
         else {
-            pushConversationLine(`{${color}-fg}${icon} ${label}${durationText}{/${color}-fg}`);
+            pushConversationLine(`{${color}-fg}${toggle}${icon ? ` ${icon}` : ''} ${label}${durationText}{/${color}-fg}`);
         }
         latestThinkingTurnId = block.turnId;
         if (block.expanded) {
@@ -1307,11 +1383,16 @@ export async function runFullscreenTui(runtime, options) {
             screen.program.showCursor();
         }
     };
-    // Focus regained is treated like a resize: one invalidate + full redraw so
-    // blessed's diff buffers, the viewport, and the overlay scrollbar positions
-    // are all rebuilt from the live state instead of a stale frame.
+    // Focus regained is treated like a resize, and only when the blur window
+    // actually skipped frames: one invalidate + full redraw rebuilds blessed's
+    // diff buffers, the viewport, and the overlay scrollbar positions from the
+    // live state instead of a stale frame. Skipping it when nothing was skipped
+    // keeps short refocuses byte-quiet (no replay burst, no scrolling flash).
     screen.program.on('focus', () => {
         windowFocused = true;
+        if (!blurredStale)
+            return;
+        blurredStale = false;
         requestFullRedraw();
         conversationDirty = true;
         scheduleRefresh();
@@ -1505,7 +1586,10 @@ export async function runFullscreenTui(runtime, options) {
     const openSessions = async () => {
         const sessions = await runtime.listSessions();
         const index = await choose('Sessions', [
-            ...sessions.map((item) => ({ label: item.sessionId, detail: `${item.messages} messages${item.sessionId.startsWith('btw-') ? '  [side]' : ''}` })),
+            ...sessions.map((item) => ({
+                label: oneLine(item.preview, 52) || item.sessionId,
+                detail: `${item.messages} msg · ${item.relativeUpdatedAt ?? ''} · ${item.sessionId}${item.sessionId.startsWith('btw-') ? ' [side]' : ''}`,
+            })),
             { label: 'New session', detail: 'Start a blank conversation' },
         ], { searchable: true });
         if (index < 0)
@@ -1617,8 +1701,16 @@ export async function runFullscreenTui(runtime, options) {
         requestFullRedraw();
         return next;
     };
-    const applyTheme = async (name) => {
+    // Commits a theme choice. `changed` must be decided against the theme the
+    // picker was opened with, not the live one: previewing already swaps the
+    // active palette, so by Enter/click time it equals the chosen name. Any
+    // commit path that actually changes the theme (Enter, mouse click, or a
+    // future caller) replays the welcome logo's opening act under the new
+    // palette; preview highlights and Esc/✕ rollbacks never do.
+    const applyTheme = async (name, changed = activeTuiTheme().name !== name) => {
         const next = applyThemeVisuals(name);
+        if (changed)
+            themeIntroReplay = true;
         notice = `Theme set to ${next.label}`;
         await options.configManager.saveConfig({ ...options.configManager.getConfig(), theme: next.name });
         refresh();
@@ -1643,7 +1735,7 @@ export async function runFullscreenTui(runtime, options) {
             },
         });
         if (index >= 0) {
-            await applyTheme(names[index]);
+            await applyTheme(names[index], names[index] !== original);
         }
         else if (activeTuiTheme().name !== original) {
             // Picker dismissed: roll back to the theme chosen before previewing.
@@ -1693,8 +1785,12 @@ export async function runFullscreenTui(runtime, options) {
                 refresh();
                 break;
             case 'cancel': {
+                // The notice renders in the conversation stream; without flagging the
+                // dirty bit renderConversation() skips the repaint entirely and the
+                // acknowledgement never shows.
                 if (!args[0]) {
                     await runtime.cancelSession(sessionId);
+                    conversationDirty = true;
                     notice = 'Stopped. Send a message to continue.';
                     refresh();
                     break;
@@ -1715,23 +1811,10 @@ export async function runFullscreenTui(runtime, options) {
                 refresh();
                 break;
             }
-            // /aside queues a side note without starting a turn; it folds into the
-            // next submitted message. /btw opens a self-contained side conversation
-            // forked from this one (/back or Ctrl+C returns); /fork copies the whole
-            // conversation into a new saved session. /goal sets a standing directive
-            // shown in the status bar and injected into every agent's prompt until
-            // cleared.
-            case 'aside': {
-                const note = args.join(' ');
-                if (!note) {
-                    notice = 'Usage: /aside <note>';
-                    refresh();
-                    break;
-                }
-                const result = await runtime.addAside(sessionId, note);
-                notice = result.detail;
-                break;
-            }
+            // /btw opens a self-contained side conversation forked from this one
+            // (/back or Ctrl+C returns); /fork copies the whole conversation into a
+            // new saved session. /goal sets a standing directive shown in the status
+            // bar and injected into every agent's prompt until cleared.
             case 'btw': {
                 const question = args.join(' ').trim();
                 if (!question) {
@@ -2109,6 +2192,8 @@ export async function runFullscreenTui(runtime, options) {
                 clearInterval(animation);
                 return;
             }
+            // Decoration only: frozen while blurred. A skipped frame leaves the
+            // screen untouched, so it must not mark the frame stale.
             if (!windowFocused)
                 return;
             shellAnimationFrame += 1;