mixdog 1.0.11 → 1.1.0

package/src/session-runtime/settings-compaction-api.mjs

@@ -1,4 +1,8 @@
 // Context lifecycle settings: compaction budgets and the idle auto-clear.
+import {
+  refreshLiveSessionsProviderCacheOpts,
+  refreshSessionProviderCacheOpts,
+} from '../runtime/agent/orchestrator/session/manager/session-lifecycle.mjs';
 
 // Every spelling of the main-context buffer budget; a new representation
 // replaces the previous one.
@@ -46,6 +50,13 @@ export function createCompactionSettings({
   formatDurationMs,
   invalidateContextStatusCache,
 }) {
+  // The Lead messages-tail TTL derives from the auto-clear idle window.
+  const refreshLeadCacheOpts = () => {
+    const config = getConfig();
+    refreshSessionProviderCacheOpts(getSession(), config);
+    refreshLiveSessionsProviderCacheOpts(config);
+  };
+
   /** Apply a per-provider idle override (or its reset) and return the resolved view. */
   const saveProviderIdle = (config, next, providerKey, input) => {
     const providerIdleMs = { ...(next.providerIdleMs || {}) };
@@ -57,6 +68,7 @@ export function createCompactionSettings({
       providerIdleMs[providerKey] = Math.max(60_000, Math.round(idleMs));
     }
     saveConfigAndAdopt({ ...config, autoClear: { ...next, providerIdleMs } });
+    refreshLeadCacheOpts();
   };
 
   return {
@@ -157,6 +169,7 @@ export function createCompactionSettings({
           if (!hasOwn(input, 'enabled')) next.enabled = true;
         }
         saveConfigAndAdopt({ ...config, autoClear: next });
+        refreshLeadCacheOpts();
       }
       const resolved = this.getAutoClear();
       return { ...resolved, label: formatDurationMs(resolved.idleMs) };

package/src/session-runtime/setup-tool/executor.mjs

@@ -5,8 +5,9 @@
  *  registers the tool executor before it finishes assembling the API object. */
 import { builtinFeatureActive } from '../../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
 import { ORCHESTRATION_MODES } from '../../runtime/shared/orchestration.mjs';
+import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 import { SETUP_DESKTOP_DOMAINS, SETUP_HANDOFFS } from './settings-contract.mjs';
-import { executeExtendedSetupAction, publicAutomation, validateMcpInput } from './extended-actions.mjs';
+import { executeExtendedSetupAction, publicAutomation, publicHookRule, validateMcpInput } from './extended-actions.mjs';
 import { SETUP_DESKTOP_UNCLAIMED, createSetupUiRequests } from './ui-requests.mjs';
 import {
   SETUP_ACTIONS,
@@ -33,6 +34,10 @@ const ACTION_APPLIES_TO = {
   delete_automation: 'future automation runs',
   set_automation_enabled: 'future automation runs',
   set_webhook_config: 'the webhook worker after configuration reload',
+  add_hook_rule: 'subsequent tool calls; no restart required',
+  set_hook_rule_enabled: 'subsequent tool calls; no restart required',
+  delete_hook_rule: 'subsequent tool calls; no restart required',
+  set_media_default: 'media generations that omit lane/model, and the Studio selection',
 };
 
 const OPEN_TARGET_HINTS = Object.freeze({
@@ -114,6 +119,7 @@ function publicProviderRows(setup) {
     api: (setup?.api || []).map((row) =>
       pick(row, {
         source: apiKeySource(row),
+        custom: row.custom === true,
         keyUrl: /^https:\/\//.test(String(row.url || '')) ? row.url : null,
       })
     ),
@@ -137,6 +143,7 @@ function publicAccounts(pool) {
   return {
     selectedId: pool.selectedId,
     auto: pool.auto,
+    useCredits: pool.useCredits === true,
     accounts: pool.accounts.map(({ id, label, authenticated, reauthRequired }) => ({
       id,
       label,
@@ -188,13 +195,49 @@ async function automationStatus(rt, { domain }) {
   };
 }
 
-function featureFlags(rt) {
-  return Object.fromEntries(
-    Object.entries(rt.getToolModuleSettings?.() || {}).map(([name, settings]) => [
-      name,
-      Object.fromEntries(Object.entries(settings).filter(([key]) => key === 'enabled' || key === 'installed')),
-    ])
-  );
+// Summary keys per built-in; Auto Effort also reports machine support and
+// judge-model readiness so a failed toggle or install is explainable.
+const FEATURE_STATUS_KEYS = ['enabled', 'installed'];
+const FEATURE_EXTRA_STATUS_KEYS = { autoEffort: ['supported', 'ready', 'installing'] };
+
+async function featureStatus(rt, getConfig) {
+  const config = getConfig();
+  return {
+    ...Object.fromEntries(
+      Object.entries(rt.getToolModuleSettings?.() || {}).map(([name, settings]) => {
+        const keys = [...FEATURE_STATUS_KEYS, ...(FEATURE_EXTRA_STATUS_KEYS[name] || [])];
+        return [name, Object.fromEntries(Object.entries(settings).filter(([key]) => keys.includes(key)))];
+      })
+    ),
+    browser: { active: builtinFeatureActive(config, 'browser') },
+    computer: { active: builtinFeatureActive(config, 'computer') },
+    terminal: { active: builtinFeatureActive(config, 'terminal') },
+    voice: rt.getVoiceStatus ? voiceFeatureStatus(await rt.getVoiceStatus()) : null,
+  };
+}
+
+async function mediaDefaults(rt) {
+  const rows = await Promise.all(MEDIA_KINDS.map((kind) => rt.getMediaDefault(kind)));
+  return {
+    defaults: Object.fromEntries(
+      MEDIA_KINDS.map((kind, i) => [kind, rows[i] ? { lane: rows[i].lane, model: rows[i].model } : null])
+    ),
+  };
+}
+
+function hookStatus(rt) {
+  const status = rt.hooksStatus();
+  return {
+    enabled: status.enabled === true,
+    configMode: status.configMode,
+    rulesPath: status.rulesPath,
+    ruleCount: status.ruleCount,
+    rules: status.rules.map(publicHookRule),
+    configuredEvents: status.configuredEvents,
+    configSources: status.configSources,
+    errors: status.errors,
+    note: status.note,
+  };
 }
 
 // status readers per non-desktop domain: (rt, { domain, getConfig }) → the
@@ -206,23 +249,16 @@ const SETUP_STATUS_READERS = {
     desktopScope: 'desktop-host; requires this conversation open in the local Desktop window',
     handoffs: SETUP_HANDOFFS,
   }),
-  summary: (rt, { getConfig }) => {
-    const config = getConfig();
-    return {
-      route: mainRoute(rt),
-      workflow: (rt.listWorkflows?.() || []).find((pack) => pack.active) || null,
-      outputStyle: rt.getOutputStyle?.()?.configured || null,
-      profile: (({ title, language, experienceLevel }) => ({ title, language, experienceLevel }))(
-        rt.getProfile?.() || {}
-      ),
-      features: {
-        ...featureFlags(rt),
-        browser: { active: builtinFeatureActive(config, 'browser') },
-        computer: { active: builtinFeatureActive(config, 'computer') },
-      },
-      onboarding: rt.getOnboardingStatus?.() || null,
-    };
-  },
+  summary: async (rt, { getConfig }) => ({
+    route: mainRoute(rt),
+    workflow: (rt.listWorkflows?.() || []).find((pack) => pack.active) || null,
+    outputStyle: rt.getOutputStyle?.()?.configured || null,
+    profile: (({ title, language, experienceLevel }) => ({ title, language, experienceLevel }))(
+      rt.getProfile?.() || {}
+    ),
+    features: await featureStatus(rt, getConfig),
+    onboarding: rt.getOnboardingStatus?.() || null,
+  }),
   model: (rt) => ({ route: mainRoute(rt), effortOptions: rt.effortOptions || [] }),
   agents: (rt) => ({
     agents: rt.listAgents?.() || [],
@@ -249,14 +285,7 @@ const SETUP_STATUS_READERS = {
   compaction: (rt) => rt.getCompactionSettings?.() || {},
   memory: (rt) => ({ ...(rt.getToolModuleSettings?.()?.memory || {}), recap: rt.getRecapSettings?.() || null }),
   'local-provider': (rt) => rt.getToolModuleSettings().localProvider,
-  features: (rt, { getConfig }) => {
-    const config = getConfig();
-    return {
-      ...featureFlags(rt),
-      browser: { active: builtinFeatureActive(config, 'browser') },
-      computer: { active: builtinFeatureActive(config, 'computer') },
-    };
-  },
+  features: (rt, { getConfig }) => featureStatus(rt, getConfig),
   shell: (rt) => rt.getSystemShell?.() || {},
   providers: async (rt) => {
     const rows = publicProviderRows(await rt.getProviderSetup?.({}));
@@ -273,6 +302,8 @@ const SETUP_STATUS_READERS = {
   onboarding: (rt) => rt.getOnboardingStatus?.() || {},
   schedules: automationStatus,
   webhooks: automationStatus,
+  hooks: hookStatus,
+  media: mediaDefaults,
 };
 
 // Shape validation shared by every action: the action enum, the JSON
@@ -294,8 +325,8 @@ function validateSetupInput(args) {
     if (action !== 'set_agent_route' && Object.hasOwn(args.route, 'disabled')) {
       throw new Error('route.disabled is only accepted by set_agent_route');
     }
-    if (action !== 'set_route' && Object.hasOwn(args.route, 'contextPercent')) {
-      throw new Error('route.contextPercent is only accepted by set_route');
+    if (action !== 'set_route' && action !== 'set_agent_route' && Object.hasOwn(args.route, 'contextPercent')) {
+      throw new Error('route.contextPercent is only accepted by set_route and set_agent_route');
     }
   }
   for (const field of ['desktop', 'appearance', 'webhook', 'compaction', 'providerAccount']) {
@@ -311,7 +342,27 @@ function mcpServerInput(args) {
   return server;
 }
 
-const DESKTOP_HOSTED_FEATURES = ['browser', 'computer', 'voice'];
+const DESKTOP_HOSTED_FEATURES = ['browser', 'computer'];
+
+const publicVoice = (status) => ({
+  enabled: status.enabled === true,
+  installed: status.installed === true,
+  components: status.components,
+});
+const voiceFeatureStatus = (status) => ({ ...publicVoice(status), installing: status.busy === true });
+
+// Voice runs on the runtime toggle the Desktop Built-in card also uses:
+// enabling installs any missing whisper/ffmpeg component first.
+async function setVoice(rt, enabled) {
+  const { status, error } = await rt.setVoiceEnabled(enabled);
+  if (status.enabled !== enabled || (enabled && status.installed !== true)) {
+    throw new Error(
+      `Voice did not reach the requested ${enabled ? 'installed and enabled' : 'disabled'} state${error ? `: ${error}` : ''}`
+    );
+  }
+  return { voice: publicVoice(status), appliesTo: 'channel voice transcription and Desktop dictation now' };
+}
+
 // Git and Office installs bring their system dependency (Git, LibreOffice) in
 // through the Desktop's guided installers, the same steps as the Built-in card.
 // A request no Desktop window takes keeps the runtime-only install.
@@ -322,6 +373,7 @@ const SETUP_INSTALLABLE_FEATURES = [
   'office',
   'tidy',
   'localProvider',
+  'autoEffort',
   'browser',
   'computer',
   'voice',
@@ -399,11 +451,13 @@ const SETUP_ACTION_HANDLERS = {
   set_builtin_enabled: (rt, args, { requestDesktop }) => {
     const name = requireEnum(args.name, SETUP_BUILTIN_TOGGLE_FEATURES, 'name');
     if (DESKTOP_HOSTED_FEATURES.includes(name)) return requestDesktop(args);
+    if (name === 'voice') return setVoice(rt, requireBoolean(args.enabled));
     return rt.setBuiltinToolEnabled(name, requireBoolean(args.enabled));
   },
   install_builtin: async (rt, args, { requestDesktop }) => {
     const name = requireEnum(args.name, SETUP_INSTALLABLE_FEATURES, 'name');
     if (DESKTOP_HOSTED_FEATURES.includes(name)) return requestDesktop(args);
+    if (name === 'voice') return setVoice(rt, true);
     if (DESKTOP_PREPARED_FEATURES.includes(name)) {
       try {
         return await requestDesktop(args);
@@ -565,9 +619,8 @@ export function createSetupToolExecutor({ getApi, getConfig, notifySessionUi, ge
     const command = requireEnum(target, SETUP_OPEN_TARGETS, 'target');
     const sessionId = clean(getSessionId?.());
     const hint = OPEN_TARGET_HINTS[command] || `TUI: /${command}`;
-    const handled = sessionId
-      ? notifySessionUi?.(sessionId, `Open /${command}`, { kind: 'ui-open', command }) === true
-      : false;
+    const handled =
+      Boolean(sessionId) && notifySessionUi?.(sessionId, `Open /${command}`, { kind: 'ui-open', command }) === true;
     return {
       opened: handled,
       target: command,
@@ -577,7 +630,7 @@ export function createSetupToolExecutor({ getApi, getConfig, notifySessionUi, ge
     };
   }
 
-  async function execute(args = {}, { signal } = {}) {
+  async function execute(args, { signal }) {
     signal?.throwIfAborted();
     const requestDesktop = (request) => desktop.request(request, { signal });
     const action = validateSetupInput(args);

package/src/session-runtime/setup-tool/extended-actions.mjs

@@ -1,4 +1,5 @@
 import { SETUP_EXTENDED_PROPERTIES, SETUP_DESKTOP_ACTIONS } from './settings-contract.mjs';
+import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 
 const own = (value, key) => Object.hasOwn(value || {}, key);
 const pick = (value, keys) => Object.fromEntries(keys.filter((key) => own(value, key)).map((key) => [key, value[key]]));
@@ -135,9 +136,10 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
   set_local_context: (rt, args) => rt.setLocalProviderContext(args.modelId, args.localContextWindow),
   async list_models(rt, args) {
     const options = args.catalog || {};
+    const refresh = options.refresh === true;
     const models = options.webSearch
-      ? await rt.listWebSearchModels({ refresh: options.refresh === true })
-      : await rt.listProviderModels({ refresh: options.refresh === true });
+      ? await rt.listWebSearchModels({ refresh })
+      : await rt.listProviderModels({ refresh });
     return { models: options.provider ? models.filter((model) => model.provider === options.provider) : models };
   },
   set_orchestration_mode: (rt, args) => rt.setOrchestrationMode(args.mode),
@@ -166,7 +168,7 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
     }
     if (kind === 'schedule' && own(input, 'parser')) throw new Error('parser is a webhook-only field');
     let previous = {};
-    if (input.overwrite === true) {
+    if (input.overwrite) {
       const status = await rt.getChannelSetup();
       previous = status[kind === 'schedule' ? 'schedules' : 'webhooks'].find((row) => row.name === input.name);
       if (!previous) throw new Error(`${kind} "${input.name}" does not exist`);
@@ -184,7 +186,11 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
     return {
       ...publicAutomation(result),
       ...(kind === 'webhook'
-        ? { secretSet: true, credentialHandoff: 'Use the Webhooks UI to copy the signing secret.' }
+        ? {
+            secretSet: true,
+            credentialHandoff:
+              'The signing secret is never returned here or shown again. Open the Webhooks panel, edit this webhook, press Regenerate secret, copy the new value, and save.',
+          }
         : {}),
     };
   },
@@ -206,7 +212,7 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
       .sections.flatMap((section) => section.options)
       .find((row) => row.id === args.name);
     if (!option) throw new Error(`Unknown developer option "${args.name}"; read status developer`);
-    if (args.enabled && option.warning && args.riskAccepted !== true) {
+    if (args.enabled && option.warning && !args.riskAccepted) {
       throw new Error(
         `Enabling ${option.label} requires riskAccepted:true after the user explicitly accepts: ${option.warning}`
       );
@@ -218,8 +224,61 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
     const status = await rt.getChannelSetup();
     return { webhook: pick(status.webhook, ['enabled', 'port', 'domain']) };
   },
+  add_hook_rule: async (rt, args) => {
+    const rule = args.hookRule;
+    const rewrites = ['modify', 'rewrite'].includes(rule.action);
+    const edits = ['patch', 'args'].filter((key) => own(rule, key));
+    if (rewrites && edits.length !== 1)
+      throw new Error(`hookRule.${rule.action} requires exactly one of patch or args`);
+    if (!rewrites && edits.length) throw new Error(`hookRule.${edits[0]} applies only to modify or rewrite rules`);
+    return { rules: publicHookRules(await rt.addHookRule(rule)) };
+  },
+  async set_hook_rule_enabled(rt, args) {
+    hookRuleAt(rt, args.ruleIndex);
+    const rules = await rt.setHookRuleEnabled(args.ruleIndex, args.enabled);
+    // Toggles are debounced; settle the write so the receipt reflects disk.
+    rt.flushHookRules();
+    return { rules: publicHookRules(rules) };
+  },
+  async delete_hook_rule(rt, args) {
+    const deleted = hookRuleAt(rt, args.ruleIndex);
+    return {
+      deleted,
+      rules: publicHookRules(await rt.deleteHookRule(args.ruleIndex)),
+      recovery: 'The rule is removed from the hook rules file; re-adding it with add_hook_rule restores it.',
+    };
+  },
+  async set_media_default(rt, args) {
+    if (!MEDIA_KINDS.includes(args.kind)) throw new Error(`kind must be one of ${MEDIA_KINDS.join(', ')}`);
+    const lane = (await rt.listMediaLanes()).find((row) => row.id === args.lane);
+    if (!lane) throw new Error(`Unknown media lane "${args.lane}"; list lanes with the media tool`);
+    if (!lane.authenticated) throw new Error(`${lane.label} is not signed in; open providers first`);
+    const spec = lane[args.kind];
+    if (!spec) throw new Error(lane.catalogError || `${lane.id} offers no ${args.kind} models`);
+    if (own(args, 'model') && !spec.models.some((model) => model.id === args.model)) {
+      throw new Error(`model "${args.model}" is not available on ${lane.id}/${args.kind}`);
+    }
+    return { media: await rt.setMediaDefault(pick(args, ['kind', 'lane', 'model'])) };
+  },
 });
 
+/** Rule metadata only. Argument edits (patch/args) may embed credentials, so
+ *  setup reports their presence, never their contents. */
+export function publicHookRule(row) {
+  return {
+    ...pick(row, ['index', 'enabled', 'tool', 'action', 'match', 'cwd', 'reason']),
+    hasArgumentEdit: row.patch != null,
+  };
+}
+
+const publicHookRules = (rules) => rules.map(publicHookRule);
+
+function hookRuleAt(rt, index) {
+  const rule = rt.hooksStatus().rules.find((row) => row.index === index);
+  if (!rule) throw new Error(`hook rule ${index} not found; read status hooks`);
+  return publicHookRule(rule);
+}
+
 export async function executeExtendedSetupAction(rt, args, requestDesktop) {
   if (SETUP_DESKTOP_ACTIONS.includes(args.action)) return requestDesktop(args);
   const handler = EXTENDED_SETUP_HANDLERS[args.action];

package/src/session-runtime/setup-tool/settings-contract.mjs

@@ -3,6 +3,7 @@ import { ORCHESTRATION_MODES } from '../../runtime/shared/orchestration.mjs';
 /** Additional settings surfaces. Keep this registry shared by the wire schema,
  * dispatch coverage tests and the model-visible capability inventory. */
 const text = { type: 'string' };
+const nonBlank = { type: 'string', minLength: 1, pattern: '\\S' };
 const removableText = { type: ['string', 'null'] };
 const boolean = { type: 'boolean' };
 const strings = { type: 'array', items: text };
@@ -33,8 +34,15 @@ export const SETUP_EXTENDED_ACTION_FIELDS = Object.freeze({
   revoke_linked_device: 'name',
   set_activity_rail_pins: 'activityRailPins',
   set_developer_option: 'name enabled riskAccepted?',
+  add_hook_rule: 'hookRule',
+  set_hook_rule_enabled: 'ruleIndex enabled',
+  delete_hook_rule: 'ruleIndex',
+  set_media_default: 'kind lane model?',
 });
 
+/** Mirrors RULE_ACTIONS in services/hook-bus/rule-store.mjs. */
+export const SETUP_HOOK_RULE_ACTIONS = Object.freeze(['allow', 'deny', 'block', 'modify', 'rewrite', 'ask']);
+
 /** Mirrors ACTIVITY_RAIL_PIN_IDS in apps/desktop/src/shared/activity-rail-pins.ts. */
 export const SETUP_ACTIVITY_RAIL_PIN_IDS = Object.freeze([
   'sessions',
@@ -57,6 +65,8 @@ export const SETUP_EXTENDED_DOMAINS = Object.freeze([
   'connection',
   'schedules',
   'webhooks',
+  'hooks',
+  'media',
 ]);
 
 export const SETUP_DESKTOP_ACTIONS = Object.freeze([
@@ -108,9 +118,9 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
   }),
   localContextWindow: {
     type: ['integer', 'null'],
-    minimum: 512,
+    minimum: 16384,
     description:
-      'Managed local model context tokens; null restores automatic allocation. Maximum comes from the model status.',
+      'Managed local model context tokens (32768+ recommended for agent work); null restores automatic allocation. Maximum comes from the model status.',
   },
   mode: {
     type: 'string',
@@ -185,6 +195,12 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
     turnNotifications: boolean,
     usagePinned: boolean,
     computerObserveOnly: boolean,
+    notificationVolume: {
+      type: 'integer',
+      minimum: 0,
+      maximum: 400,
+      description: 'Windows only: notification sound volume percent.',
+    },
   }),
   appearance: object({
     theme: { type: 'string', enum: ['system', 'dark', 'white'] },
@@ -193,13 +209,40 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
       description: 'Desktop UI language id from status appearance; independent of profile language.',
     },
     sidePanels: { type: 'string', enum: ['close-left', 'close-right', 'close-both', 'keep-open'] },
+    markdownDefaultView: { type: 'string', enum: ['preview', 'rich', 'source'] },
+    linkPreview: boolean,
+    toolActivityExpansion: { type: 'string', enum: ['collapsed', 'commands', 'all'] },
   }),
+  hookRule: object(
+    {
+      tool: { ...nonBlank, description: 'Tool name, prefix* pattern, or * (default).' },
+      action: { type: 'string', enum: [...SETUP_HOOK_RULE_ACTIONS] },
+      match: { ...nonBlank, description: 'Substring the tool arguments or cwd must contain.' },
+      cwd: { ...nonBlank, description: 'Substring the working directory must contain.' },
+      reason: nonBlank,
+      patch: { type: 'object', description: 'modify/rewrite: fields merged into the tool arguments.' },
+      args: { type: 'object', description: 'modify/rewrite: arguments that replace the tool arguments.' },
+      enabled: boolean,
+    },
+    ['action']
+  ),
+  ruleIndex: {
+    type: 'integer',
+    minimum: 0,
+    description: 'set_hook_rule_enabled/delete_hook_rule: rule index from status hooks.',
+  },
+  lane: { ...nonBlank, description: 'set_media_default: lane id from the media catalog.' },
+  model: {
+    ...nonBlank,
+    description: 'set_media_default: model id offered by the lane for the kind; omitted = the lane default.',
+  },
   project: object({ path: text, alias: text }, ['path']),
   projectPath: { ...text, description: 'Exact registered Project root.' },
   activityRailPins: {
     type: 'array',
     items: { type: 'string', enum: [...SETUP_ACTIVITY_RAIL_PIN_IDS] },
-    description: 'set_activity_rail_pins: complete ordered list of pinned activity rail items; it replaces the current list.',
+    description:
+      'set_activity_rail_pins: complete ordered list of pinned activity rail items; it replaces the current list.',
   },
   riskAccepted: {
     ...boolean,

package/src/session-runtime/setup-tool/tool-defs.mjs

@@ -4,6 +4,7 @@ import {
   SETUP_EXTENDED_PROPERTIES,
   SETUP_MCP_SCHEMA,
 } from './settings-contract.mjs';
+import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 
 /** Built-in `setup` tool: the model's handle on a Mixdog user's persisted
  *  configuration. The description is a contract only; how to use each action
@@ -115,6 +116,7 @@ export const SETUP_BUILTIN_TOGGLE_FEATURES = Object.freeze([
   'office',
   'tidy',
   'localProvider',
+  'autoEffort',
   'browser',
   'computer',
   'voice',
@@ -172,7 +174,7 @@ export const SETUP_TOOL_DEFS = Object.freeze([
         route: {
           ...ROUTE_SCHEMA,
           description:
-            'Partial route update; omitted fields are preserved. Agent or Web Search provider "" restores Main inheritance. contextPercent is Main-only.',
+            'Partial route update; omitted fields are preserved. Agent or Web Search provider "" restores Main inheritance. contextPercent applies to Main and agent routes only.',
         },
         agent: { type: 'string', description: 'set_agent_route: agent id.' },
         workflow: { type: 'string', description: 'set_workflow: pack id.' },
@@ -225,7 +227,12 @@ export const SETUP_TOOL_DEFS = Object.freeze([
           properties: {
             selectedId: { type: 'string', description: 'Account to use now.' },
             auto: { type: 'boolean', description: 'Automatic switching to another account when one is exhausted.' },
-            order: { type: 'array', items: { type: 'string' }, description: 'Every connected account id exactly once.' },
+            useCredits: { type: 'boolean', description: 'Allow paid credits once plan limits are reached.' },
+            order: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Every connected account id exactly once.',
+            },
             rename: {
               type: 'object',
               additionalProperties: false,
@@ -261,9 +268,9 @@ export const SETUP_TOOL_DEFS = Object.freeze([
         },
         contextWindow: {
           type: 'integer',
-          minimum: 512,
+          minimum: 16384,
           maximum: 32768,
-          description: 'inspect_hf_model: runtime context allocation, default 8192.',
+          description: 'inspect_hf_model: runtime context allocation; default 32768 when the GPU holds it, else 16384.',
         },
         previewId: { type: 'string', description: 'register_hf_model: unexpired read-only inspection receipt.' },
         licenseAccepted: {
@@ -296,8 +303,9 @@ export const SETUP_TOOL_DEFS = Object.freeze([
         source: { type: 'string', description: 'add_plugin: Git URL, owner/repo, or local path.' },
         kind: {
           type: 'string',
-          enum: ['skills', 'mcp', 'plugins'],
-          description: 'set_extension_scope: which extension list `name` belongs to.',
+          enum: ['skills', 'mcp', 'plugins', ...MEDIA_KINDS],
+          description:
+            'set_extension_scope: which extension list `name` belongs to (skills|mcp|plugins). set_media_default: media kind.',
         },
         projects: {
           type: 'array',

package/src/session-runtime/tool-surface.mjs

@@ -1,12 +1,20 @@
 // Lead tool surface: which tools the model sees before a session exists, and
 // how that pre-session selection is replayed once one does. runtime-core keeps
 // the mutable session/route/mode it injects here.
-import { applyDeferredToolSurface, filterDisallowedTools, selectDeferredTools } from '../runtime/agent/orchestrator/runtime-core/tool-catalog.mjs';
+import {
+  applyDeferredToolSurface,
+  filterDisallowedTools,
+  selectDeferredTools,
+} from '../runtime/agent/orchestrator/runtime-core/tool-catalog.mjs';
 import { LEAD_DISALLOWED_TOOLS } from '../runtime/agent/orchestrator/runtime-core/tool-defs.mjs';
 import { deferredSurfaceModeForLead, toolSpecForMode } from '../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { loadSkillToolDependencies } from '../runtime/agent/orchestrator/runtime-core/skill-tool-loading.mjs';
-import { disallowedModelToolNamesForProfile, filterModelToolsForProfile } from '../runtime/agent/orchestrator/runtime-core/tool-profile.mjs';
-import { configuredOrchestrationMode, sessionOrchestrationMode } from '../runtime/shared/orchestration.mjs';
+import {
+  disallowedModelToolNamesForProfile,
+  filterModelToolsForProfile,
+} from '../runtime/agent/orchestrator/runtime-core/tool-profile.mjs';
+import { workflowDisallowsAgentTool } from '../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import { configuredOrchestrationMode } from '../runtime/shared/orchestration.mjs';
 
 export function createToolSurface({
   mgr,
@@ -26,16 +34,14 @@ export function createToolSurface({
 }) {
   let preSessionSurface = null;
 
-  // A live session keeps its frozen mode; a new session uses current settings.
+  // A live session keeps its frozen capability; a new session uses current
+  // agents. Solo still offers the tool (deferred) for explicit user requests.
   function workflowAllowsAgents() {
     const session = getSession();
     if (session?.id || session?.workflow || session?.orchestrationMode) {
-      return sessionOrchestrationMode(session) !== 'none' && session?.workflow?.delegatesAgents !== false;
+      return !workflowDisallowsAgentTool(session?.workflow);
     }
-    return (
-      configuredOrchestrationMode(getConfig()) !== 'none' &&
-      (delegatableAgentIds?.(getConfig(), cfgMod.getPluginData?.() || dataDir).length ?? 1) > 0
-    );
+    return (delegatableAgentIds?.(getConfig(), cfgMod.getPluginData?.() || dataDir).length ?? 1) > 0;
   }
 
   function modelStandaloneTools() {
@@ -80,6 +86,7 @@ export function createToolSurface({
       tools: Array.isArray(tools) ? tools.slice() : [],
       mcpScopeId: getMcpScopeId(),
       cwd: getCurrentCwd?.() || null,
+      orchestrationMode: configuredOrchestrationMode(getConfig()),
     };
     applyDeferredToolSurface(surface, deferredSurfaceModeForLead(mode), modelStandaloneTools(), {
       provider: getRoute().provider,

package/src/session-runtime/turn/session-ops.mjs

@@ -79,6 +79,9 @@ export function createSessionOps(deps) {
     } catch {
       /* best-effort: PostCompact hook must never break manual compact */
     }
+    // The awaited compaction may outlive its session (user resumed/started
+    // another one). Only touch the active session if it is still this id.
+    if (getSession()?.id !== session.id) return result;
     setSession(mgr.getSession(session.id) || session);
     // Manual /compact drops the Goal's tool results exactly like the
     // automatic path, so it marks the same one-shot state reminder.

package/src/session-runtime/turn/share-ops.mjs

@@ -3,13 +3,16 @@
  * the owner side: pending-spool intake, presence beacon, and the viewer's
  * owner-liveness probe.
  */
-export function createShareOps({ getSession, getActiveTurnCount, mgr }) {
+export function createShareOps({ getSession, getActiveTurnCount, mgr, isSessionAdmissionOpen }) {
   // Owner-side injection intake: foreign user messages persisted into the
   // shared spool by an attached surface. Engine pollers call this while
   // idle and run each returned text through the normal submit queue.
   async function takeRemoteInjections() {
     const session = getSession();
     if (!session?.id || session.remoteAttached) return [];
+    // Pending-spool intake is an admission route: a fenced/closed owner leaves
+    // the spool untouched.
+    if (isSessionAdmissionOpen && !isSessionAdmissionOpen()) return [];
     if (getActiveTurnCount() > 0) return [];
     try {
       return (await mgr.drainForeignUserInjections?.(session.id)) || [];

package/src/session-runtime/turn/turn-run/turn-prepare.mjs

@@ -20,6 +20,7 @@ export function createTurnPreparation({
   hookCommonPayload,
   agentTool,
   getConfig,
+  assertSessionAdmission,
 }) {
   const scopedMcpTools = (session) => scopedMcpToolsFor(session, getConfig());
 
@@ -84,12 +85,17 @@ export function createTurnPreparation({
   // provider/model metadata initializes in the background. Only the next
   // actual turn waits, guaranteeing that it cannot run on a stale route.
   async function prepareSession(turn, prompt) {
+    // A closing/closed addressed runtime admits no turn (checked again after
+    // every await that could have outlived a close).
+    assertSessionAdmission?.();
     await turn.awaitTurn(() => awaitRoutePreparation?.());
+    assertSessionAdmission?.();
     turn.timing.routeWaitMs = performance.now() - turn.routeStartedAt;
     if (!getSession()?.id) {
       await turn.awaitTurn(() => createCurrentSession('turn', { signal: turn.signal }));
     }
     throwIfAborted(turn.signal);
+    assertSessionAdmission?.();
     ensureSessionTranscriptWriter?.();
     transcript.appendUser(prompt);
     const session0 = getSession();