newmark-agent 0.3.10 → 0.3.12

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/utilityHostToolRouter.d.ts

@@ -2,6 +2,7 @@ import { BrowserControl } from './browserControl';
 import { BrowserUseReceipt, BrowserUseRequest } from './browserUse';
 import { UtilityHostToolRequest } from './utilityAgentProtocol';
 import { runComputerUse } from '../tools/computerUse';
+import { ComputerUseSessionState } from './computerUseSession';
 import { runTerminalTakeover } from '../tools/terminalTakeover';
 export interface UtilityHostToolRouterOptions {
     persistenceRoot: string;
@@ -15,6 +16,12 @@ export interface UtilityHostToolRouterOptions {
 }
 export type RoutedUtilityHostToolHandler = ((request: UtilityHostToolRequest, signal?: AbortSignal) => Promise<unknown>) & {
     cancelTarget(runtimeKey: string): void;
+    computerUseState(runtimeKey: string): ComputerUseSessionState;
+    setComputerUseEnabled(runtimeKey: string, enabled: boolean, ownerLabel?: string): {
+        ok: boolean;
+        state: ComputerUseSessionState;
+        error?: string;
+    };
 };
 /**
  * Routes every desktop-global capability in the Electron main process.

package/dist/core/utilityHostToolRouter.js

@@ -39,6 +39,7 @@ const fs = __importStar(require("fs"));
 const browserUse_1 = require("./browserUse");
 const toolPolicy_1 = require("./toolPolicy");
 const computerUse_1 = require("../tools/computerUse");
+const computerUseSession_1 = require("./computerUseSession");
 const terminalTakeover_1 = require("../tools/terminalTakeover");
 const ROOT_AGENT_ACTOR_ID = '00000000-0000-4000-8000-000000000001';
 const AUTOMATION_TOOLS = new Set([
@@ -54,10 +55,8 @@ const AUTOMATION_TOOLS = new Set([
  * one authoritative owner lock rather than one lock per child process.
  */
 function createUtilityHostToolHandler(options) {
-    let computerUseLease = null;
     const terminalOwners = new Map();
     const ephemeralScreenshots = new Map();
-    const lockTtlMs = 10 * 60 * 1000;
     const handler = async (request, signal) => {
         throwIfAborted(signal);
         validateTargetContext(request);
@@ -73,7 +72,14 @@ function createUtilityHostToolHandler(options) {
         if (request.tool === 'browser_control') {
             if (request.args.action === 'use')
                 throw new Error('Isolated Browser-Use must use the target-bound browser_use host RPC');
-            const result = await (options.runBrowser || browserControl_1.BrowserControl.run.bind(browserControl_1.BrowserControl))(request.args, signal);
+            const result = await (options.runBrowser || browserControl_1.BrowserControl.run.bind(browserControl_1.BrowserControl))({
+                ...request.args,
+                target: {
+                    workspaceId: request.target.workspaceId,
+                    conversationId: request.target.conversationId,
+                    runtimeKey: request.target.runtimeKey,
+                },
+            }, signal);
             throwIfAborted(signal);
             return result;
         }
@@ -124,20 +130,14 @@ function createUtilityHostToolHandler(options) {
         const action = String(args.action || '').trim().toLowerCase();
         const trustedComputerUseContext = request.context;
         const owner = `${request.target.runtimeKey}:${String(request.context.actorId || terminalTakeover_1.ROOT_TERMINAL_ACTOR_ID)}`;
-        const now = Date.now();
-        if (computerUseLease && now - computerUseLease.updatedAt > lockTtlMs)
-            computerUseLease = null;
-        if (action === 'takeover_stop') {
-            if (computerUseLease && computerUseLease.owner !== owner) {
-                return computerUseLockError(action, owner, computerUseLease.owner);
-            }
-        }
-        else if (computerUseLease && computerUseLease.owner !== owner) {
-            return computerUseLockError(action, owner, computerUseLease.owner);
-        }
-        else {
-            computerUseLease = { owner, runtimeKey: request.target.runtimeKey, workspacePath: request.target.workspacePath, updatedAt: now };
-        }
+        const sessionScope = {
+            runtimeKey: request.target.runtimeKey,
+            ownerLabel: owner,
+            workspacePath: request.target.workspacePath,
+        };
+        const lockGuard = computerUseSession_1.defaultComputerUseSessionRegistry.authorize(action, sessionScope, args.dry_run === true || args.dryRun === true);
+        if (lockGuard)
+            return lockGuard;
         let retainedScreenshotPath = '';
         try {
             const result = await (options.runComputer || computerUse_1.runComputerUse)({
@@ -214,10 +214,7 @@ function createUtilityHostToolHandler(options) {
                 }
                 catch { }
             }
-            if (action === 'takeover_stop' && (!computerUseLease || computerUseLease.owner === owner))
-                computerUseLease = null;
-            else if (computerUseLease?.owner === owner)
-                computerUseLease.updatedAt = Date.now();
+            computerUseSession_1.defaultComputerUseSessionRegistry.complete(action, sessionScope);
         }
     };
     handler.cancelTarget = (runtimeKey) => {
@@ -238,9 +235,9 @@ function createUtilityHostToolHandler(options) {
                     (0, terminalTakeover_1.stopTerminalTakeoverSession)(session.id, terminalOwner, 'runtime-force-restart');
             }
         }
-        if (computerUseLease?.runtimeKey === runtimeKey) {
-            const lease = computerUseLease;
-            computerUseLease = null;
+        const hadComputerUseLease = computerUseSession_1.defaultComputerUseSessionRegistry.cancelTarget(runtimeKey);
+        if (hadComputerUseLease) {
+            const lease = { workspacePath: options.persistenceRoot, owner: runtimeKey };
             void (options.runComputer || computerUse_1.runComputerUse)({
                 action: 'takeover_stop',
                 workspacePath: lease.workspacePath,
@@ -249,6 +246,10 @@ function createUtilityHostToolHandler(options) {
             }).catch(() => undefined);
         }
     };
+    handler.computerUseState = (runtimeKey) => computerUseSession_1.defaultComputerUseSessionRegistry.state(runtimeKey);
+    handler.setComputerUseEnabled = (runtimeKey, enabled, ownerLabel = `conversation:${runtimeKey}`) => {
+        return computerUseSession_1.defaultComputerUseSessionRegistry.setEnabled({ runtimeKey, ownerLabel, workspacePath: options.persistenceRoot }, enabled);
+    };
     return handler;
 }
 function throwIfAborted(signal) {
@@ -307,13 +308,4 @@ function evaluateUtilityHostToolPolicy(request) {
         args,
     });
 }
-function computerUseLockError(action, requestedOwner, activeOwner) {
-    return JSON.stringify({
-        ok: false,
-        action,
-        error: `Computer Use is already active in ${activeOwner}. Stop it with computer_use takeover_stop or wait before another conversation takes control.`,
-        lock_owner: activeOwner,
-        requested_owner: requestedOwner,
-    }, null, 2);
-}
 //# sourceMappingURL=utilityHostToolRouter.js.map

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,15 +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 args = process.argv.slice(2);
+const cli_discovery_1 = require("./cli-discovery");
+const installUpdate_1 = require("./core/installUpdate");
+const cli_help_1 = require("./cli-help");
+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 && (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 hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
+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));
@@ -85,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');
 }
@@ -169,11 +190,31 @@ function writableRuntimeRoot(candidate) {
 }
 const explicitRoot = pathArgValue(args, '--root');
 const root = explicitRoot ? writableRuntimeRoot(explicitRoot) : userRuntimeRoot();
-function firstRunInit(r) {
+if (isHelpArg) {
+    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);
+}
+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');
     }
@@ -258,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;