@xingjisoft/neutrino 0.4.0 → 0.5.0

package/dist/screens/agentConversation.js

@@ -1,17 +1,22 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { drawHeader } from "../header.js";
-import { drawHint, drawScrollbar } from "../ui.js";
+import { drawHint, drawScrollbar, inRect } from "../ui.js";
 import { drawSpans, renderMarkdownText } from "../markdown.js";
-import { ellipsize } from "../width.js";
+import { displayWidth, ellipsize, truncateByWidth } from "../width.js";
+import { migrateAgentSession } from "../migration.js";
 export class AgentConversationScreen extends Screen {
+    source;
     title;
     messages;
     scrollTop = 0;
     followBottom = true;
     scrollbarGeom = null;
-    constructor(title, messages) {
+    migrateButton = null;
+    migrationError = "";
+    constructor(title, messages, source) {
         super();
+        this.source = source;
         this.title = title;
         this.messages = messages;
     }
@@ -37,6 +42,10 @@ export class AgentConversationScreen extends Screen {
         else if (key.name === "escape") {
             this.app.popScreen();
         }
+        else if (key.name === "enter" || key.name === "return" ||
+            (!key.ctrl && !key.meta && key.char.toLowerCase() === "m")) {
+            this.migrate();
+        }
     }
     onMouse(ev) {
         if (ev.type === "wheel") {
@@ -52,6 +61,28 @@ export class AgentConversationScreen extends Screen {
         else if (ev.type === "click" && ev.button === 2) {
             this.app.popScreen();
         }
+        else if (ev.type === "click" && ev.button === 0 && this.migrateButton &&
+            inRect(ev.x, ev.y, this.migrateButton)) {
+            this.migrate();
+        }
+    }
+    migrate() {
+        if (!this.messages.length)
+            return;
+        try {
+            const state = this.app.state;
+            const session = migrateAgentSession(this.source.agent, this.source.id, this.source.cwd, {
+                provider: state.selectedProvider, model: state.selectedModelName, intensity: state.selectedIntensity,
+            });
+            this.app.loadSession(session);
+        }
+        catch (error) {
+            this.migrationError = error instanceof Error ? error.message : String(error);
+            this.app.render();
+        }
+    }
+    alwaysRepaintRows() {
+        return [this.app.height - 3, this.app.height - 2, this.app.height - 1];
     }
     scrollbar() {
         const g = this.scrollbarGeom;
@@ -93,7 +124,7 @@ export class AgentConversationScreen extends Screen {
         const h = buf.height;
         buf.centerText(1, ellipsize(this.title, Math.max(10, w - 4)), { fg: C.dim });
         const logTop = 3;
-        const logBottom = h - 2;
+        const logBottom = h - 4;
         const viewH = Math.max(1, logBottom - logTop + 1);
         const lines = this.buildLines(Math.max(10, w - 4));
         const maxScroll = Math.max(0, lines.length - viewH);
@@ -118,6 +149,18 @@ export class AgentConversationScreen extends Screen {
         }
         // Scrollbar on the right edge, visible only when the log overflows.
         drawScrollbar(buf, w - 1, logTop, logBottom, lines.length, viewH, this.scrollTop);
-        drawHint(buf, h - 1, "↑/↓ scroll  ·  wheel or drag the bar  ·  right-click back  ·  Esc back");
+        if (this.migrationError) {
+            buf.writeText(2, h - 3, ellipsize(`迁移失败：${this.migrationError}`, Math.max(0, w - 4)), { fg: C.red });
+        }
+        const label = truncateByWidth("[ 迁移会话 ]", Math.max(0, w - 2));
+        const buttonWidth = displayWidth(label);
+        this.migrateButton = { x: Math.max(0, w - buttonWidth - 2), y: h - 2, w: buttonWidth, h: 1 };
+        buf.writeText(this.migrateButton.x, this.migrateButton.y, label, {
+            fg: this.messages.length ? C.accent : C.dim, bg: C.highlightBg, bold: true,
+        });
+        for (let x = this.migrateButton.x; x < this.migrateButton.x + buttonWidth; x++) {
+            buf.markChrome(x, this.migrateButton.y);
+        }
+        drawHint(buf, h - 1, "↑/↓ scroll  ·  M/Enter migrate  ·  right-click back  ·  Esc back");
     }
 }

package/dist/screens/agentHistory.js

@@ -97,8 +97,10 @@ export class AgentHistoryScreen extends Screen {
         if (this.selectedIdx < 0 || this.selectedIdx >= this.sessions.length)
             return;
         const s = this.sessions[this.selectedIdx];
-        const messages = loadAgentMessages(this.agent, s.id);
-        this.app.pushScreen(new AgentConversationScreen(`${this.label} · ${s.title || s.id}`, messages));
+        const messages = loadAgentMessages(this.agent, s.id, this.cwd);
+        this.app.pushScreen(new AgentConversationScreen(`${this.label} · ${s.title || s.id}`, messages, {
+            agent: this.agent, id: s.id, cwd: this.cwd,
+        }));
     }
     buildRows() {
         const rows = [];

package/dist/screens/settings.js

@@ -4,8 +4,9 @@ import { CONTEXT_WINDOW_OPTIONS, DEFAULT_CONTEXT_WINDOW, contextWindow, CONFIG_F
 import { drawHeader } from "../header.js";
 import { centerVertically, drawHint } from "../ui.js";
 import { hashWebPassword } from "../web/auth.js";
+import { runningBackground } from "../background.js";
 /** The settings that can be changed here, top to bottom. */
-const ROWS = ["intensity", "compress", "approval_model", "extreme_approval", "sound", "web_console", "web_password"];
+const ROWS = ["intensity", "compress", "approval_model", "extreme_approval", "sound", "web_console", "background", "web_password"];
 export class SettingsScreen extends Screen {
     intensityIdx = 2;
     /** Levels the current chat model accepts, in canonical order. */
@@ -20,8 +21,11 @@ export class SettingsScreen extends Screen {
     soundIdx = 1;
     /** 0 = web UI off, 1 = mounted alongside the terminal. */
     webIdx = 1;
+    /** 0 = terminal only, 1 = the Web console is run by a detached service. */
+    backgroundIdx = 0;
     /** Only a row the user actually touched rewrites the saved default. */
     webChanged = false;
+    backgroundPending = false;
     models = [];
     rowIdx = 0;
     lastHoverX = -1;
@@ -48,6 +52,9 @@ export class SettingsScreen extends Screen {
         // off, so reflect what is actually running first.
         this.webIdx = (this.app.state.webUrl || config.web_console !== false) ? 1 : 0;
         this.webChanged = false;
+        const background = runningBackground();
+        this.backgroundIdx = (state.webUrl ? state.webBackground : background?.resident ?? config.background === true) ? 1 : 0;
+        this.backgroundPending = false;
     }
     /** Change the value of a row by `delta` steps and persist it immediately. */
     cycle(row, delta) {
@@ -81,6 +88,13 @@ export class SettingsScreen extends Screen {
             void this.app.setWebConsole(this.webIdx === 1);
             return;
         }
+        else if (row === "background") {
+            if (this.backgroundPending)
+                return;
+            const service = runningBackground();
+            const current = this.app.state.webUrl ? this.app.state.webBackground : service?.resident ?? this.backgroundIdx === 1;
+            return this.applyBackground(!current);
+        }
         else {
             const options = [...new Set([...CONTEXT_WINDOW_OPTIONS, this.contextTokens])].sort((a, b) => a - b);
             const i = options.indexOf(this.contextTokens);
@@ -89,6 +103,23 @@ export class SettingsScreen extends Screen {
         }
         this.save();
     }
+    async applyBackground(enabled) {
+        this.backgroundPending = true;
+        this.app.render();
+        try {
+            const result = await this.app.setBackgroundResidency(enabled);
+            if (result.ok)
+                this.backgroundIdx = enabled ? 1 : 0;
+            else
+                this.backgroundIdx = loadConfig().background === true ? 1 : 0;
+            if (this.app.state.webUrl)
+                this.webIdx = 1;
+        }
+        finally {
+            this.backgroundPending = false;
+            this.app.render();
+        }
+    }
     onKey(key) {
         if (this.editingPassword) {
             if (key.name === "escape") {
@@ -233,9 +264,19 @@ export class SettingsScreen extends Screen {
                 value: this.webIdx === 0
                     ? "Off"
                     : this.app.state.webUrl
-                        ? `On · ${this.app.state.webUrl}`
+                        ? this.app.state.webBackground
+                            ? `On (background) · ${this.app.state.webUrl}`
+                            : `On · ${this.app.state.webUrl}`
                         : "On (not running)",
             },
+            {
+                label: "Background residency",
+                value: this.backgroundPending
+                    ? "Applying…"
+                    : this.app.state.webUrl
+                        ? this.app.state.webBackground ? "On (running)" : "Off"
+                        : runningBackground()?.resident ? "On (running)" : this.backgroundIdx === 1 ? "On (not running)" : "Off",
+            },
             {
                 label: "Web password",
                 value: this.editingPassword ? "*".repeat(Math.min(this.passwordDraft.length, 24)) || "Type new password" : this.passwordMessage,

package/dist/screens/start.js

@@ -2,7 +2,7 @@ import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { loadLogo, loadVersion, loadConfig, saveConfig, normalizeApprovalMode } from "../config.js";
 import { drawHeader } from "../header.js";
-import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, approvalToggle, drawApprovalToggle, drawProModeButton, proModeButton, } from "../ui.js";
+import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, approvalToggle, drawApprovalToggle, drawHeaderButton, proModeButton, webModeButton, } from "../ui.js";
 const TABS = ["Model", "History", "Settings"];
 const LOGO = loadLogo();
 const FOCUS_COUNT = TABS.length + 2; // input box + 3 tabs + approval mode
@@ -31,6 +31,7 @@ export class StartScreen extends Screen {
     focusIdx = 0; // 0 = input box, 1..3 = tabs, 4 = approval mode
     hoverIdx = -1; // -1 = nothing, otherwise the control index
     proHover = false; // pointer is over the Pro-mode button
+    webHover = false; // pointer is over the Web-mode button
     lastHoverX = -1;
     lastHoverY = -1;
     showsCursor() {
@@ -138,12 +139,15 @@ export class StartScreen extends Screen {
             this.lastHoverX = ev.x;
             this.lastHoverY = ev.y;
             const pro = proModeButton(this.app.width, this.app.height);
+            const web = webModeButton(this.app.width, this.app.height);
             const proHover = pro !== null && inRect(ev.x, ev.y, pro);
+            const webHover = web !== null && inRect(ev.x, ev.y, web);
             const layout = this.layout();
             let hover = -1;
-            // While the pointer is over the Pro button no other control is hovered
-            // underneath it: the box is opaque, so its neighbours must not light up.
-            if (!proHover) {
+            // While the pointer is over one of the top-left buttons no other control
+            // is hovered underneath it: the boxes are opaque, so their neighbours
+            // must not light up.
+            if (!proHover && !webHover) {
                 if (inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
                     hover = FOCUS_COUNT - 1;
                 }
@@ -159,8 +163,9 @@ export class StartScreen extends Screen {
                     }
                 }
             }
-            if (proHover !== this.proHover || hover !== this.hoverIdx) {
+            if (proHover !== this.proHover || webHover !== this.webHover || hover !== this.hoverIdx) {
                 this.proHover = proHover;
+                this.webHover = webHover;
                 this.hoverIdx = hover;
                 this.app.render();
             }
@@ -172,13 +177,19 @@ export class StartScreen extends Screen {
                 return;
             if (ev.button === 2)
                 return; // right click: no-op on start screen
-            // The Pro button is a control of its own and is checked first: a left
-            // click anywhere in its box opens Pro mode instead of the control below.
+            // The top-left buttons are controls of their own and are checked first:
+            // a left click anywhere in a box opens its workspace instead of the
+            // control below.
             const pro = proModeButton(this.app.width, this.app.height);
             if (ev.button === 0 && pro && inRect(ev.x, ev.y, pro)) {
                 void this.app.openProMode();
                 return;
             }
+            const web = webModeButton(this.app.width, this.app.height);
+            if (ev.button === 0 && web && inRect(ev.x, ev.y, web)) {
+                void this.app.openWebMode();
+                return;
+            }
             if (ev.y >= 1 && inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
                 this.focusIdx = FOCUS_COUNT - 1;
                 this.toggleApproval();
@@ -224,8 +235,8 @@ export class StartScreen extends Screen {
         for (let y = inputY; y <= tabY + TAB_H; y++)
             if (y >= 0 && y < h)
                 rows.push(y);
-        // The Pro button sits directly below the status bar; repainting its rows
-        // makes it self-heal exactly like the input box and the tabs.
+        // The top-left buttons sit directly below the status bar; repainting their
+        // rows makes them self-heal exactly like the input box and the tabs.
         for (let y = 1; y <= 3; y++)
             if (y >= 0 && y < h)
                 rows.push(y);
@@ -259,8 +270,8 @@ export class StartScreen extends Screen {
     }
     /**
      * First content row. The centered block normally floats in the middle, but
-     * it must start below the Pro button when that button is visible: the box is
-     * opaque chrome and would otherwise clip the top of the logo.
+     * it must start below the top-left buttons when they are visible: the boxes
+     * are opaque chrome and would otherwise clip the top of the logo.
      */
     contentTop(height, contentH) {
         const top = centerVertically(height - 4, contentH);
@@ -353,8 +364,9 @@ export class StartScreen extends Screen {
             buf.centerText(versionY, `v${version}`, { fg: C.dim });
         }
         drawApprovalToggle(buf, approvalY, this.approvalMode, this.focusIdx === FOCUS_COUNT - 1 || this.hoverIdx === FOCUS_COUNT - 1);
-        // Painted last so its opaque footprint is never clipped by the decorative
-        // content above it. Its hit box uses the same top-left geometry.
-        drawProModeButton(buf, this.proHover);
+        // Painted last so their opaque footprints are never clipped by the
+        // decorative content drawn before them. Hit testing shares the geometry.
+        drawHeaderButton(buf, proModeButton(w, h), this.proHover);
+        drawHeaderButton(buf, webModeButton(w, h), this.webHover);
     }
 }

package/dist/screens/updatePrompt.js

@@ -0,0 +1,200 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { drawHeader } from "../header.js";
+import { drawHint, drawTabButton, inRect, wrapText } from "../ui.js";
+import { MANUAL_UPDATE_COMMAND, installUpdate } from "../update.js";
+const TITLE_ROW = 2;
+const META_ROW = 3;
+const BODY_TOP = 5;
+const BUTTON_H = 3;
+const BUTTON_X = 1;
+const BODY_X = 3;
+/**
+ * The "a newer Neutrino is published" notice.
+ *
+ * It is pushed over the start screen only, never over a conversation: the
+ * answer arrives a moment after launch, and stealing a chat the user has
+ * already opened would be worse than a missed notice.
+ *
+ * Confirming runs npm here, in this process; the running code is not replaced,
+ * so a successful update ends by telling the user to restart. A failed one
+ * shows the command to run by hand, because npm usually fails for a reason the
+ * user has to fix (permissions, a proxy, an offline machine).
+ */
+export class UpdatePromptScreen extends Screen {
+    phase = "prompt";
+    /** Why the install failed, or which version landed. */
+    detail = "";
+    selectedIdx = 0;
+    lastHoverX = -1;
+    lastHoverY = -1;
+    current;
+    latest;
+    constructor(status) {
+        super();
+        this.current = status.currentVersion;
+        this.latest = status.latestVersion;
+    }
+    /** The buttons drawn right now; a click always lands on one of these. */
+    buttons() {
+        if (this.phase === "prompt")
+            return ["Update now", "Later"];
+        if (this.phase === "installing")
+            return [];
+        return ["Close"];
+    }
+    buttonRow(index) {
+        const count = this.buttons().length;
+        const top = this.app.height - 1 - count * BUTTON_H;
+        return top + index * BUTTON_H;
+    }
+    /** Columns the body paragraphs may use before wrapping. */
+    bodyWidth() {
+        return Math.max(10, this.app.width - BODY_X * 2);
+    }
+    start() {
+        if (this.phase !== "prompt")
+            return;
+        this.phase = "installing";
+        this.selectedIdx = 0;
+        this.app.render();
+        void installUpdate().then((result) => {
+            this.phase = result.ok ? "updated" : "failed";
+            this.detail = result.ok
+                ? result.version || this.latest
+                : result.error || "npm did not report a reason.";
+            this.selectedIdx = 0;
+            this.app.render();
+        });
+    }
+    close() {
+        if (this.phase === "installing")
+            return;
+        this.app.popScreen();
+    }
+    activate(index) {
+        const label = this.buttons()[index];
+        if (!label)
+            return;
+        if (label === "Update now")
+            this.start();
+        else
+            this.close();
+    }
+    move(delta) {
+        const count = this.buttons().length;
+        if (count === 0)
+            return;
+        this.selectedIdx = (this.selectedIdx + delta + count) % count;
+        this.app.render();
+    }
+    onKey(key) {
+        if (key.name === "up")
+            this.move(-1);
+        else if (key.name === "down")
+            this.move(1);
+        else if (key.name === "return" || key.name === "enter")
+            this.activate(this.selectedIdx);
+        else if (key.name === "escape")
+            this.close();
+    }
+    onMouse(ev) {
+        const count = this.buttons().length;
+        const indexAt = (x, y) => {
+            for (let i = 0; i < count; i++) {
+                if (inRect(x, y, { x: BUTTON_X, y: this.buttonRow(i), w: this.app.width - 2, h: BUTTON_H }))
+                    return i;
+            }
+            return -1;
+        };
+        if (ev.type === "move") {
+            if (ev.x === this.lastHoverX && ev.y === this.lastHoverY)
+                return;
+            this.lastHoverX = ev.x;
+            this.lastHoverY = ev.y;
+            const hover = indexAt(ev.x, ev.y);
+            if (hover >= 0 && hover !== this.selectedIdx) {
+                this.selectedIdx = hover;
+                this.app.render();
+            }
+            return;
+        }
+        if (ev.type === "wheel") {
+            this.move(ev.dir === -1 ? -1 : 1);
+            return;
+        }
+        if (ev.type === "click") {
+            if (ev.button === 2) {
+                this.close();
+                return;
+            }
+            const index = indexAt(ev.x, ev.y);
+            if (index < 0)
+                return;
+            this.selectedIdx = index;
+            this.activate(index);
+        }
+    }
+    /** What the dialog says, in the order it is drawn. */
+    body() {
+        const normal = { fg: C.white };
+        const note = { fg: C.dim };
+        if (this.phase === "installing") {
+            return [
+                { text: `Installing Neutrino ${this.latest} with npm…`, style: normal },
+                { text: "This can take a minute. Neutrino keeps running while npm works.", style: note },
+            ];
+        }
+        if (this.phase === "updated") {
+            return [
+                { text: `Neutrino ${this.detail} was installed.`, style: { fg: C.green, bold: true } },
+                { text: "Restart Neutrino to run the new version: this terminal keeps the old one until it exits.", style: normal },
+            ];
+        }
+        if (this.phase === "failed") {
+            return [
+                { text: "The automatic update failed. Neutrino was not changed.", style: { fg: C.red, bold: true } },
+                { text: this.detail, style: normal },
+                { text: "Update by hand with:", style: note },
+                { text: MANUAL_UPDATE_COMMAND, style: { fg: C.accent, bold: true } },
+            ];
+        }
+        return [
+            { text: `Neutrino ${this.latest} is available.`, style: normal },
+            { text: "Update now installs it with npm. Restart Neutrino afterwards to use it.", style: note },
+        ];
+    }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        const h = buf.height;
+        const title = this.phase === "prompt" ? "Update available"
+            : this.phase === "installing" ? "Updating Neutrino"
+                : this.phase === "updated" ? "Update installed"
+                    : "Update failed";
+        buf.centerText(TITLE_ROW, title, { fg: C.accent, bold: true });
+        buf.centerText(META_ROW, `Running ${this.current} · Published ${this.latest}`, { fg: C.dim });
+        // Body paragraphs wrap to the terminal width so a narrow window still reads,
+        // and stop above the buttons so the two can never overlap.
+        const width = this.bodyWidth();
+        const bodyEnd = h - 1 - this.buttons().length * BUTTON_H;
+        let y = BODY_TOP;
+        for (const line of this.body()) {
+            for (const piece of wrapText(line.text, width)) {
+                if (y >= bodyEnd)
+                    break;
+                buf.writeText(BODY_X, y, piece, line.style);
+                y++;
+            }
+        }
+        const buttons = this.buttons();
+        for (let i = 0; i < buttons.length; i++) {
+            drawTabButton(buf, BUTTON_X, this.buttonRow(i), buf.width - BUTTON_X * 2, buttons[i], i === this.selectedIdx);
+        }
+        const hint = this.phase === "installing"
+            ? "npm is running; this screen closes when it finishes"
+            : buttons.length > 1
+                ? "↑/↓ select · Enter confirm · click to choose · Esc later"
+                : "Enter or Esc close";
+        drawHint(buf, h - 1, hint);
+    }
+}

package/dist/state.js

@@ -11,6 +11,7 @@ export function defaultState() {
         cursorOn: true,
         approval: null,
         webUrl: null,
+        webBackground: false,
         selection: null,
     };
 }

package/dist/terminal/restore.js

@@ -89,17 +89,7 @@ export function writeCrashLog(kind, err) {
         return null;
     }
 }
-/**
- * Installs process-wide handlers that restore the terminal before the process
- * dies.
- *
- * Without this, any throw that escapes a timer, a stream callback or a floating
- * promise kills the process with raw mode still on and the alternate screen
- * still active. The visible result is a terminal that works but spews
- * `[<b>;<x>;<y>M` mouse reports at the shell prompt, because the shell now
- * receives the mouse events the TUI asked the terminal to send.
- */
-export function installCrashGuard() {
+export function installCrashGuard(options = {}) {
     if (installed)
         return;
     installed = true;
@@ -123,7 +113,8 @@ export function installCrashGuard() {
     });
     // These signals otherwise bypass Node's exit hook, including Ctrl+Break on
     // Windows. The app handles SIGINT as an interrupt and SIGTERM as a quit.
-    process.on("SIGHUP", () => process.exit(129));
+    if (!options.surviveHangup)
+        process.on("SIGHUP", () => process.exit(129));
     process.on("SIGBREAK", () => process.exit(149));
     const fatal = (kind, err) => {
         // Restore first: the terminal must be usable even if logging itself fails.

package/dist/tray.js

@@ -0,0 +1,138 @@
+/**
+ * Windows notification-area icon for the background Web console.
+ *
+ * Node cannot create a tray icon by itself, and the project deliberately has
+ * no native dependencies, so a tiny Windows PowerShell process hosts a
+ * `System.Windows.Forms.NotifyIcon`. It uses the same orbit badge as the
+ * regular console's top-left mark. Everything is best-effort: an unavailable
+ * icon must never stop the service.
+ */
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { BACKGROUND_LOG_FILE, backgroundLog } from "./background.js";
+import { NEUTRINO_DIR } from "./config.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = path.resolve(__dirname, "..");
+const ICON_FILE = path.join(PKG_ROOT, "assets", "neutrino.ico");
+/** Quote a value as a PowerShell single-quoted literal. */
+function psString(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+/** The icon itself. Only Windows has a notification area, and only it can run this. */
+export function startBackgroundTray(options) {
+    if (process.platform !== "win32")
+        return null;
+    if (process.env.NEUTRINO_NO_TRAY === "1")
+        return null;
+    if (!fs.existsSync(ICON_FILE)) {
+        backgroundLog(`tray icon not found at ${ICON_FILE}`);
+        return null;
+    }
+    // Separate files let an old icon close cleanly even if residency is turned
+    // back on before its PowerShell message loop has processed the shutdown.
+    const suffix = `${process.pid}-${randomBytes(8).toString("hex")}`;
+    const scriptFile = path.join(NEUTRINO_DIR, `tray-${suffix}.ps1`);
+    const closeFile = path.join(NEUTRINO_DIR, `tray-${suffix}.stop`);
+    const script = `
+$ErrorActionPreference = 'Continue'
+$scriptFile = ${psString(scriptFile)}
+$closeFile = ${psString(closeFile)}
+try {
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$iconPath = ${psString(ICON_FILE)}
+$url = ${psString(options.url)}
+$stopUrl = ${psString(options.stopUrl)}
+$token = ${psString(options.token)}
+$parent = ${options.pid}
+$notify = New-Object System.Windows.Forms.NotifyIcon
+$notify.Icon = New-Object System.Drawing.Icon($iconPath)
+$notify.Text = 'Neutrino - background console'
+$notify.Visible = $true
+$menu = New-Object System.Windows.Forms.ContextMenuStrip
+$open = $menu.Items.Add('Open Neutrino console')
+$open.add_Click({ Start-Process -FilePath $url })
+$stop = $menu.Items.Add('Stop background service')
+$stop.add_Click({
+  try {
+    Invoke-RestMethod -Method Post -Uri $stopUrl -Headers @{ Authorization = "Bearer $token" } -TimeoutSec 5 | Out-Null
+  } catch {
+    Stop-Process -Id $parent -Force
+  }
+  $notify.Visible = $false
+  [System.Windows.Forms.Application]::Exit()
+})
+$menu.Items.Add((New-Object System.Windows.Forms.ToolStripSeparator)) | Out-Null
+$notify.ContextMenuStrip = $menu
+$notify.add_MouseClick({ param($sender, $eventArgs) if ($eventArgs.Button -eq [System.Windows.Forms.MouseButtons]::Left) { Start-Process -FilePath $url } })
+$notify.add_DoubleClick({ Start-Process -FilePath $url })
+$timer = New-Object System.Windows.Forms.Timer
+$timer.Interval = 250
+$timer.add_Tick({
+  if ((Test-Path -LiteralPath $closeFile) -or -not (Get-Process -Id $parent -ErrorAction SilentlyContinue)) {
+    $notify.Visible = $false
+    [System.Windows.Forms.Application]::Exit()
+  }
+})
+$timer.Start()
+[System.Windows.Forms.Application]::Run()
+} finally {
+  if ($notify) { $notify.Visible = $false; $notify.Dispose() }
+  Remove-Item -LiteralPath $closeFile, $scriptFile -Force -ErrorAction SilentlyContinue
+}
+`;
+    const cleanup = () => {
+        for (const file of [scriptFile, closeFile]) {
+            try {
+                fs.rmSync(file, { force: true });
+            }
+            catch { /* The helper also cleans up. */ }
+        }
+    };
+    try {
+        fs.mkdirSync(NEUTRINO_DIR, { recursive: true });
+        fs.writeFileSync(scriptFile, `\ufeff${script}`, { encoding: "utf-8", mode: 0o600 });
+        const logFd = fs.openSync(BACKGROUND_LOG_FILE, "a");
+        let child;
+        try {
+            child = spawn("powershell.exe", [
+                "-NoProfile", "-NonInteractive", "-STA", "-ExecutionPolicy", "Bypass", "-WindowStyle", "Hidden",
+                "-File", scriptFile,
+            ], 
+            // Not detached: on Windows a detached PowerShell exits before its
+            // message loop starts. The icon outlives the service on its own; its
+            // timer notices the parent pid disappearing and shuts it down.
+            { stdio: ["ignore", "ignore", logFd], windowsHide: true });
+        }
+        finally {
+            fs.closeSync(logFd);
+        }
+        let active = true;
+        child.once("error", (error) => { active = false; cleanup(); backgroundLog(`tray failed: ${error.message}`); });
+        child.once("exit", (code) => { active = false; cleanup(); backgroundLog(`tray exited (${code ?? "signal"})`); });
+        child.unref();
+        backgroundLog(`tray icon started (pid ${child.pid ?? "unknown"})`);
+        return { close: () => {
+                if (!active)
+                    return;
+                try {
+                    fs.writeFileSync(closeFile, "", { mode: 0o600 });
+                }
+                catch {
+                    try {
+                        child.kill();
+                    }
+                    catch { /* Already gone. */ }
+                }
+            } };
+    }
+    catch (error) {
+        cleanup();
+        backgroundLog(`tray failed: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}