mixdog 1.4.2 → 1.4.3

package/src/standalone/session-service/session-calls/session-turns.mjs

@@ -4,6 +4,7 @@
 // sessions that carry an active Goal after daemon replacement is wired in from
 // ./goal-recovery.mjs.
 import { createGoalRecovery } from './goal-recovery.mjs';
+import { createSessionTurnGate } from './turn-gate.mjs';
 import {
   attachmentsForIntake,
   materializePromptSubmission,
@@ -54,6 +55,8 @@ export function createSessionTurnCalls(ctx) {
   const { log, readStoredGoal, listStoredActiveGoalSessionIds, hasAgentSession, sessionResult, advanceForCaller } = ctx;
   const { retainUnwatched } = ctx.retention;
   const { entryForSession } = ctx.entries;
+  // One gate per service, shared with the idle-only delete (session-calls.mjs).
+  const turnGate = ctx.turnGate ?? createSessionTurnGate();
 
   /** Publishes the step an action produced and keeps the entry on the retention clock. */
   const settleAction = (entry, reason) => {
@@ -66,16 +69,26 @@ export function createSessionTurnCalls(ctx) {
   // attachment conversion that has not yet become a turn.
   const intakeAborts = new Map();
 
-  async function submitSession({
-    sessionId,
-    prompt,
-    options = {},
-    open: openHints = {},
-    baseRevision = null,
-    signal = null,
-  } = {}) {
-    const id = String(sessionId || '');
+  /** Run `start` as an admitted turn start of `sessionId` (turn-gate.mjs). */
+  async function admitted(sessionId, start) {
+    const leave = turnGate.enter(sessionId);
+    try {
+      return await start();
+    } finally {
+      leave();
+    }
+  }
+
+  async function submitSession(params = {}) {
+    const id = String(params?.sessionId || '');
     if (!id) throw new TypeError('sessionId is required');
+    return admitted(id, () => submitAdmitted(id, params));
+  }
+
+  async function submitAdmitted(
+    id,
+    { prompt, options = {}, open: openHints = {}, baseRevision = null, signal = null } = {}
+  ) {
     const entry = await entryForSession(id, openHints || {});
     const target = entry.runtime.submitAsync;
     if (typeof target !== 'function') throw new TypeError('session runtime must implement submitAsync');
@@ -150,9 +163,12 @@ export function createSessionTurnCalls(ctx) {
   async function materializeSession(sessionId, openHints = {}) {
     const id = String(sessionId || '');
     if (!id) throw new TypeError('sessionId is required');
-    const entry = await entryForSession(id, openHints || {});
-    retainUnwatched(entry, 'daemon session owner');
-    return entry.runtime;
+    // Its callers start work on the runtime (Goal and quota resumes, bots).
+    return admitted(id, async () => {
+      const entry = await entryForSession(id, openHints || {});
+      retainUnwatched(entry, 'daemon session owner');
+      return entry.runtime;
+    });
   }
 
   const recoverActiveGoals = createGoalRecovery({
@@ -196,12 +212,15 @@ export function createSessionTurnCalls(ctx) {
   async function approveSession({ sessionId, approvalId, decision, open: openHints = {}, baseRevision = null } = {}) {
     const id = String(sessionId || '');
     if (!id) throw new TypeError('sessionId is required');
-    const entry = await entryForSession(id, openHints || {});
-    const target = entry.runtime.resolveToolApproval;
-    if (typeof target !== 'function') {
-      throw new TypeError('session action resolveToolApproval is unavailable');
-    }
-    const approved = await target.call(entry.runtime, approvalId, decision);
+    // An answer resumes the turn: an admitted start.
+    const { entry, approved } = await admitted(id, async () => {
+      const hosted = await entryForSession(id, openHints || {});
+      const target = hosted.runtime.resolveToolApproval;
+      if (typeof target !== 'function') {
+        throw new TypeError('session action resolveToolApproval is unavailable');
+      }
+      return { entry: hosted, approved: await target.call(hosted.runtime, approvalId, decision) };
+    });
     const step = settleAction(entry, 'headless session approval');
     return sessionResult(entry, step, baseRevision, { approved: approved === true });
   }

package/src/standalone/session-service/session-calls/turn-gate.mjs

@@ -0,0 +1,34 @@
+// session-calls/turn-gate.mjs
+// The service's turn starts per session (a submit's intake, an approval that
+// resumes a turn, a materialization for a Goal or quota resume) against the
+// desktop's idle-only delete: the delete closes a session to new starts only
+// while none is being admitted, and a start refuses while it is closed.
+import { SessionClosedError } from '../../../runtime/agent/orchestrator/session/manager/session-errors.mjs';
+
+export function createSessionTurnGate() {
+  const starting = new Map(); // sessionId -> admissions in flight
+  const fenced = new Set();
+  return {
+    /** Admit a turn start of `sessionId`; the returned release ends it. */
+    enter(sessionId) {
+      if (fenced.has(sessionId)) {
+        throw new SessionClosedError(sessionId, 'session is being deleted', 'auto-retention-delete');
+      }
+      starting.set(sessionId, (starting.get(sessionId) || 0) + 1);
+      let left = false;
+      return () => {
+        if (left) return;
+        left = true;
+        const count = (starting.get(sessionId) || 1) - 1;
+        if (count > 0) starting.set(sessionId, count);
+        else starting.delete(sessionId);
+      };
+    },
+    /** Close `sessionId` to turn starts; null while one is being admitted. */
+    fence(sessionId) {
+      if (starting.has(sessionId) || fenced.has(sessionId)) return null;
+      fenced.add(sessionId);
+      return () => fenced.delete(sessionId);
+    },
+  };
+}

package/src/standalone/session-service/session-calls.mjs

@@ -14,6 +14,7 @@
 import { createSessionActionCalls } from './session-calls/session-action.mjs';
 import { createSessionTurnCalls } from './session-calls/session-turns.mjs';
 import { createSessionViewCalls } from './session-calls/session-views.mjs';
+import { createSessionTurnGate } from './session-calls/turn-gate.mjs';
 
 /**
  * @param {object} deps
@@ -54,7 +55,7 @@ export function createSessionCalls(deps) {
     return step;
   }
 
-  const ctx = { ...deps, sessionResult, responseSessionId, advanceForCaller };
+  const ctx = { ...deps, sessionResult, responseSessionId, advanceForCaller, turnGate: createSessionTurnGate() };
   const actions = createSessionActionCalls(ctx);
   const views = createSessionViewCalls({ ...ctx, runSessionAction: actions.runSessionAction });
   const turns = createSessionTurnCalls(ctx);

package/src/tui/App.jsx

@@ -242,6 +242,13 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
   // it, so a slow (daemon) snapshot from a superseded build cannot re-open the
   // panel after it was closed.
   const settingsRequestRef = useRef(0);
+  // The open Settings panel's re-read (null-op once another panel took over or
+  // it closed): a settings change applied by the runtime (any writer) or the
+  // setup tool repaints it.
+  const settingsLiveRefreshRef = useRef(null);
+  useEffect(() => {
+    if (state.setupChanged) settingsLiveRefreshRef.current?.();
+  }, [state.setupChanged]);
   const [providerPrompt, setProviderPrompt] = useState(null);
   const oauthSubmitRef = useRef(false);
   const [settingsPrompt, setSettingsPrompt] = useState(null);
@@ -371,6 +378,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     onboardingPrefetchSeqRef,
     settingsHeavyCacheRef,
     settingsRequestRef,
+    settingsLiveRefreshRef,
     livePickerRef,
     disabledSkills,
     setDisabledSkills,

package/src/tui/app/clipboard.mjs

@@ -47,7 +47,7 @@ const LINUX_CLIPBOARD_HINT =
   'install wl-clipboard (Wayland) or xclip (X11), for example `sudo apt install wl-clipboard xclip`';
 
 /** A clipboard helper that is not installed, named with the package to add. */
-export function clipboardHelperError(cmd, error) {
+function clipboardHelperError(cmd, error) {
   if (error?.code !== 'ENOENT' || process.platform !== 'linux') return error;
   return new Error(`${cmd} is not installed; ${LINUX_CLIPBOARD_HINT}`);
 }

package/src/tui/app/create-app-pickers.mjs

@@ -47,6 +47,7 @@ export function createAppPickers({
   onboardingPrefetchSeqRef,
   settingsHeavyCacheRef,
   settingsRequestRef,
+  settingsLiveRefreshRef,
   livePickerRef,
   disabledSkills,
   setDisabledSkills,
@@ -180,6 +181,7 @@ export function createAppPickers({
     setSettingsPrompt,
     settingsHeavyCacheRef,
     settingsRequestRef,
+    settingsLiveRefreshRef,
     formatDuration,
     displayModelName,
     routeModelLabel,

package/src/tui/app/doctor.mjs

@@ -23,10 +23,10 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const GLYPH = { ok: '✓', warn: '⚠', fail: '✗' };
-export const DOCTOR_CHECK_TIMEOUT_MS = 8000;
+const DOCTOR_CHECK_TIMEOUT_MS = 8000;
 // Per-process log siblings are pruned by the channel worker; far above its
 // cap means pruning is not running.
-export const DOCTOR_LOG_FILE_WARN = 300;
+const DOCTOR_LOG_FILE_WARN = 300;
 
 // Only the stable ^major.minor.patch and >=major.minor.patch alternatives
 // used by our Node engine contract are supported. Fail open to "unverified",

package/src/tui/app/panel-signature.mjs

@@ -20,7 +20,7 @@ export const PANEL_LAYOUT_SIG = {
   // Queued steering band rows (full wrapped height, see queuedBandRows).
   QUEUED: 10,
 };
-export const PROJECT_TEXT_ENTRY_KINDS = new Set(['project-new', 'project-create-confirm', 'project-rename']);
+const PROJECT_TEXT_ENTRY_KINDS = new Set(['project-new', 'project-create-confirm', 'project-rename']);
 export const CORE_MULTILINE_TEXT_ENTRY_KINDS = new Set(['core-add', 'core-edit']);
 
 export function panelSignatureFlags(signature) {

package/src/tui/app/settings-picker.mjs

@@ -13,6 +13,16 @@ import { settingsHandoffPanel, createSettingsNavigation } from './settings-picke
 import { buildSettingsItems, readSettingsView } from './settings-picker/settings-rows.mjs';
 import { createSettingsToggles } from './settings-picker/settings-toggles.mjs';
 
+// The factory is rebuilt every render, so the heavy-read gate lives beside the
+// App-owned cache ref it protects: `running` is the one heavy read in flight,
+// `queued` the single follow-up owed to changes that arrived meanwhile, and
+// `freshWrites` counts heavy reads that wrote the cache.
+const heavyGates = new WeakMap();
+const heavyGateOf = (cacheRef) => {
+  if (!heavyGates.has(cacheRef)) heavyGates.set(cacheRef, { running: false, queued: false, freshWrites: 0 });
+  return heavyGates.get(cacheRef);
+};
+
 export function createSettingsPicker({
   store,
   state,
@@ -21,6 +31,7 @@ export function createSettingsPicker({
   setSettingsPrompt,
   settingsHeavyCacheRef,
   settingsRequestRef,
+  settingsLiveRefreshRef,
   formatDuration,
   displayModelName,
   routeModelLabel,
@@ -51,16 +62,31 @@ export function createSettingsPicker({
     // destination synchronously before the daemon snapshot so the empty-chat
     // welcome logo cannot appear between the old panel and Settings.
     if (!light && !own.paint(settingsHandoffPanel())) return;
-    const heavyCache = light ? settingsHeavyCacheRef.current : null;
+    // `heavy` re-reads MCP/plugin/skill status even on a light (no handoff
+    // paint) build: the cached values would otherwise win over a fresh snapshot.
+    const heavyCache = light && opts.heavy !== true ? settingsHeavyCacheRef.current : null;
     // ONE round-trip for the whole panel: on a daemon-backed store each getter
     // below is a serialized remote call, and reading them synchronously handed
     // back promises (every row rendered its default). getSettingsSnapshot runs
     // the same getters engine-side and answers once.
+    const gate = heavyGateOf(settingsHeavyCacheRef);
+    const freshWritesAtStart = gate.freshWrites;
     const snapshot = (await store.getSettingsSnapshot?.({ heavy: !heavyCache })) || {};
-    const view = readSettingsView({ snapshot, heavyCache, state });
+    const view = readSettingsView({ snapshot, heavyCache, state }); // A superseded build (newer open/refresh) or one whose panel was already
+    // closed with Esc must never paint, clear prompts or write the cache: an
+    // older response settling late would otherwise roll the cache back for
+    // every later light refresh.
+    if (!isCurrentSettingsRequest(requestId)) {
+      // Its fresh heavy rows were dropped; unless a newer heavy read already
+      // refreshed the cache, owe the still-open panel one follow-up read.
+      if (!heavyCache && own.owns() && gate.freshWrites === freshWritesAtStart) gate.queued = true;
+      return;
+    }
+    if (!own.owns()) return;
     // Refresh the cache every build (light or full) so the next light
     // refresh reuses whatever was most recently known.
     settingsHeavyCacheRef.current = { mcp: view.mcp, plugins: view.plugins, skills: view.skills };
+    if (!heavyCache) gate.freshWrites += 1;
     const toggles = createSettingsToggles({
       store,
       view,
@@ -85,10 +111,6 @@ export function createSettingsPicker({
       routeModelLabel,
       workflowDisplayName,
     });
-    // A superseded build (newer open/refresh) or one whose panel was already
-    // closed with Esc must never paint or clear prompts.
-    if (!isCurrentSettingsRequest(requestId)) return;
-    if (!own.owns()) return;
     setProviderPrompt(null);
     setSettingsPrompt(null);
     own.paint({
@@ -116,6 +138,11 @@ export function createSettingsPicker({
         own.close();
       },
     });
+    // A settings change from elsewhere re-reads this panel while it is still
+    // the one on screen (the claim's epoch guards a closed or replaced panel).
+    // The change names no section (MCP servers, plugins and skills may have
+    // moved), so unlike a post-write refresh it re-reads the heavy rows too.
+    if (settingsLiveRefreshRef) settingsLiveRefreshRef.current = own.defer(() => refreshSettings({ heavy: true }));
   };
 
   // Public entry point. NEVER rejects: callers fire it detached
@@ -130,8 +157,26 @@ export function createSettingsPicker({
       store.pushNotice(`settings unavailable: ${error?.message || error}`, 'error');
     }
   };
-  const refreshSettings = () => {
-    void openSettingsPicker({ light: true });
+  // One heavy read at a time; changes arriving meanwhile share a single
+  // follow-up, which goes through the live-refresh callback so it is a no-op
+  // once the panel was closed or replaced.
+  const refreshHeavy = () => {
+    const gate = heavyGateOf(settingsHeavyCacheRef);
+    if (gate.running) {
+      gate.queued = true;
+      return;
+    }
+    gate.running = true;
+    void openSettingsPicker({ light: true, heavy: true }).finally(() => {
+      gate.running = false;
+      if (!gate.queued) return;
+      gate.queued = false;
+      settingsLiveRefreshRef?.current?.();
+    });
+  };
+  const refreshSettings = ({ heavy = false } = {}) => {
+    if (heavy) refreshHeavy();
+    else void openSettingsPicker({ light: true });
   };
   const navigation = createSettingsNavigation({ openers, openSettingsPicker, setSettingsPrompt });
 

package/src/tui/app/shell-layout/row-budgets.mjs

@@ -139,8 +139,8 @@ function floatingPanelBudget({
   else if (btwPanel) desiredFloatingPanelRows = btwPanelRows(btwPanel, frameColumns);
   const floatingPanelRows = desiredFloatingPanelRows > 0 ? Math.min(desiredFloatingPanelRows, maxFloatingPanelRows) : 0;
   // Give the list every content row the panel exposes. The panel already grew
-  // by OPTION_PANEL_EXTRA_ROWS; previously that growth was subtracted back out
-  // here, so the rows leaked into an empty flexGrow gap instead of the list.
+  // by OPTION_PANEL_EXTRA_ROWS; subtracting that growth back out would leak the
+  // rows into an empty flexGrow gap instead of the list.
   // Reserving only PICKER_CHROME_ROWS lets the list occupy the full interior
   // (the footer's own reservation is handled inside Picker).
   const pickerVisibleRows = picker ? Math.max(1, floatingPanelRows - PICKER_CHROME_ROWS) : PANEL_MAX_VISIBLE;

package/src/tui/app/slash-commands.mjs

@@ -24,7 +24,7 @@ export const SLASH_COMMANDS = [
   {
     name: 'goal',
     usage: '/goal',
-    params: '[objective --time 1h --time-mode max|status|pause|resume|edit|stop]',
+    params: '[objective --time 1h|status|pause|resume|edit|stop]',
     description: 'Run and manage a durable session Goal',
   },
   {

package/src/tui/app/slash-dispatch/route-commands.mjs

@@ -139,7 +139,7 @@ export const routeCommands = {
 
   effort(ctx, arg) {
     const { state, store, openSlashPanel, deps } = ctx;
-    // A running turn no longer blocks the switch: the in-flight turn keeps
+    // A running turn does not block the switch: the in-flight turn keeps
     // the effort it started with, and the new level applies from the next
     // turn. Same for /fast below.
     const pendingTurn = state.busy ? ' (applies from the next turn)' : '';

package/src/tui/app/slash-dispatch/session-commands.mjs

@@ -85,7 +85,7 @@ export const sessionCommands = {
           store.pushNotice('Goal is unavailable.', 'warn');
           return;
         }
-        store.pushNotice(result.message || 'Goal updated.', 'info');
+        store.pushNotice(result.message || 'Goal updated.', result.ok === false ? 'warn' : 'info');
       })
       .catch((error) => store.pushNotice(`Goal failed: ${error?.message || error}`, 'error'));
     return true;

package/src/tui/app/use-prompt-queue-history.mjs

@@ -86,8 +86,8 @@ export function usePromptQueueHistory({
 
   const recentPromptHistory = useMemo(() => {
     // The engine maintains this list incrementally (rebuilt only when a user
-    // item is appended or the transcript is bulk-swapped), so App no longer
-    // rescans all items on every transcript change. Fall back to a local scan
+    // item is appended or the transcript is bulk-swapped), so App does not
+    // rescan all items on every transcript change. Fall back to a local scan
     // only if the engine did not publish it (older snapshot).
     if (Array.isArray(state.promptHistoryList)) return state.promptHistoryList;
     return scanPromptHistory(Array.isArray(state.items) ? state.items : []);

package/src/tui/app/use-transcript-activity.mjs

@@ -59,7 +59,7 @@ export function useTranscriptActivity({ state }) {
   // the StatusLine effect only re-fires when the numbers actually change.
   const activeToolsSignature = useMemo(() => {
     // The engine maintains this signature incrementally (updated on tool
-    // start/early-complete/result/turn-end), so App no longer scans every
+    // start/early-complete/result/turn-end), so App does not scan every
     // transcript item on each change. Prefer it; fall back to the local scan
     // only when the engine did not publish it (older snapshot).
     if (state.activeToolSummary !== undefined) return state.activeToolSummary || '';

package/src/tui/app/use-transcript-window/geometry.mjs

@@ -59,7 +59,7 @@ export function useTranscriptGeometry(state, props) {
     transcriptGeomRef,
     maxScrollRowsRef,
   } = refs;
-  // The settled array no longer changes during streaming. Geometry is keyed by
+  // The settled array does not change during streaming. Geometry is keyed by
   // the engine revision plus the live tail's resolved height, so same-height
   // text flushes do not copy/walk the settled prefix or rerun heavy memos.
   const streamingTailItem = streamingTail?.kind === 'assistant' && streamingTail.streaming ? streamingTail : null;

package/src/tui/components/prompt-input/escape-policy.d.mts

@@ -1,4 +1,3 @@
-export const PROMPT_ESCAPE_CLEAR_WINDOW_MS: number;
 export const PROMPT_ESCAPE_HINT_TIMEOUT_MS: number;
 
 export type PromptEscapeAction =

package/src/tui/components/prompt-input/escape-policy.mjs

@@ -1,4 +1,4 @@
-export const PROMPT_ESCAPE_CLEAR_WINDOW_MS = 800;
+const PROMPT_ESCAPE_CLEAR_WINDOW_MS = 800;
 export const PROMPT_ESCAPE_HINT_TIMEOUT_MS = 1000;
 
 /**

package/src/tui/components/question-panel-model.mjs

@@ -7,8 +7,8 @@ import wrapAnsi from 'wrap-ansi';
 import { truncatePanelText } from './panel-cell-text.mjs';
 
 export const CUSTOM_LABEL = '직접 입력…';
-export const RECOMMENDED_SUFFIX = ' (추천)';
-export const MULTI_HINT = ' (여러 개 선택 가능)';
+const RECOMMENDED_SUFFIX = ' (추천)';
+const MULTI_HINT = ' (여러 개 선택 가능)';
 // border(2) + title + blank + blank-after-question; question rows added separately.
 const FIXED_ROWS = 5;
 // Panel interior = frame − 2 border − 2 paddingX.
@@ -60,7 +60,7 @@ export function optionLayout(question, columns) {
   return { rows, prefixCells, avail, indexCells };
 }
 
-export const MAX_ANSWER_CHARS = 4000;
+const MAX_ANSWER_CHARS = 4000;
 const MIN_OPTION_ROWS = 3;
 
 // Append `text` to `base`, never exceeding MAX_ANSWER_CHARS UTF-16 units (the
@@ -74,7 +74,7 @@ export function appendCapped(base, text) {
   return out;
 }
 
-export function questionLines(question, columns) {
+function questionLines(question, columns) {
   const shown = `${question?.question ?? ''}${question?.multi_select ? MULTI_HINT : ''}`;
   return wrapAnsi(shown, Math.max(1, columns - CHROME_COLUMNS), { trim: false, hard: true }).split('\n');
 }

package/src/tui/components/tool-execution/standard-card.jsx

@@ -191,10 +191,9 @@ export function renderStandardToolCard(card) {
     summaryOut = truncatedSummary ? ` (${truncatedSummary})` : '';
   }
   // Keep trailing content (ctrl+o hint only; pending elapsed lives on the detail
-  // row) attached directly after the body for the whole lifecycle. The
-  // fixed-column pin previously used for elapsed is what made the trailing text
-  // jump to the right edge and snap back on the pending→done flip, so there is no
-  // pad. `avail` stays reserved (rightReserve) so the body clip point never reflows.
+  // row) attached directly after the body for the whole lifecycle. A
+  // fixed-column pin would make the trailing text jump to the right edge and
+  // snap back on the pending→done flip, so there is no pad. `avail` stays reserved (rightReserve) so the body clip point never reflows.
   return (
     <Box flexDirection="column" marginTop={attached ? 0 : 1} width={rowWidth} overflow="hidden">
       <Box flexDirection="row" width="100%">

package/src/tui/components/user-message-skills.mjs

@@ -10,7 +10,7 @@
 import { skillMentions } from '../../runtime/shared/skill-mentions.mjs';
 
 /** The applied skill names of a row value: non-empty strings only. */
-export function appliedSkillNames(value) {
+function appliedSkillNames(value) {
   return (Array.isArray(value) ? value : []).filter((name) => typeof name === 'string' && name);
 }