newmark-agent 0.6.3 → 0.6.7

package/dist/core/wslAgentProtocol.d.ts

@@ -4,7 +4,7 @@ import { ConversationRuntimeTarget } from './conversationTarget';
 import { TerminalTakeoverEvent, TerminalTakeoverOwnerFilter, TerminalTakeoverState } from '../tools/terminalTakeover';
 import { BrowserUseRequest } from './browserUse';
 import { BrowserControlRequest } from './browserControl';
-import type { AutoRouteRatingResult, ConversationSnapshot } from './agent';
+import type { ConversationSnapshot } from './agent';
 export interface WslAgentWorkspace {
     id?: string;
     name: string;
@@ -136,14 +136,6 @@ export type WslAgentRequest = {
         target: ConversationRuntimeTarget;
         options?: ConversationContextCompressOptions;
     };
-} | {
-    id: string;
-    method: 'rate_auto_route';
-    params: {
-        target: ConversationRuntimeTarget;
-        score: number;
-        routeId?: string;
-    };
 } | {
     id: string;
     method: 'set_work_run_expanded';
@@ -272,7 +264,6 @@ export type WslAgentStopResult = ConversationStopResult & {
     distro: string;
 };
 export type WslGuideResult = GuideReceipt;
-export type WslAutoRouteRatingResult = AutoRouteRatingResult;
 export type WslConversationRewindResult = ConversationSnapshot;
 export {};
 //# sourceMappingURL=wslAgentProtocol.d.ts.map

package/dist/core/wslAgentRuntimePool.d.ts

@@ -2,7 +2,7 @@ import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } fr
 import { ConversationQueueAction, ConversationQueueActionInput } from './conversationKernel';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
 import { WslHostToolHandler } from './wslAgentClient';
-import { WslAgentPromptRequest, WslAgentPromptResult, WslAutoRouteRatingResult, WslAgentStopResult, WslConversationRewindResult } from './wslAgentProtocol';
+import { WslAgentPromptRequest, WslAgentPromptResult, WslAgentStopResult, WslConversationRewindResult } from './wslAgentProtocol';
 export interface WslTargetRuntimeClient {
     subscribe(listener: (event: AgentWorkEvent) => void): () => void;
     setHostToolHandler(handler: WslHostToolHandler | null): void;
@@ -20,7 +20,6 @@ export interface WslTargetRuntimeClient {
         keepRecent?: number;
         force?: boolean;
     }): Promise<Record<string, unknown>>;
-    rateAutoRoute?(target: ConversationRuntimeTarget, score: number, routeId?: string): Promise<WslAutoRouteRatingResult>;
     setWorkRunExpanded(target: ConversationRuntimeTarget, runId: string, expanded: boolean): Promise<boolean>;
     setMode?(target: ConversationRuntimeTarget, mode: AgentMode): Promise<AgentMode>;
     setModel?(target: ConversationRuntimeTarget, model: string): Promise<string>;
@@ -87,7 +86,6 @@ export declare class WslAgentRuntimePool {
         keepRecent?: number;
         force?: boolean;
     }): Promise<Record<string, unknown>>;
-    rateAutoRoute(target: ConversationRuntimeTarget, score: number, routeId?: string): Promise<WslAutoRouteRatingResult>;
     setWorkRunExpanded(target: ConversationRuntimeTarget, runId: string, expanded: boolean): Promise<boolean>;
     setInputMode(target: ConversationRuntimeTarget, mode: string): Promise<'guide' | 'next' | null>;
     setMode(target: ConversationRuntimeTarget, mode: AgentMode): Promise<AgentMode | null>;

package/dist/core/wslAgentRuntimePool.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WslAgentRuntimePool = void 0;
+const runtimeMemoryBudget_1 = require("./runtimeMemoryBudget");
 const conversationTarget_1 = require("./conversationTarget");
 const wslAgentClient_1 = require("./wslAgentClient");
 const runtimePoolCapacity_1 = require("./runtimePoolCapacity");
@@ -68,6 +69,15 @@ class WslAgentRuntimePool {
     }
     async snapshot(target, options = {}) {
         const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
+        const wantsDefaultWindow = options.before == null && (options.window == null || options.window === 200);
+        // Same contract as the Electron pool: a timed status poll must not 500
+        // while the target's runtime is being force-stopped by an archive.
+        if (wantsDefaultWindow) {
+            const pending = this.entries.get(normalized.runtimeKey);
+            if (pending && (this.disposing.has(normalized.runtimeKey) || this.restarting.has(normalized.runtimeKey))) {
+                return this.supervisorSnapshot(pending);
+            }
+        }
         const entry = await this.acquire(normalized);
         let scheduleIdle = false;
         try {
@@ -246,19 +256,6 @@ class WslAgentRuntimePool {
             this.release(entry, true);
         }
     }
-    async rateAutoRoute(target, score, routeId = '') {
-        const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
-        const entry = await this.acquireExisting(normalized);
-        if (!entry || !entry.client.rateAutoRoute) {
-            return { ok: false, reason: 'no_active_auto_route' };
-        }
-        try {
-            return await entry.client.rateAutoRoute(normalized, score, routeId);
-        }
-        finally {
-            this.release(entry, true);
-        }
-    }
     async setWorkRunExpanded(target, runId, expanded) {
         const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
         const entry = await this.acquire(normalized);
@@ -575,12 +572,9 @@ class WslAgentRuntimePool {
         return this.accessSequence;
     }
     maxResidentRuntimes() {
-        // Same rationale as the Electron utility pool: one runtime per active
-        // conversation target. The previous default of 2 blocked parallel
-        // conversations with a capacity error; idle LRU eviction still bounds
-        // resident memory.
-        const configured = Number(this.options.maxResidentRuntimes ?? 8);
-        return Number.isFinite(configured) ? Math.max(1, Math.floor(configured)) : 8;
+        const fallback = (0, runtimeMemoryBudget_1.runtimeMemoryBudget)().maxResidentRuntimes;
+        const configured = Number(this.options.maxResidentRuntimes ?? fallback);
+        return Number.isFinite(configured) ? Math.max(1, Math.floor(configured)) : fallback;
     }
     async serializeCapacity(operation) {
         const previous = this.capacityTail;
@@ -628,7 +622,7 @@ class WslAgentRuntimePool {
     }
     scheduleIdle(entry) {
         this.touch(entry);
-        const ttl = Math.max(10, Number(this.options.idleTtlMs ?? 5 * 60 * 1000));
+        const ttl = Math.max(10, Number(this.options.idleTtlMs ?? (0, runtimeMemoryBudget_1.runtimeMemoryBudget)().idleTtlMs));
         const timer = setTimeout(() => {
             void this.evictIfIdle(entry.target.runtimeKey, entry.lastUsedAt).catch(() => {
                 // Failed cleanup retains the entry and its client's explicit error /
@@ -771,11 +765,12 @@ class WslAgentRuntimePool {
             ...cached,
             target: entry.target,
             runtime: {
+                ...(cached.runtime || {}),
                 target: entry.target,
                 workspaceKey: entry.target.workspaceKey,
                 runtimeKey: entry.target.runtimeKey,
-                runId: intent.runId,
-                generation: intent.generation,
+                runId: intent?.runId || entry.lastRunId,
+                generation: intent?.generation || entry.lastGeneration,
                 running: true,
                 stopRequested: true,
                 workRuns: cachedRuntime?.workRuns || [],

package/dist/llm/provider.d.ts

@@ -144,7 +144,9 @@ export declare class LLMProvider {
      * protocol field. Prompt-only JSON requests must not be treated as evidence
      * that a deployment supports structured output.
      */
-    chatStrictJson(model: string, messages: Array<Record<string, unknown>>, systemPrompt: string | null, temperature: number, maxTokens: number, schema: Readonly<Record<string, unknown>>, signal?: AbortSignal): Promise<string>;
+    chatStrictJson(model: string, messages: Array<Record<string, unknown>>, systemPrompt: string | null, temperature: number, maxTokens: number, schema: Readonly<Record<string, unknown>>, signal?: AbortSignal, reasoningTier?: string, schemaName?: string, onUsage?: (usage: NonNullable<StreamToken['usage']>) => void, reasoningControlRequired?: boolean): Promise<string>;
+    private requiresNativeReasoningControl;
+    private supportsNativeNoReasoningEffort;
     /**
      * Small streaming probe with explicit terminal-event evidence. Reading until
      * the socket closes is insufficient: truncated SSE must not validate.

package/dist/llm/provider.js

@@ -238,6 +238,12 @@ class LLMProvider {
         }
     }
     reasoningEffort(model, tier) {
+        // JEV route decisions explicitly request the lowest native reasoning mode.
+        // This bypasses per-model tier maps so a configured map cannot silently
+        // turn a "no thinking" decision request back into medium effort.
+        if (tier === 'none') {
+            return this.supportsNativeNoReasoningEffort(model) ? 'none' : undefined;
+        }
         const mapped = this.mappedNativeEffort(model, tier);
         if (mapped !== undefined)
             return mapped;
@@ -410,6 +416,20 @@ class LLMProvider {
         // several isolated workers concurrently call a plain-HTTP local provider.
         // Node's HTTP client owns the full body lifecycle and is deterministic for
         // loopback transports, while remote HTTPS providers retain fetch semantics.
+        /**
+         * dev-0.6.6: serialize the request body **once** per attempt and reuse that
+         * same string for the loopback transport and for the Node-HTTP fallback.
+         * Re-serializing the whole context on the fallback path held a second full
+         * copy of a potentially very large payload (the heap snapshot showed an
+         * 84 MiB serialized request body) for no behavioural difference — the bytes
+         * are identical.
+         */
+        let serializedBody = '';
+        const bodyText = () => {
+            if (!serializedBody)
+                serializedBody = JSON.stringify(body);
+            return serializedBody;
+        };
         if (this.isPlainHttpLoopback(url)) {
             const pathname = (() => { try {
                 return new URL(url).pathname;
@@ -418,7 +438,7 @@ class LLMProvider {
                 return '';
             } })();
             this.transportDiagnostic('loopback:start', pathname);
-            const local = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal, effectiveTimeout);
+            const local = await this.nodeHttpJson('POST', url, headers, bodyText(), signal, effectiveTimeout);
             this.transportDiagnostic('loopback:complete', `status=${local.status} bytes=${Buffer.byteLength(local.body || '')}`);
             return {
                 ok: local.status >= 200 && local.status < 300,
@@ -441,7 +461,7 @@ class LLMProvider {
             const response = await this.providerFetch(url, {
                 method: 'POST',
                 headers,
-                body: JSON.stringify(body),
+                body: bodyText(),
                 signal: abort.signal,
             }, true);
             // Keep the caller's cancellation and explicit deadline attached through
@@ -462,7 +482,7 @@ class LLMProvider {
                 throw abortFailure(abort.signal);
             if (!this.shouldUseNodeHttpFallback(e))
                 throw e;
-            const fallback = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal, effectiveTimeout);
+            const fallback = await this.nodeHttpJson('POST', url, headers, bodyText(), signal, effectiveTimeout);
             return {
                 ok: fallback.status >= 200 && fallback.status < 300,
                 status: fallback.status,
@@ -890,7 +910,7 @@ class LLMProvider {
         };
         const effort = this.reasoningEffort(model, reasoningTier);
         if (effort)
-            body.reasoning = { effort, summary: 'auto' };
+            body.reasoning = effort === 'none' ? { effort } : { effort, summary: 'auto' };
         if (systemPrompt)
             body.instructions = systemPrompt;
         const convertedTools = this.responsesTools(tools);
@@ -1449,8 +1469,14 @@ class LLMProvider {
      * protocol field. Prompt-only JSON requests must not be treated as evidence
      * that a deployment supports structured output.
      */
-    async chatStrictJson(model, messages, systemPrompt, temperature, maxTokens, schema, signal) {
-        const schemaName = 'newmark_validation_probe';
+    async chatStrictJson(model, messages, systemPrompt, temperature, maxTokens, schema, signal, reasoningTier, schemaName = 'newmark_validation_probe', onUsage, reasoningControlRequired = false) {
+        if (reasoningTier === 'none' && this.protocol() !== 'anthropic'
+            && (reasoningControlRequired || this.requiresNativeReasoningControl(model))) {
+            const supportsNone = this.protocol() !== 'github_models' && this.supportsNativeNoReasoningEffort(model);
+            if (!supportsNone) {
+                throw new Error('The current model does not expose a native no-reasoning mode; JEV requires thinking off.');
+            }
+        }
         if (this.protocol() === 'anthropic') {
             const { system, messages: anthropicMessages } = this.anthropicMessages(messages, systemPrompt);
             const body = {
@@ -1462,26 +1488,34 @@ class LLMProvider {
                     format: { type: 'json_schema', schema },
                 },
             };
+            if (reasoningTier === 'none') {
+                // Fail closed if the provider rejects disabled thinking for this
+                // request; Auto routing has no alternate decision selector.
+                body.thinking = { type: 'disabled' };
+            }
             if (system)
                 body.system = system;
             const response = await this.postJsonWithFetchFallback((0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/messages'), this.anthropicHeaders(), body, 120000, signal);
             if (!response.ok)
                 throw new Error(this.llmErrorText(response, await response.text()));
             const json = await response.json();
+            onUsage?.((0, agentKernelDiagnostics_1.extractProviderUsage)(json, { protocol: 'anthropic' }));
             return (json.content || [])
                 .filter(block => block.type === 'text' && block.text)
                 .map(block => this.extractTextValue(block.text))
                 .join('');
         }
         if (this.protocol() !== 'github_models' && this.openAITransportMode() === 'responses') {
-            const body = this.responsesBody(model, messages, systemPrompt, temperature, maxTokens);
+            const body = this.responsesBody(model, messages, systemPrompt, temperature, maxTokens, [], reasoningTier);
             body.text = {
                 format: { type: 'json_schema', name: schemaName, strict: true, schema },
             };
             const response = await this.postJsonWithFetchFallback((0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/responses'), this.openAIHeaders(), body, 120000, signal);
             if (!response.ok)
                 throw new Error(this.llmErrorText(response, await response.text()));
-            return this.extractResponsesText(this.normalizeResponsesPayload(await response.json()));
+            const json = this.normalizeResponsesPayload(await response.json());
+            onUsage?.((0, agentKernelDiagnostics_1.extractProviderUsage)(json));
+            return this.extractResponsesText(json);
         }
         const isGitHubModels = this.protocol() === 'github_models';
         const url = isGitHubModels
@@ -1500,10 +1534,20 @@ class LLMProvider {
                 json_schema: { name: schemaName, strict: true, schema },
             },
         };
+        if (!isGitHubModels)
+            this.applyChatReasoningEffort(body, model, reasoningTier);
         const response = await this.postJsonWithFetchFallback(url, isGitHubModels ? this.githubModelsHeaders() : this.openAIHeaders(), body, 120000, signal);
         if (!response.ok)
             throw new Error(this.llmErrorText(response, await response.text()));
-        return this.extractChatCompletionText(await response.json());
+        const json = await response.json();
+        onUsage?.((0, agentKernelDiagnostics_1.extractProviderUsage)(json));
+        return this.extractChatCompletionText(json);
+    }
+    requiresNativeReasoningControl(model) {
+        return /(?:^|[/:])(?:gpt-5(?:[-.]|$)|o[134](?:[-.]|$))|(?:reasoner|reasoning|deepseek-r1|deepseek-reasoner|\br1\b)/i.test(model);
+    }
+    supportsNativeNoReasoningEffort(model) {
+        return /(?:^|[/:])gpt-5\.(?:[1-9]\d*)(?:[-.]|$)/i.test(model);
     }
     /**
      * Small streaming probe with explicit terminal-event evidence. Reading until

package/dist/main.js

@@ -361,6 +361,13 @@ function dispatchAgentWorkEvent(event, mirrorToMobile = true) {
 }
 const workEventCoalescer = new workEventCoalescer_1.WorkEventCoalescer(event => dispatchAgentWorkEvent(event, true));
 const workEventNoMobileCoalescer = new workEventCoalescer_1.WorkEventCoalescer(event => dispatchAgentWorkEvent(event, false));
+/**
+ * dev-0.6.6: transcript revisions a renderer has actually painted/cached, keyed
+ * by `webContentsId::workspaceId::conversationId`. Only what the renderer
+ * itself acknowledged is ever attached to a state request, so a slim snapshot
+ * can never be handed to a renderer that does not hold that exact revision.
+ */
+const transcriptRevisionAcks = new Map();
 let projectConversationEvent = null;
 function publishConversationList(workspace = agent?.workspace.current || null) {
     if (agent && workspace)
@@ -2153,9 +2160,7 @@ else {
                     conversationLocked: false,
                     routeDecision: startupAgent.lastRouteDecision,
                     resolvedDeployment: startupAgent.activeDeployment(),
-                    autoRouteRatingAvailable: startupAgent.model === 'auto'
-                        && startupAgent.lastRouteDecision?.requestedSelection.kind === 'auto'
-                        && !!startupAgent.lastRouteDecision.resolvedDeployment,
+                    jevDecisionModel: startupAgent.jevDecisionModelState(),
                 };
             };
             const ensureStartupAutomation = async () => {
@@ -2804,7 +2809,22 @@ else {
             });
             const ensureElectronUtilityPool = () => {
                 if (!electronUtilityRuntimePool) {
-                    electronUtilityRuntimePool = new electronUtilityRuntimePool_1.ElectronUtilityRuntimePool(root, ensureElectronUtilityRuntimeHost());
+                    electronUtilityRuntimePool = new electronUtilityRuntimePool_1.ElectronUtilityRuntimePool(root, ensureElectronUtilityRuntimeHost(), undefined, {
+                        // dev-0.6.6: per-conversation visual budget. The pool recycles an idle
+                        // host whose resident memory grew past the machine-derived watermark
+                        // (long ComputerUse/BrowserControl conversations) instead of reusing a
+                        // process that is already close to a V8 abort.
+                        sampleProcessMemoryBytes: pid => {
+                            try {
+                                const metric = electron_1.app.getAppMetrics().find(item => Number(item.pid) === Number(pid));
+                                // Electron reports workingSetSize in kilobytes.
+                                return metric && metric.memory ? Math.round(Number(metric.memory.workingSetSize || 0) * 1024) : 0;
+                            }
+                            catch {
+                                return 0;
+                            }
+                        },
+                    });
                     electronUtilityRuntimePool.subscribe(event => broadcastAgentWorkEvent(event));
                     electronUtilityRuntimePool.setHostToolHandler(utilityHostToolHandler);
                 }
@@ -3123,7 +3143,7 @@ else {
             };
             const mutateConversationQueue = async (target, rawAction, input = {}) => {
                 const action = rawAction.replace(/^queue_/, '');
-                if (!['enqueue', 'update', 'delete', 'reorder', 'toggle_pause', 'set_pause', 'guide'].includes(action))
+                if (!['enqueue', 'update', 'delete', 'reorder', 'toggle_pause', 'set_pause', 'repair_blocked', 'guide'].includes(action))
                     throw new Error('Unknown queue action');
                 const key = activeFlowStateKey(target);
                 const flow = activeFlowStateFor(target);
@@ -3972,6 +3992,18 @@ else {
                 const target = conversationRuntimeTarget(targetInput || agent.activeConversationId || 'default');
                 return (await applyConversationAction(target, 'goal_clear')).cleared;
             });
+            // dev-0.6.6: a renderer reports the transcript revision it just painted (or
+            // `''` to clear, e.g. on reload). Nothing else may set this value.
+            electron_1.ipcMain.handle('conversation:ackTranscript', (event, targetInput, revision) => {
+                const target = conversationRuntimeTarget(targetInput || agent?.activeConversationId || 'default');
+                const key = `${event.sender.id}::${String(target.workspaceId || '')}::${String(target.conversationId || '')}`;
+                const value = typeof revision === 'string' ? revision.slice(0, 200) : '';
+                if (value)
+                    transcriptRevisionAcks.set(key, value);
+                else
+                    transcriptRevisionAcks.delete(key);
+                return true;
+            });
             electron_1.ipcMain.handle('agent:getState', async (event, targetInput) => {
                 const startupPrewarmRequest = isStartupPrewarmSender(event);
                 if (startupPrewarmRequest && !agent && startupAgentReady)
@@ -3989,11 +4021,19 @@ else {
                     : {});
                 const requestedWindow = Math.max(1, Math.floor(Number(windowInput.window) || 0) || 200);
                 const requestedBefore = windowInput.before == null ? undefined : Math.max(0, Math.floor(Number(windowInput.before) || 0));
+                // dev-0.6.6 long-run memory reclamation: attach the transcript revision
+                // this exact renderer acknowledged, so the runtime can answer with a slim
+                // snapshot instead of re-serializing the whole conversation. The revision
+                // is only ever set from that renderer's own acknowledgement, and a caller
+                // that holds nothing simply never matches.
+                const acknowledgedRevision = transcriptRevisionAcks.get(`${event.sender.id}::${String(target.workspaceId || '')}::${String(target.conversationId || '')}`);
                 let conversationSnapshot;
                 try {
                     conversationSnapshot = startupPrewarmRequest
                         ? localConversationSnapshotForStartup(target, { window: requestedWindow, before: requestedBefore })
-                        : await runtimeSnapshotForTarget(target, { window: requestedWindow, before: requestedBefore });
+                        : await runtimeSnapshotForTarget(target, acknowledgedRevision
+                            ? { window: requestedWindow, before: requestedBefore, transcript: 'auto', transcriptRevision: acknowledgedRevision }
+                            : { window: requestedWindow, before: requestedBefore });
                 }
                 catch (error) {
                     conversationSnapshot = {
@@ -4015,6 +4055,7 @@ else {
                     modelLabel: agent.modelLabel(),
                     resolvedDeployment: agent.activeDeployment(),
                     routeDecision: agent.lastRouteDecision,
+                    jevDecisionModel: agent.jevDecisionModelState(),
                     intelligence: agent.intelligence,
                     ...conversationSnapshot,
                     chatMessages: conversationSnapshot.chatMessages || [],
@@ -4247,11 +4288,7 @@ else {
                                     agent.config.set('models', 'fallback_on_unavailable', value === true || value === 'on');
                                     break;
                                 case 'switchTendency':
-                                    agent.config.set('models', 'auto_switch_preference', value);
-                                    break;
-                                case 'clearLearnedAutoPreferences':
-                                    if (value === true)
-                                        agent.clearLearnedModelPreferences();
+                                    agent.config.set('models', 'auto_switch_preference', ['conservative', 'balanced', 'aggressive'].includes(String(value)) ? String(value) : 'balanced');
                                     break;
                                 case 'openAIApiMode':
                                     agent.config.set('models', 'openai_api_mode', ['chat_stream', 'chat', 'responses'].includes(String(value)) ? value : 'chat_stream');
@@ -4482,17 +4519,38 @@ else {
                     ? await ensureWslConversationPool().contextCompress(target, options)
                     : await ensureElectronUtilityPool().contextCompress(target, options);
             });
-            electron_1.ipcMain.handle('agent:rateAutoRoute', async (_event, request) => {
+            /** Current-model JEV policy editor; the Agent remains authoritative. */
+            electron_1.ipcMain.handle('agent:setJevDecisionModel', async (_event, request) => {
                 if (!agent)
-                    return { ok: false, reason: 'no_active_auto_route' };
-                const target = conversationRuntimeTarget(request);
-                const score = Number(request?.score);
-                const routeId = String(request?.routeId || '');
-                if (mainConversationOwners.has(activeFlowStateKey(target)))
-                    return ensureConversationKernel(root).rateAutoRoute(target, score, routeId);
-                return wslBackendEnabled()
-                    ? await ensureWslConversationPool().rateAutoRoute(target, score, routeId)
-                    : await ensureElectronUtilityPool().rateAutoRoute(target, score, routeId);
+                    return { ok: false, reason: 'auto_disabled', state: null };
+                const patch = request && typeof request === 'object' ? request : {};
+                const result = agent.updateJevDecisionModel({
+                    ...(patch.enabled === undefined ? {} : { enabled: patch.enabled === true }),
+                    ...(patch.timeoutMs === undefined ? {} : { timeoutMs: Number(patch.timeoutMs) }),
+                });
+                if (result.ok) {
+                    resetConversationKernel();
+                    // Every runtime (main, Electron Utility, WSL) uses the same current
+                    // conversation-model decision policy.
+                    const propagated = [
+                        ['jev_enabled', result.state.enabled],
+                        ['jev_timeout_ms', result.state.timeoutMs],
+                    ];
+                    for (const pool of [electronUtilityRuntimePool, wslAgentRuntimePool]) {
+                        if (!pool)
+                            continue;
+                        for (const [key, value] of propagated) {
+                            try {
+                                await pool.updateSetting('models', key, value);
+                            }
+                            catch {
+                                // A runtime that is not currently running picks the value up from
+                                // the shared config on its next start.
+                            }
+                        }
+                    }
+                }
+                return result;
             });
             electron_1.ipcMain.handle('agent:stopConversation', async (_event, request) => {
                 if (!agent)
@@ -4655,19 +4713,38 @@ else {
                     try {
                         // Archive is a destructive lifecycle command. It intentionally
                         // bypasses the normal mutation/active-prompt guard. Cancel the
-                        // conversation-local Flow synchronously, then start the resident
-                        // runtime hard-stop in the background so a stuck child cannot hold
-                        // the archive click hostage.
+                        // conversation-local Flow synchronously, then release the occupancy
+                        // the conversation is holding -- the hard stop of its resident
+                        // runtime plus the kernel's own abort bookkeeping -- and let those
+                        // teardown paths run *in parallel* instead of one after the other.
+                        //
+                        // Releasing the occupancy is what ends the wait for a wedged run:
+                        // the hard stop invalidates the in-flight request, so the run really
+                        // settles instead of the archive giving up on it after some budget
+                        // (and abandoning its transcript to a later resurrecting flush).
                         const ownedFlow = activeFlowStateFor(normalized);
-                        const mainOwnerPreparation = mainConversationOwners.has(normalized.runtimeKey)
-                            ? ensureConversationKernel(root).prepareForArchive(normalized) : Promise.resolve(null);
-                        interruptActiveFlowForArchive(normalized);
-                        const mainArchiveOwner = await mainOwnerPreparation;
-                        if (ownedFlow?.settlement)
-                            await ownedFlow.settlement;
-                        void forceStopTargetRuntime(normalized).catch(error => {
+                        const kernelOwned = mainConversationOwners.has(normalized.runtimeKey);
+                        const targetRuntime = kernelOwned
+                            ? { resident: true, running: false, stopping: false, connected: true }
+                            : peekTargetRuntime(normalized);
+                        // An idle runtime has nothing to settle, so its stop stays off the
+                        // critical path; a running (or already stopping) one must be down and
+                        // checkpointed before the writer snapshots the store.
+                        const occupancyMustSettle = !kernelOwned && (targetRuntime.running === true || targetRuntime.stopping === true);
+                        const occupancyRelease = forceStopTargetRuntime(normalized).catch(error => {
                             console.error('[Newmark] archive runtime force-stop failed:', error instanceof Error ? error.message : String(error));
                         });
+                        const mainOwnerPreparation = kernelOwned
+                            ? ensureConversationKernel(root).prepareForArchive(normalized, {
+                                releaseOccupancy: () => occupancyRelease,
+                            })
+                            : Promise.resolve(null);
+                        interruptActiveFlowForArchive(normalized);
+                        const [mainArchiveOwner] = await Promise.all([
+                            mainOwnerPreparation,
+                            occupancyMustSettle ? occupancyRelease : Promise.resolve(),
+                            ownedFlow?.settlement ?? Promise.resolve(),
+                        ]);
                         const currentWorkspacePath = path.resolve(agent.workspace.current?.path || '');
                         const targetWorkspacePath = path.resolve(normalized.workspace?.path || '');
                         const ownsTargetWorkspace = !!normalized.workspace

package/dist/preload.js

@@ -15,7 +15,7 @@ contextBridge.exposeInMainWorld('api', {
     queueAction: (action, input, target) => ipcRenderer.invoke('agent:queueAction', action, input, target),
     checkpointConversation: (request) => ipcRenderer.invoke('agent:checkpointConversation', request),
     compressContext: (request) => ipcRenderer.invoke('agent:compressContext', request),
-    rateAutoRoute: (request) => ipcRenderer.invoke('agent:rateAutoRoute', request),
+    setJevDecisionModel: (request) => ipcRenderer.invoke('agent:setJevDecisionModel', request),
     stopConversation: (request) => ipcRenderer.invoke('agent:stopConversation', request),
     setWorkRunExpanded: (request) => ipcRenderer.invoke('agent:setWorkRunExpanded', request),
     sendPrompt: (message, _model) => ipcRenderer.invoke('agent:sendPrompt', message),
@@ -30,6 +30,8 @@ contextBridge.exposeInMainWorld('api', {
     clearGoal: (target) => ipcRenderer.invoke('agent:clearGoal', target),
     ensureConversation: (target) => ipcRenderer.invoke('agent:ensureConversation', target),
     getState: (target) => ipcRenderer.invoke('agent:getState', target),
+    /** dev-0.6.6: report (or clear with '') the transcript revision this renderer holds. */
+    ackTranscript: (target, revision) => ipcRenderer.invoke('conversation:ackTranscript', target, revision),
     getConversationDraft: (conversationId) => ipcRenderer.invoke('conversation:getDraft', conversationId),
     saveConversationDraft: (conversationId, draft) => ipcRenderer.invoke('conversation:saveDraft', conversationId, draft),
     getConversationPlan: (conversationId) => ipcRenderer.invoke('agent:getConversationPlan', conversationId),