@geminilight/mindos 0.5.56 → 0.5.58

package/app/lib/core/fs-ops.ts

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { resolveSafe, assertWithinRoot } from './security';
 import { MindOSError, ErrorCodes } from '@/lib/errors';
-import { scaffoldIfNewSpace } from './space-scaffold';
+import { scaffoldIfNewSpace, cleanDirName, INSTRUCTION_TEMPLATE, README_TEMPLATE } from './space-scaffold';
 
 /**
  * Reads the content of a file given a relative path from mindRoot.
@@ -55,6 +55,48 @@ export function deleteFile(mindRoot: string, filePath: string): void {
   fs.unlinkSync(resolved);
 }
 
+/**
+ * Recursively deletes a directory and all its contents.
+ * Throws if the path does not exist, is outside mindRoot, or is not a directory.
+ */
+export function deleteDirectory(mindRoot: string, dirPath: string): void {
+  const resolved = resolveSafe(mindRoot, dirPath);
+  if (!fs.existsSync(resolved)) {
+    throw new MindOSError(ErrorCodes.FILE_NOT_FOUND, `Directory not found: ${dirPath}`, { dirPath });
+  }
+  if (!fs.statSync(resolved).isDirectory()) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, `Not a directory: ${dirPath}`, { dirPath });
+  }
+  fs.rmSync(resolved, { recursive: true, force: true });
+}
+
+/**
+ * Converts an existing directory into a Space by creating INSTRUCTION.md
+ * (and README.md if missing). Idempotent — skips files that already exist.
+ */
+export function convertToSpace(mindRoot: string, dirPath: string): void {
+  const resolved = resolveSafe(mindRoot, dirPath);
+  if (!fs.existsSync(resolved)) {
+    throw new MindOSError(ErrorCodes.FILE_NOT_FOUND, `Directory not found: ${dirPath}`, { dirPath });
+  }
+  if (!fs.statSync(resolved).isDirectory()) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, `Not a directory: ${dirPath}`, { dirPath });
+  }
+
+  const dirName = path.basename(resolved);
+  const name = cleanDirName(dirName);
+
+  const instructionPath = path.join(resolved, 'INSTRUCTION.md');
+  if (!fs.existsSync(instructionPath)) {
+    fs.writeFileSync(instructionPath, INSTRUCTION_TEMPLATE(name), 'utf-8');
+  }
+
+  const readmePath = path.join(resolved, 'README.md');
+  if (!fs.existsSync(readmePath)) {
+    fs.writeFileSync(readmePath, README_TEMPLATE(name), 'utf-8');
+  }
+}
+
 /**
  * Renames a file within its current directory.
  * newName must be a plain filename (no path separators).
@@ -79,6 +121,41 @@ export function renameFile(mindRoot: string, oldPath: string, newName: string):
   return path.relative(root, newResolved);
 }
 
+/**
+ * Renames a directory (Mind Space) under mindRoot. `newName` must be a single segment (no `/` or `\\`).
+ * Does not rewrite links inside markdown files.
+ */
+export function renameSpaceDirectory(mindRoot: string, spacePath: string, newName: string): string {
+  const trimmedName = newName.trim();
+  if (!trimmedName || trimmedName.includes('/') || trimmedName.includes('\\')) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, 'Invalid space name: must not contain path separators', { newName });
+  }
+  const normalized = spacePath.replace(/\/+$/g, '').trim();
+  if (!normalized) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, 'Space path is required', { spacePath });
+  }
+
+  const root = path.resolve(mindRoot);
+  const oldResolved = resolveSafe(mindRoot, normalized);
+  if (!fs.existsSync(oldResolved)) {
+    throw new MindOSError(ErrorCodes.FILE_NOT_FOUND, `Space not found: ${normalized}`, { spacePath: normalized });
+  }
+  if (!fs.statSync(oldResolved).isDirectory()) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, `Not a directory: ${normalized}`, { spacePath: normalized });
+  }
+
+  const parentDir = path.dirname(oldResolved);
+  const newResolved = path.join(parentDir, trimmedName);
+  assertWithinRoot(newResolved, root);
+
+  if (fs.existsSync(newResolved)) {
+    throw new MindOSError(ErrorCodes.FILE_ALREADY_EXISTS, 'A space with that name already exists', { newName: trimmedName });
+  }
+
+  fs.renameSync(oldResolved, newResolved);
+  return path.relative(root, newResolved);
+}
+
 /**
  * Moves a file from one path to another within mindRoot.
  * Returns the new path and a list of files that referenced the old path.

package/app/lib/core/index.ts

@@ -22,7 +22,10 @@ export {
   writeFile,
   createFile,
   deleteFile,
+  deleteDirectory,
+  convertToSpace,
   renameFile,
+  renameSpaceDirectory,
   moveFile,
   getRecentlyModified,
 } from './fs-ops';
@@ -56,3 +59,8 @@ export { findBacklinks } from './backlinks';
 
 // Git
 export { isGitRepo, gitLog, gitShowFile } from './git';
+
+// Mind Space
+export { createSpaceFilesystem } from './create-space';
+export { summarizeTopLevelSpaces } from './list-spaces';
+export type { MindSpaceSummary } from './list-spaces';

package/app/lib/core/types.ts

@@ -1,3 +1,8 @@
+export interface SpacePreview {
+  instructionLines: string[];
+  readmeLines: string[];
+}
+
 export interface FileNode {
   name: string;
   path: string;
@@ -5,6 +10,8 @@ export interface FileNode {
   children?: FileNode[];
   extension?: string;
   mtime?: number;
+  isSpace?: boolean;
+  spacePreview?: SpacePreview;
 }
 
 export interface SearchResult {

package/app/lib/fs.ts

@@ -7,7 +7,10 @@ import {
   writeFile as coreWriteFile,
   createFile as coreCreateFile,
   deleteFile as coreDeleteFile,
+  deleteDirectory as coreDeleteDirectory,
+  convertToSpace as coreConvertToSpace,
   renameFile as coreRenameFile,
+  renameSpaceDirectory as coreRenameSpaceDirectory,
   moveFile as coreMoveFile,
   readLines as coreReadLines,
   insertLines as coreInsertLines,
@@ -21,8 +24,10 @@ import {
   gitLog as coreGitLog,
   gitShowFile as coreGitShowFile,
   invalidateSearchIndex,
+  summarizeTopLevelSpaces,
 } from './core';
-import { FileNode } from './core/types';
+import type { MindSpaceSummary } from './core';
+import { FileNode, SpacePreview } from './core/types';
 import { SearchMatch } from './types';
 import { effectiveSopRoot } from './settings';
 
@@ -77,8 +82,31 @@ function ensureCache(): FileTreeCache {
 
 // ─── Internal builders ────────────────────────────────────────────────────────
 
-function buildFileTree(dirPath: string): FileNode[] {
-  const root = getMindRoot();
+const SPACE_PREVIEW_MAX_LINES = 3;
+
+function extractBodyLines(filePath: string, maxLines: number): string[] {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const bodyLines: string[] = [];
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      bodyLines.push(trimmed);
+      if (bodyLines.length >= maxLines) break;
+    }
+    return bodyLines;
+  } catch { return []; }
+}
+
+function buildSpacePreview(dirAbsPath: string) {
+  return {
+    instructionLines: extractBodyLines(path.join(dirAbsPath, 'INSTRUCTION.md'), SPACE_PREVIEW_MAX_LINES),
+    readmeLines: extractBodyLines(path.join(dirAbsPath, 'README.md'), SPACE_PREVIEW_MAX_LINES),
+  };
+}
+
+function buildFileTree(dirPath: string, rootOverride?: string): FileNode[] {
+  const root = rootOverride ?? getMindRoot();
   let entries: fs.Dirent[];
   try {
     entries = fs.readdirSync(dirPath, { withFileTypes: true });
@@ -94,9 +122,15 @@ function buildFileTree(dirPath: string): FileNode[] {
 
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const children = buildFileTree(fullPath);
+      const children = buildFileTree(fullPath, root);
       if (children.length > 0) {
-        nodes.push({ name: entry.name, path: relativePath, type: 'directory', children });
+        const hasInstruction = children.some(c => c.type === 'file' && c.name === 'INSTRUCTION.md');
+        const node: FileNode = { name: entry.name, path: relativePath, type: 'directory', children };
+        if (hasInstruction) {
+          node.isSpace = true;
+          node.spacePreview = buildSpacePreview(fullPath);
+        }
+        nodes.push(node);
       }
     } else if (entry.isFile()) {
       const ext = path.extname(entry.name).toLowerCase();
@@ -114,6 +148,11 @@ function buildFileTree(dirPath: string): FileNode[] {
   return nodes;
 }
 
+/** Exposed for testing only — builds a file tree from an arbitrary root path. */
+export function buildFileTreeForTest(rootPath: string): FileNode[] {
+  return buildFileTree(rootPath, rootPath);
+}
+
 function buildAllFiles(dirPath: string): string[] {
   const root = getMindRoot();
   let entries: fs.Dirent[];
@@ -146,6 +185,20 @@ export function getFileTree(): FileNode[] {
   return ensureCache().tree;
 }
 
+/** Top-level Mind Spaces (same cached tree as home Spaces grid). */
+export function listMindSpaces(): MindSpaceSummary[] {
+  return summarizeTopLevelSpaces(getMindRoot(), ensureCache().tree);
+}
+
+/** Returns space preview (INSTRUCTION + README excerpts) for a directory, or null if not a space. */
+export function getSpacePreview(dirPath: string): SpacePreview | null {
+  const root = getMindRoot();
+  const abs = path.join(root, dirPath);
+  const instructionPath = path.join(abs, 'INSTRUCTION.md');
+  if (!fs.existsSync(instructionPath)) return null;
+  return buildSpacePreview(abs);
+}
+
 /** Returns cached list of all file paths (relative to MIND_ROOT). */
 export function collectAllFiles(): string[] {
   return ensureCache().allFiles;
@@ -251,6 +304,25 @@ export function renameFile(oldPath: string, newName: string): string {
   return result;
 }
 
+/** Renames a Space directory under MIND_ROOT. newName must be a single path segment. */
+export function renameSpace(spacePath: string, newName: string): string {
+  const result = coreRenameSpaceDirectory(getMindRoot(), spacePath, newName);
+  invalidateCache();
+  return result;
+}
+
+/** Recursively deletes a directory under MIND_ROOT. */
+export function deleteDirectory(dirPath: string): void {
+  coreDeleteDirectory(getMindRoot(), dirPath);
+  invalidateCache();
+}
+
+/** Converts a regular folder into a Space by adding INSTRUCTION.md + README.md. */
+export function convertToSpace(dirPath: string): void {
+  coreConvertToSpace(getMindRoot(), dirPath);
+  invalidateCache();
+}
+
 // ─── Public API: Line-level operations (delegated to @mindos/core) ───────────
 
 export function readLines(filePath: string): string[] {
@@ -471,6 +543,7 @@ export function gitShowFile(filePath: string, commit: string): string {
 
 import type { BacklinkEntry } from './core/types';
 export type { BacklinkEntry } from './core/types';
+export type { MindSpaceSummary } from './core';
 
 export function findBacklinks(targetPath: string): BacklinkEntry[] {
   return coreFindBacklinks(getMindRoot(), targetPath);

package/app/lib/i18n-en.ts

@@ -97,6 +97,11 @@ export const en = {
     placeholder: 'Ask a question... or type @ to attach a file',
     emptyPrompt: 'Ask anything about your knowledge base',
     send: 'send',
+    newlineHint: 'new line',
+    panelComposerResize: 'Drag up to enlarge the input area',
+    panelComposerFooter: 'Resize height',
+    panelComposerResetHint: 'Double-click to reset height',
+    panelComposerKeyboard: 'Arrow keys adjust height; Home/End min/max',
     attachFile: 'attach file',
     attachCurrent: 'attach current file',
     stopTitle: 'Stop',
@@ -273,6 +278,16 @@ export const en = {
     enterFileName: 'Enter a file name',
     failed: 'Failed',
     confirmDelete: (name: string) => `Delete "${name}"? This cannot be undone.`,
+    rules: 'Rules',
+    about: 'About',
+    viewAll: 'View all',
+    editRules: 'Edit Rules',
+    renameSpace: 'Rename Space',
+    deleteSpace: 'Delete Space',
+    confirmDeleteSpace: (name: string) => `Delete space "${name}" and all its files? This cannot be undone.`,
+    convertToSpace: 'Convert to Space',
+    deleteFolder: 'Delete Folder',
+    confirmDeleteFolder: (name: string) => `Delete folder "${name}" and all its contents? This cannot be undone.`,
   },
   dirView: {
     gridView: 'Grid view',

package/app/lib/i18n-zh.ts

@@ -122,6 +122,11 @@ export const zh = {
     placeholder: '输入问题，或输入 @ 添加附件文件',
     emptyPrompt: '可以问任何关于知识库的问题',
     send: '发送',
+    newlineHint: '换行',
+    panelComposerResize: '向上拖拽以拉高输入区',
+    panelComposerFooter: '拉高输入区',
+    panelComposerResetHint: '双击恢复默认高度',
+    panelComposerKeyboard: '方向键调节高度；Home/End 最小或最大',
     attachFile: '附加文件',
     attachCurrent: '附加当前文件',
     stopTitle: '停止',
@@ -297,6 +302,16 @@ export const zh = {
     enterFileName: '请输入文件名',
     failed: '操作失败',
     confirmDelete: (name: string) => `确定删除「${name}」？此操作不可撤销。`,
+    rules: '规则',
+    about: '说明',
+    viewAll: '查看全部',
+    editRules: '编辑规则',
+    renameSpace: '重命名空间',
+    deleteSpace: '删除空间',
+    confirmDeleteSpace: (name: string) => `删除空间「${name}」及其所有文件？此操作不可撤销。`,
+    convertToSpace: '转为空间',
+    deleteFolder: '删除文件夹',
+    confirmDeleteFolder: (name: string) => `删除文件夹「${name}」及其所有内容？此操作不可撤销。`,
   },
   dirView: {
     gridView: '网格视图',

package/app/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/app/next.config.ts

@@ -4,6 +4,7 @@ import path from "path";
 const nextConfig: NextConfig = {
   transpilePackages: ['github-slugger'],
   serverExternalPackages: ['chokidar', 'openai', '@mariozechner/pi-ai', '@mariozechner/pi-agent-core'],
+  output: 'standalone',
   outputFileTracingRoot: path.join(__dirname),
   turbopack: {
     root: path.join(__dirname),

package/bin/cli.js

@@ -394,7 +394,11 @@ const commands = {
       startSyncDaemon(mindRoot).catch(() => {});
     }
     await printStartupInfo(webPort, mcpPort);
-    run(`${NEXT_BIN} start -p ${webPort} ${extra}`, resolve(ROOT, 'app'));
+    run(
+      `${NEXT_BIN} start -p ${webPort} ${extra}`,
+      resolve(ROOT, 'app'),
+      process.env.HOSTNAME ? undefined : { HOSTNAME: '127.0.0.1' }
+    );
   },
 
   // ── build ──────────────────────────────────────────────────────────────────

package/bin/lib/utils.js

@@ -3,9 +3,13 @@ import { resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { ROOT } from './constants.js';
 
-export function run(command, cwd = ROOT) {
+/**
+ * @param {Record<string, string | undefined>} [envPatch] merged into process.env (for child only)
+ */
+export function run(command, cwd = ROOT, envPatch) {
   try {
-    execSync(command, { cwd, stdio: 'inherit', env: process.env });
+    const env = envPatch ? { ...process.env, ...envPatch } : process.env;
+    execSync(command, { cwd, stdio: 'inherit', env });
   } catch (err) {
     process.exit(err.status || 1);
   }

package/mcp/README.md

@@ -1,6 +1,6 @@
 # MindOS MCP Server
 
-Pure HTTP client wrapper that maps 20 MCP tools to the App REST API via `fetch`. Zero business logic — all operations are delegated to the App.
+Pure HTTP client wrapper that maps 22 MCP tools to the App REST API via `fetch`. Zero business logic — all operations are delegated to the App.
 
 ## Architecture
 
@@ -41,7 +41,7 @@ MCP_TRANSPORT=stdio mindos mcp   # stdio mode
 | `MCP_PORT` | `8781` | HTTP listen port (configurable via `mindos onboard`) |
 | `MCP_ENDPOINT` | `/mcp` | HTTP endpoint path |
 
-## MCP Tools (20)
+## MCP Tools (22)
 
 | Tool | App API | Description |
 |------|---------|-------------|
@@ -49,6 +49,8 @@ MCP_TRANSPORT=stdio mindos mcp   # stdio mode
 | `mindos_read_file` | `GET /api/file?path=...` | Read file content (with offset/limit pagination) |
 | `mindos_write_file` | `POST /api/file` op=save_file | Overwrite file content |
 | `mindos_create_file` | `POST /api/file` op=create_file | Create a new .md or .csv file |
+| `mindos_create_space` | `POST /api/file` op=create_space | Create a Mind Space (README + INSTRUCTION scaffold) |
+| `mindos_rename_space` | `POST /api/file` op=rename_space | Rename a Space directory (folder only) |
 | `mindos_delete_file` | `POST /api/file` op=delete_file | Delete a file |
 | `mindos_rename_file` | `POST /api/file` op=rename_file | Rename a file (same directory) |
 | `mindos_move_file` | `POST /api/file` op=move_file | Move a file to a new path |

package/mcp/package.json

@@ -8,11 +8,11 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.0",
+    "tsx": "^4.19.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/node": "^22",
-    "tsx": "^4.19.0",
     "typescript": "^5"
   }
 }

package/mcp/src/index.ts

@@ -173,6 +173,56 @@ server.registerTool("mindos_create_file", {
   } catch (e) { logOp("mindos_create_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
+// ── mindos_create_space ─────────────────────────────────────────────────────
+
+server.registerTool("mindos_create_space", {
+  title: "Create Mind Space",
+  description:
+    "Create a new Mind Space (top-level or under parent_path): directory + README.md + INSTRUCTION.md scaffold. Use this instead of create_file when adding a new cognitive zone to the knowledge base.",
+  inputSchema: z.object({
+    name: z.string().min(1).describe("Space directory name (no path separators)"),
+    description: z.string().default("").describe("Short purpose text stored in README.md"),
+    parent_path: z.string().default("").describe("Optional parent directory under MIND_ROOT (empty = top-level Space)"),
+  }),
+}, async ({ name, description, parent_path }) => {
+  try {
+    const json = await post("/api/file", {
+      op: "create_space",
+      path: "_",
+      name,
+      description,
+      parent_path,
+    });
+    const p = json.path as string;
+    logOp("mindos_create_space", { name, parent_path }, "ok", p);
+    return ok(`Created Mind Space at "${p}"`);
+  } catch (e) {
+    logOp("mindos_create_space", { name, parent_path }, "error", String(e));
+    return error(String(e));
+  }
+});
+
+// ── mindos_rename_space ─────────────────────────────────────────────────────
+
+server.registerTool("mindos_rename_space", {
+  title: "Rename Mind Space",
+  description:
+    "Rename a Space directory (relative path to the folder, e.g. Notes or Work/Notes). Only the final folder name changes; new_name must be a single segment. Does not rewrite links inside files.",
+  inputSchema: z.object({
+    path: z.string().min(1).describe("Relative path to the space directory to rename"),
+    new_name: z.string().min(1).describe("New folder name only (no slashes)"),
+  }),
+}, async ({ path: spacePath, new_name }) => {
+  try {
+    const json = await post("/api/file", { op: "rename_space", path: spacePath, new_name });
+    logOp("mindos_rename_space", { path: spacePath, new_name }, "ok", String(json.newPath));
+    return ok(`Renamed space "${spacePath}" → "${json.newPath}"`);
+  } catch (e) {
+    logOp("mindos_rename_space", { path: spacePath, new_name }, "error", String(e));
+    return error(String(e));
+  }
+});
+
 // ── mindos_delete_file ──────────────────────────────────────────────────────
 
 server.registerTool("mindos_delete_file", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.5.56",
+  "version": "0.5.58",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",
@@ -64,6 +64,7 @@
     "start": "mindos start",
     "mcp": "mindos mcp",
     "test": "cd app && npx vitest run",
+    "verify:standalone": "node scripts/verify-standalone.mjs",
     "release": "bash scripts/release.sh"
   },
   "engines": {

package/scripts/release.sh

@@ -28,6 +28,13 @@ else
   exit 1
 fi
 cd ..
+echo "🩺 Verifying standalone server (/api/health)..."
+if node scripts/verify-standalone.mjs; then
+  echo "   ✅ Standalone smoke OK"
+else
+  echo "❌ Standalone verify failed (trace / serverExternalPackages?)"
+  exit 1
+fi
 # Restore any files modified by next build (e.g. next-env.d.ts)
 git checkout -- . 2>/dev/null || true
 echo ""

package/scripts/verify-standalone.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+/**
+ * Smoke-test Next standalone server: merge static/public, spawn server.js, GET /api/health.
+ * Catches missing serverExternalPackages / file-trace gaps (MODULE_NOT_FOUND at startup).
+ *
+ * Run from repo root after: cd app && ./node_modules/.bin/next build
+ *   node scripts/verify-standalone.mjs
+ *
+ * @see wiki/specs/spec-desktop-standalone-runtime.md
+ */
+import { spawn } from 'child_process';
+import http from 'http';
+import { existsSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { materializeStandaloneAssets } from '../desktop/scripts/prepare-mindos-bundle.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(__dirname, '..');
+const appDir = path.join(root, 'app');
+const serverJs = path.join(appDir, '.next', 'standalone', 'server.js');
+
+if (!existsSync(serverJs)) {
+  console.error(
+    `[verify-standalone] Missing ${serverJs}\nBuild first: cd app && ./node_modules/.bin/next build`
+  );
+  process.exit(1);
+}
+
+try {
+  materializeStandaloneAssets(appDir);
+} catch (e) {
+  console.error(e instanceof Error ? e.message : String(e));
+  process.exit(1);
+}
+
+const port = 31000 + Math.floor(Math.random() * 5000);
+const nodeBin = process.execPath;
+
+function waitHealth(timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve, reject) => {
+    const tick = () => {
+      if (Date.now() > deadline) {
+        reject(new Error(`Timeout waiting for http://127.0.0.1:${port}/api/health`));
+        return;
+      }
+      const req = http.get(
+        `http://127.0.0.1:${port}/api/health`,
+        { timeout: 2000 },
+        (res) => {
+          let body = '';
+          res.on('data', (c) => {
+            body += c;
+          });
+          res.on('end', () => {
+            if (res.statusCode === 200) {
+              try {
+                const j = JSON.parse(body);
+                if (j.ok === true && j.service === 'mindos') {
+                  resolve();
+                  return;
+                }
+              } catch {
+                /* fall through */
+              }
+            }
+            setTimeout(tick, 300);
+          });
+        }
+      );
+      req.on('error', () => {
+        setTimeout(tick, 300);
+      });
+      req.on('timeout', () => {
+        req.destroy();
+        setTimeout(tick, 300);
+      });
+    };
+    tick();
+  });
+}
+
+let stderr = '';
+const child = spawn(nodeBin, [serverJs], {
+  cwd: appDir,
+  env: {
+    ...process.env,
+    NODE_ENV: 'production',
+    PORT: String(port),
+    /** Next binds to machine hostname by default; Desktop health checks use 127.0.0.1 */
+    HOSTNAME: '127.0.0.1',
+  },
+  stdio: ['ignore', 'pipe', 'pipe'],
+});
+
+child.stderr?.on('data', (c) => {
+  stderr += c.toString();
+});
+
+function killChild() {
+  try {
+    child.kill('SIGTERM');
+  } catch {
+    /* ignore */
+  }
+}
+
+async function main() {
+  try {
+    await waitHealth(90_000);
+    console.log(`[verify-standalone] OK (port ${port})`);
+    return 0;
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    if (stderr.trim()) console.error('--- server stderr (tail) ---\n', stderr.slice(-4000));
+    return 1;
+  } finally {
+    killChild();
+    await new Promise((r) => setTimeout(r, 500));
+  }
+}
+
+child.on('error', (err) => {
+  console.error('[verify-standalone] spawn failed:', err.message);
+  process.exit(1);
+});
+
+main().then((code) => process.exit(code));