newmark-agent 0.3.11 → 0.3.12

package/dist/core/config.js

@@ -64,8 +64,10 @@ class ConfigManager {
     rootPath;
     config;
     workspaceOverrides;
-    constructor(rootPath) {
+    readOnly;
+    constructor(rootPath, options = {}) {
         this.rootPath = rootPath;
+        this.readOnly = options.readOnly === true;
         this.workspaceOverrides = new Map();
         this.config = this.load();
     }
@@ -80,6 +82,8 @@ class ConfigManager {
                 const raw = JSON.parse(readJsonText(cp));
                 const normalized = normalizeConfigShape(raw, true);
                 if (isCorruptConfig(raw, normalized)) {
+                    if (this.readOnly)
+                        return defaultConfig();
                     this.backupConfig(cp, 'invalid-shape');
                     return this.writeRecoveredConfig(cp);
                 }
@@ -87,7 +91,8 @@ class ConfigManager {
                     // Provider ids are routing identities, so legacy/malformed catalogs must
                     // not wait for an unrelated settings save before becoming collision-safe.
                     try {
-                        fs.writeFileSync(cp, JSON.stringify(normalized, null, 2), 'utf-8');
+                        if (!this.readOnly)
+                            fs.writeFileSync(cp, JSON.stringify(normalized, null, 2), 'utf-8');
                     }
                     catch {
                         // A read-only root may still be used for this process. The normalized
@@ -97,6 +102,8 @@ class ConfigManager {
                 return normalized;
             }
             catch {
+                if (this.readOnly)
+                    return defaultConfig();
                 this.backupConfig(cp, 'invalid-json');
                 return this.writeRecoveredConfig(cp);
             }
@@ -146,10 +153,14 @@ class ConfigManager {
         this.config[section][key] = { value: normalizedValue };
     }
     save() {
+        if (this.readOnly)
+            return;
         const j = JSON.stringify(this.config, null, 2);
         fs.writeFileSync(path.join(this.rootPath, 'config.json'), j, 'utf-8');
     }
     saveTo(targetPath) {
+        if (this.readOnly)
+            return;
         const j = JSON.stringify(this.config, null, 2);
         fs.writeFileSync(targetPath, j, 'utf-8');
     }
@@ -393,12 +404,16 @@ class ConfigManager {
         return providers;
     }
     writeRecoveredConfig(configPath) {
+        if (this.readOnly)
+            return defaultConfig();
         const config = loadExampleConfig();
         fs.mkdirSync(path.dirname(configPath), { recursive: true });
         fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
         return config;
     }
     backupConfig(configPath, reason) {
+        if (this.readOnly)
+            return;
         try {
             if (!fs.existsSync(configPath))
                 return;
@@ -412,13 +427,13 @@ class ConfigManager {
     }
 }
 exports.ConfigManager = ConfigManager;
-function ensureRootConfig(rootPath) {
+function ensureRootConfig(rootPath, options = {}) {
     const configPath = path.join(rootPath, 'config.json');
     if (fs.existsSync(configPath)) {
-        new ConfigManager(rootPath);
+        new ConfigManager(rootPath, options);
         return;
     }
-    new ConfigManager(rootPath).save();
+    new ConfigManager(rootPath, options).save();
 }
 function normalizeConfigShape(raw, withDefaults) {
     const base = withDefaults ? defaultConfig() : {};
@@ -827,7 +842,10 @@ function defaultConfig() {
         general: {
             tone: { _description: "Conversation style", _type: "choice", _values: ["strict_simple", "casual_friendly"], value: "strict_simple" },
             language: { _description: "Default language", _type: "choice", _values: ["en", "zh", "auto"], value: "auto" },
-            close_behavior: { _description: "Close behavior", _type: "choice", _values: ["minimize", "exit"], value: "minimize" },
+            // A first-run desktop window must have a deterministic close/exit
+            // contract. Users who explicitly choose minimize-to-tray keep that
+            // choice, but a fresh install must not hide the process on OS close.
+            close_behavior: { _description: "Close behavior", _type: "choice", _values: ["minimize", "exit"], value: "exit" },
             default_input: { _description: "Default input mode", _type: "choice", _values: ["guide", "next"], value: "guide" },
             auto_archive_on_close: { _description: "Auto archive on close", _type: "boolean", value: true },
         },

package/dist/core/conversationKernel.js

@@ -499,7 +499,7 @@ class ConversationKernel {
                     stopped = true;
                 }
                 else {
-                    runtime.runner.finishConversationWorkRun(runId, 'error');
+                    runtime.runner.finishConversationWorkRun(runId, 'error', undefined, error instanceof Error ? error.message : String(error));
                     throw error;
                 }
             }

package/dist/core/electronUtilityRuntimePool.d.ts

@@ -55,6 +55,7 @@ export declare class ElectronUtilityRuntimePool {
     private restarting;
     private quarantined;
     private disposing;
+    private forceStopPromises;
     private capacityTail;
     private accessSequence;
     constructor(root: string, hostScript: string, createClient?: ElectronTargetRuntimeClientFactory, options?: ElectronUtilityRuntimePoolOptions);
@@ -86,6 +87,16 @@ export declare class ElectronUtilityRuntimePool {
     hasActiveWorkspace(target: ConversationRuntimeTarget): Promise<boolean>;
     stopWorkspace(target: ConversationRuntimeTarget): Promise<void>;
     stopTarget(target: ConversationRuntimeTarget): Promise<void>;
+    /**
+     * Immediately terminate a target runtime for destructive lifecycle actions.
+     * Archive is deliberately stronger than the user-facing two-click Stop
+     * contract: the target may be running, already stopping, or holding an
+     * active prompt lease. Give the kernel only the short checkpoint window
+     * owned by forceTerminateEntry, then hard-stop and evict the client so no
+     * delayed runtime event can keep the archived target resident.
+     */
+    forceStopTarget(target: ConversationRuntimeTarget): Promise<void>;
+    private forceStopTargetInternal;
     stopAll(): Promise<void>;
     private throwStopFailures;
     private stopEntry;

package/dist/core/electronUtilityRuntimePool.js

@@ -16,6 +16,7 @@ class ElectronUtilityRuntimePool {
     restarting = new Set();
     quarantined = new Map();
     disposing = new Set();
+    forceStopPromises = new Map();
     capacityTail = Promise.resolve();
     accessSequence = 0;
     constructor(root, hostScript, createClient = target => new electronUtilityAgentClient_1.ElectronUtilityAgentClient(root, hostScript, target), options = {}) {
@@ -342,6 +343,67 @@ class ElectronUtilityRuntimePool {
         if (entry)
             await this.stopEntry(entry);
     }
+    /**
+     * Immediately terminate a target runtime for destructive lifecycle actions.
+     * Archive is deliberately stronger than the user-facing two-click Stop
+     * contract: the target may be running, already stopping, or holding an
+     * active prompt lease. Give the kernel only the short checkpoint window
+     * owned by forceTerminateEntry, then hard-stop and evict the client so no
+     * delayed runtime event can keep the archived target resident.
+     */
+    async forceStopTarget(target) {
+        const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
+        const existing = this.forceStopPromises.get(normalized.runtimeKey);
+        if (existing)
+            return existing;
+        const operation = this.forceStopTargetInternal(normalized);
+        this.forceStopPromises.set(normalized.runtimeKey, operation);
+        try {
+            await operation;
+        }
+        finally {
+            if (this.forceStopPromises.get(normalized.runtimeKey) === operation) {
+                this.forceStopPromises.delete(normalized.runtimeKey);
+            }
+        }
+    }
+    async forceStopTargetInternal(target) {
+        let entry;
+        await this.serializeCapacity(async () => {
+            entry = this.entries.get(target.runtimeKey);
+            if (entry)
+                this.disposing.add(target.runtimeKey);
+        });
+        if (!entry)
+            return;
+        const intent = entry.stopIntent || {
+            runId: entry.lastRunId,
+            generation: entry.lastGeneration,
+            checkpointed: false,
+            forcePromise: null,
+        };
+        if (!entry.stopIntent)
+            entry.stopIntent = intent;
+        try {
+            await this.forceTerminateEntry(entry, intent);
+            // forceStop is expected to disconnect the utility child. If a client
+            // reports a stale connected flag, retry the hard boundary once before
+            // declaring archive unsafe.
+            if (entry.client.status().connected)
+                await entry.client.forceStop();
+            if (entry.client.status().connected) {
+                throw new Error(`Electron utility runtime ${target.runtimeKey} remained connected after force stop`);
+            }
+            if (this.entries.get(target.runtimeKey) === entry) {
+                this.entries.delete(target.runtimeKey);
+                entry.unsubscribe();
+                entry.client.setHostToolHandler(null);
+            }
+        }
+        finally {
+            this.disposing.delete(target.runtimeKey);
+        }
+    }
     async stopAll() {
         const targets = Array.from(this.entries.values(), entry => entry.target);
         const results = await Promise.allSettled(targets.map(target => this.stopTarget(target)));

package/dist/core/flow-runner.js

@@ -126,7 +126,7 @@ async function runFlowBuild(agent, prompt, options) {
             if (!options.signal?.aborted && typeof agent.emitWorkEvent === 'function') {
                 agent.emitWorkEvent({ type: 'error', content: reportedError.message, runId });
             }
-            agent.finishConversationWorkRun(runId, options.signal?.aborted ? 'interrupted' : 'error');
+            agent.finishConversationWorkRun(runId, options.signal?.aborted ? 'interrupted' : 'error', undefined, options.signal?.aborted ? '' : reportedError.message);
             agent.flushWorkspaceConversationState();
         }
         throw reportedError;

package/dist/core/modelValidationStore.d.ts

@@ -2,8 +2,11 @@ import { ModelValidationCache, ModelValidationRecord } from './modelValidation';
 /** Durable validation evidence. The file contains probe metadata only, never prompts, tool arguments or credentials. */
 export declare class FileModelValidationCache implements ModelValidationCache {
     private readonly filePath;
+    private readonly readOnly;
     private readonly records;
-    constructor(rootPath: string);
+    constructor(rootPath: string, options?: {
+        readOnly?: boolean;
+    });
     get(modelKey: string): ModelValidationRecord | undefined;
     set(record: ModelValidationRecord): void;
     delete(modelKey: string): void;

package/dist/core/modelValidationStore.js

@@ -42,9 +42,11 @@ function key(model) {
 /** Durable validation evidence. The file contains probe metadata only, never prompts, tool arguments or credentials. */
 class FileModelValidationCache {
     filePath;
+    readOnly;
     records = new Map();
-    constructor(rootPath) {
+    constructor(rootPath, options = {}) {
         this.filePath = path.join(rootPath, 'model-validation', 'records.json');
+        this.readOnly = options.readOnly === true;
         this.load();
     }
     get(modelKey) {
@@ -53,11 +55,15 @@ class FileModelValidationCache {
     }
     set(record) {
         this.records.set(record.modelKey || key(record.model), JSON.parse(JSON.stringify(record)));
+        if (this.readOnly)
+            return;
         this.save();
     }
     delete(modelKey) {
         if (!this.records.delete(modelKey))
             return;
+        if (this.readOnly)
+            return;
         this.save();
     }
     load() {

package/dist/core/workspace.d.ts

@@ -52,6 +52,12 @@ export declare class WorkspaceManager {
     private saveState;
     private findWorkspace;
     private restoreCurrent;
+    /**
+     * Re-read the registry and persisted current-workspace pointer after another
+     * Newmark entrypoint updates Work/*.json. This intentionally does not create
+     * a workspace: a refresh must reflect the shared on-disk state exactly.
+     */
+    reloadFromStorage(): WorkspaceInfo | null;
     private saveInternal;
     private saveExternal;
     private sleepSync;

package/dist/core/workspace.js

@@ -358,6 +358,20 @@ class WorkspaceManager {
             this.saveState();
         }
     }
+    /**
+     * Re-read the registry and persisted current-workspace pointer after another
+     * Newmark entrypoint updates Work/*.json. This intentionally does not create
+     * a workspace: a refresh must reflect the shared on-disk state exactly.
+     */
+    reloadFromStorage() {
+        if (this.detached)
+            return this.current;
+        this.scan();
+        this.validate();
+        this.current = null;
+        this.restoreCurrent();
+        return this.current;
+    }
     saveInternal() {
         if (this.detached)
             return;

package/dist/core/wslAgentRuntimePool.d.ts

@@ -56,6 +56,7 @@ export declare class WslAgentRuntimePool {
     private hostToolHandler;
     private restarting;
     private disposing;
+    private forceStopPromises;
     private capacityTail;
     private accessSequence;
     constructor(distro: string, windowsRoot: string, windowsHostScript: string, createClient?: WslTargetRuntimeClientFactory, options?: WslAgentRuntimePoolOptions);
@@ -90,6 +91,9 @@ export declare class WslAgentRuntimePool {
     hasActiveWorkspace(target: ConversationRuntimeTarget): Promise<boolean>;
     stopWorkspace(target: ConversationRuntimeTarget): Promise<void>;
     stopTarget(target: ConversationRuntimeTarget): Promise<void>;
+    /** Hard-stop a target for destructive lifecycle actions such as archive. */
+    forceStopTarget(target: ConversationRuntimeTarget): Promise<void>;
+    private forceStopTargetInternal;
     stopAll(): Promise<void>;
     private throwStopFailures;
     private stopEntry;

package/dist/core/wslAgentRuntimePool.js

@@ -20,6 +20,7 @@ class WslAgentRuntimePool {
     hostToolHandler = null;
     restarting = new Set();
     disposing = new Set();
+    forceStopPromises = new Map();
     capacityTail = Promise.resolve();
     accessSequence = 0;
     constructor(distro, windowsRoot, windowsHostScript, createClient = (target) => new wslAgentClient_1.WslAgentClient(distro, windowsRoot, windowsHostScript, target), options = {}) {
@@ -356,6 +357,61 @@ class WslAgentRuntimePool {
         if (entry)
             await this.stopEntry(entry);
     }
+    /** Hard-stop a target for destructive lifecycle actions such as archive. */
+    async forceStopTarget(target) {
+        const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
+        const existing = this.forceStopPromises.get(normalized.runtimeKey);
+        if (existing)
+            return existing;
+        const operation = this.forceStopTargetInternal(normalized);
+        this.forceStopPromises.set(normalized.runtimeKey, operation);
+        try {
+            await operation;
+        }
+        finally {
+            if (this.forceStopPromises.get(normalized.runtimeKey) === operation) {
+                this.forceStopPromises.delete(normalized.runtimeKey);
+            }
+        }
+    }
+    async forceStopTargetInternal(target) {
+        let entry;
+        await this.serializeCapacity(async () => {
+            entry = this.entries.get(target.runtimeKey);
+            if (entry)
+                this.disposing.add(target.runtimeKey);
+        });
+        if (!entry)
+            return;
+        const intent = entry.stopIntent || {
+            runId: entry.lastRunId,
+            generation: entry.lastGeneration,
+            checkpointed: false,
+            forcePromise: null,
+        };
+        if (!entry.stopIntent)
+            entry.stopIntent = intent;
+        try {
+            await this.forceTerminateEntry(entry, intent);
+            if (entry.client.status().connected) {
+                if (entry.client.forceStopRuntimeGroup)
+                    await entry.client.forceStopRuntimeGroup();
+                else
+                    await entry.client.forceRestartRuntimeGroup();
+            }
+            if (entry.client.status().connected) {
+                throw new Error(`WSL runtime ${target.runtimeKey} remained connected after force stop`);
+            }
+            if (this.entries.get(target.runtimeKey) === entry) {
+                this.entries.delete(target.runtimeKey);
+                entry.unsubscribe();
+                entry.client.setHostToolHandler(null);
+            }
+        }
+        finally {
+            this.disposing.delete(target.runtimeKey);
+        }
+    }
     async stopAll() {
         const targets = Array.from(this.entries.values(), entry => entry.target);
         const results = await Promise.allSettled(targets.map(target => this.stopTarget(target)));

package/dist/launcher.js

@@ -43,19 +43,27 @@ const agent_1 = require("./core/agent");
 const flow_1 = require("./core/flow");
 const flow_runner_1 = require("./core/flow-runner");
 const cli_commands_1 = require("./cli-commands");
+const cli_discovery_1 = require("./cli-discovery");
 const installUpdate_1 = require("./core/installUpdate");
 const cli_help_1 = require("./cli-help");
-const args = process.argv.slice(2);
+const rawArgs = process.argv.slice(2);
+const args = rawArgs[0] === '--' ? rawArgs.slice(1) : rawArgs;
 const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
+const isEdit = args[0] === 'edit';
+const editFile = isEdit ? args[1] : '';
+const isFlow = args[0] === 'flow';
 const isHelpArg = !hasCliCommand && (args.some(arg => ['--help', '-h'].includes(arg.toLowerCase())) || args[0]?.toLowerCase() === 'help');
-const isVersionArg = !hasCliCommand && args.some(arg => ['--version', '-v'].includes(arg.toLowerCase()));
+const isVersionArg = !hasCliCommand && (0, cli_discovery_1.isVersionArgument)(args);
+const isReadOnlyValidation = hasCliCommand && args.includes('validate-models') && !args.includes('--persist');
 const isTui = args.some(arg => arg.toLowerCase() === '--tui');
 const isGui = args.some(arg => arg.toLowerCase() === '--gui');
 const isCli = args.includes('--cli');
 const isServer = args.includes('--server');
-const isEdit = args[0] === 'edit';
-const editFile = isEdit ? args[1] : '';
-const isFlow = args[0] === 'flow';
+const invalidArgument = (0, cli_discovery_1.invalidTopLevelArgument)(args);
+if (invalidArgument) {
+    console.error(`Invalid Newmark argument: ${invalidArgument}`);
+    process.exit(2);
+}
 function pathArgValue(values, key) {
     const prefix = `${key}=`;
     const inlineIdx = values.findIndex(a => a.startsWith(prefix));
@@ -89,6 +97,15 @@ function pathArgValue(values, key) {
     }
     return best || parts.join(' ') || undefined;
 }
+function resolveTuiWorkspacePath(values, root) {
+    const explicitWorkspace = pathArgValue(values, '--workspace');
+    if (explicitWorkspace)
+        return explicitWorkspace;
+    // An explicitly isolated runtime must not silently register the caller's
+    // cwd as an external workspace. Keep the opt-in --workspace escape hatch,
+    // while making the safe one-argument form fully self-contained.
+    return pathArgValue(values, '--root') ? root : process.cwd();
+}
 function userRuntimeRoot() {
     return path.join(os.homedir(), '.Newmark');
 }
@@ -174,18 +191,30 @@ function writableRuntimeRoot(candidate) {
 const explicitRoot = pathArgValue(args, '--root');
 const root = explicitRoot ? writableRuntimeRoot(explicitRoot) : userRuntimeRoot();
 if (isHelpArg) {
-    console.log((0, cli_help_1.newmarkHelpText)((0, installUpdate_1.currentAppVersion)()));
+    console.log(isFlow ? (0, cli_help_1.newmarkFlowHelpText)() : isEdit ? (0, cli_help_1.newmarkEditHelpText)() : (0, cli_help_1.newmarkHelpText)((0, installUpdate_1.currentAppVersion)()));
     process.exit(0);
 }
 if (isVersionArg) {
     console.log((0, installUpdate_1.currentAppVersion)());
     process.exit(0);
 }
-function firstRunInit(r) {
+const unknownCommand = !hasCliCommand && !isTui && !isGui && !isCli && !isServer && !isFlow && !isEdit
+    ? (0, cli_discovery_1.unknownTopLevelCommand)(args)
+    : undefined;
+if (unknownCommand) {
+    console.error(`Unknown Newmark command or argument: ${unknownCommand}. Run --help to see the supported entrypoints.`);
+    process.exit(2);
+}
+function firstRunInit(r, options = {}) {
     fs.mkdirSync(r, { recursive: true });
-    migrateLegacyRuntimeRoot(r);
+    // Legacy AppData migration is only valid for the canonical user runtime.
+    // An explicit --root is an isolation boundary (tests, portable roots, and
+    // caller-selected workspaces) and must never inherit the user's sessions,
+    // archives, providers, or workspaces.
+    if (path.resolve(r) === path.resolve(userRuntimeRoot()))
+        migrateLegacyRuntimeRoot(r);
     const { ensureRootConfig } = require('./core/config');
-    ensureRootConfig(r);
+    ensureRootConfig(r, options);
     if (!fs.existsSync(path.join(r, 'agent.md'))) {
         fs.writeFileSync(path.join(r, 'agent.md'), '# Newmark Agent\n\nYou are a powerful coding assistant.\n', 'utf-8');
     }
@@ -270,13 +299,13 @@ function launchGui() {
     console.error('Unable to locate the Newmark GUI runtime. Reinstall newmark-agent with optional dependencies enabled, or install a Newmark desktop package.');
     process.exit(1);
 }
-firstRunInit(root);
+firstRunInit(root, { readOnly: isReadOnlyValidation });
 if (isGui) {
     launchGui();
 }
 else if (isTui) {
     const { start } = require('./tui/src/app');
-    start({ root, workspacePath: process.cwd(), desktopDist: __dirname });
+    start({ root, workspacePath: resolveTuiWorkspacePath(args, root), desktopDist: __dirname });
 }
 else if (hasCliCommand) {
     (0, cli_commands_1.runCliCommand)(root, args).then(handled => {

package/dist/llm/provider.d.ts

@@ -28,9 +28,12 @@ export declare class LLMProvider {
     explicitProtocol?: ProviderProtocol | undefined;
     openAIMode: OpenAITransportMode | boolean;
     useProviderAdaptersV2: boolean;
+    requestTimeoutMs: number;
     static nodeHttpTransport: ((method: 'GET' | 'POST', url: string, headers: Record<string, string>, body?: string) => Promise<NodeHttpResult>) | null;
     static powershellTransport: ((method: 'GET' | 'POST', url: string, headers: Record<string, string>, body?: string) => Promise<NodeHttpResult>) | null;
-    constructor(name: string, baseUrl: string, apiKey: string, explicitProtocol?: ProviderProtocol | undefined, openAIMode?: OpenAITransportMode | boolean, useProviderAdaptersV2?: boolean);
+    constructor(name: string, baseUrl: string, apiKey: string, explicitProtocol?: ProviderProtocol | undefined, openAIMode?: OpenAITransportMode | boolean, useProviderAdaptersV2?: boolean, requestTimeoutMs?: number);
+    private effectiveRequestTimeout;
+    private withRequestTimeout;
     intelligenceConfig(tier: string): IntelligenceConfig;
     private reasoningEffort;
     private applyChatReasoningEffort;
@@ -85,10 +88,10 @@ export declare class LLMProvider {
     private toStreamUsage;
     private shouldDowngradeToResponses;
     /**
-     * Loopback-aware transport injected into adapter `execute`. Mirrors the
-     * legacy orchestration exactly: streaming requests go through fetch with a
-     * 120s timeout and degrade to a non-streaming node-http request on fetch
-     * failure; non-streaming requests reuse postJsonWithFetchFallback.
+     * Loopback-aware transport injected into adapter `execute`. Streaming
+     * requests retain the fetch-to-node fallback for transport failures, while
+     * a local deadline is returned directly so one request cannot become a
+     * second Windows fallback request.
      */
     private buildProviderAdapterTransport;
     private toTransportResponse;