mixdog 0.9.151 → 0.9.152

package/src/tui/session/goal-continuation.test.mjs

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createGoalContinuation } from './goal-continuation.mjs';
+
+const settleImmediate = () => new Promise((resolve) => setImmediate(resolve));
+
+test('idle Goal schedules one hidden continuation and user input cancels it', async () => {
+  const goal = { id: 'goal-1', status: 'active', objective: 'Finish it' };
+  const state = { busy: false, commandBusy: false, sessionId: 'sess_goal', goal };
+  const pending = [];
+  let listener = null;
+  let archived = 0;
+  const controller = createGoalContinuation({
+    runtime: {
+      id: 'sess_goal',
+      goalStatus: () => goal,
+      goalContinuation: () => ({ run: true, reason: 'idle', goal, prompt: 'hidden continuation' }),
+      onGoalStatusChange: (next) => {
+        listener = next;
+        return () => { listener = null; };
+      },
+      archiveCompletedGoalOnUserInput: async () => { archived += 1; },
+    },
+    flags: { disposed: false, pendingSessionReset: false },
+    getState: () => state,
+    set: (patch) => Object.assign(state, patch),
+    getPending: () => pending,
+    enqueue: (text, options) => {
+      pending.push({ content: text, ...options });
+      return true;
+    },
+  });
+  try {
+    assert.equal(controller.scheduleGoalContinuation(), true);
+    controller.scheduleGoalContinuation();
+    await settleImmediate();
+    assert.equal(pending.length, 1);
+    assert.equal(pending[0].mode, 'goal-continuation');
+    assert.equal(pending[0].priority, 'later');
+    assert.equal(controller.shouldRunGoalContinuation(pending[0]), true);
+
+    controller.archiveCompletedGoalOnUserInput();
+    assert.equal(pending.length, 0);
+    await settleImmediate();
+    assert.equal(archived, 1);
+
+    listener?.({ sessionId: 'sess_goal', goal: { ...goal, status: 'paused' } });
+    await settleImmediate();
+    assert.equal(pending.length, 0);
+  } finally {
+    controller.disposeGoalContinuation();
+  }
+});
+
+test('busy or agent-parked Goal does not enqueue a continuation', async () => {
+  const goal = { id: 'goal-2', status: 'active' };
+  const state = { busy: true, commandBusy: false, sessionId: 'sess_goal_busy', goal };
+  const pending = [];
+  const controller = createGoalContinuation({
+    runtime: {
+      id: 'sess_goal_busy',
+      goalStatus: () => goal,
+      goalContinuation: () => ({ run: false, reason: 'agent-running', goal }),
+      onGoalStatusChange: () => () => {},
+    },
+    flags: { disposed: false, pendingSessionReset: false },
+    getState: () => state,
+    set: (patch) => Object.assign(state, patch),
+    getPending: () => pending,
+    enqueue: (text, options) => pending.push({ content: text, ...options }),
+  });
+  try {
+    controller.scheduleGoalContinuation();
+    await settleImmediate();
+    assert.equal(pending.length, 0);
+    state.busy = false;
+    controller.onGoalTurnSettled('done');
+    await settleImmediate();
+    assert.equal(pending.length, 0);
+  } finally {
+    controller.disposeGoalContinuation();
+  }
+});

package/src/tui/session/queue-helpers.mjs

@@ -36,7 +36,10 @@ export function defaultQueuePriority(mode) {
 
 export function isQueuedEntryEditable(entry) {
   const mode = entry?.mode || 'prompt';
-  return mode !== 'task-notification' && mode !== 'pending-resume' && entry?.isMeta !== true;
+  return mode !== 'task-notification'
+    && mode !== 'pending-resume'
+    && mode !== 'goal-continuation'
+    && entry?.isMeta !== true;
 }
 
 export function isQueuedEntryVisible(entry) {
@@ -44,7 +47,7 @@ export function isQueuedEntryVisible(entry) {
   // task completions stay in the internal pending queue, but should never look
   // like commands typed by the user while they wait to be drained.
   const mode = entry?.mode || 'prompt';
-  if (mode === 'pending-resume') return false;
+  if (mode === 'pending-resume' || mode === 'goal-continuation') return false;
   return isQueuedEntryEditable(entry);
 }
 

package/src/tui/session/session-action-surface.test.mjs

@@ -0,0 +1,108 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createSessionApi } from './session-api.mjs';
+import {
+  SESSION_CONFIGURE_ACTIONS,
+  SESSION_READ_ACTIONS,
+} from '../../standalone/session-protocol.mjs';
+
+// The daemon resolves every session action by NAME on the object
+// createLocalSessionRuntime returns — this surface. An action that only exists
+// on the runtime beneath it passes the protocol allowlist and then dies in the
+// session runtime worker as "session action <name> is unavailable" (desktop
+// /inherit shipped exactly that way).
+function stubBag(overrides = {}) {
+  const defaults = {
+    flags: {},
+    autoClearState: {},
+    pending: [],
+    listeners: new Set(),
+  };
+  return new Proxy({}, {
+    get: (_target, key) => {
+      if (key in overrides) return overrides[key];
+      if (key in defaults) return defaults[key];
+      return () => ({});
+    },
+    has: () => true,
+  });
+}
+
+test('every advertised session action exists on the session surface', () => {
+  const api = createSessionApi(stubBag());
+  const missing = [...SESSION_READ_ACTIONS, ...SESSION_CONFIGURE_ACTIONS]
+    .filter((action) => typeof api[action] !== 'function');
+  assert.deepEqual(missing, []);
+});
+
+test('extension editor actions are advertised and forwarded', async () => {
+  const calls = [];
+  let state = { commandBusy: false, stats: {} };
+  const api = createSessionApi(stubBag({
+    runtime: {
+      getMcpServerConfig: (name) => {
+        calls.push(['getMcpServerConfig', name]);
+        return { name };
+      },
+      saveMcpServer: async (input) => {
+        calls.push(['saveMcpServer', input]);
+        return { name: input.name };
+      },
+      saveSkill: async (input) => {
+        calls.push(['saveSkill', input]);
+        return { skill: { name: input.name } };
+      },
+    },
+    getState: () => state,
+    set: (patch) => { state = { ...state, ...patch }; },
+    routeState: () => ({}),
+  }));
+
+  assert.ok(SESSION_READ_ACTIONS.includes('getMcpServerConfig'));
+  assert.ok(SESSION_CONFIGURE_ACTIONS.includes('saveMcpServer'));
+  assert.ok(SESSION_CONFIGURE_ACTIONS.includes('saveSkill'));
+  assert.deepEqual(api.getMcpServerConfig('UnityMCP'), { name: 'UnityMCP' });
+  await api.saveMcpServer({ name: 'UnityMCP' });
+  await api.saveSkill({ name: 'unity-helper' });
+  assert.deepEqual(calls, [
+    ['getMcpServerConfig', 'UnityMCP'],
+    ['saveMcpServer', { name: 'UnityMCP' }],
+    ['saveSkill', { name: 'unity-helper' }],
+  ]);
+});
+
+test('inheritFrom carries the conversation and rebuilds the heir transcript', async () => {
+  const carried = [
+    { role: 'system', content: 'target system prompt' },
+    { role: 'user', content: 'first question' },
+    { role: 'assistant', content: 'first answer' },
+  ];
+  let state = { sessionId: 'sess_heir', stats: {}, items: [] };
+  const calls = [];
+  const api = createSessionApi(stubBag({
+    runtime: {
+      inheritFrom: (sourceSessionId) => {
+        calls.push(sourceSessionId);
+        return { sessionId: 'sess_heir', sourceSessionId, messages: 2 };
+      },
+      readModelMessages: () => ({ messageCount: carried.length, messages: carried }),
+    },
+    getState: () => state,
+    set: (patch) => { state = { ...state, ...patch }; },
+    replaceItems: (items) => items,
+    routeState: () => ({}),
+  }));
+
+  const result = await api.inheritFrom('sess_source');
+
+  assert.deepEqual(calls, ['sess_source']);
+  assert.equal(result.messages, 2);
+  assert.equal(state.sessionId, 'sess_heir');
+  // Only the conversation travels: the target's own system block never becomes
+  // a transcript item.
+  assert.deepEqual(
+    state.items.map((item) => [item.kind, item.text]),
+    [['user', 'first question'], ['assistant', 'first answer']],
+  );
+});

package/src/tui/session/session-api-ext.mjs

@@ -437,9 +437,40 @@ export function sessionContextSnapshotProjection(session, contextStatus) {
 
 export function createSessionApiB(bag) {
   const {
-    runtime, nextId, flags, lifecycle, listeners, getState, set, flushEmitImmediate, disposeEmit, replaceItems, pushNotice, removeNotice, setProgressHint, clearToastTimers, disposeTranscriptSpill, routeState, syncContextStats, finishToolApproval, denyAllToolApprovals, restoreLeadSteeringFromDisk, resetStats, clearUiActivityBeforeContextSync, resetTuiForPendingSessionReset, snapshotTuiBeforeSessionReset, restoreTuiAfterFailedSessionReset, commitTuiSessionReset, resetStatsAndSyncContext,
+    runtime, nextId, flags, lifecycle, listeners, getState, set, flushEmitImmediate, disposeEmit, replaceItems, pushNotice, removeNotice, setProgressHint, clearToastTimers, disposeTranscriptSpill, disposeGoalContinuation, routeState, syncContextStats, finishToolApproval, denyAllToolApprovals, restoreLeadSteeringFromDisk, resetStats, clearUiActivityBeforeContextSync, resetTuiForPendingSessionReset, snapshotTuiBeforeSessionReset, restoreTuiAfterFailedSessionReset, commitTuiSessionReset, resetStatsAndSyncContext,
   } = bag;
   const oauthFlows = createSessionOAuthFlowRegistry();
+  /**
+   * Session inheritance as ONE addressable session action. THIS session is the
+   * already-created heir, so only the carry step runs here — the desktop
+   * creates and routes the new session first, then calls this by name. The
+   * daemon resolves actions on THIS surface, so `inheritFrom` has to live here
+   * and not only on the runtime beneath it.
+   */
+  const inheritFrom = async (sourceSessionId) => {
+    const result = await runtime.inheritFrom(sourceSessionId);
+    const sessionId = String(result?.sessionId || runtime.sessionId || getState().sessionId || '');
+    // Only model messages travel with the conversation. Rebuild the visible
+    // transcript from them right here so the heir opens showing the carried
+    // conversation; without it the view stays blank until a cold reopen
+    // resumes the session from disk and restores the same items.
+    const carried = runtime.readModelMessages?.(0)?.messages;
+    const items = restoreTranscriptItems(Array.isArray(carried) ? carried : [], { sessionId });
+    resetStatsAndSyncContext();
+    set({
+      sessionId,
+      items: replaceItems(items),
+      toasts: [],
+      queued: [],
+      thinking: null,
+      spinner: null,
+      lastTurn: null,
+      ...routeState(),
+      stats: { ...getState().stats },
+    });
+    flushEmitImmediate();
+    return result;
+  };
   return {
     resolveToolApproval: (id, decision = {}) => {
       const approved = decision === true || decision?.approved === true;
@@ -639,17 +670,17 @@ export function createSessionApiB(bag) {
     getTurnReviewDiff: async (options = {}) => {
       return (await runtime.getTurnReviewDiff?.(options)) ?? { supported: false, files: [], patch: '' };
     },
-    revertTurnReview: async () => {
+    revertTurnReview: async (checkpointId) => {
       if (typeof runtime.revertTurnReview !== 'function') {
         throw new Error('Turn review revert is unavailable');
       }
-      return await runtime.revertTurnReview();
+      return await runtime.revertTurnReview(checkpointId);
     },
-    revertTurnReviewFile: async (file) => {
+    revertTurnReviewFile: async (file, checkpointId) => {
       if (typeof runtime.revertTurnReviewFile !== 'function') {
         throw new Error('Turn review revert is unavailable');
       }
-      return await runtime.revertTurnReviewFile(file);
+      return await runtime.revertTurnReviewFile(file, checkpointId);
     },
     getOnboardingStatus: () => {
       return runtime.getOnboardingStatus?.() || { completed: true, workflowRoutes: {} };
@@ -915,6 +946,7 @@ export function createSessionApiB(bag) {
      * conversation into it. The source session file is left as it is, so the
      * two transcripts share a prefix and then diverge.
      */
+    inheritFrom,
     inheritSession: async () => {
       if (getState().commandBusy) return false;
       const sourceId = getState().sessionId || null;
@@ -922,9 +954,7 @@ export function createSessionApiB(bag) {
       set({ commandBusy: true });
       try {
         await runtime.newSession();
-        const result = await runtime.inheritFrom(sourceId);
-        set({ sessionId: runtime.sessionId ?? getState().sessionId });
-        return result;
+        return await inheritFrom(sourceId);
       } finally {
         set({ commandBusy: false });
       }
@@ -1071,6 +1101,7 @@ export function createSessionApiB(bag) {
       try { runtime.clearSessionPresence?.(); } catch { /* best-effort */ }
       clearToastTimers();
       disposeTranscriptSpill?.();
+      disposeGoalContinuation?.();
       try { clearInterval(lifecycle.runtimePulseTimer); } catch {}
       try { lifecycle.unsubscribeRuntimeNotifications?.(); } catch {}
       lifecycle.unsubscribeRuntimeNotifications = null;

package/src/tui/session/session-api.mjs

@@ -85,6 +85,9 @@ export function createSessionApiA(bag) {
     // turn or the background task. The returned running snapshot creates the
     // normal post-tool boundary, where this queued prompt is injected.
     if (accepted !== false) {
+      if ((intake.queueOptions.mode || 'prompt') === 'prompt') {
+        bag.archiveCompletedGoalOnUserInput?.();
+      }
       try { runtime.interruptTaskWait?.('user-message'); } catch {}
     }
     return accepted;
@@ -381,6 +384,18 @@ export function createSessionApiA(bag) {
         set({ commandBusy: false });
       }
     },
+    // Background-task control (list/read/monitor/cancel) is a CONTROL surface,
+    // not a conversation turn: the desktop stop button fires it WHILE a turn
+    // runs, so it neither waits on commandBusy nor leaves a transcript card.
+    // It must exist here because the daemon addresses actions on this surface.
+    taskControl: (args = {}) => {
+      return runtime.taskControl?.(args) ?? null;
+    },
+    goalControl: async (args = {}) => {
+      const result = await runtime.goalControl?.(args);
+      set({ goal: runtime.goalStatus?.() || result?.goal || null });
+      return result;
+    },
     toolsStatus: (query = '') => {
       return runtime.toolsStatus?.(query) || { mode: getState().toolMode, count: 0, activeCount: 0, tools: [] };
     },
@@ -428,6 +443,9 @@ export function createSessionApiA(bag) {
     mcpStatus: () => {
       return runtime.mcpStatus?.() || { servers: [], configuredCount: 0, connectedCount: 0, failedCount: 0 };
     },
+    getMcpServerConfig: (name) => {
+      return runtime.getMcpServerConfig?.(name);
+    },
     reconnectMcp: async () => {
       if (getState().commandBusy) return null;
       set({ commandBusy: true });
@@ -457,6 +475,19 @@ export function createSessionApiA(bag) {
         set({ commandBusy: false });
       }
     },
+    saveMcpServer: async (input) => {
+      if (getState().commandBusy) return null;
+      set({ commandBusy: true });
+      try {
+        const result = await runtime.saveMcpServer?.(input);
+        resetStatsAndSyncContext();
+        set({ ...routeState(), stats: { ...getState().stats } });
+        pushNotice(`mcp saved: ${result?.name || input?.name || 'server'}`, 'info');
+        return result;
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
     removeMcpServer: async (name) => {
       if (getState().commandBusy) return null;
       set({ commandBusy: true });
@@ -514,6 +545,19 @@ export function createSessionApiA(bag) {
         set({ commandBusy: false });
       }
     },
+    saveSkill: async (input) => {
+      if (getState().commandBusy) return null;
+      set({ commandBusy: true });
+      try {
+        const result = await runtime.saveSkill?.(input);
+        resetStatsAndSyncContext();
+        set({ ...routeState(), stats: { ...getState().stats } });
+        pushNotice(`skill saved: ${result?.skill?.name || input?.name || 'skill'}`, 'info');
+        return result;
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
     reloadSkills: async () => {
       if (getState().commandBusy) return null;
       set({ commandBusy: true });
@@ -569,6 +613,20 @@ export function createSessionApiA(bag) {
         set({ commandBusy: false });
       }
     },
+    setPluginEnabled: async (plugin, enabled) => {
+      if (getState().commandBusy) return null;
+      set({ commandBusy: true });
+      try {
+        const result = await runtime.setPluginEnabled?.(plugin, enabled);
+        resetStatsAndSyncContext();
+        set({ ...routeState(), stats: { ...getState().stats } });
+        pushNotice(`plugin ${enabled === false ? 'disabled' : 'enabled'}: ${
+          result?.plugin?.title || result?.plugin?.name || plugin?.name || plugin}`, 'info');
+        return result;
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
     removePlugin: async (plugin) => {
       if (getState().commandBusy) return null;
       set({ commandBusy: true });

package/src/tui/session/session-flow.mjs

@@ -88,6 +88,8 @@ export function createSessionFlow(bag) {
         : [],
       steeringPersistId: options.steeringPersistId || null,
       steeringPersistRestored: options.steeringPersistRestored === true,
+      isMeta: options.isMeta === true,
+      goalId: options.goalId || null,
     };
   }
 
@@ -215,6 +217,10 @@ export function createSessionFlow(bag) {
         });
         firstBatch = false;
         if (batch.length === 0) break;
+        if (batch[0]?.mode === 'goal-continuation'
+          && bag.shouldRunGoalContinuation?.(batch[0]) !== true) {
+          continue;
+        }
         tuiDebug(`busy-queue drain batch=${batch.length} remaining=${pending.length}`);
         const ids = new Set(batch.map((e) => e.id));
         const merged = mergePromptContents(batch);

package/src/tui/session/turn.mjs

@@ -1384,6 +1384,7 @@ export function createRunTurn(bag) {
     flushEmit?.();
     _publishedThinkingActive = false; // turn teardown cleared getState().thinking
     const finalStatus = cancelled ? 'cancelled' : (failed ? 'failed' : 'done');
+    try { bag.onGoalTurnSettled?.(finalStatus); } catch {}
     tuiDebug(`runTurn end turn=${turnIndex} status=${finalStatus} elapsedMs=${Date.now() - startedAt} pending=${pending.length}`);
     return finalStatus;
   }

package/src/tui/session-local.mjs

@@ -31,6 +31,7 @@ import { listThemes, getThemeSetting, setThemeSetting } from './theme.mjs';
 import { resetAllStreamingMarkdownStablePrefixes } from './markdown/streaming-markdown.mjs';
 import { bootProfile } from './session/boot-profile.mjs';
 import { createSessionStats, applyUsageDelta } from './session/session-stats.mjs';
+import { createGoalContinuation } from './session/goal-continuation.mjs';
 import {
   pickVerb,
   pickDoneVerb,
@@ -896,6 +897,14 @@ export async function createLocalSessionRuntime({
     kickExecutionPendingResume, flushDeferredExecutionPendingResumeKick, scheduleExecutionPendingResumeKick, discardExecutionPendingResume, updateAgentJobCard, subscribeRuntimeNotifications,
   });
   Object.assign(bag, createSessionFlow(bag));
+  Object.assign(bag, createGoalContinuation({
+    runtime,
+    flags,
+    getState: () => state,
+    set,
+    getPending: () => pending,
+    enqueue: (...args) => bag.enqueue(...args),
+  }));
   bag.runTurn = createRunTurn(bag);
   const api = createSessionApi(bag);
   // Cross-surface share: presence + the durable pending spool remain the
@@ -1069,6 +1078,9 @@ export async function createLocalSessionRuntime({
     const base = api[method].bind(api);
     api[method] = async (...args) => {
       const result = await base(...args);
+      bag.cancelQueuedGoalContinuations?.();
+      bag.refreshGoalState?.();
+      bag.scheduleGoalContinuation?.();
       reconcileLiveShareNow();
       if (method === 'resume' && result === true && state.sessionRemoteAttached) {
         const id = String(state.sessionId || '');
@@ -1165,6 +1177,8 @@ export async function createLocalSessionRuntime({
     } catch { /* best-effort */ }
   }, 3000);
   remoteAttachTimer.unref?.();
-  void bag.restoreLeadSteeringFromDisk();
+  void Promise.resolve(bag.restoreLeadSteeringFromDisk())
+    .catch(() => {})
+    .finally(() => bag.scheduleGoalContinuation?.());
   return api;
 }