@xingjisoft/neutrino 0.2.0 → 0.3.0

package/dist/web/hub.js

@@ -175,6 +175,15 @@ class LiveHub {
         this.notify(key);
         return true;
     }
+    /** Empty a live conversation in place, keeping its key and working folder. */
+    clear(key) {
+        const entry = this.entries.get(key);
+        if (!entry?.agent.liveClear)
+            return false;
+        entry.agent.liveClear();
+        this.notify(key);
+        return true;
+    }
 }
 /** Process-wide singleton shared by the TUI and the web server. */
 export const hub = new LiveHub();

package/dist/web/server.js

@@ -16,13 +16,14 @@ import http from "node:http";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { SESSION_DIR, listSessions, resolveModelSelection } from "../config.js";
+import { SESSION_DIR, deleteSession, listSessions, loadConfig, normalizeApprovalMode, resolveModelSelection, saveConfig, } from "../config.js";
 import { getWebSettings, updateWebSettings } from "./settings.js";
 import { WebAuth } from "./auth.js";
-import { normalizeCwd } from "../cwd.js";
+import { normalizeCwd, sameCwd } from "../cwd.js";
 import { hub } from "./hub.js";
 import { writeCrashLog } from "../terminal/restore.js";
-import { resumeSession } from "./session.js";
+import { createWebSession, resumeSession } from "./session.js";
+import { listAgentSessions, loadAgentMessages } from "../agents.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // dist/web -> package root (mirrors the same trick used in config.ts).
 const PKG_ROOT = path.resolve(__dirname, "..", "..");
@@ -132,6 +133,194 @@ function loadSessionSafe(id) {
         return null;
     }
 }
+// ------------------------------------------------------- working directories
+//
+// The browser console can open any folder on this machine, which is exactly
+// what the terminal can do by being launched from that folder. Every route
+// below still sits behind the login cookie: browsing the filesystem is only as
+// exposed as the authenticated console itself.
+class ApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+function sendApiError(res, error) {
+    if (error instanceof ApiError) {
+        sendJson(res, error.status, { error: error.message, code: error.code });
+        return;
+    }
+    const message = error instanceof Error ? error.message : "invalid request";
+    sendJson(res, 400, { error: message });
+}
+const MAX_RECENT_WORKSPACES = 12;
+const AGENT_IDS = new Set(["claude", "codex", "opencode"]);
+const AGENT_SESSION_ID_RE = /^[A-Za-z0-9._-]{1,200}$/;
+/** Expand `~` and require an absolute path; used by every folder route. */
+function absolutePath(raw) {
+    if (typeof raw !== "string" || !raw.trim()) {
+        throw new ApiError(400, "working directory is required", "working directory is required");
+    }
+    let value = raw.trim();
+    if (value === "~")
+        value = os.homedir();
+    else if (/^~[\\/]/.test(value))
+        value = path.join(os.homedir(), value.slice(2));
+    if (!path.isAbsolute(value)) {
+        throw new ApiError(400, "working directory must be an absolute path", "working directory must be an absolute path");
+    }
+    return path.resolve(value);
+}
+function existingDirectory(raw) {
+    const dir = absolutePath(raw);
+    let stat;
+    try {
+        stat = fs.statSync(dir);
+    }
+    catch {
+        throw new ApiError(400, "working directory does not exist", "working directory does not exist");
+    }
+    if (!stat.isDirectory()) {
+        throw new ApiError(400, "working directory is not a folder", "working directory is not a folder");
+    }
+    return dir;
+}
+let cachedRoots = null;
+/** Filesystem roots worth offering as shortcuts (every existing drive on Windows). */
+function filesystemRoots() {
+    if (cachedRoots)
+        return cachedRoots;
+    if (process.platform !== "win32") {
+        cachedRoots = ["/"];
+        return cachedRoots;
+    }
+    const roots = [];
+    for (let code = 65; code <= 90; code += 1) {
+        const root = `${String.fromCharCode(code)}:\\`;
+        try {
+            if (fs.statSync(root).isDirectory())
+                roots.push(root);
+        }
+        catch {
+            // A drive letter that does not exist is simply not offered.
+        }
+    }
+    cachedRoots = roots.length ? roots : [path.parse(process.cwd()).root];
+    return cachedRoots;
+}
+/** One directory listing for the folder picker. Files are hidden: the picker chooses directories. */
+function readFolder(raw) {
+    const dir = existingDirectory(raw);
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        throw new ApiError(403, "cannot read this folder", err instanceof Error ? err.message : "cannot read this folder");
+    }
+    const folders = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => ({
+        name: entry.name,
+        path: path.join(dir, entry.name),
+        hidden: entry.name.startsWith("."),
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" }));
+    const parent = path.dirname(dir);
+    return {
+        path: dir,
+        name: path.basename(dir) || dir,
+        parent: parent === dir ? null : parent,
+        separator: path.sep,
+        home: os.homedir(),
+        cwd: process.cwd(),
+        roots: filesystemRoots(),
+        entries: folders,
+    };
+}
+/** Recent working directories: explicitly opened ones first, then saved-session folders. */
+function recentWorkspacePaths() {
+    const config = loadConfig();
+    const stored = Array.isArray(config.web_workspaces)
+        ? config.web_workspaces.filter((entry) => typeof entry === "string" && entry.trim() !== "")
+        : [];
+    const saved = listSessions().map((session) => session.cwd).filter(Boolean);
+    const seen = new Set();
+    const out = [];
+    for (const dir of [...stored, ...saved, process.cwd()]) {
+        const key = normalizeCwd(dir);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(dir);
+        if (out.length >= MAX_RECENT_WORKSPACES)
+            break;
+    }
+    return out;
+}
+function workspaceList() {
+    const sessions = listSessions();
+    return recentWorkspacePaths().map((dir) => {
+        let exists = false;
+        try {
+            exists = fs.statSync(dir).isDirectory();
+        }
+        catch {
+            // A folder that disappeared stays listed, greyed out, so it can be removed by choosing another.
+        }
+        return {
+            path: dir,
+            name: path.basename(dir) || dir,
+            sessions: sessions.filter((session) => sameCwd(session.cwd, dir)).length,
+            exists,
+        };
+    });
+}
+/** Best-effort persistence: failing to remember a folder must not fail the conversation. */
+function recordWorkspace(dir) {
+    try {
+        const config = loadConfig();
+        const stored = Array.isArray(config.web_workspaces)
+            ? config.web_workspaces.filter((entry) => typeof entry === "string")
+            : [];
+        config.web_workspaces = [dir, ...stored.filter((entry) => !sameCwd(entry, dir))]
+            .slice(0, MAX_RECENT_WORKSPACES);
+        saveConfig(config);
+    }
+    catch {
+        // The picked folder still works for this conversation.
+    }
+}
+/** Create one folder inside an existing parent. */
+function createFolder(raw) {
+    const target = absolutePath(raw);
+    if (target === path.parse(target).root) {
+        throw new ApiError(400, "cannot create a folder here", "cannot create a folder here");
+    }
+    const parent = path.dirname(target);
+    if (!fs.existsSync(parent) || !fs.statSync(parent).isDirectory()) {
+        throw new ApiError(400, "parent folder does not exist", "parent folder does not exist");
+    }
+    if (fs.existsSync(target)) {
+        throw new ApiError(409, "folder already exists", "folder already exists");
+    }
+    try {
+        fs.mkdirSync(target);
+    }
+    catch (err) {
+        throw new ApiError(400, "cannot create a folder here", err instanceof Error ? err.message : "cannot create a folder here");
+    }
+    return target;
+}
+function isAgentId(value) {
+    return AGENT_IDS.has(value);
+}
+function safeAgentSessionId(id) {
+    return AGENT_SESSION_ID_RE.test(id) && !id.includes("..") && id !== "." && id !== "..";
+}
 /** Build the sidebar payload: every session grouped by working directory. */
 function buildOverview() {
     const sessions = listSessions();
@@ -178,7 +367,9 @@ function buildOverview() {
             provider: live.provider,
             intensity: live.intensity,
             cwd: live.cwd,
-            title: live.title || "New conversation",
+            // An unnamed conversation keeps an empty title: the browser translates
+            // its own fallback, and the terminal/server never impose one language.
+            title: live.title || "",
             message_count: 0,
             live: true,
             liveKey: live.key,
@@ -424,6 +615,155 @@ async function handleApi(req, res, url, auth) {
         sendJson(res, 200, { sessions: listSessions() });
         return true;
     }
+    if (pathname === "/api/workspaces") {
+        if (req.method === "GET") {
+            sendJson(res, 200, {
+                cwd: process.cwd(),
+                home: os.homedir(),
+                workspaces: workspaceList(),
+            });
+            return true;
+        }
+        if (req.method === "POST") {
+            if (!isSameOrigin(req)) {
+                sendJson(res, 403, { error: "cross-origin request rejected" });
+                return true;
+            }
+            try {
+                const body = await readJsonBody(req);
+                const dir = existingDirectory(body?.path);
+                recordWorkspace(dir);
+                sendJson(res, 200, { ok: true, path: dir, workspaces: workspaceList() });
+            }
+            catch (err) {
+                sendApiError(res, err);
+            }
+            return true;
+        }
+        sendJson(res, 405, { error: "method not allowed" });
+        return true;
+    }
+    if (pathname === "/api/fs") {
+        if (req.method !== "GET") {
+            sendJson(res, 405, { error: "method not allowed" });
+            return true;
+        }
+        try {
+            sendJson(res, 200, readFolder(url.searchParams.get("path") ?? process.cwd()));
+        }
+        catch (err) {
+            sendApiError(res, err);
+        }
+        return true;
+    }
+    if (pathname === "/api/fs/mkdir") {
+        if (req.method !== "POST") {
+            sendJson(res, 405, { error: "method not allowed" });
+            return true;
+        }
+        if (!isSameOrigin(req)) {
+            sendJson(res, 403, { error: "cross-origin request rejected" });
+            return true;
+        }
+        try {
+            const body = await readJsonBody(req);
+            const created = createFolder(body?.path);
+            sendJson(res, 200, { ok: true, path: created });
+        }
+        catch (err) {
+            sendApiError(res, err);
+        }
+        return true;
+    }
+    // Start a brand-new conversation in a working directory chosen by the
+    // browser. Unlike `/continue`, there is no transcript to load first.
+    if (pathname === "/api/conversations") {
+        if (req.method !== "POST") {
+            sendJson(res, 405, { error: "method not allowed" });
+            return true;
+        }
+        if (!isSameOrigin(req)) {
+            sendJson(res, 403, { error: "cross-origin request rejected" });
+            return true;
+        }
+        try {
+            const body = await readJsonBody(req);
+            if (!body || typeof body !== "object" || Array.isArray(body)) {
+                throw new ApiError(400, "invalid request", "invalid request");
+            }
+            const input = body;
+            const cwd = existingDirectory(input.cwd ?? process.cwd());
+            const requested = input.selection === undefined
+                ? getWebSettings().selection
+                : input.selection;
+            const selection = resolveModelSelection(requested, false);
+            let approvalMode;
+            if (input.approval_mode !== undefined) {
+                if (input.approval_mode !== "request" && input.approval_mode !== "auto") {
+                    throw new ApiError(400, "invalid approval mode", "invalid approval mode");
+                }
+                approvalMode = normalizeApprovalMode(input.approval_mode);
+            }
+            const session = createWebSession(cwd, selection, approvalMode);
+            const key = session.start();
+            webSessions.set(key, session);
+            recordWorkspace(cwd);
+            sendJson(res, 200, { ok: true, key, cwd, snapshot: hub.snapshot(key) });
+        }
+        catch (err) {
+            sendApiError(res, err);
+        }
+        return true;
+    }
+    const deleteMatch = /^\/api\/session\/([^/]+)\/delete$/.exec(pathname);
+    if (req.method === "POST" && deleteMatch) {
+        if (!isSameOrigin(req)) {
+            sendJson(res, 403, { error: "cross-origin request rejected" });
+            return true;
+        }
+        const id = decodeURIComponent(deleteMatch[1]);
+        if (!isSafeSessionId(id)) {
+            sendJson(res, 400, { error: "invalid session id" });
+            return true;
+        }
+        if (hub.list().some((entry) => entry.sessionId === id)) {
+            sendJson(res, 409, { error: "cannot delete a running conversation" });
+            return true;
+        }
+        if (!deleteSession(id)) {
+            sendJson(res, 404, { error: "session not found" });
+            return true;
+        }
+        sendJson(res, 200, { ok: true, deleted: true });
+        return true;
+    }
+    // Read-only history recorded by other agents (Claude Code, Codex, OpenCode).
+    const agentSessionsMatch = /^\/api\/agents\/([^/]+)\/sessions$/.exec(pathname);
+    if (req.method === "GET" && agentSessionsMatch) {
+        const agent = decodeURIComponent(agentSessionsMatch[1]);
+        if (!isAgentId(agent)) {
+            sendJson(res, 400, { error: "unknown agent" });
+            return true;
+        }
+        const cwd = url.searchParams.get("cwd") || process.cwd();
+        sendJson(res, 200, { agent, cwd, sessions: listAgentSessions(agent, cwd) });
+        return true;
+    }
+    const agentSessionMatch = /^\/api\/agents\/([^/]+)\/sessions\/([^/]+)$/.exec(pathname);
+    if (req.method === "GET" && agentSessionMatch) {
+        const agent = decodeURIComponent(agentSessionMatch[1]);
+        const id = decodeURIComponent(agentSessionMatch[2]);
+        if (!isAgentId(agent)) {
+            sendJson(res, 400, { error: "unknown agent" });
+            return true;
+        }
+        if (!safeAgentSessionId(id)) {
+            sendJson(res, 400, { error: "invalid session id" });
+            return true;
+        }
+        sendJson(res, 200, { agent, id, messages: loadAgentMessages(agent, id) });
+        return true;
+    }
     const sessionMatch = /^\/api\/session\/([^/]+)$/.exec(pathname);
     if (req.method === "GET" && sessionMatch) {
         const id = decodeURIComponent(sessionMatch[1]);
@@ -499,7 +839,7 @@ async function handleApi(req, res, url, auth) {
         streamLive(decodeURIComponent(streamMatch[1]), req, res);
         return true;
     }
-    const liveMatch = /^\/api\/live\/([^/]+)(?:\/(pause|resume|message|approve|close|model|approval-mode))?$/.exec(pathname);
+    const liveMatch = /^\/api\/live\/([^/]+)(?:\/(pause|resume|message|approve|close|model|approval-mode|clear))?$/.exec(pathname);
     if (liveMatch) {
         const key = decodeURIComponent(liveMatch[1]);
         const action = liveMatch[2];
@@ -593,6 +933,14 @@ async function handleApi(req, res, url, auth) {
                 sendJson(res, 200, { ok: true, closed: true });
                 return true;
             }
+            if (action === "clear") {
+                if (!hub.clear(key)) {
+                    sendJson(res, 409, { error: "this session cannot be cleared" });
+                    return true;
+                }
+                sendJson(res, 200, { ok: true, snapshot: hub.snapshot(key) });
+                return true;
+            }
             // action === "message"
             let body;
             try {

package/dist/web/session.js

@@ -10,10 +10,11 @@
  * registers itself in the live hub, so the regular `/api/live/*` endpoints
  * (snapshot, stream, pause, resume, message) work unchanged.
  */
+import { randomUUID } from "node:crypto";
 import { findModel, contextCompressionThreshold, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadModels, loadPrompt, saveSession, } from "../config.js";
 import { COMPACT_KEEP, planCompaction, transcriptFor, modelHistory, normalizeContext, } from "../compact.js";
 import { LLMClient, describeError } from "../llm/client.js";
-import { advancePlan, buildPlannerInput, lastRequestText, parsePlan, planMessage, planTranscript, renderStepDirective, resumePlan, stopPlan, } from "../llm/plan.js";
+import { advancePlan, buildPlannerInput, lastRequestText, needsPlan, parsePlan, planMessage, planTranscript, renderStepDirective, resumePlan, stopPlan, } from "../llm/plan.js";
 import { DELEGATE_TOOL, executeTool, getSubAgentToolDefinitions, getToolDefinitions } from "../llm/tools.js";
 import { buildSubAgentTask, formatSubAgentResult, runSubAgent as runSubAgentTask, } from "../llm/subagent.js";
 import { assessToolCall } from "../llm/risk.js";
@@ -31,6 +32,35 @@ const TOOL_PENDING = "…";
 const SUB_AGENT_TOOLS = getSubAgentToolDefinitions();
 /** Marker for the model-only summary, separate from the original transcript. */
 const SUMMARY_PREFIX = "Context was compressed. Summary of the earlier part:";
+/**
+ * A fresh session id in the same shape `saveSession` generates, so a new
+ * browser conversation has a stable identity before its first message exists.
+ */
+export function newSessionId(now = new Date()) {
+    return `${now.toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+}
+/**
+ * Start an empty conversation in a caller-chosen working directory. Nothing is
+ * written to disk until the first message, so an abandoned new-chat dialog
+ * cannot litter the history with empty transcripts.
+ */
+export function createWebSession(cwd, selection, approvalMode) {
+    const now = new Date();
+    const source = {
+        id: newSessionId(now),
+        created_at: now.toISOString(),
+        updated_at: now.toISOString(),
+        model: selection.model.name,
+        provider: selection.provider,
+        intensity: selection.intensity,
+        cwd,
+        title: "",
+        messages: [],
+        tokens: { prompt: 0, completion: 0 },
+        approval_mode: normalizeApprovalMode(approvalMode ?? loadConfig().approval_mode),
+    };
+    return new WebSession(source, selection.model);
+}
 function parseArguments(raw) {
     const text = raw?.trim() ?? "";
     if (!text)
@@ -267,6 +297,40 @@ export class WebSession {
         this.save();
         this.publishLive();
     }
+    /**
+     * Start a fresh chat in the same working directory, mirroring the terminal's
+     * clear shortcut. The finished transcript is checkpointed first and stays on
+     * disk; this session simply moves on under a new id.
+     */
+    liveClear() {
+        if (this.disposed)
+            return;
+        if (!this.checkpoint.flush())
+            return;
+        this.turnToken++;
+        if (this.pendingApproval) {
+            const pending = this.pendingApproval;
+            this.pendingApproval = null;
+            pending.resolve(false);
+        }
+        this.busy = false;
+        this.paused = false;
+        this.queued = null;
+        this.compressing = false;
+        this.retrying = null;
+        this.subagent = null;
+        this.reviewing = null;
+        this.streamingContent = null;
+        this.plan = null;
+        this.planning = false;
+        this.messages = [];
+        this.context = null;
+        this.lastPromptTokens = 0;
+        this.saveError = null;
+        this.sessionId = newSessionId();
+        this.publishLive();
+        this.touch();
+    }
     // ---- turn driving ----------------------------------------------------
     send(text) {
         const trimmed = text.trim();
@@ -371,6 +435,9 @@ export class WebSession {
         const request = lastRequestText(this.messages);
         if (!request.trim())
             return null;
+        // One action is not a plan: run the turn in one pass, as the terminal does.
+        if (!needsPlan(request))
+            return null;
         this.planning = true;
         this.publishLive();
         try {
@@ -472,13 +539,32 @@ export class WebSession {
                     this.tokens.completion += client.usage.completion;
                     this.lastPromptTokens = client.usage.prompt;
                 }
+                const toolCalls = client.toolCalls;
                 if (text.trim()) {
                     this.messages.push({ role: "assistant", content: text });
-                    apiMessages.push({ role: "assistant", content: text });
+                }
+                if (text.trim() || toolCalls.length > 0) {
+                    // The assistant message and the tool results it produced must stay
+                    // paired: a `tool` message without its `tool_calls` parent is
+                    // rejected by every OpenAI-compatible endpoint. The reasoning is the
+                    // thinking that produced the calls, which DeepSeek requires back.
+                    apiMessages.push({
+                        role: "assistant",
+                        content: text,
+                        reasoning_content: client.reasoningContent ?? "",
+                        ...(toolCalls.length > 0
+                            ? {
+                                tool_calls: toolCalls.map((call) => ({
+                                    id: call.id,
+                                    type: "function",
+                                    function: { name: call.name, arguments: call.arguments },
+                                })),
+                            }
+                            : {}),
+                    });
                 }
                 this.save();
                 this.publishLive();
-                const toolCalls = client.toolCalls;
                 if (toolCalls.length === 0)
                     break;
                 for (const call of toolCalls) {
@@ -703,7 +789,7 @@ export class WebSession {
                 return line.length > 80 ? `${line.slice(0, 77)}…` : line;
             }
         }
-        return "Resumed chat";
+        return "";
     }
     retainStreamingContent() {
         if (this.streamingContent) {

package/dist/web/settings.js

@@ -1,4 +1,4 @@
-import { DEFAULT_CONFIG, INTENSITY_LEVELS, contextWindow, isContextWindow, loadConfig, loadModels, resolveModelSelection, saveConfig, saveModels, } from "../config.js";
+import { DEFAULT_CONFIG, INTENSITY_LEVELS, WEB_LANGUAGES, contextWindow, isContextWindow, loadConfig, loadModels, normalizeApprovalMode, normalizeWebLanguage, resolveModelSelection, saveConfig, saveModels, } from "../config.js";
 import { hashWebPassword, validateWebPassword } from "./auth.js";
 /** Public settings use a whitelist: API keys and cached credentials stay on disk. */
 export function getWebSettings() {
@@ -15,6 +15,7 @@ export function getWebSettings() {
     return {
         providers,
         intensities: INTENSITY_LEVELS,
+        languages: WEB_LANGUAGES.map((value) => ({ value, label: value === "zh" ? "简体中文" : "English" })),
         selection: {
             provider: provider?.name ?? "",
             model: model?.name ?? "",
@@ -26,6 +27,10 @@ export function getWebSettings() {
             approval_model: String(config.approval_model ?? ""),
             auto_approve_extreme_risk: config.auto_approve_extreme_risk === true,
             sound_alerts: config.sound_alerts !== false,
+            language: normalizeWebLanguage(config.language),
+            plan_first: config.plan_first !== false,
+            approval_mode: normalizeApprovalMode(config.approval_mode),
+            web_console: config.web_console !== false,
         },
     };
 }
@@ -67,6 +72,27 @@ export function updateWebSettings(value) {
                     throw new Error("auto-approval must be a boolean");
                 config[key] = val;
             }
+            else if (key === "language") {
+                if (typeof val !== "string" || !WEB_LANGUAGES.includes(val)) {
+                    throw new Error("invalid language");
+                }
+                config.language = val;
+            }
+            else if (key === "plan_first") {
+                if (typeof val !== "boolean")
+                    throw new Error("invalid plan setting");
+                config.plan_first = val;
+            }
+            else if (key === "approval_mode") {
+                if (val !== "request" && val !== "auto")
+                    throw new Error("invalid approval mode");
+                config.approval_mode = val;
+            }
+            else if (key === "web_console") {
+                if (typeof val !== "boolean")
+                    throw new Error("web console must be a boolean");
+                config.web_console = val;
+            }
             else if (key === "web_password") {
                 validateWebPassword(val);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xingjisoft/neutrino",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "XINGJI Neutrino - a CLI coding agent in the terminal.",
   "type": "module",
   "license": "Apache-2.0",
@@ -18,7 +18,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node scripts/test-paste.mjs && node scripts/test-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-drag-scroll.mjs && node scripts/test-selection-performance.mjs && node scripts/test-copy.mjs && node scripts/test-scrollbar.mjs && node scripts/test-render.mjs && node scripts/test-drift.mjs && node scripts/test-sanitize.mjs && node scripts/test-markdown.mjs && node scripts/test-wrap.mjs && node scripts/test-fetch.mjs && node scripts/test-compact.mjs && node scripts/test-history-fold.mjs && node scripts/test-web-history.mjs && node scripts/test-web-default.mjs && node scripts/test-turn-fold.mjs && node scripts/test-plan.mjs && node scripts/test-subagent.mjs && node scripts/test-web-settings.mjs && node scripts/test-tools.mjs && node scripts/test-approval.mjs && node scripts/test-approval-review.mjs && node scripts/test-approval-ui.mjs && node scripts/test-web-approval-details.mjs && node scripts/test-approval-mode.mjs && node scripts/test-approval-context.mjs && node scripts/test-settings-render.mjs && node scripts/test-approval-flow.mjs && node scripts/test-web.mjs && node scripts/test-web-settings-http.mjs && node scripts/test-web-auth.mjs && node scripts/test-web-auth-ui.mjs && node scripts/test-interrupt.mjs && node scripts/test-terminal-lifecycle.mjs && node scripts/test-persistence.mjs && node scripts/test-resilience.mjs && node scripts/test-approval-timeout.mjs && node scripts/test-approval-hardening.mjs && node scripts/test-approval-extreme.mjs && node scripts/test-approval-reason.mjs",
+    "test": "npm run build && node scripts/test-paste.mjs && node scripts/test-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-drag-scroll.mjs && node scripts/test-selection-performance.mjs && node scripts/test-copy.mjs && node scripts/test-scrollbar.mjs && node scripts/test-render.mjs && node scripts/test-drift.mjs && node scripts/test-sanitize.mjs && node scripts/test-markdown.mjs && node scripts/test-wrap.mjs && node scripts/test-fetch.mjs && node scripts/test-compact.mjs && node scripts/test-history-fold.mjs && node scripts/test-web-history.mjs && node scripts/test-web-default.mjs && node scripts/test-turn-fold.mjs && node scripts/test-plan.mjs && node scripts/test-subagent.mjs && node scripts/test-web-settings.mjs && node scripts/test-web-markdown.mjs && node scripts/test-web-i18n.mjs && node scripts/test-web-workspaces.mjs && node scripts/test-tools.mjs && node scripts/test-approval.mjs && node scripts/test-approval-review.mjs && node scripts/test-approval-ui.mjs && node scripts/test-web-approval-details.mjs && node scripts/test-approval-mode.mjs && node scripts/test-approval-context.mjs && node scripts/test-settings-render.mjs && node scripts/test-approval-flow.mjs && node scripts/test-web.mjs && node scripts/test-web-settings-http.mjs && node scripts/test-web-auth.mjs && node scripts/test-web-auth-ui.mjs && node scripts/test-interrupt.mjs && node scripts/test-terminal-lifecycle.mjs && node scripts/test-persistence.mjs && node scripts/test-resilience.mjs && node scripts/test-approval-timeout.mjs && node scripts/test-approval-hardening.mjs && node scripts/test-approval-extreme.mjs && node scripts/test-approval-reason.mjs",
     "prepare": "npm run build",
     "web": "node dist/bin.js web"
   },