dominds 1.25.16 → 1.25.17

package/dist/cli/create.d.ts

@@ -10,5 +10,5 @@
  * - Template can be a short name (resolved via DOMINDS_TEMPLATE_BASE) or a git URL.
  * - rtws directory is `process.cwd()`. Use 'dominds -C <dir> create ...' to create under another base dir.
  */
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/create.js

@@ -201,9 +201,9 @@ async function runGit(args, cwd) {
     const detail = res.signal ? `signal ${res.signal}` : `exit code ${String(res.code)}`;
     throw new Error(`git failed (${detail}): ${res.cmd}`);
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     try {
-        const parsed = parseArgs(process.argv.slice(2));
+        const parsed = parseArgs(argv);
         switch (parsed.kind) {
             case 'help':
                 printHelp();

package/dist/cli/disable.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/disable.js

@@ -33,10 +33,10 @@ function parseArgs(argv) {
         throw new Error('disable requires exactly one <appId>');
     return { appId: positional[0] };
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/doctor.d.ts

@@ -41,5 +41,5 @@ declare function runDoctor(params: {
     issues: ReadonlyArray<AppsResolutionIssue>;
     diagnoses: ReadonlyArray<AppDiagnosis>;
 }>;
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main, runDoctor };

package/dist/cli/doctor.js

@@ -240,10 +240,10 @@ function printDiagnosis(params) {
         console.log(`    - ${action}`);
     }
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/enable.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/enable.js

@@ -33,10 +33,10 @@ function parseArgs(argv) {
         throw new Error('enable requires exactly one <appId>');
     return { appId: positional[0] };
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/install.d.ts

@@ -5,5 +5,5 @@
  * Usage:
  *   dominds install <spec|path> [--local] [--id <appId>] [--enable] [--force]
  */
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/install.js

@@ -119,11 +119,11 @@ async function resolveInstallSource(params) {
     }
     return { kind: 'npx', spec: params.specOrPath };
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     const rtwsRootAbs = process.cwd();
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/manual.d.ts

@@ -11,4 +11,4 @@
  *   dominds man team_mgmt --topics index,tools
  */
 import '../tools/builtins';
-export declare function main(): Promise<void>;
+export declare function main(argv?: readonly string[]): Promise<void>;

package/dist/cli/manual.js

@@ -134,9 +134,9 @@ function listAvailableToolsets() {
     }
     console.log(`Available toolsets: ${names.map((name) => `\`${name}\``).join(', ')}`);
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     try {
-        const parsed = parseArgs(process.argv.slice(2));
+        const parsed = parseArgs(argv);
         if (parsed.list || !parsed.toolsetId) {
             listAvailableToolsets();
             return;

package/dist/cli/read.d.ts

@@ -13,5 +13,5 @@
  *   --find <pattern>     Find case-insensitive text in rendered output
  *   --help               Show help
  */
-declare function main(): Promise<void>;
+declare function main(args?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/read.js

@@ -437,8 +437,7 @@ function resolveTargetMemberIds(team, memberId) {
         throw new Error('No team members found.');
     return [fallback.id];
 }
-async function main() {
-    const args = process.argv.slice(2);
+async function main(args = process.argv.slice(2)) {
     let parsed;
     try {
         parsed = parseArgs(args);

package/dist/cli/tui.d.ts

@@ -14,5 +14,5 @@
  *   -p, --print-only: Non-interactive mode (for automated testing)
  *   --version: Show version information
  */
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/tui.js

@@ -166,10 +166,10 @@ function parseArgs(argv) {
     }
     return out;
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     try {
         (0, process_title_1.setRtwsProcessTitle)();
-        const args = parseArgs(process.argv.slice(2));
+        const args = parseArgs(argv);
         // Handle version flag
         if (args.version) {
             showVersion();

package/dist/cli/uninstall.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/uninstall.js

@@ -48,10 +48,10 @@ function parseArgs(argv) {
         throw new Error('uninstall requires exactly one <appId>');
     return { appId: positional[0], purge };
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/update.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/update.js

@@ -36,10 +36,10 @@ function parseArgs(argv) {
         throw new Error('update accepts at most one <appId>');
     return { appId: positional[0] ?? null };
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/validate-team-def.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export declare function main(): Promise<void>;
+export declare function main(argv?: readonly string[]): Promise<void>;

package/dist/cli/validate-team-def.js

@@ -50,10 +50,10 @@ function resolveTargetMemberIds(team, memberId) {
         throw new Error('No team members found.');
     return [fallback.id];
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let parsed;
     try {
-        parsed = parseArgs(process.argv.slice(2));
+        parsed = parseArgs(argv);
     }
     catch (err) {
         console.error('Error:', err instanceof Error ? err.message : String(err));

package/dist/cli/webui.d.ts

@@ -11,5 +11,5 @@
  *   --nobrowser          Do not open a browser (opt-out)
  *   -h, --help           Show help
  */
-declare function main(): Promise<void>;
+declare function main(args?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/webui.js

@@ -63,9 +63,8 @@ function openInBrowser(url) {
     }
     (0, child_process_1.spawn)('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
 }
-async function main() {
+async function main(args = process.argv.slice(2)) {
     (0, process_title_1.setRtwsProcessTitle)();
-    const args = process.argv.slice(2);
     let port;
     let host = 'localhost';
     let mode = process.env.NODE_ENV === 'dev' ? 'dev' : 'prod';

package/dist/cli.d.ts

@@ -29,4 +29,4 @@
  */
 import './tools/builtins';
 export declare function configureEnvProxySupport(): void;
-export declare function main(): Promise<void>;
+export declare function main(argv?: readonly string[]): Promise<void>;

package/dist/cli.js

@@ -158,11 +158,11 @@ function printVersion() {
         console.log('dominds (version unknown)');
     }
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     const baseCwd = process.cwd();
     let parsed;
     try {
-        parsed = (0, rtws_cli_1.extractGlobalRtwsChdir)({ argv: process.argv.slice(2), baseCwd });
+        parsed = (0, rtws_cli_1.extractGlobalRtwsChdir)({ argv, baseCwd });
     }
     catch (err) {
         console.error('Error:', err instanceof Error ? err.message : String(err));
@@ -317,52 +317,46 @@ async function main() {
 async function runSubcommand(subcommand, args) {
     try {
         (0, process_title_1.setRtwsProcessTitle)();
-        // Save original argv
-        const originalArgv = process.argv;
-        // Set argv to simulate direct execution of the subcommand
-        process.argv = ['node', subcommand, ...args];
         if (subcommand === 'webui') {
-            await (0, webui_1.main)();
+            await (0, webui_1.main)(args);
         }
         else if (subcommand === 'tui') {
-            await (0, tui_1.main)();
+            await (0, tui_1.main)(args);
         }
         else if (subcommand === 'read') {
-            await (0, read_1.main)();
+            await (0, read_1.main)(args);
         }
         else if (subcommand === 'manual') {
-            await (0, manual_1.main)();
+            await (0, manual_1.main)(args);
         }
         else if (subcommand === 'validate_team_def') {
-            await (0, validate_team_def_1.main)();
+            await (0, validate_team_def_1.main)(args);
         }
         else if (subcommand === 'create') {
-            await (0, create_1.main)();
+            await (0, create_1.main)(args);
         }
         else if (subcommand === 'install') {
-            await (0, install_1.main)();
+            await (0, install_1.main)(args);
         }
         else if (subcommand === 'doctor') {
-            await (0, doctor_1.main)();
+            await (0, doctor_1.main)(args);
         }
         else if (subcommand === 'enable') {
-            await (0, enable_1.main)();
+            await (0, enable_1.main)(args);
         }
         else if (subcommand === 'disable') {
-            await (0, disable_1.main)();
+            await (0, disable_1.main)(args);
         }
         else if (subcommand === 'uninstall') {
-            await (0, uninstall_1.main)();
+            await (0, uninstall_1.main)(args);
         }
         else if (subcommand === 'update') {
-            await (0, update_1.main)();
+            await (0, update_1.main)(args);
         }
         else {
             console.error(`Error: Subcommand '${subcommand}' not implemented`);
             process.exit(1);
         }
-        // Restore original argv
-        process.argv = originalArgv;
     }
     catch (err) {
         console.error(`Failed to execute subcommand '${subcommand}':`, err);

package/dist/persistence.js

@@ -345,7 +345,7 @@ async function normalizeIdleWhileReplyObligationPending(dialogId, status, previo
         executionMarker: healedExecutionMarker,
     };
 }
-const quarantiningMainDialogs = new Set();
+const quarantiningMainDialogs = new Map();
 const PERSISTABLE_DIALOG_STATUSES = ['running', 'completed', 'archived'];
 const RUN_STATUS_DIR = 'run';
 const DONE_STATUS_DIR = 'done';
@@ -5458,74 +5458,119 @@ class DialogPersistence {
     static async quarantineMalformedDialog(dialogId, status, reason, error) {
         const mainDialogId = dialogId.rootId === dialogId.selfId ? dialogId : new dialog_1.DialogID(dialogId.rootId);
         const quarantineKey = `${status}|${mainDialogId.selfId}`;
-        if (quarantiningMainDialogs.has(quarantineKey)) {
-            return;
-        }
-        quarantiningMainDialogs.add(quarantineKey);
-        let quarantined = false;
-        try {
-            await prepareDialogQuarantineHook?.({
-                dialogId,
-                mainDialogId,
-                status,
-                reason,
-                error,
-            });
-            this.quarantinedMainDialogScopes.add(this.getMainDialogWriteBackCancelScopeKey(mainDialogId, status));
-            this.cancelMainDialogWriteBacks(mainDialogId, status);
-            const sourcePath = this.getMainDialogPath(mainDialogId, status);
-            if (!(await this.pathExists(sourcePath))) {
-                return;
-            }
-            let destinationPath = this.getMalformedMainDialogPath(mainDialogId, status);
-            if (await this.pathExists(destinationPath)) {
-                destinationPath = path.join(this.getDialogsRootDir(), this.MALFORMED_DIR, `${mainDialogId.selfId}__${(0, node_crypto_1.randomUUID)()}`);
-            }
-            await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
-            await fs.promises.rename(sourcePath, destinationPath);
-            quarantined = true;
-            log_1.log.warn(`Quarantined malformed dialog ${mainDialogId.selfId}`, undefined, {
-                status,
-                reason,
-                sourcePath,
-                destinationPath,
-                errorMessage: error.message,
-                dialogId: dialogId.valueOf(),
-                mainDialogId: mainDialogId.valueOf(),
-            });
-            dialogsQuarantinedBroadcaster?.({
-                type: 'dialogs_quarantined',
-                status: 'quarantining',
-                fromStatus: assertPersistableDialogStatus(status, 'DialogPersistence.quarantineMalformedDialog(fromStatus)'),
-                rootId: mainDialogId.selfId,
-                dialogId: dialogId.selfId,
-                reason,
-                timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            });
+        const activeQuarantine = quarantiningMainDialogs.get(quarantineKey);
+        if (activeQuarantine) {
+            return await activeQuarantine;
         }
-        finally {
+        const quarantinePromise = Promise.resolve().then(async () => {
+            let quarantined = false;
+            let writeBackCancelScopeKey = null;
             try {
-                await finalizeDialogQuarantineHook?.({
+                await prepareDialogQuarantineHook?.({
                     dialogId,
                     mainDialogId,
                     status,
                     reason,
                     error,
-                    quarantined,
+                });
+                writeBackCancelScopeKey = this.getMainDialogWriteBackCancelScopeKey(mainDialogId, status);
+                this.quarantinedMainDialogScopes.add(writeBackCancelScopeKey);
+                this.cancelMainDialogWriteBacks(mainDialogId, status);
+                const sourcePath = this.getMainDialogPath(mainDialogId, status);
+                if (!(await this.pathExists(sourcePath))) {
+                    return true;
+                }
+                let destinationPath = this.getMalformedMainDialogPath(mainDialogId, status);
+                if (await this.pathExists(destinationPath)) {
+                    destinationPath = path.join(this.getDialogsRootDir(), this.MALFORMED_DIR, `${mainDialogId.selfId}__${(0, node_crypto_1.randomUUID)()}`);
+                }
+                await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
+                try {
+                    await this.renameWithRetry(sourcePath, destinationPath);
+                }
+                catch (renameError) {
+                    log_1.log.error('Failed to quarantine malformed dialog; dialog remains in its source status', renameError, {
+                        status,
+                        reason,
+                        sourcePath,
+                        destinationPath,
+                        errorMessage: error.message,
+                        dialogId: dialogId.valueOf(),
+                        mainDialogId: mainDialogId.valueOf(),
+                        renameErrorCode: getErrorCode(renameError),
+                    });
+                    return false;
+                }
+                quarantined = true;
+                log_1.log.warn(`Quarantined malformed dialog ${mainDialogId.selfId}`, undefined, {
+                    status,
+                    reason,
+                    sourcePath,
+                    destinationPath,
+                    errorMessage: error.message,
+                    dialogId: dialogId.valueOf(),
+                    mainDialogId: mainDialogId.valueOf(),
+                });
+                dialogsQuarantinedBroadcaster?.({
+                    type: 'dialogs_quarantined',
+                    status: 'quarantining',
+                    fromStatus: assertPersistableDialogStatus(status, 'DialogPersistence.quarantineMalformedDialog(fromStatus)'),
+                    rootId: mainDialogId.selfId,
+                    dialogId: dialogId.selfId,
+                    reason,
+                    timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
                 });
             }
             finally {
-                quarantiningMainDialogs.delete(quarantineKey);
+                try {
+                    if (!quarantined && writeBackCancelScopeKey) {
+                        this.quarantinedMainDialogScopes.delete(writeBackCancelScopeKey);
+                    }
+                    await finalizeDialogQuarantineHook?.({
+                        dialogId,
+                        mainDialogId,
+                        status,
+                        reason,
+                        error,
+                        quarantined,
+                    });
+                }
+                finally {
+                    const active = quarantiningMainDialogs.get(quarantineKey);
+                    if (active === quarantinePromise) {
+                        quarantiningMainDialogs.delete(quarantineKey);
+                    }
+                }
             }
-        }
+            return quarantined;
+        });
+        quarantiningMainDialogs.set(quarantineKey, quarantinePromise);
+        return await quarantinePromise;
     }
     static async quarantineMalformedRuntimeState(dialogId, status, reason, detail) {
-        await this.quarantineMalformedDialog(dialogId, status, reason, new Error(detail));
+        const quarantined = await this.quarantineMalformedDialog(dialogId, status, reason, new Error(detail));
+        if (!quarantined) {
+            throw new Error(`Failed to quarantine malformed runtime state ` +
+                `(rootId=${dialogId.rootId}, selfId=${dialogId.selfId}, status=${status}, reason=${reason}): ` +
+                detail);
+        }
     }
     static async rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, reason, error) {
         const persistenceError = (0, persistence_errors_1.findDomindsPersistenceFileError)(error);
         if (persistenceError) {
-            await this.quarantineMalformedDialog(dialogId, status, reason, persistenceError);
+            try {
+                await this.quarantineMalformedDialog(dialogId, status, reason, persistenceError);
+            }
+            catch (quarantineError) {
+                log_1.log.error('Failed to complete malformed dialog quarantine', quarantineError, {
+                    status,
+                    reason,
+                    dialogId: dialogId.valueOf(),
+                    mainDialogId: dialogId.rootId,
+                    persistenceErrorMessage: persistenceError.message,
+                    quarantineErrorCode: getErrorCode(quarantineError),
+                });
+            }
             throw persistenceError;
         }
         throw error;
@@ -5664,6 +5709,13 @@ class DialogPersistence {
                     }
                 }
                 catch (error) {
+                    if (getErrorCode(error) === 'ENOENT') {
+                        log_1.log.debug(`🔍 listDialogs: Directory disappeared while scanning ${dirPath}`, undefined, {
+                            status,
+                            dirPath,
+                        });
+                        return;
+                    }
                     // Directory enumeration failures are filesystem-level access/I/O problems, not evidence
                     // that a specific dialog record is malformed. If we cannot even read this directory,
                     // attempting to quarantine a child dialog via move/rename is unlikely to be reliable.
@@ -5708,6 +5760,13 @@ class DialogPersistence {
                 entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
             }
             catch (error) {
+                if (getErrorCode(error) === 'ENOENT') {
+                    log_1.log.debug(`listMainDialogIds: Directory disappeared while scanning ${dirPath}`, undefined, {
+                        status,
+                        dirPath,
+                    });
+                    return;
+                }
                 log_1.log.warn(`listMainDialogIds: Error reading directory ${dirPath}:`, error);
                 return;
             }
@@ -5868,6 +5927,13 @@ class DialogPersistence {
                 entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
             }
             catch (err) {
+                if (getErrorCode(err) === 'ENOENT') {
+                    log_1.log.debug(`🔍 listAllDialogIds: Directory disappeared while scanning ${dirPath}`, undefined, {
+                        status,
+                        dirPath,
+                    });
+                    return;
+                }
                 // This is an environment/filesystem failure rather than confirmed dialog corruption. We log
                 // loudly and keep enumeration partial instead of fabricating a quarantine target that may
                 // not even be reachable through the same broken directory path.

package/dist/server/dominds-self-update.js

@@ -32,6 +32,8 @@ const PROXY_URL_ENV_KEYS = new Set([
     'npm_config_https_proxy',
 ]);
 const IDLE_RESTART_STATE = { kind: 'idle' };
+const PROCESS_START_ARGV = [...process.argv];
+const PROCESS_START_EXEC_ARGV = [...process.execArgv];
 const PROCESS_START_CWD = process.cwd();
 let runtimeConfig = null;
 let latestObservation = { kind: 'unknown' };
@@ -76,7 +78,7 @@ function compareVersions(a, b) {
 function detectRunKind(mode) {
     if (mode !== 'production')
         return 'disabled';
-    const scriptPath = (process.argv[1] ?? '').replace(/\\/g, '/');
+    const scriptPath = (PROCESS_START_ARGV[1] ?? '').replace(/\\/g, '/');
     if (scriptPath.includes('/_npx/') && scriptPath.includes('/node_modules/dominds/')) {
         return 'npx';
     }
@@ -111,7 +113,7 @@ async function getComparableRealPath(absPath) {
     }
 }
 function getCurrentProcessEntrypoint() {
-    const entrypoint = process.argv[1];
+    const entrypoint = PROCESS_START_ARGV[1];
     if (typeof entrypoint !== 'string' || entrypoint.trim() === '') {
         throw new Error('Cannot restart Dominds because the current process entrypoint is unavailable');
     }
@@ -119,10 +121,10 @@ function getCurrentProcessEntrypoint() {
 }
 function buildCurrentProcessRestartArgs() {
     getCurrentProcessEntrypoint();
-    return [...process.execArgv, ...process.argv.slice(1)];
+    return [...PROCESS_START_EXEC_ARGV, ...PROCESS_START_ARGV.slice(1)];
 }
 function buildCurrentDomindsCliArgs() {
-    return process.argv.slice(2);
+    return PROCESS_START_ARGV.slice(2);
 }
 function getNpxWorkspaceDirAbs() {
     const entrypoint = getCurrentProcessEntrypoint().replace(/\\/g, '/');
@@ -683,7 +685,7 @@ async function queryLatestVersion() {
     }
 }
 async function findRunningDomindsPackageRootAbs() {
-    const scriptPath = process.argv[1];
+    const scriptPath = PROCESS_START_ARGV[1];
     if (typeof scriptPath !== 'string' || scriptPath.trim() === '')
         return null;
     const scriptPathAbs = path_1.default.isAbsolute(scriptPath)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.25.16",
+  "version": "1.25.17",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {