dominds 1.26.0 → 1.26.2

package/dist/cli.js

@@ -1,34 +1,5 @@
 #!/usr/bin/env node
 "use strict";
-/**
- * Main CLI entry point for dominds
- *
- * Usage:
- *   dominds [subcommand] [options]
- *
- * Subcommands:
- *   webui    - Start WebUI server (default)
- *   tui      - Start Text User Interface
- *   run      - Run task dialog (alias for tui)
- *   read     - Read team configuration
- *   man      - Render toolset manual to stdout
- *   manual   - Alias for man
- *   validate_team_def - Validate explicit team toolset declarations
- *   cert     - Create and inspect local HTTPS certificates
- *   create   - Create a new runtime workspace (rtws) from a template
- *   install  - Install a Dominds App into this rtws
- *   doctor   - Diagnose Dominds App state in this rtws
- *   enable   - Enable an installed Dominds App in this rtws
- *   disable  - Disable an installed Dominds App in this rtws
- *   uninstall- Uninstall a Dominds App from this rtws
- *   update   - Update installed Dominds App(s)
- *   new      - Alias for create
- *   help     - Show help
- *
- * Global installation:
- *   pnpm add -g dominds
- *   dominds webui
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -62,315 +33,580 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configureEnvProxySupport = configureEnvProxySupport;
 exports.main = main;
-const fs = __importStar(require("fs"));
-const http = __importStar(require("node:http"));
-const path = __importStar(require("path"));
-const runtime_1 = require("./apps/runtime");
-const dotenv_1 = require("./bootstrap/dotenv");
+const child_process_1 = require("child_process");
+const promises_1 = __importDefault(require("fs/promises"));
+const net_1 = __importDefault(require("net"));
+const path_1 = __importDefault(require("path"));
+const time_1 = require("@longrun-ai/kernel/utils/time");
 const rtws_cli_1 = require("./bootstrap/rtws-cli");
-const cert_1 = require("./cli/cert");
-const create_1 = require("./cli/create");
-const disable_1 = require("./cli/disable");
-const doctor_1 = require("./cli/doctor");
-const enable_1 = require("./cli/enable");
-const install_1 = require("./cli/install");
-const manual_1 = require("./cli/manual");
-const read_1 = require("./cli/read");
-const tui_1 = require("./cli/tui");
-const uninstall_1 = require("./cli/uninstall");
-const update_1 = require("./cli/update");
-const validate_team_def_1 = require("./cli/validate-team-def");
-const webui_1 = require("./cli/webui");
-const process_title_1 = require("./process-title");
-require("./tools/builtins");
-function configureEnvProxySupport() {
-    const domindsUseEnvProxy = process.env.DOMINDS_USE_ENV_PROXY?.trim();
-    if (domindsUseEnvProxy === '0') {
-        return;
+const supervisor_protocol_1 = require("./supervisor-protocol");
+const RUNNER_JS_FILENAME = 'cli-runner.js';
+const RUNNER_TS_FILENAME = 'cli-runner.ts';
+const INITIAL_RESTART_BACKOFF_MS = 1000;
+const MAX_RESTART_BACKOFF_MS = 30 * 60 * 1000;
+const PORT_RELEASE_TIMEOUT_MS = 15000;
+const PORT_PROBE_INTERVAL_MS = 150;
+const RESTART_RUNNER_EXIT_GRACE_MS = 30000;
+const RESTART_RUNNER_KILL_GRACE_MS = 5000;
+function getDefaultRunnerCommandSpec() {
+    if (__filename.endsWith('.ts')) {
+        return {
+            command: process.execPath,
+            args: [
+                require.resolve('tsx/cli'),
+                '--tsconfig',
+                path_1.default.resolve(__dirname, 'tsconfig.dev.json'),
+                path_1.default.resolve(__dirname, RUNNER_TS_FILENAME),
+            ],
+        };
     }
-    try {
-        const setGlobalProxyFromEnv = http.setGlobalProxyFromEnv;
-        if (typeof setGlobalProxyFromEnv !== 'function') {
-            console.error('Error: DOMINDS_USE_ENV_PROXY requires Node.js 24.5+ because http.setGlobalProxyFromEnv() is unavailable.');
-            process.exit(1);
-        }
-        setGlobalProxyFromEnv(process.env);
+    return { command: process.execPath, args: [path_1.default.resolve(__dirname, RUNNER_JS_FILENAME)] };
+}
+function isLongRunningCommand(argv) {
+    return argv.length === 0 || argv[0] === 'webui';
+}
+function isDevelopmentMode(argv) {
+    if (process.env.NODE_ENV === 'dev')
+        return true;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--mode')
+            return argv[i + 1] === 'dev';
+        if (arg === '--mode=dev')
+            return true;
     }
-    catch (err) {
-        console.error('Error: invalid proxy environment configuration:', err instanceof Error ? err.message : String(err));
-        process.exit(1);
+    return false;
+}
+function parseSupervisorArgs(argv) {
+    const launchCwd = process.cwd();
+    const parsed = (0, rtws_cli_1.extractGlobalRtwsChdir)({ argv, baseCwd: launchCwd });
+    return {
+        cwd: parsed.chdir ?? launchCwd,
+        runnerArgv: parsed.argv,
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isRestartRunKind(value) {
+    return value === 'global' || value === 'npx';
+}
+function parseRunnerMessage(message) {
+    if (!isRecord(message))
+        return { kind: 'ignore' };
+    if (message['type'] !== supervisor_protocol_1.DOMINDS_SUPERVISOR_RESTART_WEBUI)
+        return { kind: 'ignore' };
+    const cwd = message['cwd'];
+    const host = message['host'];
+    const port = message['port'];
+    const traceFile = message['traceFile'];
+    const debugDir = message['debugDir'];
+    const currentVersion = message['currentVersion'];
+    const targetVersion = message['targetVersion'];
+    const runKind = message['runKind'];
+    const invalid = (reason) => ({
+        kind: 'invalid',
+        reason,
+        traceFile: typeof traceFile === 'string' ? traceFile : null,
+        debugDir: typeof debugDir === 'string' ? debugDir : null,
+    });
+    if (typeof cwd !== 'string')
+        return invalid('cwd must be a string');
+    if (typeof host !== 'string')
+        return invalid('host must be a string');
+    if (typeof port !== 'number' || !Number.isInteger(port) || port <= 0 || port > 65535) {
+        return invalid('port must be an integer in 1..65535');
+    }
+    if (typeof traceFile !== 'string')
+        return invalid('traceFile must be a string');
+    if (typeof debugDir !== 'string')
+        return invalid('debugDir must be a string');
+    if (typeof currentVersion !== 'string')
+        return invalid('currentVersion must be a string');
+    if (targetVersion !== null && typeof targetVersion !== 'string') {
+        return invalid('targetVersion must be a string or null');
     }
+    if (!isRestartRunKind(runKind))
+        return invalid('runKind must be global or npx');
+    return {
+        kind: 'restart',
+        message: {
+            type: supervisor_protocol_1.DOMINDS_SUPERVISOR_RESTART_WEBUI,
+            cwd,
+            host,
+            port,
+            traceFile,
+            debugDir,
+            currentVersion,
+            targetVersion,
+            runKind,
+        },
+    };
 }
-function printHelp() {
-    console.log(`
-Dominds CLI - AI-driven DevOps framework with persistent memory
-
-Usage:
-  dominds [-C <abs-dir>] [subcommand] [options]
-
-Global Options:
-  -C <abs-dir>        Change to absolute runtime workspace directory (rtws) before running
-
-Subcommands:
-  webui [options]    Start WebUI server (default)
-  tui [options]      Start Text User Interface
-  run [options]      Run task dialog (alias for tui)
-  read [options]     Read team configuration
-  man [options]      Render toolset manual to stdout
-  manual [options]   Alias for man
-  validate_team_def [options] Validate explicit team toolset declarations
-  cert [options]     Create and inspect local HTTPS certificates
-  create [options]   Create a new runtime workspace (rtws) from a template
-  install [options]  Install a Dominds App into this rtws
-  doctor [options]   Read-only diagnosis across manifest/lock/configuration/resolution/handshake
-  enable [options]   Enable an installed Dominds App in this rtws
-  disable [options]  Disable an installed Dominds App in this rtws
-  uninstall [options] Uninstall a Dominds App from this rtws
-  update [options]   Update installed Dominds App(s)
-  new [options]      Alias for create
-  help               Show this help message
-
-Examples:
-  dominds                    # Start WebUI server (default)
-  dominds webui              # Start WebUI server
-  dominds -C /path/to/my-ws webui # Start in specific rtws
-  dominds tui --help         # Show TUI help
-  dominds run task.tsk       # Run task dialog
-  dominds read               # Read team configuration
-  dominds man ws_read --lang zh --all
-  dominds validate_team_def  # Validate toolset references in .minds/team.yaml
-  dominds cert create --host 192.168.1.10
-  dominds create web-scaffold my-project   # Create rtws from a template
-  dominds doctor @longrun-ai/web-dev       # Diagnose a single app across all app-state layers
-
-Installation:
-  pnpm add -g dominds
-
-For detailed help on a specific subcommand:
-  dominds <subcommand> --help
-`);
+async function appendSupervisorTrace(message, event, details = {}) {
+    const record = {
+        ...details,
+        event,
+        capturedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        supervisorPid: process.pid,
+        platform: process.platform,
+    };
+    await promises_1.default.mkdir(message.debugDir, { recursive: true });
+    await promises_1.default.appendFile(message.traceFile, `${JSON.stringify(record)}\n`, 'utf8');
+}
+function appendSupervisorTraceSoon(message, event, details = {}) {
+    void appendSupervisorTrace(message, event, details).catch((error) => {
+        const text = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to write Dominds supervisor trace: ${text}`);
+    });
 }
-function printVersion() {
+async function appendSupervisorTraceBestEffort(message, event, details = {}) {
     try {
-        const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
-        console.log(`dominds v${packageJson.version}`);
+        await appendSupervisorTrace(message, event, details);
     }
-    catch {
-        console.log('dominds (version unknown)');
+    catch (error) {
+        const text = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to write Dominds supervisor trace: ${text}`);
     }
 }
-async function main(argv = process.argv.slice(2)) {
-    let parsed;
-    try {
-        parsed = (0, rtws_cli_1.extractGlobalRtwsChdir)({ argv });
+function appendInvalidSupervisorTraceSoon(parsed, event = 'supervisor.invalid_restart_message', details = {}) {
+    if (parsed.traceFile === null || parsed.debugDir === null)
+        return;
+    const message = {
+        type: supervisor_protocol_1.DOMINDS_SUPERVISOR_RESTART_WEBUI,
+        cwd: process.cwd(),
+        host: 'unknown',
+        port: 1,
+        traceFile: parsed.traceFile,
+        debugDir: parsed.debugDir,
+        currentVersion: 'unknown',
+        targetVersion: null,
+        runKind: 'global',
+    };
+    appendSupervisorTraceSoon(message, event, {
+        ...details,
+        reason: parsed.reason,
+    });
+}
+async function delayUnlessStopping(ms, stopState) {
+    if (stopState.stopping)
+        return;
+    await new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearInterval(poll);
+            resolve();
+        };
+        const timer = setTimeout(finish, ms);
+        const poll = setInterval(() => {
+            if (!stopState.stopping)
+                return;
+            finish();
+        }, 100);
+    });
+}
+function getPortProbeHost(host) {
+    if (host === '0.0.0.0')
+        return '127.0.0.1';
+    if (host === '::')
+        return '::1';
+    return host;
+}
+function isPortBusy(host, port) {
+    return new Promise((resolve) => {
+        const socket = net_1.default.createConnection({ host, port });
+        let settled = false;
+        const finish = (busy) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(busy);
+        };
+        socket.once('connect', () => finish(true));
+        socket.once('error', () => finish(false));
+        socket.setTimeout(1000, () => finish(true));
+    });
+}
+async function waitForPortRelease(params) {
+    const probeHost = getPortProbeHost(params.host);
+    const deadline = Date.now() + PORT_RELEASE_TIMEOUT_MS;
+    let consecutiveReady = 0;
+    while (!params.stopState.stopping && Date.now() < deadline) {
+        if (!(await isPortBusy(probeHost, params.port))) {
+            consecutiveReady += 1;
+            if (consecutiveReady >= 2)
+                return true;
+        }
+        else {
+            consecutiveReady = 0;
+        }
+        await delayUnlessStopping(PORT_PROBE_INTERVAL_MS, params.stopState);
     }
-    catch (err) {
-        console.error('Error:', err instanceof Error ? err.message : String(err));
-        process.exit(1);
+    return false;
+}
+async function resolveNpmCommandSpec() {
+    const nodeDir = path_1.default.dirname(process.execPath);
+    const candidates = process.platform === 'win32'
+        ? [path_1.default.join(nodeDir, 'node_modules', 'npm', 'bin', 'npm-cli.js')]
+        : [
+            path_1.default.join(nodeDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+            path_1.default.join(nodeDir, '..', 'share', 'nodejs', 'npm', 'bin', 'npm-cli.js'),
+        ];
+    for (const candidate of candidates) {
+        try {
+            await promises_1.default.access(candidate);
+            return { command: process.execPath, args: [candidate] };
+        }
+        catch {
+            continue;
+        }
+    }
+    if (process.platform === 'win32') {
+        throw new Error(`Cannot find bundled npm CLI at ${candidates.join(', ')}`);
     }
-    const args = parsed.argv;
-    // Handle no arguments - default to webui
-    if (args.length === 0) {
-        if (parsed.chdir) {
-            try {
-                process.chdir(parsed.chdir);
+    return { command: 'npm', args: [] };
+}
+async function captureCommandStdout(command, args) {
+    return await new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        const child = (0, child_process_1.spawn)(command, [...args], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        child.stdout?.setEncoding('utf8');
+        child.stderr?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.once('error', reject);
+        child.once('exit', (code, signal) => {
+            if (code === 0 && signal === null) {
+                resolve(stdout);
+                return;
             }
-            catch (err) {
-                console.error(`Error: failed to change directory to '${parsed.chdir}':`, err);
-                process.exit(1);
+            reject(new Error(`Command failed while resolving dominds@latest runner (code=${String(code)}, signal=${String(signal)}): ${stderr.trim()}`));
+        });
+    });
+}
+async function resolveNpxLatestRunnerEntrypoint() {
+    const npm = await resolveNpmCommandSpec();
+    const packageJsonPath = (await captureCommandStdout(npm.command, [
+        ...npm.args,
+        'exec',
+        '-y',
+        '--package',
+        'dominds@latest',
+        '--',
+        process.execPath,
+        '-e',
+        [
+            "const fs=require('fs');",
+            "const path=require('path');",
+            "for (const dir of (process.env.PATH||'').split(path.delimiter)) {",
+            "  if (path.basename(dir) !== '.bin') continue;",
+            "  const candidate=path.join(path.dirname(dir),'dominds','package.json');",
+            '  if (fs.existsSync(candidate)) {',
+            '    process.stdout.write(fs.realpathSync(candidate));',
+            '    process.exit(0);',
+            '  }',
+            '}',
+            "process.stderr.write('Cannot find dominds package in npm exec PATH');",
+            'process.exit(1);',
+        ].join(' '),
+    ])).trim();
+    if (packageJsonPath === '') {
+        throw new Error('npm exec dominds@latest did not return a package path');
+    }
+    const packageRoot = path_1.default.dirname(packageJsonPath);
+    const runnerEntrypoint = path_1.default.join(packageRoot, 'dist', RUNNER_JS_FILENAME);
+    await promises_1.default.access(runnerEntrypoint);
+    return runnerEntrypoint;
+}
+function spawnRunner(params) {
+    return (0, child_process_1.spawn)(params.commandSpec.command, [...params.commandSpec.args, ...params.argv], {
+        cwd: params.cwd,
+        env: {
+            ...process.env,
+            DOMINDS_SUPERVISOR_PID: String(process.pid),
+        },
+        stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        windowsHide: false,
+    });
+}
+function isRunningChild(child) {
+    return child.exitCode === null && child.signalCode === null;
+}
+async function runOneShot(params) {
+    const commandSpec = getDefaultRunnerCommandSpec();
+    const child = (0, child_process_1.spawn)(commandSpec.command, [...commandSpec.args, ...params.runnerArgv], {
+        cwd: params.cwd,
+        env: process.env,
+        stdio: 'inherit',
+        windowsHide: false,
+    });
+    return await new Promise((resolve) => {
+        child.once('error', (error) => {
+            console.error(`Failed to start dominds-runner: ${error.message}`);
+            resolve(1);
+        });
+        child.once('exit', (code, signal) => {
+            if (signal !== null) {
+                console.error(`dominds-runner terminated by signal: ${signal}`);
+                resolve(1);
+                return;
             }
-        }
-        (0, dotenv_1.loadRtwsDotenv)({ cwd: process.cwd() });
-        configureEnvProxySupport();
-        await runSubcommand('webui', []);
-        return;
+            resolve(code ?? 1);
+        });
+    });
+}
+async function runDevelopmentRunner(params) {
+    try {
+        process.chdir(params.cwd);
+        const { main: runnerMain } = await Promise.resolve().then(() => __importStar(require('./cli-runner')));
+        await runnerMain(params.runnerArgv);
+        return 0;
     }
-    const subcommand = args[0];
-    const subcommandArgs = args.slice(1);
-    // Handle help and version flags
-    if (subcommand === '-h' || subcommand === '--help' || subcommand === 'help') {
-        printHelp();
-        process.exit(0);
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`dominds development runner failed: ${message}`);
+        return 1;
     }
-    if (subcommand === '-v' || subcommand === '--version') {
-        printVersion();
-        process.exit(0);
+}
+async function runSupervised(params) {
+    let backoffMs = INITIAL_RESTART_BACKOFF_MS;
+    const stopState = { stopping: false };
+    let activeChild = null;
+    const restartState = {
+        pending: null,
+    };
+    const invalidRestartState = { pending: null };
+    let runnerCommandSpec = getDefaultRunnerCommandSpec();
+    const stopFromSignal = (signal) => {
+        if (stopState.stopping)
+            return;
+        stopState.stopping = true;
+        const child = activeChild;
+        if (child !== null && child.exitCode === null && child.signalCode === null) {
+            child.kill(signal);
+        }
+    };
+    process.once('SIGINT', stopFromSignal);
+    process.once('SIGTERM', stopFromSignal);
+    if (process.platform === 'win32') {
+        process.once('SIGBREAK', stopFromSignal);
     }
-    const shouldSkipRtwsSetup = subcommand === 'cert' ||
-        subcommandArgs.includes('--help') ||
-        (subcommand === 'tui' && subcommandArgs.includes('-h')) ||
-        (subcommand === 'run' && subcommandArgs.includes('-h')) ||
-        (subcommand === 'read' && subcommandArgs.includes('-h')) ||
-        (subcommand === 'validate_team_def' && subcommandArgs.includes('-h')) ||
-        (subcommand === 'man' && subcommandArgs.includes('-h')) ||
-        (subcommand === 'manual' && subcommandArgs.includes('-h')) ||
-        ((subcommand === 'create' || subcommand === 'new') && subcommandArgs.includes('-h')) ||
-        (subcommand === 'install' &&
-            (subcommandArgs.includes('--help') || subcommandArgs.includes('-h'))) ||
-        (subcommand === 'doctor' &&
-            (subcommandArgs.includes('--help') || subcommandArgs.includes('-h'))) ||
-        (subcommand === 'enable' &&
-            (subcommandArgs.includes('--help') || subcommandArgs.includes('-h'))) ||
-        (subcommand === 'disable' &&
-            (subcommandArgs.includes('--help') || subcommandArgs.includes('-h'))) ||
-        (subcommand === 'uninstall' &&
-            (subcommandArgs.includes('--help') || subcommandArgs.includes('-h'))) ||
-        (subcommand === 'update' &&
-            (subcommandArgs.includes('--help') || subcommandArgs.includes('-h')));
-    if (!shouldSkipRtwsSetup) {
-        if (parsed.chdir) {
-            try {
-                process.chdir(parsed.chdir);
+    while (true) {
+        let restartExitTimer = null;
+        let restartKillTimer = null;
+        const clearRestartExitEnforcement = () => {
+            if (restartExitTimer !== null) {
+                clearTimeout(restartExitTimer);
+                restartExitTimer = null;
             }
-            catch (err) {
-                console.error(`Error: failed to change directory to '${parsed.chdir}':`, err);
-                process.exit(1);
+            if (restartKillTimer !== null) {
+                clearTimeout(restartKillTimer);
+                restartKillTimer = null;
             }
+        };
+        const scheduleRestartExitEnforcement = (child, message) => {
+            clearRestartExitEnforcement();
+            restartExitTimer = setTimeout(() => {
+                if (!isRunningChild(child))
+                    return;
+                appendSupervisorTraceSoon(message, 'supervisor.restart_runner_exit_timeout', {
+                    runnerPid: child.pid ?? null,
+                    graceMs: RESTART_RUNNER_EXIT_GRACE_MS,
+                });
+                console.error(`dominds-runner did not exit within ${String(RESTART_RUNNER_EXIT_GRACE_MS)}ms after restart request; sending SIGTERM`);
+                child.kill('SIGTERM');
+                restartKillTimer = setTimeout(() => {
+                    if (!isRunningChild(child))
+                        return;
+                    appendSupervisorTraceSoon(message, 'supervisor.restart_runner_kill_timeout', {
+                        runnerPid: child.pid ?? null,
+                        graceMs: RESTART_RUNNER_KILL_GRACE_MS,
+                    });
+                    console.error(`dominds-runner still did not exit after SIGTERM; sending SIGKILL before restart`);
+                    child.kill('SIGKILL');
+                }, RESTART_RUNNER_KILL_GRACE_MS);
+            }, RESTART_RUNNER_EXIT_GRACE_MS);
+        };
+        const scheduleInvalidRestartExitEnforcement = (child, parsed) => {
+            clearRestartExitEnforcement();
+            restartKillTimer = setTimeout(() => {
+                if (!isRunningChild(child))
+                    return;
+                appendInvalidSupervisorTraceSoon(parsed, 'supervisor.invalid_restart_runner_kill_timeout', {
+                    runnerPid: child.pid ?? null,
+                    graceMs: RESTART_RUNNER_KILL_GRACE_MS,
+                });
+                console.error(`dominds-runner did not exit after invalid restart message; sending SIGKILL`);
+                child.kill('SIGKILL');
+            }, RESTART_RUNNER_KILL_GRACE_MS);
+        };
+        const child = spawnRunner({
+            cwd: params.cwd,
+            argv: params.runnerArgv,
+            commandSpec: runnerCommandSpec,
+        });
+        activeChild = child;
+        const exit = await new Promise((resolve) => {
+            child.once('error', (error) => {
+                console.error(`Failed to start dominds-runner: ${error.message}`);
+                resolve({ code: 1, signal: null });
+            });
+            child.on('message', (raw) => {
+                const parsed = parseRunnerMessage(raw);
+                if (parsed.kind === 'ignore')
+                    return;
+                if (parsed.kind === 'invalid') {
+                    if (invalidRestartState.pending !== null)
+                        return;
+                    console.error(`Invalid dominds-runner restart message: ${parsed.reason}`);
+                    invalidRestartState.pending = parsed.reason;
+                    appendInvalidSupervisorTraceSoon(parsed);
+                    child.kill('SIGTERM');
+                    scheduleInvalidRestartExitEnforcement(child, parsed);
+                    return;
+                }
+                const { message } = parsed;
+                restartState.pending = message;
+                appendSupervisorTraceSoon(message, 'supervisor.restart_requested', {
+                    runnerPid: child.pid ?? null,
+                    cwd: message.cwd,
+                    host: message.host,
+                    port: message.port,
+                });
+                scheduleRestartExitEnforcement(child, message);
+            });
+            child.once('exit', (code, signal) => {
+                clearRestartExitEnforcement();
+                resolve({ code, signal });
+            });
+        });
+        activeChild = null;
+        if (stopState.stopping) {
+            return exit.signal === null ? (exit.code ?? 0) : 1;
         }
-        // Load runtime workspace env files into process.env once, in the main entry.
-        // Precedence: `.env` then `.env.local` (later overwrites earlier), and both
-        // overwrite any existing process.env values.
-        (0, dotenv_1.loadRtwsDotenv)({ cwd: process.cwd() });
-        configureEnvProxySupport();
-    }
-    const shouldLoadApps = subcommand !== 'webui' &&
-        subcommand !== 'cert' &&
-        subcommand !== 'create' &&
-        subcommand !== 'new' &&
-        subcommand !== 'install' &&
-        subcommand !== 'doctor' &&
-        subcommand !== 'enable' &&
-        subcommand !== 'disable' &&
-        subcommand !== 'uninstall' &&
-        subcommand !== 'update';
-    if (!shouldSkipRtwsSetup && shouldLoadApps) {
-        try {
-            // Register toolset proxies so Team.load() can validate toolset bindings (read/man/manual included).
-            await (0, runtime_1.registerEnabledAppsToolProxies)({ rtwsRootAbs: process.cwd() });
-            // Start apps-host only for interactive runtime commands (do not auto-start app frontends for read/man/manual).
-            const shouldStartAppsHost = subcommand === 'tui' || subcommand === 'run';
-            if (shouldStartAppsHost) {
-                await (0, runtime_1.initAppsRuntime)({
-                    rtwsRootAbs: process.cwd(),
-                    kernel: { scheme: 'http', host: '127.0.0.1', port: 0 },
+        if (invalidRestartState.pending !== null) {
+            console.error(`dominds supervisor stopped after invalid restart message: ${invalidRestartState.pending}`);
+            return 1;
+        }
+        if (restartState.pending !== null) {
+            const restart = restartState.pending;
+            restartState.pending = null;
+            while (true) {
+                await appendSupervisorTraceBestEffort(restart, 'supervisor.wait_port_release.start', {
+                    host: restart.host,
+                    port: restart.port,
+                    timeoutMs: PORT_RELEASE_TIMEOUT_MS,
+                });
+                const released = await waitForPortRelease({
+                    host: restart.host,
+                    port: restart.port,
+                    stopState,
+                });
+                await appendSupervisorTraceBestEffort(restart, 'supervisor.wait_port_release.finish', {
+                    host: restart.host,
+                    port: restart.port,
+                    released,
+                });
+                if (stopState.stopping)
+                    return 0;
+                if (released)
+                    break;
+                await appendSupervisorTraceBestEffort(restart, 'supervisor.restart_blocked_port_busy', {
+                    host: restart.host,
+                    port: restart.port,
+                    retryDelayMs: backoffMs,
                 });
+                console.error(`Dominds restart is waiting because port ${restart.host}:${String(restart.port)} is still busy; retrying in ${String(backoffMs)}ms`);
+                await delayUnlessStopping(backoffMs, stopState);
+                if (stopState.stopping)
+                    return 0;
+                backoffMs = Math.min(backoffMs * 2, MAX_RESTART_BACKOFF_MS);
             }
+            if (restart.runKind === 'npx') {
+                while (true) {
+                    try {
+                        const runnerEntrypoint = await resolveNpxLatestRunnerEntrypoint();
+                        runnerCommandSpec = { command: process.execPath, args: [runnerEntrypoint] };
+                        await appendSupervisorTraceBestEffort(restart, 'supervisor.npx_latest_runner_resolved', {
+                            runnerEntrypoint,
+                        });
+                        break;
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        await appendSupervisorTraceBestEffort(restart, 'supervisor.npx_latest_runner_error', {
+                            message,
+                            retryDelayMs: backoffMs,
+                        });
+                        console.error(`Dominds restart could not resolve dominds@latest runner: ${message}; retrying in ${String(backoffMs)}ms`);
+                        await delayUnlessStopping(backoffMs, stopState);
+                        if (stopState.stopping)
+                            return 0;
+                        backoffMs = Math.min(backoffMs * 2, MAX_RESTART_BACKOFF_MS);
+                    }
+                }
+            }
+            else {
+                runnerCommandSpec = getDefaultRunnerCommandSpec();
+            }
+            backoffMs = INITIAL_RESTART_BACKOFF_MS;
+            continue;
         }
-        catch (err) {
-            console.error('Error: failed to load enabled apps:', err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    }
-    // Route to appropriate subcommand
-    switch (subcommand) {
-        case 'webui':
-            await runSubcommand('webui', subcommandArgs);
-            break;
-        case 'tui':
-        case 'run':
-            await runSubcommand('tui', subcommandArgs);
-            break;
-        case 'read':
-            await runSubcommand('read', subcommandArgs);
-            break;
-        case 'man':
-            await runSubcommand('manual', subcommandArgs);
-            break;
-        case 'manual':
-            await runSubcommand('manual', subcommandArgs);
-            break;
-        case 'validate_team_def':
-            await runSubcommand('validate_team_def', subcommandArgs);
-            break;
-        case 'cert':
-            await runSubcommand('cert', subcommandArgs);
-            break;
-        case 'create':
-        case 'new':
-            await runSubcommand('create', subcommandArgs);
-            break;
-        case 'install':
-            await runSubcommand('install', subcommandArgs);
-            break;
-        case 'doctor':
-            await runSubcommand('doctor', subcommandArgs);
-            break;
-        case 'enable':
-            await runSubcommand('enable', subcommandArgs);
-            break;
-        case 'disable':
-            await runSubcommand('disable', subcommandArgs);
-            break;
-        case 'uninstall':
-            await runSubcommand('uninstall', subcommandArgs);
-            break;
-        case 'update':
-            await runSubcommand('update', subcommandArgs);
-            break;
-        default:
-            console.error(`Error: Unknown subcommand '${subcommand}'`);
-            console.error(`Run 'dominds help' for usage information.`);
-            process.exit(1);
+        console.error(`dominds-runner exited unexpectedly (code=${String(exit.code)}, signal=${String(exit.signal)}); restarting in ${String(backoffMs)}ms`);
+        await delayUnlessStopping(backoffMs, stopState);
+        if (stopState.stopping)
+            return 0;
+        backoffMs = Math.min(backoffMs * 2, MAX_RESTART_BACKOFF_MS);
     }
 }
-async function runSubcommand(subcommand, args) {
+async function main(argv = process.argv.slice(2)) {
+    let parsed;
     try {
-        (0, process_title_1.setRtwsProcessTitle)();
-        if (subcommand === 'webui') {
-            await (0, webui_1.main)(args);
-        }
-        else if (subcommand === 'tui') {
-            await (0, tui_1.main)(args);
-        }
-        else if (subcommand === 'read') {
-            await (0, read_1.main)(args);
-        }
-        else if (subcommand === 'manual') {
-            await (0, manual_1.main)(args);
-        }
-        else if (subcommand === 'validate_team_def') {
-            await (0, validate_team_def_1.main)(args);
-        }
-        else if (subcommand === 'cert') {
-            await (0, cert_1.main)(args);
-        }
-        else if (subcommand === 'create') {
-            await (0, create_1.main)(args);
-        }
-        else if (subcommand === 'install') {
-            await (0, install_1.main)(args);
-        }
-        else if (subcommand === 'doctor') {
-            await (0, doctor_1.main)(args);
-        }
-        else if (subcommand === 'enable') {
-            await (0, enable_1.main)(args);
-        }
-        else if (subcommand === 'disable') {
-            await (0, disable_1.main)(args);
-        }
-        else if (subcommand === 'uninstall') {
-            await (0, uninstall_1.main)(args);
-        }
-        else if (subcommand === 'update') {
-            await (0, update_1.main)(args);
-        }
-        else {
-            console.error(`Error: Subcommand '${subcommand}' not implemented`);
-            process.exit(1);
+        parsed = parseSupervisorArgs(argv);
+        const stat = await promises_1.default.stat(parsed.cwd);
+        if (!stat.isDirectory()) {
+            throw new Error(`rtws path is not a directory: ${parsed.cwd}`);
         }
     }
-    catch (err) {
-        console.error(`Failed to execute subcommand '${subcommand}': ${err instanceof Error ? err.message : String(err)}`);
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
         process.exit(1);
+        return;
+    }
+    if (isLongRunningCommand(parsed.runnerArgv) && isDevelopmentMode(parsed.runnerArgv)) {
+        const exitCode = await runDevelopmentRunner(parsed);
+        if (exitCode !== 0)
+            process.exit(exitCode);
+        return;
     }
+    const exitCode = isLongRunningCommand(parsed.runnerArgv)
+        ? await runSupervised(parsed)
+        : await runOneShot(parsed);
+    process.exit(exitCode);
 }
 if (require.main === module) {
-    main().catch((err) => {
-        console.error('Unhandled error:', err);
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Unhandled dominds supervisor error: ${message}`);
         process.exit(1);
     });
 }