zames_pro 2.75.5 → 2.76.0

package/dist/net-capture.js

@@ -1,7 +1,7 @@
 import fs from 'fs/promises';
 import os from 'os';
 import path from 'path';
-import { FINISHED_STATUS_RE, RESPONSE_CONTENT_RE } from './deepseek-ui.js';
+import { FINISHED_STATUS_RE } from './deepseek-ui.js';
 // Extraction of the RAW model answer text from DeepSeek's network data.
 //
 // Why: the answer is read from the RENDERED DOM, and DeepSeek's rendering
@@ -160,15 +160,43 @@ export function extractAnswer(body) {
         return sse;
     return extractFromJson(body);
 }
+// The smallest RESPONSE that counts as a REAL answer rather than a truncated
+// head. A live hang: DeepSeek began the RESPONSE fragment with a single `{`
+// (`"type":"RESPONSE","content":"{"`), then the stream ended with
+// `quasi_status: FINISHED` and no tool-call JSON ever followed. The OLD
+// RESPONSE_CONTENT_RE (one non-quote char) matched that `{`, so the body looked
+// "finished WITH an answer" (isFinishedWithAnswer === true,
+// isFinishedWithoutAnswer === false): the finish loop kept polling for a
+// complete answer and `ask()` gave up only at the askDeadlineMs watchdog — the
+// operator watched a spinner for ~4 minutes with no tool call.
+// A real answer (a tool-call JSON, prose, a `respond` call) is far longer, so
+// anything below this is treated as a truncated/empty turn and retried.
+const MIN_FINISHED_ANSWER_CHARS = 4;
+// How many chars of RESPONSE text the body carries, or -1 when there is NO
+// RESPONSE fragment at all. The fragment is SSE/JSON-encoded, so the content
+// may contain `\"` escapes AND raw `"` inside the JSON (the capture is the RAW
+// body — `{"type":"RESPONSE","content":"{"tool": ...` is a real shape). A naive
+// `[^"]*` therefore stops at the first escaped quote and MIS-reads a long
+// answer as one char. Reuse the real extractor instead of a regex: it decodes
+// the content properly, so the length is exact (we only compare it to a small
+// threshold; the answer text itself comes from extractAnswer()).
+function responseContentLength(body) {
+    const b = String(body || '');
+    if (!/"type":"RESPONSE"/.test(b))
+        return -1;
+    return extractFromSse(b).length;
+}
 // True when the SSE body shows a turn that ENDED (`quasi_status: FINISHED`)
-// but produced NO answer text — the reasoning (THINK fragment) was generated
-// and then the model stopped WITHOUT writing a RESPONSE fragment.
+// but produced NO real answer text — the reasoning (THINK fragment) was
+// generated and then the model stopped WITHOUT writing a RESPONSE fragment,
+// OR the RESPONSE fragment is a truncated head (a lone `{`, a couple of
+// chars).
 //
 // This is the "Stopped + Continue button" case: DeepSeek finishes the turn
 // with only reasoning, the UI shows a Continue button, and extractAnswer()
-// returns '' (it only collects RESPONSE fragments). The old code then saw an
-// empty capture, ignored it, and the finish loop waited out the whole timeout
-// and threw ds.send_no_new_answer — to the operator the agent "hung on Stopped".
+// returns '' or a fragment. The old code saw a non-empty capture (the `{`),
+// treated the turn as answered, and the finish loop waited out the whole
+// askDeadlineMs — to the operator the agent "hung on Stopped".
 // Unlike generation_err, `quasi_status` here is FINISHED, so
 // isGenerationIncompleteText() does NOT catch it.
 //
@@ -179,11 +207,12 @@ export function isFinishedWithoutAnswer(body) {
     const finished = FINISHED_STATUS_RE.test(b);
     if (!finished)
         return false;
-    // A RESPONSE fragment with actual content means the model DID answer.
-    if (RESPONSE_CONTENT_RE.test(b))
+    // A RESPONSE fragment with real content means the model DID answer.
+    const len = responseContentLength(b);
+    if (len >= MIN_FINISHED_ANSWER_CHARS)
         return false;
-    // The turn carried reasoning (THINK) or was truncated mid-way; treat the
-    // absence of response content as "no answer produced".
+    // No RESPONSE fragment at all (len === -1) or only a truncated head:
+    // treat the absence of a real answer as "no answer produced".
     return true;
 }
 /**
@@ -202,7 +231,10 @@ export function isFinishedWithAnswer(body) {
         return false;
     if (!FINISHED_STATUS_RE.test(b))
         return false;
-    return RESPONSE_CONTENT_RE.test(b);
+    // A truncated RESPONSE head (a lone `{`) is NOT a complete answer: the
+    // finish loop would return it as the model's text and the tool-call parser
+    // would fail on it. Require real content (see MIN_FINISHED_ANSWER_CHARS).
+    return responseContentLength(b) >= MIN_FINISHED_ANSWER_CHARS;
 }
 // The CONTEXT size (in tokens) DeepSeek reports for the current answer.
 //

package/dist/provider-handoff.js

@@ -67,7 +67,3 @@ export function clearProviderHandoff() {
     }
     catch { }
 }
-/** For tests: the file the handoff lives in. */
-export function providerHandoffFile() {
-    return HANDOFF_FILE;
-}

package/dist/qwen-ui.js

@@ -21,9 +21,6 @@ export const CHAT_ID_RE = /\/c\/([A-Za-z0-9_-]+)/;
 export function chatUrl(id) {
     return CHAT_URL + 'c/' + id;
 }
-// The two-step API. `NEW_CHAT_URL` creates a chat and returns its id;
-// `COMPLETIONS_URL(id)` streams the answer.
-export const NEW_CHAT_URL = 'https://chat.qwen.ai/api/v2/chats/new';
 export const MODELS_URL = 'https://chat.qwen.ai/api/v2/models/';
 // The chat list, newest first, EXCLUDING project chats (verified live on a
 // signed-in session). Used by listChats() instead of scraping the sidebar.
@@ -36,10 +33,6 @@ export function chatHistoryUrl(chatId, limit = 50) {
         '?direction=up&limit=' +
         String(limit));
 }
-export function completionsUrl(chatId) {
-    return ('https://chat.qwen.ai/api/v2/chat/completions?chat_id=' +
-        encodeURIComponent(chatId));
-}
 // The completions SSE endpoint carries the real answer; used to gate the
 // network capture so an unrelated JSON endpoint never clobbers it.
 export const ANSWER_URL_RE = /\/api\/v2\/chat\/completions/i;
@@ -164,7 +157,6 @@ export const ATTACH_SELECTORS = ['input#filesUpload', 'input[type="file"]'];
 // ---------- login ----------
 // Qwen's sign-in is a SEPARATE origin (auth.qwen.ai) opened from the header
 // "Log in" button. Email / Google / GitHub are accepted; no phone required.
-export const LOGIN_BUTTON_RE = /^\s*(log ?in|sign ?in|войти)\s*$/i;
 export const PASSWORD_SELECTORS = [
     'input[type="password"]',
     'input[autocomplete="current-password"]',

package/dist/run-task.js

@@ -278,7 +278,7 @@ async function evaluateGoal(browser, condition, config, transcript) {
 }
 export async function runTask(deps, browser, tools, taskText, workdir, opts, attachments = []) {
     const { t, locale, debug, maxIter, config, runAgentLoop, createSpinner } = deps;
-    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, goalIsCondition = false, onGoalCleared = null, goalMaxTurns = GOAL_MAX_TURNS, goalQuery = null, todosQuery = null, selfImprovement = false, onSubagent = null, } = opts;
+    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, goalIsCondition = false, onGoalCleared = null, goalMaxTurns = GOAL_MAX_TURNS, goalQuery = null, todosQuery = null, selfImprovement = false, onSubagent = null, onAskUser = undefined, } = opts;
     // The ACTIVE goal for the duration of this run. It is mutable because a
     // completion goal can be cleared mid-run (verdict MET/IMPOSSIBLE, or the
     // operator runs `/goal clear` while the task is in flight). `goalQuery`
@@ -410,6 +410,29 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
                 getTokenUsage,
                 selfImprovement,
                 onSubagent,
+                // The `AskUser` seam. Default: pause the editor, show the Ink modal,
+                // resume; on a non-TTY (or no editor) it resolves null so the model is
+                // told to pick a default rather than being stuck on a question nobody
+                // can see.
+                onAskUser: onAskUser === undefined
+                    ? async (req) => {
+                        if (!editor)
+                            return null;
+                        editor.pause();
+                        try {
+                            const { askQuestionInk } = await import('./tui/run-ask.js');
+                            return await askQuestionInk({
+                                question: req.question,
+                                options: req.options,
+                                recommended: req.recommended,
+                                allowText: req.allowText,
+                            });
+                        }
+                        finally {
+                            editor.resume();
+                        }
+                    }
+                    : onAskUser,
                 // N38: the check command appended to a tool result after an edit
                 // (off by default; config.diagnostics).
                 diagnostics: deps.config.diagnostics,

package/dist/shell.js

@@ -195,12 +195,6 @@ export function killBackground(id) {
     BG_PROCS.delete(id);
     return `Killed background process ${id}.`;
 }
-/** List running background processes (for /status and cleanup). */
-export function listBackground() {
-    return [...BG_PROCS.values()]
-        .filter((p) => p.status === 'running')
-        .map((p) => ({ id: p.id, command: p.command }));
-}
 /** Kill every background process — called on exit so no orphan survives. */
 export function killAllBackground() {
     for (const id of [...BG_PROCS.keys()])

package/dist/system-prompt.js

@@ -21,11 +21,56 @@ Rules for that note:
 - this is the ONE exception to "do not touch unrelated files". If nothing
   worth noting, add nothing.
 `;
+// The skills DISCIPLINE, appended to the `## Skills` section (and mirrored in
+// the section above it): the model must CHECK the list before a non-trivial
+// task and READ a matching skill's body, instead of only seeing a static list.
+// This is the zames equivalent of superpowers' `using-superpowers` bootstrap —
+// no SessionStart hook needed, the text simply lives in the system prompt. Kept
+// narrow ("when relevant", not "always") so the model does not burn iterations
+// Reading SKILL.md files for a trivial edit.
+const SKILLS_DISCIPLINE = `
+Before starting a NON-TRIVIAL task (a new feature, a bug hunt, a multi-file
+change), scan the list above for a matching skill and, if one applies, Read
+its \`file:\` path FIRST — the body is the workflow you must follow. Skip this
+for a trivial edit or a single read: the scan must never cost more than the
+task itself. If a skill looks relevant but you are unsure, reading it is
+cheap; guessing is not.
+`;
 // Guidance for the `Task` tool (subagents), injected only when that tool is in
 // the model's set. Without it the model under-uses subagents (it does every
 // broad search itself and floods the main context) or misuses them (delegates
 // work that needs THIS conversation's history, which the isolated subagent
 // cannot see). Kept short: it competes with the tool list for space.
+// Guidance for the `AskUser` tool, injected only when that tool is offered.
+// Without it the model either never asks (and silently guesses) or asks about
+// things it could verify itself. Kept short and biased toward NOT asking.
+const ASKUSER_SECTION = `
+## AskUser tool (asking the operator)
+
+AskUser shows the operator a MODAL multi-choice question: a short list of
+options, one of them marked recommended, plus an "other" escape where they can
+type free text. It BLOCKS the run until answered and costs the operator a
+context switch, so use it SPARINGLY — only when the decision is genuinely
+ambiguous AND you cannot proceed safely by choosing a sensible default.
+
+Ask when:
+- the request has two or more materially different interpretations and the
+  wrong one wastes real work (e.g. "delete the feature" — code only, or code
+  plus its tests and docs?);
+- a destructive/irreversible action needs a decision you cannot derive from
+  the repo (which remote, which branch to force-push);
+- the operator explicitly asked you to check before deciding.
+
+Do NOT ask when:
+- you can read the answer from the code, the config or the git history;
+- one option is clearly right — pick it and state the assumption in your
+  final answer instead;
+- the task is trivial or already precise.
+
+Keep 2–4 options, put the RECOMMENDED one FIRST and mark it, and give each a
+one-line consequence ("X — because …"). The question text says WHY you are
+asking and what you will do with the answer.
+`;
 const SUBAGENT_SECTION = `
 ## Task tool (subagents)
 
@@ -126,7 +171,8 @@ export function renderContextSection(context) {
             '\n## Skills\n\n' +
                 'Specialized workflows. A skill with a `file:` is a SKILL.md on disk (read it when it applies); a `(built-in)` skill has no file — the operator can invoke it with /<name> and its instructions arrive as the task. Skills are progressive disclosure: only read the body when the skill applies.\n\n' +
                 lines.join('\n') +
-                '\n';
+                '\n' +
+                SKILLS_DISCIPLINE;
     }
     if (context.commands.length) {
         const lines = context.commands.map((c) => '- /' + c.name + ': ' + (c.description || '(no description)'));
@@ -158,6 +204,10 @@ export function buildSystemPrompt({ workdir, tools, gitContext = null, locale =
     const subagentSection = tools.some((x) => x.name === 'Task')
         ? SUBAGENT_SECTION
         : '';
+    // Same idea for AskUser: guidance only when the tool is in the set.
+    const askUserSection = tools.some((x) => x.name === 'AskUser')
+        ? ASKUSER_SECTION
+        : '';
     const gitSection = gitContext
         ? `\n## Git context\n\n${gitContext}\n`
         : '\n## Git context\n\nNot a git repository (or git is not installed).\n';
@@ -261,7 +311,7 @@ Rules for a batch:
 - Typical wins: read all the files a task mentions at once; grep for all the
   symbols you need at once; after planning a multi-file change, write all the
   files you can write independently at once.
-${subagentSection}
+${subagentSection}${askUserSection}
 ## MCP tools
 
 Some tools are provided by external MCP servers and their names look

package/dist/tools.js

@@ -303,6 +303,33 @@ export function createTools(workdir, { undo, todos, readOnly = false, subagents
         },
         fn: async () => 'Subagents are not available in this run. Do the work yourself.',
     };
+    // The AskUser seam: a MODAL question to the operator (multi-choice with a
+    // recommended option and a free-text escape). Like `Task`, it is handled by
+    // the CALLER (onAskUser), not by `fn` — the live path intercepts the name in
+    // agent-loop. `fn` only answers a direct unit-test call. It is not offered in
+    // plan/read-only mode (a plan must not interrupt).
+    const askUserTool = {
+        name: 'AskUser',
+        description: 'Ask the operator a question with a short list of OPTIONS when a decision ' +
+            'is genuinely ambiguous and you cannot proceed safely without it. One ' +
+            'option may be marked recommended (the model puts it FIRST and sets ' +
+            '`recommended` to its index/label). The operator can also pick "other" ' +
+            'and type free text. Use it SPARINGLY: prefer a reasonable default and ' +
+            'state it in your final answer — a question costs the operator a ' +
+            'context switch and blocks the run until answered. Do NOT ask for ' +
+            'confirmation of something you can verify yourself (read the file, run ' +
+            'the test). Returns the chosen option label, or the typed text, or an ' +
+            'empty answer when the operator dismissed the dialog.',
+        parameters: {
+            question: 'string',
+            options: 'array',
+            recommended: 'number?',
+            allow_text: 'boolean?',
+        },
+        fn: async ({ question }) => 'AskUser is not available in this run (no interactive UI). Proceed with ' +
+            'your best judgement and state the assumption. Question was: ' +
+            String(question ?? ''),
+    };
     // In plan (read-only) mode `Task` is dropped too: a `general` subagent could
     // otherwise write through it and defeat the read-only promise.
     const all = [
@@ -311,6 +338,7 @@ export function createTools(workdir, { undo, todos, readOnly = false, subagents
         ...gitTools,
         ...webTools,
         ...(subagents && !readOnly ? [taskTool] : []),
+        ...(readOnly ? [] : [askUserTool]),
         respondTool,
     ];
     return readOnly ? filterToolsForReadOnly(all) : all;
@@ -330,6 +358,11 @@ export const MUTATING_TOOLS = new Set([
     'GitAdd',
     'GitCommit',
     'GitPush',
+    // AskUser is NOT mutating (it touches no file), but plan mode exists to
+    // PRODUCE a plan with no side effects and no interruptions; a modal question
+    // mid-plan is exactly what plan mode must not do. Dropped in read-only mode
+    // so the model records the open question as a plan note instead.
+    'AskUser',
 ]);
 /** Drop mutating tools for read-only / plan mode. Pure; unit-tested. */
 export function filterToolsForReadOnly(tools) {

package/dist/tui/AskQuestion.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A modal QUESTION with CHOICES for the model's `AskUser` tool.
+//
+// The operator sees the model's question and a short list of options; one may
+// be marked as the model's recommendation and is highlighted. The operator can
+// ALWAYS answer in their own words via a last "other" row, so imperfect
+// options never block the run. Esc dismisses the question (the model is then
+// told to pick a default and continue).
+//
+// Visual language matches SelectList / ConfirmDialog (rounded border, title,
+// hint bar); it is a separate component because the free-text escape needs an
+// inline one-line editor, which SelectList does not have.
+import { useState } from 'react';
+import { Box, Text, useInput, useApp, useWindowSize } from 'ink';
+import { UI, HintBar } from './widgets.js';
+import { translate } from '../i18n.js';
+export function AskQuestion({ question, options, recommended, allowText, locale = 'ru', onResult, }) {
+    const { exit } = useApp();
+    const { columns } = useWindowSize();
+    const t = translate(locale);
+    const innerCols = Math.max(10, (columns || 80) - 6);
+    const otherLabel = t('askuser.other');
+    const rows = allowText ? [...options, otherLabel] : options;
+    const [cursor, setCursor] = useState(recommended !== null && recommended >= 0 && recommended < options.length
+        ? recommended
+        : 0);
+    const [typing, setTyping] = useState(false);
+    const [text, setText] = useState('');
+    const finish = (v) => {
+        onResult(v);
+        exit();
+    };
+    useInput((input, key) => {
+        if (key.escape || (key.ctrl && input === 'c')) {
+            finish(null);
+            return;
+        }
+        if (typing) {
+            if (key.return) {
+                const v = text.trim();
+                finish(v || null);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setText((s) => Array.from(s).slice(0, -1).join(''));
+                return;
+            }
+            if (input && input >= ' ')
+                setText((s) => s + input);
+            return;
+        }
+        if (key.upArrow || input === 'k') {
+            setCursor((c) => (rows.length ? (c - 1 + rows.length) % rows.length : 0));
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            setCursor((c) => (rows.length ? (c + 1) % rows.length : 0));
+            return;
+        }
+        if (key.return) {
+            if (allowText && cursor === options.length) {
+                setTyping(true);
+                return;
+            }
+            finish(rows[cursor] ?? null);
+            return;
+        }
+        // A printable char on the "other" row opens the editor immediately.
+        if (allowText && cursor === options.length && input && input >= ' ') {
+            setTyping(true);
+            setText(input);
+        }
+    });
+    // Word-wrap the question to the inner width (Ink wraps Text too, but a
+    // wrapped box row is not counted by the layout, so wrap it here).
+    const wrap = (s) => {
+        const words = String(s).split(/\s+/);
+        const out = [];
+        let line = '';
+        for (const w of words) {
+            const cand = line ? line + ' ' + w : w;
+            if (cand.length > innerCols && line) {
+                out.push(line);
+                line = w;
+            }
+            else {
+                line = cand;
+            }
+        }
+        if (line)
+            out.push(line);
+        return out.length ? out : [''];
+    };
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.accent, paddingX: 2, children: [_jsx(Text, { color: UI.title, bold: true, children: '◆ ' + t('askuser.title') }), wrap(question).map((line, i) => (_jsx(Text, { color: UI.text, children: line }, i))), _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(innerCols) }), typing ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: UI.dim, children: t('askuser.your_answer') }), _jsxs(Text, { color: UI.accent, children: ['❯ ', text, '▏'] })] })) : (rows.map((label, i) => {
+                const sel = i === cursor;
+                const isRec = i === recommended;
+                return (_jsxs(Text, { children: [_jsx(Text, { color: UI.accent, children: sel ? '❯ ' : '  ' }), _jsx(Text, { color: sel ? UI.accent : undefined, bold: sel, children: label }), isRec ? (_jsx(Text, { color: "#6fd0b0", children: '  (' + t('askuser.recommended') + ')' })) : null] }, i));
+            })), _jsx(HintBar, { hints: typing
+                    ? [
+                        ['Enter', t('askuser.hint_send')],
+                        ['Esc', t('askuser.hint_cancel')],
+                    ]
+                    : [
+                        ['↑/↓', t('askuser.hint_select')],
+                        ['Enter', t('askuser.hint_ok')],
+                        ['Esc', t('askuser.hint_dismiss')],
+                    ] })] }));
+}

package/dist/tui/FullScreenApp.js

@@ -113,6 +113,7 @@ export function FullScreenApp({ store, inputProps, }) {
     }, state.mouseScroll);
     return (_jsxs(Box, { flexDirection: "column", height: termRows, children: [_jsx(Header, { store: store }), _jsx(Box, { flexDirection: "column", height: logHeight, overflow: "hidden", justifyContent: "flex-end", children: all.length === 0 ? (_jsx(Text, { color: "#5b616e", children: translate(state.locale)('editor.empty_hint') })) : (_jsx(LogList, { entries: visible })) }), _jsx(StatusBar, { state: state, divider: false }), _jsx(InputLine, { ...inputProps, store: store, 
                 // Cursor rows above the input box: header + log viewport + status.
-                cursorTop: HEADER_ROWS + logHeight + suggestRows + STATUS_ROWS + 1, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked }), _jsx(Text, { color: "#5b616e", wrap: "truncate", children: ' ' + translate(state.locale)('editor.keys_hint') })] }));
+                cursorTop: HEADER_ROWS + logHeight + suggestRows + STATUS_ROWS + 1, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked }), _jsx(Text, { color: "#5b616e", wrap: "truncate", children: ' ' +
+                    translate(state.locale)(state.mouseScroll ? 'editor.keys_hint' : 'editor.keys_hint_select') })] }));
 }
 void contentWidth;

package/dist/tui/InputLine.js

@@ -213,9 +213,6 @@ export function InputLine(props) {
             case 'clipboard':
                 void tryClipboard();
                 return;
-            case 'copyCode':
-                props.onCopyCode();
-                return;
             default:
                 return;
         }

package/dist/tui/StatusBar.js

@@ -37,10 +37,6 @@ export function badgeTextWidth(state) {
         w += visLen('[' + state.provider + '] ');
     if (state.queueLength > 0)
         w += visLen('⧗' + state.queueLength + ' ');
-    if (state.codeBlocks.length > 0) {
-        const idx = state.codeFocus >= 0 ? state.codeFocus + 1 : state.codeBlocks.length;
-        w += visLen('⌘ ' + idx + '/' + state.codeBlocks.length + ' ');
-    }
     if (state.tasks)
         w += visLen(state.tasks) + 1;
     const toggles = [];
@@ -80,11 +76,6 @@ function Badges({ state, budget = Infinity, }) {
     if (state.queueLength > 0) {
         add('q', visLen('⧗' + state.queueLength + ' '), _jsxs(Text, { color: "#c9a86a", children: ['⧗' + state.queueLength, ' '] }, "q"));
     }
-    if (state.codeBlocks.length > 0) {
-        const idx = state.codeFocus >= 0 ? state.codeFocus + 1 : state.codeBlocks.length;
-        const label = '⌘ ' + idx + '/' + state.codeBlocks.length + ' ';
-        add('code', visLen(label), _jsx(Text, { color: "#7fc4f0", children: label }, "code"));
-    }
     if (state.tasks) {
         add('t', visLen(state.tasks) + 1, _jsxs(Text, { color: "#808896", children: [state.tasks, ' '] }, "t"));
     }

package/dist/tui/TuiEditor.js

@@ -26,7 +26,6 @@ import { contentWidth } from '../width.js';
 import { theme } from '../theme.js';
 import { renderMarkdown } from '../markdown.js';
 import { summarizeToolCall, looksLikeToolError } from '../tool-summary.js';
-import { extractCodeBlocks } from '../code-blocks.js';
 import { randomThinkingPhrase, stripEllipsis } from '../spinner.js';
 export class TuiEditor {
     store = new TuiStore();
@@ -42,9 +41,6 @@ export class TuiEditor {
     onTasksQuery = null;
     onContextQuery = null;
     onToggleQuery = null;
-    /** Copy text to the OS clipboard. Wired to writeClipboardText in index.ts;
-     *  returns { ok, via } so the editor can report the outcome. */
-    onCopyText = null;
     busy = false;
     locked = false;
     history = [];
@@ -98,7 +94,6 @@ export class TuiEditor {
             onSubmit: (text, atts) => this.handleSubmit(text, atts),
             onEscape: () => this.onEscape?.(),
             onCtrlC: () => this.onCtrlC?.(),
-            onCopyCode: () => this.copyCode(),
             onAttach: (raw) => this.onAttach?.(raw) ?? null,
             onClipboard: () => this.onClipboard?.() ?? Promise.resolve(null),
             onHistoryChange: (h) => {
@@ -259,6 +254,10 @@ export class TuiEditor {
         this.printAbove(theme.userBar('▌ ') +
             theme.user(wrapToWidth(display, contentWidth() - 2)));
         this.store.set({ pastes: [] });
+        // Sending a message pins the log back to the newest content: the operator
+        // expects their message (and the answer) at the BOTTOM, so a viewport left
+        // scrolled-up (PgUp / wheel) must snap to scroll=0 on submit.
+        this.store.set({ scroll: 0 });
         this.onSubmit?.(text, atts);
         if (this.busy)
             this.thinking();
@@ -472,44 +471,6 @@ export class TuiEditor {
         this.printAbove('\n' + theme.assistant(translate(this.locale)('editor.answer')));
         this.printAbove(rendered);
         this.printAbove('\n');
-        // Remember the answer's code blocks so the operator can copy one by hotkey
-        // (a terminal has no copy buttons). Extraction is on the RAW markdown —
-        // the rendered text is full of ANSI and must never be copied.
-        const blocks = extractCodeBlocks(msg);
-        this.store.set({ codeBlocks: blocks, codeFocus: -1 });
-        if (blocks.length)
-            this.refreshBadges();
-    }
-    /** Copy the focused code block (or the LAST when none is focused). */
-    copyCode(index) {
-        const snap = this.store.getSnapshot();
-        const blocks = snap.codeBlocks;
-        if (!blocks.length) {
-            this.printAbove(theme.dim(translate(this.locale)('copy.no_code')));
-            return false;
-        }
-        const pick = typeof index === 'number'
-            ? (blocks.find((b) => b.index === index) ?? null)
-            : snap.codeFocus >= 0
-                ? (blocks[snap.codeFocus] ?? null)
-                : blocks[blocks.length - 1];
-        if (!pick) {
-            this.printAbove(theme.warn(translate(this.locale)('copy.bad_index', { n: String(index) })));
-            return false;
-        }
-        const res = this.onCopyText?.(pick.text) ?? { ok: false, via: 'none' };
-        const label = 'code #' + pick.index + (pick.lang ? ' (' + pick.lang + ')' : '');
-        if (res.ok) {
-            this.printAbove(theme.assistant(translate(this.locale)('copy.done', { tool: res.via }) +
-                ' — ' +
-                label));
-        }
-        else {
-            this.printAbove(theme.warn(translate(this.locale)('copy.failed', { tool: res.via }) +
-                ' — ' +
-                label));
-        }
-        return res.ok;
     }
     warning(msg) {
         const wrapped = wrapToWidth('⚠ ' + msg, contentWidth());

package/dist/tui/edit.js

@@ -82,35 +82,26 @@ export function deleteWordLeft(s) {
     return { ...s, buf: chars.join(''), cursor: i };
 }
 /**
- * Delete the word on the RIGHT of the cursor (Ctrl+Delete / Alt+Delete).
- *
- * FALLBACK: at the END of the line there is no word to the right, so the key
- * did NOTHING and the operator (whose terminal sends the standard xterm
- * Ctrl+Delete) read it as "Ctrl+Delete does not delete the word before the
- * cursor". Deleting the word on the LEFT there matches what other terminal
- * editors do and what the operator expects, while keeping the standard
- * right-delete when the cursor is mid-line.
+ * Delete the word on the RIGHT of the cursor (Ctrl+Delete / Alt+Delete):
+ * skip the whitespace after the cursor, then delete up to the end of the next
+ * word — the mirror of deleteWordLeft(). At the end of the line there is
+ * nothing to the right, so the buffer is left UNCHANGED (never a surprise
+ * leftward delete), matching the legacy LineEditor's _deleteWordRight().
  */
 export function deleteWordRight(s) {
     const chars = charsOf(s);
-    // Nothing to the right (end of buffer or only whitespace to the newline):
-    // delete the word on the LEFT instead of doing nothing.
-    let probe = s.cursor;
-    while (probe < chars.length &&
-        chars[probe] !== NL &&
-        /\s/.test(chars[probe])) {
-        probe++;
-    }
-    if (probe >= chars.length || chars[probe] === NL) {
-        return deleteWordLeft(s);
-    }
+    // Stop at a NEWLINE: it is whitespace for /\s/ but must never be swallowed
+    // by a word delete (the old code guarded this; without the guard the key
+    // ate the line break).
     let i = s.cursor;
-    while (i < chars.length && /\s/.test(chars[i]))
+    while (i < chars.length && chars[i] !== NL && /\s/.test(chars[i]))
         i++;
-    while (i < chars.length && !/\s/.test(chars[i]))
+    while (i < chars.length && chars[i] !== NL && !/\s/.test(chars[i]))
         i++;
+    if (i === s.cursor)
+        return s;
     chars.splice(s.cursor, i - s.cursor);
-    return { ...s, buf: chars.join('') };
+    return { ...s, buf: chars.join(''), cursor: s.cursor };
 }
 /** Delete from the cursor to the end of the current LOGICAL line (Ctrl+K). */
 export function killToLineEnd(s) {