newmark-agent 0.3.10 → 0.3.12

package/dist/providers/provider-events.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultProviderTransport = defaultProviderTransport;
 exports.providerAbortError = providerAbortError;
+exports.providerStreamTimeoutError = providerStreamTimeoutError;
+exports.readProviderStreamChunk = readProviderStreamChunk;
 exports.parseProviderSse = parseProviderSse;
 exports.isContentPolicyBlocked = isContentPolicyBlocked;
 exports.normalizeProviderUsage = normalizeProviderUsage;
@@ -34,6 +36,48 @@ function providerAbortError(signal) {
         error.name = 'AbortError';
     return error;
 }
+function providerStreamTimeoutError(timeoutMs) {
+    const error = new Error('Stream read timeout');
+    error.name = 'TimeoutError';
+    error.message = `Stream read timeout after ${timeoutMs}ms`;
+    return error;
+}
+/**
+ * Read one SSE chunk with both user cancellation and an inactivity deadline.
+ * Cancelling the reader is important: rejecting the race alone leaves the
+ * provider socket alive and lets later requests accumulate behind it.
+ */
+async function readProviderStreamChunk(reader, signal, timeoutMs = 30_000) {
+    if (signal.aborted)
+        throw providerAbortError(signal);
+    let timer;
+    let onAbort;
+    const abortPromise = new Promise((_, reject) => {
+        onAbort = () => reject(providerAbortError(signal));
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+    const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(providerStreamTimeoutError(timeoutMs)), timeoutMs);
+    });
+    try {
+        return await Promise.race([reader.read(), abortPromise, timeoutPromise]);
+    }
+    catch (error) {
+        if (signal.aborted || (error instanceof Error && error.name === 'TimeoutError')) {
+            try {
+                await reader.cancel(error);
+            }
+            catch { }
+        }
+        throw error;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (onAbort)
+            signal.removeEventListener('abort', onAbort);
+    }
+}
 function parseProviderSse(raw) {
     const events = [];
     for (const block of String(raw || '').replace(/\r\n/g, '\n').split(/\n\n+/)) {

package/dist/providers/responses.adapter.js

@@ -132,9 +132,7 @@ class ResponsesAdapter {
         let streamError = '';
         try {
             while (true) {
-                if (signal.aborted)
-                    throw (0, provider_events_1.providerAbortError)(signal);
-                const { done, value } = await reader.read();
+                const { done, value } = await (0, provider_events_1.readProviderStreamChunk)(reader, signal);
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, '\n');

package/dist/tools/index.js

@@ -57,8 +57,7 @@ const nativeBash_1 = require("../core/nativeBash");
 const toolArgumentValidator_1 = require("../core/toolArgumentValidator");
 const localOcr_1 = require("../core/localOcr");
 const visualTextFallback_1 = require("../core/visualTextFallback");
-let computerUseLock = null;
-const COMPUTER_USE_LOCK_TTL_MS = 10 * 60 * 1000;
+const computerUseSession_1 = require("../core/computerUseSession");
 function normalizeComputerUseAction(action) {
     return String(action || '').trim().toLowerCase();
 }
@@ -154,50 +153,28 @@ async function abortableToolDelay(durationMs, signal) {
             abort();
     });
 }
-function clearStaleComputerUseLock(now = Date.now()) {
-    if (computerUseLock && now - computerUseLock.updatedAt > COMPUTER_USE_LOCK_TTL_MS) {
-        computerUseLock = null;
-    }
-}
-function computerUseLockError(action, owner) {
-    return JSON.stringify({
-        ok: false,
-        action,
-        error: `ComputerUse is already active in ${computerUseLock?.owner || 'another conversation'}. Stop it with computer_use takeover_stop or wait before using ComputerUse from another conversation.`,
-        lock_owner: computerUseLock?.owner || '',
-        requested_owner: owner,
-    }, null, 2);
-}
-function acquireComputerUseLock(action, owner, wsPath) {
-    const now = Date.now();
-    clearStaleComputerUseLock(now);
-    if (computerUseLock && computerUseLock.owner !== owner) {
-        return computerUseLockError(action, owner);
-    }
-    computerUseLock = {
-        owner,
+function computerUseSessionScope(context, wsPath, owner) {
+    return {
+        runtimeKey: browserUseScope(context, wsPath).runtimeKey,
+        ownerLabel: owner,
         workspacePath: path.resolve(wsPath || process.cwd()),
-        acquiredAt: computerUseLock?.owner === owner ? computerUseLock.acquiredAt : now,
-        updatedAt: now,
     };
-    return null;
 }
-function releaseComputerUseLock(action, owner) {
-    clearStaleComputerUseLock();
-    if (computerUseLock && computerUseLock.owner !== owner) {
-        return computerUseLockError(action, owner);
-    }
-    if (computerUseLock?.owner === owner)
-        computerUseLock = null;
-    return null;
+function acquireComputerUseLock(action, owner, wsPath, context = {}, dryRun = false) {
+    return computerUseSession_1.defaultComputerUseSessionRegistry.authorize(action, computerUseSessionScope(context, wsPath, owner), dryRun);
 }
-function assertComputerUseLockOwner(action, owner) {
-    clearStaleComputerUseLock();
-    if (computerUseLock && computerUseLock.owner !== owner) {
-        return computerUseLockError(action, owner);
-    }
+function releaseComputerUseLock(action, owner, context = {}, wsPath = context.workspacePath || '') {
+    const scope = computerUseSessionScope(context, wsPath, owner);
+    computerUseSession_1.defaultComputerUseSessionRegistry.complete(action, scope);
     return null;
 }
+function assertComputerUseLockOwner(action, owner, context = {}, wsPath = context.workspacePath || '') {
+    return computerUseSession_1.defaultComputerUseSessionRegistry.authorize(action, computerUseSessionScope(context, wsPath, owner));
+}
+// A competing conversation receives the stable user-facing marker
+// "ComputerUse is already active" / "computerUse occupied".
+// The two-argument releaseComputerUseLock(action, owner) form remains valid
+// for direct callers; routed Build calls additionally provide their target.
 class ToolExecutor {
     config;
     ssh;
@@ -754,8 +731,8 @@ class ToolExecutor {
                     const action = normalizeComputerUseAction(g('action'));
                     const owner = `${computerUseOwner(context, wsPath)}:${String(context.actorId || 'root')}`;
                     const lockGuard = action === 'takeover_stop'
-                        ? assertComputerUseLockOwner(action, owner)
-                        : acquireComputerUseLock(action, owner, wsPath);
+                        ? assertComputerUseLockOwner(action, owner, context, wsPath)
+                        : acquireComputerUseLock(action, owner, wsPath, context, args.dry_run === true);
                     if (lockGuard)
                         return lockGuard;
                     if (process.env.NEWMARK_WSL_DISTRO) {
@@ -772,7 +749,7 @@ class ToolExecutor {
                         }
                         finally {
                             if (action === 'takeover_stop')
-                                releaseComputerUseLock(action, owner);
+                                releaseComputerUseLock(action, owner, context, wsPath);
                         }
                     }
                     if (process.env.NEWMARK_ISOLATED_RUNTIME === '1') {
@@ -794,7 +771,7 @@ class ToolExecutor {
                         }
                         finally {
                             if (action === 'takeover_stop')
-                                releaseComputerUseLock(action, owner);
+                                releaseComputerUseLock(action, owner, context, wsPath);
                         }
                     }
                     const output = await (0, computerUse_1.runComputerUse)({
@@ -838,7 +815,7 @@ class ToolExecutor {
                             : undefined,
                     });
                     if (action === 'takeover_stop')
-                        releaseComputerUseLock(action, owner);
+                        releaseComputerUseLock(action, owner, context, wsPath);
                     return output;
                 }
                 case 'terminal_takeover': {
@@ -1352,9 +1329,17 @@ class ToolExecutor {
         }
     }
     async browserRun(request, signal, context = {}, workspacePath = this.root) {
+        const scope = browserUseScope(context, workspacePath);
+        const scopedRequest = {
+            ...request,
+            target: {
+                workspaceId: context.workspaceId || (0, terminalTakeover_1.terminalTakeoverWorkspaceId)(workspacePath),
+                conversationId: context.conversationId || 'default',
+                runtimeKey: scope.runtimeKey,
+            },
+        };
         if (process.env.NEWMARK_WSL_DISTRO) {
-            const scope = browserUseScope(context, workspacePath);
-            const result = await (0, wslHostToolBridge_1.requestWindowsHostTool)('browser_control', request, {
+            const result = await (0, wslHostToolBridge_1.requestWindowsHostTool)('browser_control', scopedRequest, {
                 conversationId: context.conversationId || process.env.NEWMARK_CONVERSATION_ID || 'default',
                 workspaceId: process.env.NEWMARK_WORKSPACE_ID || context.workspaceId || (0, terminalTakeover_1.terminalTakeoverWorkspaceId)(workspacePath),
                 actorId: context.actorId || terminalTakeover_1.ROOT_TERMINAL_ACTOR_ID,
@@ -1364,10 +1349,12 @@ class ToolExecutor {
             return this.formatBrowserResult(result);
         }
         if (process.env.NEWMARK_ISOLATED_RUNTIME === '1') {
-            const result = await (0, utilityHostToolBridge_1.requestUtilityHostTool)('browser_control', request, undefined, 30_000, signal);
+            const result = await (0, utilityHostToolBridge_1.requestUtilityHostTool)('browser_control', scopedRequest, undefined, 30_000, signal);
             return this.formatBrowserResult(result);
         }
-        const result = await browserControl_1.BrowserControl.run(request, signal);
+        // Preserve the cancellation contract of BrowserControl.run(request, signal)
+        // while routing the concrete request through the target-bound copy above.
+        const result = await browserControl_1.BrowserControl.run(scopedRequest, signal);
         return this.formatBrowserResult(result);
     }
     formatBrowserResult(result) {

package/dist/tui/src/adapters/core-runtime-adapter.js

@@ -93,6 +93,41 @@ function samePath(left, right) {
   return normalize(left) === normalize(right);
 }
 
+function isPathInside(parent, child) {
+  try {
+    const relative = path.relative(path.resolve(parent), path.resolve(child));
+    return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+  } catch {
+    return false;
+  }
+}
+
+function isProtectedInstallPath(candidate) {
+  if (process.platform !== "win32") return false;
+  const protectedRoots = [
+    process.env.ProgramFiles,
+    process.env["ProgramFiles(x86)"],
+    process.env.ProgramW6432
+  ].filter(Boolean);
+  return protectedRoots.some((root) => isPathInside(root, candidate));
+}
+
+function safeWorkspacePath(root, candidate) {
+  const resolvedRoot = path.resolve(root);
+  const resolvedCandidate = path.resolve(candidate || resolvedRoot);
+  const executableRoot = path.dirname(process.execPath);
+  // A packaged TUI launched from its installation directory must never turn
+  // that directory into an external workspace. The runtime root owns the
+  // default internal workspace in this case.
+  if (
+    samePath(resolvedCandidate, resolvedRoot)
+    || isPathInside(resolvedRoot, resolvedCandidate)
+    || isPathInside(executableRoot, resolvedCandidate)
+    || isProtectedInstallPath(resolvedCandidate)
+  ) return resolvedRoot;
+  return resolvedCandidate;
+}
+
 function mergeProviderConfig(currentProviders, incomingProviders) {
   return (incomingProviders || []).map((incoming) => {
     const current = (currentProviders || []).find((provider) => provider.id === incoming.id);
@@ -120,7 +155,7 @@ function createCoreRuntimeAdapter(options = {}) {
   const { FlowEngine } = require(path.join(desktopDist, "core", "flow.js"));
   const installUpdate = require(path.join(desktopDist, "core", "installUpdate.js"));
   const root = path.resolve(options.root || path.join(os.homedir(), ".Newmark"));
-  const workspacePath = path.resolve(options.workspacePath || process.cwd());
+  const workspacePath = safeWorkspacePath(root, options.workspacePath || process.cwd());
   ensureRuntimeRoot(root, configModule);
 
   const agent = new Agent(root);
@@ -128,7 +163,9 @@ function createCoreRuntimeAdapter(options = {}) {
     .find((workspace) => samePath(workspace.path, workspacePath));
   const selectedWorkspace = knownWorkspace
     ? agent.selectWorkspaceFromStorage(knownWorkspace.id)
-    : agent.addExternalWorkspace(workspacePath);
+    : samePath(workspacePath, root)
+      ? (agent.workspace.current || agent.createInternalWorkspace())
+      : agent.addExternalWorkspace(workspacePath);
   if (!selectedWorkspace) {
     throw new Error(
       `The current folder cannot be registered as a Newmark workspace: ${workspacePath}. ` +
@@ -454,4 +491,4 @@ function createCoreRuntimeAdapter(options = {}) {
   };
 }
 
-module.exports = { createCoreRuntimeAdapter, mergeProviderConfig, resolveDesktopDist, samePath, sanitizeProviders };
+module.exports = { createCoreRuntimeAdapter, mergeProviderConfig, resolveDesktopDist, samePath, safeWorkspacePath, sanitizeProviders };

package/dist/tui/src/app.js

@@ -3,6 +3,7 @@
 const readline = require("node:readline");
 const path = require("node:path");
 const { render } = require("./render");
+const { targetKey } = require("./adapters/newmark-contract");
 const {
   activateMenu,
   activateMemorySelection,
@@ -89,6 +90,20 @@ function executeAction(state, action) {
   }
 }
 
+function argumentValue(args, name) {
+  const inline = args.find((arg) => String(arg).startsWith(`${name}=`));
+  if (inline) return String(inline).slice(name.length + 1);
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] || "" : "";
+}
+
+function resolveTuiWorkspacePath(args, options = {}) {
+  const explicitWorkspace = options.workspacePath || argumentValue(args, "--workspace");
+  if (explicitWorkspace) return explicitWorkspace;
+  const explicitRoot = options.root || argumentValue(args, "--root");
+  return explicitRoot || process.cwd();
+}
+
 function start(options = {}) {
   const forcedTerminal = process.env.NEWMARK_FORCE_TTY === "1";
   if ((!process.stdin.isTTY || !process.stdout.isTTY) && !forcedTerminal) {
@@ -98,20 +113,16 @@ function start(options = {}) {
   }
 
   const args = process.argv.slice(2);
-  const optionValue = (name) => {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] : "";
-  };
   let adapter;
   try {
     if (args.includes("--demo") || process.env.NEWMARK_TUI_DEMO === "1") {
       adapter = require("./adapters/mock-newmark-adapter").createMockNewmarkAdapter();
     } else {
-      const root = options.root || optionValue("--root");
-      const workspacePath = options.workspacePath || optionValue("--workspace");
+      const root = options.root || argumentValue(args, "--root");
+      const workspacePath = resolveTuiWorkspacePath(args, { root, workspacePath: options.workspacePath });
       adapter = require("./adapters/core-runtime-adapter").createCoreRuntimeAdapter({
         root: root ? path.resolve(root) : undefined,
-        workspacePath: workspacePath ? path.resolve(workspacePath) : process.cwd(),
+        workspacePath: path.resolve(workspacePath),
         desktopDist: options.desktopDist
       });
     }
@@ -185,6 +196,7 @@ function start(options = {}) {
 
   async function sendRealMessage(text) {
     const target = { ...state.target };
+    const key = targetKey(target);
     state.input = "";
     state.inputCursor = 0;
     state.inputMode = false;
@@ -201,13 +213,26 @@ function start(options = {}) {
       }, 250);
     }
     paint();
+    const previous = state.sendQueueByConversation?.get(key) || Promise.resolve();
+    const current = previous
+      .catch(() => {})
+      .then(() => state.adapter.sendMessage(text, target));
+    state.sendQueueByConversation?.set(key, current);
     try {
-      const snapshot = await state.adapter.sendMessage(text, target);
-      applyConversationResult(state, target, snapshot);
+      const snapshot = await current;
+      if (state.sendQueueByConversation?.get(key) === current) {
+        applyConversationResult(state, target, snapshot);
+      }
     } catch (error) {
-      markConversationRunning(state, target, false);
-      state.notice = `Agent error: ${error.message}`;
-      paint();
+      if (state.sendQueueByConversation?.get(key) === current) {
+        markConversationRunning(state, target, false);
+        state.notice = `Agent error: ${error.message}`;
+        paint();
+      }
+    } finally {
+      if (state.sendQueueByConversation?.get(key) === current) {
+        state.sendQueueByConversation.delete(key);
+      }
     }
   }
 
@@ -439,6 +464,15 @@ function start(options = {}) {
 
   function handleKey(str, key) {
     if (key.ctrl && key.name === "c") return quit();
+    // A real run leaves input mode immediately after Enter. Keep Esc target-bound
+    // at the app boundary so users can stop that run from the content view too.
+    if (key.name === "escape"
+      && !state.overlay
+      && !state.memorySearchActive
+      && state.runningConversationKeys?.size) {
+      Promise.resolve(requestConversationStop(state)).finally(paint);
+      return;
+    }
     if (state.overlay === "palette") handlePalette(str, key);
     else if (state.overlay === "flow-select") handleFlowSelection(key);
     else if (state.overlay === "settings-choice") handleSettingChoice(key);
@@ -501,4 +535,4 @@ function start(options = {}) {
   paint();
 }
 
-module.exports = { createPaintScheduler, executeAction, start };
+module.exports = { createPaintScheduler, executeAction, resolveTuiWorkspacePath, start };

package/dist/tui/src/render.js

@@ -1,7 +1,13 @@
 "use strict";
 
 const data = require("./data");
-const { activeConversationModelLabel, filteredCommands, memoryTagOptions, selectedMemoryDetail } = require("./state");
+const {
+  activeConversationModelLabel,
+  filteredCommands,
+  memoryTagOptions,
+  resolveThemeAppearance,
+  selectedMemoryDetail
+} = require("./state");
 const { SETTINGS_CATEGORIES, displaySettingValue, settingsRows } = require("./settings-schema");
 
 const ESC = "\u001b[";
@@ -94,11 +100,16 @@ function palette(state) {
   };
   const colors = state.theme === "light" ? light : dark;
   const appearance = state.settings?.personalization;
-  if (!appearance || contrastRatio(appearance.fontColor, appearance.backgroundColor) < 4.5) {
+  if (!appearance) {
     return { ...colors, paint: "", final: `${ESC}0m` };
   }
-  const [fr, fg, fb] = hexRgb(appearance.fontColor);
-  const [br, bg, bb] = hexRgb(appearance.backgroundColor);
+  const resolvedAppearance = resolveThemeAppearance(
+    state.theme,
+    appearance.fontColor,
+    appearance.backgroundColor
+  );
+  const [fr, fg, fb] = hexRgb(resolvedAppearance.fontColor);
+  const [br, bg, bb] = hexRgb(resolvedAppearance.backgroundColor);
   const paint = `${ESC}38;2;${fr};${fg};${fb}m${ESC}48;2;${br};${bg};${bb}m`;
   return {
     ...colors,
@@ -951,10 +962,15 @@ function contrastRatio(foreground, background) {
 
 function personalizationPreview(state, p) {
   const appearance = state.settings.personalization;
-  const [fr, fg, fb] = hexRgb(appearance.fontColor);
-  const [br, bg, bb] = hexRgb(appearance.backgroundColor);
+  const resolvedAppearance = resolveThemeAppearance(
+    state.theme,
+    appearance.fontColor,
+    appearance.backgroundColor
+  );
+  const [fr, fg, fb] = hexRgb(resolvedAppearance.fontColor);
+  const [br, bg, bb] = hexRgb(resolvedAppearance.backgroundColor);
   const sample = `${ESC}38;2;${fr};${fg};${fb}m${ESC}48;2;${br};${bg};${bb}m Newmark Aa 中 123 ${p.reset}`;
-  const contrast = contrastRatio(appearance.fontColor, appearance.backgroundColor);
+  const contrast = contrastRatio(resolvedAppearance.fontColor, resolvedAppearance.backgroundColor);
   return [
     `${p.bold}Live color preview${p.reset}  ${sample}`,
     `${p.muted}Font request: ${appearance.fontFamily} · contrast ${contrast.toFixed(2)}:1 ${contrast >= 4.5 ? "PASS" : "LOW"}${p.reset}`,

package/dist/tui/src/state.js

@@ -5,6 +5,55 @@ const { createMockNewmarkAdapter } = require("./adapters/mock-newmark-adapter");
 const { targetKey, validateSnapshot } = require("./adapters/newmark-contract");
 const { SETTINGS_CATEGORIES, settingsRows } = require("./settings-schema");
 const INTELLIGENCE_TIERS = Object.freeze(["low", "medium", "high", "xhigh", "max", "ultra"]);
+const HEX_COLOR_PATTERN = /^#[0-9a-f]{6}$/i;
+const THEME_APPEARANCE_DEFAULTS = Object.freeze({
+  dark: Object.freeze({ fontColor: "#E6EAF2", backgroundColor: "#0A0A1A" }),
+  light: Object.freeze({ fontColor: "#1F2937", backgroundColor: "#F0F2F8" })
+});
+
+function normalizedTheme(value) {
+  return String(value || "dark").trim().toLowerCase() === "light" ? "light" : "dark";
+}
+
+function normalizedHexColor(value) {
+  const candidate = String(value || "").trim();
+  return HEX_COLOR_PATTERN.test(candidate) ? candidate.toUpperCase() : "";
+}
+
+function contrastRatio(foreground, background) {
+  const luminance = (value) => {
+    const channels = [0, 2, 4].map((offset) => Number.parseInt(value.slice(offset, offset + 2), 16) / 255)
+      .map((channel) => channel <= 0.03928 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4);
+    return 0.2126 * channels[0] + 0.7152 * channels[1] + 0.0722 * channels[2];
+  };
+  const foregroundLuminance = luminance(foreground.slice(1));
+  const backgroundLuminance = luminance(background.slice(1));
+  return (Math.max(foregroundLuminance, backgroundLuminance) + 0.05)
+    / (Math.min(foregroundLuminance, backgroundLuminance) + 0.05);
+}
+
+/**
+ * Resolve persisted appearance without allowing a legacy/mismatched color
+ * pair to disable the whole terminal canvas. Explicit colors are retained
+ * when readable; otherwise the closest theme-safe pair is used for rendering.
+ */
+function resolveThemeAppearance(theme, fontColor, backgroundColor) {
+  const resolvedTheme = normalizedTheme(theme);
+  const defaults = THEME_APPEARANCE_DEFAULTS[resolvedTheme];
+  let foreground = normalizedHexColor(fontColor) || defaults.fontColor;
+  let background = normalizedHexColor(backgroundColor) || defaults.backgroundColor;
+  if (contrastRatio(foreground, background) < 4.5) {
+    if (contrastRatio(defaults.fontColor, background) >= 4.5) {
+      foreground = defaults.fontColor;
+    } else if (contrastRatio(foreground, defaults.backgroundColor) >= 4.5) {
+      background = defaults.backgroundColor;
+    } else {
+      foreground = defaults.fontColor;
+      background = defaults.backgroundColor;
+    }
+  }
+  return { theme: resolvedTheme, fontColor: foreground, backgroundColor: background };
+}
 
 function applySnapshot(state, snapshot) {
   const valid = validateSnapshot(snapshot);
@@ -53,15 +102,15 @@ function applyThemeAppearance(state, selection) {
     : String(selection || "Dark").toLowerCase() === "system"
       ? "System"
       : "Dark";
-  const resolvedTheme = label === "Light" ? "light" : "dark";
-  state.theme = resolvedTheme;
+  const appearance = resolveThemeAppearance(label, "", "");
+  state.theme = appearance.theme;
   state.settings.personalization.theme = label;
-  state.settings.personalization.fontColor = resolvedTheme === "light" ? "#1F2937" : "#E6EAF2";
-  state.settings.personalization.backgroundColor = resolvedTheme === "light" ? "#F0F2F8" : "#0A0A1A";
+  state.settings.personalization.fontColor = appearance.fontColor;
+  state.settings.personalization.backgroundColor = appearance.backgroundColor;
   return {
     theme: label.toLowerCase(),
-    fontColor: state.settings.personalization.fontColor,
-    backgroundColor: state.settings.personalization.backgroundColor
+    fontColor: appearance.fontColor,
+    backgroundColor: appearance.backgroundColor
   };
 }
 
@@ -101,6 +150,7 @@ function createState(options = {}) {
     }
     return [name, workflow || { name, components: [] }];
   }));
+  const appearance = resolveThemeAppearance(snapshot.darkMode, snapshot.fontColor, snapshot.backgroundColor);
   return {
     adapter,
     adapterKind: adapter.kind,
@@ -135,7 +185,7 @@ function createState(options = {}) {
     flowSelectionIndex: 0,
     flowByConversation: initialFlow ? { [`${target.workspaceId}::${target.conversationId}`]: initialFlow } : {},
     currentFlow: initialFlow,
-    theme: String(snapshot.darkMode || "dark").toLowerCase() === "light" ? "light" : "dark",
+    theme: appearance.theme,
     overlay: null,
     settingChoiceTab: "",
     settingChoiceKey: "",
@@ -161,6 +211,7 @@ function createState(options = {}) {
       : `Newmark core connected · ${workspaces.find((item) => item.id === target.workspaceId)?.path || target.workspaceId}`,
     busy: false,
     runningConversationKeys: new Set(),
+    sendQueueByConversation: new Map(),
     stopStageByConversation: new Map(),
     tick: 0,
     messages: snapshot.chatMessages.map((item) => ({ ...item })),
@@ -199,8 +250,8 @@ function createState(options = {}) {
       personalization: {
         theme: { light: "Light", system: "System", dark: "Dark" }[String(snapshot.darkMode || "dark").toLowerCase()] || "Dark",
         fontFamily: snapshot.fontFamily || "Terminal default",
-        fontColor: snapshot.fontColor || "#E6EAF2",
-        backgroundColor: snapshot.backgroundColor || (String(snapshot.darkMode).toLowerCase() === "light" ? "#F0F2F8" : "#0A0A1A"),
+        fontColor: appearance.fontColor,
+        backgroundColor: appearance.backgroundColor,
         glassAlpha: Number(snapshot.glassAlpha || 0.85)
       },
       runtime: {
@@ -1285,6 +1336,7 @@ module.exports = {
   activateMenu,
   activateMemorySelection,
   applyThemeAppearance,
+  resolveThemeAppearance,
   applySnapshot,
   applyConversationResult,
   beginAutomationCreate,