mixdog 0.9.151 → 0.9.152

package/src/session-runtime/runtime-core.mjs

@@ -10,11 +10,18 @@ import keychain from '../lib/keychain-cjs.cjs';
 import './hitch-profile.mjs';
 import { ensureStandaloneEnvironment } from '../standalone/seeds.mjs';
 import { createStandaloneAgent } from '../standalone/agent-tool.mjs';
+import {
+  executeRemoteAgentControl,
+  remoteAgentControlEnabled,
+} from '../standalone/session-runtime-agent-control-client.mjs';
 import { isAgentOwner } from '../runtime/agent/orchestrator/agent-owner.mjs';
 import { createStandaloneChannelWorker } from '../standalone/channel-worker.mjs';
 import { createStandaloneHookBus } from '../standalone/hook-bus.mjs';
 import { getStandaloneMemoryRuntime } from '../standalone/memory-runtime-proxy.mjs';
-import { writeLastSessionCwd } from '../runtime/shared/user-cwd.mjs';
+import {
+  updateCurrentCwdOverride,
+  writeLastSessionCwd,
+} from '../runtime/shared/user-cwd.mjs';
 import { cancelBackgroundTasks } from '../runtime/shared/background-tasks.mjs';
 import { createTranscriptWriter } from '../runtime/shared/transcript-writer.mjs';
 import { mixdogHome } from '../runtime/shared/plugin-paths.mjs';
@@ -149,7 +156,6 @@ import {
 } from './output-styles.mjs';
 import { readJsonSafe, readTextSafe } from './fs-utils.mjs';
 import {
-  readProjectMcpServers,
   countSkillFiles,
   mcpScriptForPlugin,
   normalizePluginMcpServerConfig,
@@ -187,7 +193,6 @@ import {
   estimateToolSchemaBreakdown,
   measuredToolUsage,
   parseToolSelection,
-  parseToolSearchQuerySelection,
   sortedCatalogByMeasuredUsage,
   filterDisallowedTools,
   sortedNamesByMeasuredUsage,
@@ -247,6 +252,7 @@ import { createToolSurface } from './tool-surface.mjs';
 import { createToolPolicyRefresh } from './tool-policy-refresh.mjs';
 import { readRuntimeTunables } from './runtime-tunables.mjs';
 import { createSessionTurnApi } from './session-turn-api.mjs';
+import { createGoalRuntime } from './goal-runtime.mjs';
 import { providerInitCacheKey } from './provider-init-key.mjs';
 import { createRoutePreparationGate } from './route-preparation.mjs';
 import {
@@ -262,6 +268,19 @@ import {
   STANDALONE_ROOT,
   STANDALONE_DATA_DIR,
 } from './runtime-paths.mjs';
+// Desktop-app browser bridge: tiny fs/fetch client, so a static import adds
+// no meaningful boot cost. The tool itself is gated per session by the sync
+// bridge-availability probe (headless runs never see it).
+import {
+  browserBridgeAvailableSync,
+  executeBrowserTool,
+} from '../runtime/browser-bridge/client.mjs';
+import { TOOL_DEFS as BROWSER_BRIDGE_TOOL_DEFS } from '../runtime/browser-bridge/tool-defs.mjs';
+import {
+  computerBridgeAvailableSync,
+  executeComputerTool,
+} from '../runtime/computer-bridge/client.mjs';
+import { TOOL_DEFS as COMPUTER_BRIDGE_TOOL_DEFS } from '../runtime/computer-bridge/tool-defs.mjs';
 import {
   dispatchWebSearchRuntimeTool,
   memoryToolArgsForCaller,
@@ -416,9 +435,15 @@ export async function createMixdogSessionRuntime({
   const webSearchEnabled = () => featureEnvOverride('MIXDOG_FEATURE_WEB_SEARCH')
     ?? moduleEnabled(rt.config, 'webSearch', true);
   const channelsEnabled = () => moduleEnabled(rt.config, 'channels', true);
+  const browserToolEnabled = () => featureEnvOverride('MIXDOG_FEATURE_BROWSER')
+    ?? browserBridgeAvailableSync();
+  const computerToolEnabled = () => featureEnvOverride('MIXDOG_FEATURE_COMPUTER')
+    ?? computerBridgeAvailableSync();
   const featureDisallowedTools = () => [
     ...(webSearchEnabled() ? [] : ['web_search', 'web_fetch']),
     ...(memoryToolsEnabledFn() ? [] : ['memory', 'recall']),
+    ...(browserToolEnabled() ? [] : ['browser']),
+    ...(computerToolEnabled() ? [] : ['computer']),
   ];
 
   async function getMemoryModule() {
@@ -618,7 +643,6 @@ export async function createMixdogSessionRuntime({
   // True while the boot-time provider-catalog refresh is in flight: warming a
   // model cache it is about to invalidate only burns the load twice.
   rt.startupProviderCatalogRefreshPending = false;
-  rt.lastProjectMcpKey = null;
   // MCP connect state, owned here so teardown/reconnect paths still observe it;
   // the mcp-glue factory mutates this object in place (see createMcpGlue).
   const mcpState = {
@@ -632,6 +656,7 @@ export async function createMixdogSessionRuntime({
     mcpTransportLabel,
     resolveEffectiveMcpServers,
     mcpStatus,
+    getMcpServerConfig,
     connectConfiguredMcp,
     awaitInitialMcpConnect,
     normalizeMcpServerInput,
@@ -685,6 +710,7 @@ export async function createMixdogSessionRuntime({
   // Notification fan-out (listener broadcast + pending-queue mirroring of
   // terminal completions) lives in notification-bus.mjs.
   let sessionTurnApi = null;
+  let goalRuntime = null;
   const completionWakeups = new Set();
   const wakeQueuedCompletion = ({ sessionId, executionId, enqueuedAt } = {}) => {
     const ownerSessionId = String(sessionId || '').trim();
@@ -743,6 +769,7 @@ export async function createMixdogSessionRuntime({
     if (v?.id) {
       rt.reservedSessionId = null;
       bindRuntimeNotificationSession(v.id);
+      goalRuntime?.watchSession(v.id);
     }
   };
 
@@ -752,12 +779,14 @@ export async function createMixdogSessionRuntime({
     skillsStatus,
     skillContent,
     skillToolContent,
-    addProjectSkill,
+    addGlobalSkill,
+    saveSkillDocument,
+    invalidateSkills,
   } = createSkillsApi({ contextMod, getCwd: () => rt.currentCwd });
 
   // cwd resolution/apply + plugins-status + core-memory context. Extracted to
   // session-runtime/cwd-plugins.mjs; the facade keeps ownership of the mutable
-  // currentCwd/session/config/lastProjectMcpKey locals via getter/setter
+  // currentCwd/session/config locals via getter/setter
   // injection and passes the later-defined callbacks (prewarm/tool-surface/
   // memory) as closures.
   const {
@@ -771,9 +800,9 @@ export async function createMixdogSessionRuntime({
     setCurrentCwd: (next) => { rt.currentCwd = next; },
     getConfig: () => rt.config,
     getSession: () => rt.session,
+    getDesktopSession: () => rt.desktopSession,
+    setDesktopSession: (next) => { rt.desktopSession = next; },
     getRoute: () => rt.route,
-    getLastProjectMcpKey: () => rt.lastProjectMcpKey,
-    setLastProjectMcpKey: (next) => { rt.lastProjectMcpKey = next; },
     isCodeGraphPrewarmLazy: () => codeGraphPrewarmLazy,
     isCodeGraphFirstTurnPrewarmDone: () => rt.codeGraphFirstTurnPrewarmDone,
     getCodeGraphPrewarmDelayMs: () => codeGraphPrewarmDelayMs,
@@ -791,8 +820,8 @@ export async function createMixdogSessionRuntime({
     pluginMcpServerName,
     mcpScriptForPlugin,
     countSkillFiles,
-    readProjectMcpServers,
     writeLastSessionCwd,
+    updateCurrentCwdOverride,
     clean,
     resolve,
     statSync,
@@ -825,6 +854,27 @@ export async function createMixdogSessionRuntime({
       } catch { /* best-effort: subagent hook must never affect worker lifecycle */ }
     },
   });
+  const routedAgentTool = {
+    ...agentTool,
+    execute(args, context = {}) {
+      return remoteAgentControlEnabled()
+        ? executeRemoteAgentControl(args, context)
+        : agentTool.execute(args, context);
+    },
+    closeAll(reason, scope = {}) {
+      if (!remoteAgentControlEnabled()) return agentTool.closeAll(reason, scope);
+      void executeRemoteAgentControl({
+        type: '__close_all',
+        reason: String(reason || 'agent owner closed'),
+      }, {
+        callerCwd: rt.currentCwd,
+        invocationSource: 'runtime-lifecycle',
+        callerSessionId: scope?.callerSessionId || rt.session?.id || null,
+        clientHostPid: rt.session?.clientHostPid || process.pid,
+      }).catch(() => {});
+      return undefined;
+    },
+  };
   bootProfile('agent:ready', { ms: (performance.now() - agentToolStartedAt).toFixed(1) });
   const agentStatusState = () => {
     try {
@@ -841,6 +891,12 @@ export async function createMixdogSessionRuntime({
       return { agentWorkers: [], agentJobs: [], agentScope: null };
     }
   };
+  goalRuntime = createGoalRuntime({
+    dataDir: cfgMod.getPluginData?.() || STANDALONE_DATA_DIR,
+  });
+  if (rt.session?.id || rt.reservedSessionId) {
+    goalRuntime.watchSession(rt.session?.id || rt.reservedSessionId);
+  }
   const channelsStartedAt = performance.now();
   const channels = createStandaloneChannelWorker({
     rootDir: STANDALONE_ROOT,
@@ -876,6 +932,9 @@ export async function createMixdogSessionRuntime({
     ...(memoryToolDefs?.TOOL_DEFS || []).filter((tool) => tool?.name === 'recall' || tool?.name === 'memory'),
     ...(channelToolDefs?.TOOL_DEFS || []).filter((tool) => channels.isChannelTool(tool?.name)),
     ...(codeGraphToolDefs?.CODE_GRAPH_TOOL_DEFS || []).filter((tool) => tool?.name === 'code_graph'),
+    ...BROWSER_BRIDGE_TOOL_DEFS.filter((tool) => tool?.name === 'browser'),
+    ...COMPUTER_BRIDGE_TOOL_DEFS.filter((tool) => tool?.name === 'computer'),
+    ...goalRuntime.tools,
     ...agentTool.tools,
   ].map(applyStandaloneToolDefaults);
   bootProfile('tools:ready', { ms: (performance.now() - toolsStartedAt).toFixed(1), count: standaloneTools.length });
@@ -889,6 +948,7 @@ export async function createMixdogSessionRuntime({
   // replay) lives in tool-surface.mjs.
   const {
     modelStandaloneTools,
+    activateTools: activateRuntimeTools,
     invalidatePreSessionToolSurface,
     activeToolSurface,
     applyPreSessionToolSelection,
@@ -941,6 +1001,18 @@ export async function createMixdogSessionRuntime({
           throw new Error('memory tools are disabled in settings; background memory and manual core memory remain available');
         }
       }
+      if (name === 'browser') {
+        if (callerCtx?.invocationSource === 'model-tool' && featureEnvOverride('MIXDOG_FEATURE_BROWSER') === false) {
+          throw new Error('the browser tool is disabled in this environment');
+        }
+        return await executeBrowserTool(args);
+      }
+      if (name === 'computer') {
+        if (callerCtx?.invocationSource === 'model-tool' && featureEnvOverride('MIXDOG_FEATURE_COMPUTER') === false) {
+          throw new Error('the computer tool is disabled in this environment');
+        }
+        return await executeComputerTool(args);
+      }
       if (name === 'web_search' || name === 'web_fetch' || name === 'local_fetch' || name === 'image_fetch') {
         return dispatchWebSearchRuntimeTool(name, args, callerCtx, {
           getWebSearchModule,
@@ -978,7 +1050,7 @@ export async function createMixdogSessionRuntime({
           if (!stat.isDirectory()) throw new Error(`cwd: not a directory: ${nextCwd}`);
           currentCwd = typeof callerCtx?.setCallerCwd === 'function'
             ? clean(await callerCtx.setCallerCwd(nextCwd)) || nextCwd
-            : applyResolvedCwd(nextCwd);
+            : applyResolvedCwd(nextCwd, { persistProjectSelection: true });
         } else if (action !== 'get') {
           throw new Error(`cwd: unknown action "${action}"`);
         }
@@ -990,9 +1062,14 @@ export async function createMixdogSessionRuntime({
       if (name === 'Skill') {
         return skillToolContent(args?.name);
       }
+      if (name === 'get_goal' || name === 'create_goal' || name === 'update_goal') {
+        return await goalRuntime.executeTool(name, args || {}, {
+          callerSessionId: callerCtx?.callerSessionId || rt.session?.id || rt.reservedSessionId || null,
+        });
+      }
       if (name === 'agent') {
         const callerSessionId = callerCtx?.callerSessionId || rt.session?.id || null;
-        return await agentTool.execute(args, {
+        return await routedAgentTool.execute(args, {
           callerCwd,
           invocationSource: 'model-tool',
           callerSessionId,
@@ -1009,7 +1086,6 @@ export async function createMixdogSessionRuntime({
     },
   });
   internalTools.markBootReady?.();
-  try { rt.lastProjectMcpKey = resolve(rt.currentCwd) + '\u0000' + JSON.stringify(readProjectMcpServers(rt.currentCwd)); } catch { rt.lastProjectMcpKey = null; }
   void connectConfiguredMcp()
     .then((status) => bootProfile('mcp:ready', {
       connected: Number(status?.connectedCount || 0),
@@ -1301,7 +1377,7 @@ export async function createMixdogSessionRuntime({
     channelStartDelayMs,
     codeGraphPrewarmEnabled,
     prewarmState,
-    agentTool,
+    agentTool: routedAgentTool,
   });
   const ensureSessionTranscriptWriter = () => remoteTranscript.ensureSessionTranscriptWriter();
 
@@ -1322,8 +1398,8 @@ export async function createMixdogSessionRuntime({
     providerWarmup: providerWarmupEnabled,
     codeGraphPrewarm: codeGraphPrewarmEnabled,
   });
-  // Heavy session/tool/code-graph work is demand-driven. Startup restores the
-  // visible pane tree only; the first real turn arms these warmups.
+  // Heavy work remains demand-driven. Native helpers overlap provider.send;
+  // memory and code-graph parsing stay cold until their feature is used.
   bootProfile('runtime:prewarm-deferred', { reason: 'first-turn' });
   scheduleProviderWarmup();
   scheduleProviderModelWarmup();
@@ -1443,6 +1519,7 @@ export async function createMixdogSessionRuntime({
       mgr.updateSessionGeneratedTitle(sessionId, title, stage)
     ),
   });
+  let disposeGlobalExtensionSubscription = () => {};
   const lifecycleApi = createLifecycleApi({
     getSession: () => rt.session,
     setSession: adoptSession,
@@ -1464,7 +1541,7 @@ export async function createMixdogSessionRuntime({
     mgr,
     statusRoutes,
     channels,
-    agentTool,
+    agentTool: routedAgentTool,
     mcpClient,
     warmupTimers,
     prewarmTimers,
@@ -1489,7 +1566,9 @@ export async function createMixdogSessionRuntime({
     // workflow's agent-tool gate, not reuse the boot-time array.
     getStandaloneTools: modelStandaloneTools,
     clearRuntimeNotifications,
+    goalRuntime,
     disposeSessionTitles: () => sessionTitles.disposeAll(),
+    disposeGlobalExtensionSubscription: () => disposeGlobalExtensionSubscription(),
   });
   const resourceApi = createResourceApi({
     getConfig: () => rt.config,
@@ -1505,15 +1584,22 @@ export async function createMixdogSessionRuntime({
     recreateCurrentSessionIfReady,
     normalizeMcpServerInput,
     mcpStatus,
+    getMcpServerConfig,
     skillsStatus,
     skillContent,
-    addProjectSkill,
+    addGlobalSkill,
+    saveSkillDocument,
+    invalidateSkills,
+    getDisabledSkills: () => settingsApi.getDisabledSkills(),
+    setDisabledSkills: (names) => settingsApi.setDisabledSkills(names),
     pluginsStatus,
     getMemoryModule,
     reloadFullConfig,
+    flushSkillsSave,
     awaitKeychainPrewarm,
     getActiveTurnCount: () => rt.activeTurnCount,
   });
+  disposeGlobalExtensionSubscription = () => resourceApi.disposeGlobalExtensionSubscription?.();
   const modelRouteApi = createModelRouteApi({
     getConfig: () => rt.config,
     getRoute: () => rt.route,
@@ -1609,7 +1695,7 @@ export async function createMixdogSessionRuntime({
     scheduleProviderWarmup,
     scheduleProviderModelWarmup,
     invalidateContextStatusCache,
-    agentTool,
+    agentTool: routedAgentTool,
     recreateCurrentSessionIfReady,
     invalidatePreSessionToolSurface,
     activeToolSurface,
@@ -1636,18 +1722,26 @@ export async function createMixdogSessionRuntime({
       rt.session?.id,
       options,
     ),
-    revertTurnReview: () => revertTurnSnapshotReview(
+    revertTurnReview: (checkpointId) => revertTurnSnapshotReview(
       rt.currentCwd,
       rt.session?.id,
+      checkpointId,
     ),
-    revertTurnReviewFile: (file) => revertTurnSnapshotReviewFile(
+    revertTurnReviewFile: (file, checkpointId) => revertTurnSnapshotReviewFile(
       rt.currentCwd,
       rt.session?.id,
       file,
+      checkpointId,
     ),
     get id() {
       return rt.session?.id || rt.reservedSessionId || null;
     },
+    deliverToolCompletion(sessionId, text, meta = {}) {
+      const target = String(sessionId || '').trim();
+      const current = String(rt.session?.id || rt.reservedSessionId || '').trim();
+      if (!target || target !== current) return false;
+      return notifySessionCompletion(target, text, meta);
+    },
     reserveSessionId(sessionId) {
       const id = String(sessionId || '').trim();
       if (!id || !/^[A-Za-z0-9_-]+$/.test(id)) {
@@ -1658,6 +1752,7 @@ export async function createMixdogSessionRuntime({
       }
       rt.reservedSessionId = id;
       bindRuntimeNotificationSession(id);
+      goalRuntime?.watchSession(id);
       // Reservation is the earliest safe point to prepare keychain, memory,
       // provider metadata, hooks, and the provider transport. This starts no
       // model response and therefore incurs no inference/token usage. The first
@@ -1669,6 +1764,39 @@ export async function createMixdogSessionRuntime({
       });
       return id;
     },
+    goalStatus() {
+      const sessionId = rt.session?.id || rt.reservedSessionId || null;
+      return sessionId ? goalRuntime.snapshot(sessionId) : null;
+    },
+    async goalControl(args = {}) {
+      let sessionId = rt.session?.id || rt.reservedSessionId || null;
+      if (!sessionId) {
+        await createCurrentSession('goal');
+        sessionId = rt.session?.id || rt.reservedSessionId || null;
+      }
+      if (!sessionId) throw new Error('goal: session could not be created');
+      const result = await goalRuntime.control(sessionId, args);
+      if (result?.goal?.status === 'active') {
+        activateRuntimeTools(goalRuntime.tools.map((tool) => tool.name));
+      }
+      return result;
+    },
+    goalContinuation() {
+      const sessionId = rt.session?.id || rt.reservedSessionId || null;
+      if (!sessionId) return { run: false, reason: 'missing-session', goal: null };
+      const continuation = goalRuntime.continuation(sessionId, { agentStatus: agentStatusState() });
+      if (continuation.run) {
+        activateRuntimeTools(goalRuntime.tools.map((tool) => tool.name));
+      }
+      return continuation;
+    },
+    archiveCompletedGoalOnUserInput() {
+      const sessionId = rt.session?.id || rt.reservedSessionId || null;
+      return sessionId ? goalRuntime.archiveCompletedOnUserInput(sessionId) : null;
+    },
+    onGoalStatusChange(listener) {
+      return goalRuntime.subscribe(listener);
+    },
     get provider() {
       return rt.route.provider;
     },

package/src/session-runtime/runtime-tunables.mjs

@@ -5,7 +5,9 @@
 import { envDelayMs, envFlag, envPresent } from './env.mjs';
 
 export function readRuntimeTunables() {
-  const codeGraphPrewarmEnabled = !envFlag('MIXDOG_DISABLE_CODE_GRAPH_PREWARM');
+  const codeGraphPrewarmEager = envFlag('MIXDOG_CODE_GRAPH_PREWARM_EAGER');
+  const codeGraphPrewarmEnabled = !envFlag('MIXDOG_DISABLE_CODE_GRAPH_PREWARM')
+    && (envFlag('MIXDOG_ENABLE_CODE_GRAPH_PREWARM') || codeGraphPrewarmEager);
   const daemonHosted = envFlag('MIXDOG_DAEMON_HOST');
   return {
     providerSetupWarmupDelayMs: envDelayMs('MIXDOG_PROVIDER_SETUP_WARMUP_DELAY_MS', 300, { min: 0, max: 60_000 }),
@@ -50,12 +52,8 @@ export function readRuntimeTunables() {
       && !envFlag('MIXDOG_DISABLE_MODEL_PREFETCH'),
     codeGraphPrewarmEnabled,
     modelCatalogWarmupEnabled: !envFlag('MIXDOG_DISABLE_MODEL_CATALOG_WARMUP'),
-    // Lazy code-graph prewarm (default ON): do NOT prewarm at startup / on cwd
-    // change — that fired ~250ms after the first frame and, in a large tree,
-    // burned a worker (and felt like a freeze) before the user did anything.
-    // Instead prewarm ONCE on the first real turn, when a code lookup is
-    // actually imminent. MIXDOG_CODE_GRAPH_PREWARM_EAGER=1 restores the old
-    // eager behavior.
-    codeGraphPrewarmLazy: codeGraphPrewarmEnabled && !envFlag('MIXDOG_CODE_GRAPH_PREWARM_EAGER'),
+    // Code-graph parsing is demand-driven by default. Operators may opt into
+    // first-turn warming, or explicitly restore eager cwd warming.
+    codeGraphPrewarmLazy: codeGraphPrewarmEnabled && !codeGraphPrewarmEager,
   };
 }

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

@@ -15,6 +15,7 @@ import { beginTurnSnapshot, cancelTurnSnapshot, completeTurnSnapshot } from '../
 import { isVisibleStreamProgress } from '../runtime/shared/stream-progress.mjs';
 import { runAbortable, settleWithin, throwIfAborted } from '../runtime/shared/abort-race.mjs';
 import { interruptTaskWaitForSession } from '../runtime/agent/orchestrator/session/task-wait-control.mjs';
+import { runWithCwdOverride } from '../runtime/shared/user-cwd.mjs';
 
 export function splitToolStatusCounts(rows) {
   const list = Array.isArray(rows) ? rows : [];
@@ -78,6 +79,7 @@ export function createSessionTurnApi(deps) {
       };
     },
     async ask(prompt, options = {}) {
+      return runWithCwdOverride(getCurrentCwd(), async () => {
       // Remote-attach: this surface is a viewer on a session that another
       // live process owns. Never run a turn here — persist the prompt into
       // the shared pending spool; the owner's injection poller submits it as
@@ -123,24 +125,26 @@ export function createSessionTurnApi(deps) {
         // path. Every actual tool execution joins this same promise below, so
         // shell/apply_patch cannot mutate the worktree before the baseline.
         turnSnapshotPromise = Promise.resolve()
-          .then(() => beginTurnSnapshotForTurn(getCurrentCwd(), id))
+          .then(() => beginTurnSnapshotForTurn(getCurrentCwd(), id, {
+            // The first submitted row is the outer prompt. Mid-loop steering
+            // is drained inside this ask() and deliberately keeps this ID.
+            checkpointId: String(options.id || '').trim(),
+          }))
           .catch(() => undefined);
       };
       const routeStartedAt = performance.now();
       startTurnSnapshot(getSession()?.id || getReservedSessionId?.());
       let routeWaitMs = 0;
       setActiveTurnCount(getActiveTurnCount() + 1);
-      try { scheduleSearchRuntimeWarmup?.(0); } catch { /* search warmup is best-effort */ }
       let mcpWaitMs = 0;
       let providerStartedAt = 0;
       let turnTimingStatus = 'error';
       let turnTimingEmitted = false;
-      // Heavy runtime warmup is one-shot and demand-driven: idle desktop panes
-      // never spawn shell/token/search helpers or a code-graph worker. More
-      // importantly, do not start them until the provider has produced visible
-      // text/reasoning/tool progress: transport headers and response-created
-      // acknowledgements arrive earlier and would make PowerShell + graph
-      // workers compete with the actual first-token critical path.
+      // First-turn fallback for hosts that disabled or have not completed the
+      // post-connect idle warmup. Do not start it until the provider has
+      // produced visible text/reasoning/tool progress: transport headers and
+      // response-created acknowledgements arrive earlier and would make
+      // PowerShell + graph workers compete with the first-token critical path.
       const heavyRuntimeWarmupPending = typeof getCodeGraphFirstTurnPrewarmDone === 'function'
         && !getCodeGraphFirstTurnPrewarmDone();
       if (heavyRuntimeWarmupPending) {
@@ -211,7 +215,7 @@ export function createSessionTurnApi(deps) {
         // can update the caller instead of whichever runtime registered the
         // shared internal-tool executor most recently.
         Object.defineProperty(session0, '_applyResolvedCwdForCaller', {
-          value: applyResolvedCwd,
+          value: (nextCwd) => applyResolvedCwd(nextCwd, { persistProjectSelection: true }),
           enumerable: false,
           configurable: true,
           writable: true,
@@ -354,7 +358,13 @@ export function createSessionTurnApi(deps) {
               // after session locking, history shaping and pre-send compact.
               // The old timestamp above mgr.askSession mislabeled all of that
               // Mixdog work as provider latency.
-              if (!providerStartedAt) providerStartedAt = performance.now();
+              if (!providerStartedAt) {
+                providerStartedAt = performance.now();
+                // Warm the two small native helpers only after provider.send
+                // owns the request. Their startup overlaps network/model time
+                // without competing with route, snapshot, or compact work.
+                try { scheduleSearchRuntimeWarmup?.(0); } catch { /* best-effort */ }
+              }
               return options.onProviderSendStarted?.(...args);
             },
             onToolPhaseStarted: options.onToolPhaseStarted,
@@ -444,6 +454,7 @@ export function createSessionTurnApi(deps) {
           scheduleProviderModelWarmup();
         }
       }
+      });
     },
     async clear(options = {}) {
       const session = getSession();
@@ -622,7 +633,7 @@ export function createSessionTurnApi(deps) {
       return { ...result, status: this.toolsStatus() };
     },
     setCwd(path) {
-      applyResolvedCwd(resolveCwdPath(path));
+      applyResolvedCwd(resolveCwdPath(path), { persistProjectSelection: true });
       return getCurrentCwd();
     },
   };

package/src/session-runtime/skills-api.mjs

@@ -1,34 +1,31 @@
-// Skill surface (status listing, resource load, tool envelope, project skill
-// creation). Extracted from runtime-core so the facade only wires the mutable
+// Skill surface (status listing, resource load, tool envelope, global skill
+// creation/editing). Extracted from runtime-core so the facade only wires the mutable
 // cwd and the context module into it.
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
+import {
+  createSkillDocument,
+  updateSkillDocument,
+  validateSkillDescription,
+  validateSkillName,
+} from '../runtime/shared/skill-document.mjs';
 import { clean } from './session-text.mjs';
 
-const SKILL_TEMPLATE = (name, description) => [
-  '---',
-  `name: ${name}`,
-  `description: ${description}`,
-  '---',
-  '',
-  '# Instructions',
-  '',
-  'Describe when and how to use this skill.',
-  '',
-].join('\n');
+const DEFAULT_SKILL_BODY = '# Instructions\n\nDescribe how to use this skill.';
 
 export function createSkillsApi({ contextMod, getCwd }) {
+  const globalSkillsRoot = () => resolve(resolvePluginData(), 'skills');
+
   function skillsStatus() {
     const cwd = getCwd();
     const skills = typeof contextMod.collectSkillsCached === 'function'
       ? contextMod.collectSkillsCached(cwd)
       : [];
     const norm = (value) => String(value || '').replace(/\\/g, '/').toLowerCase();
-    const cwdNorm = norm(cwd);
-    // A skill under <cwd>/.mixdog/skills is project-scoped; everything else
-    // comes from the user/global tree.
+    const globalRoot = `${norm(globalSkillsRoot())}/`;
     const sourceForSkill = (filePath) => (
-      cwdNorm && norm(filePath).startsWith(`${cwdNorm}/.mixdog/skills/`) ? 'project' : 'skill'
+      norm(filePath).startsWith(globalRoot) ? 'global' : 'plugin'
     );
     return {
       cwd,
@@ -38,6 +35,7 @@ export function createSkillsApi({ contextMod, getCwd }) {
         description: skill.description || '',
         filePath: skill.filePath || null,
         source: sourceForSkill(skill.filePath),
+        editable: sourceForSkill(skill.filePath) === 'global',
       })),
     };
   }
@@ -65,16 +63,72 @@ export function createSkillsApi({ contextMod, getCwd }) {
     return contextMod.buildSkillToolEnvelope(skill.name, skill.content, skill.dir);
   }
 
-  function addProjectSkill(input = {}) {
-    const name = clean(input.name).replace(/[^a-zA-Z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
-    if (!name) throw new Error('skill name is required');
-    const dir = join(getCwd(), '.mixdog', 'skills', name);
+  function addGlobalSkill(input = {}) {
+    const name = validateSkillName(clean(input.name));
+    const description = validateSkillDescription(input.description);
+    const body = String(input.instructions || input.body || DEFAULT_SKILL_BODY);
+    const dir = join(globalSkillsRoot(), name);
     const filePath = join(dir, 'SKILL.md');
     if (existsSync(filePath)) throw new Error(`skill already exists: ${name}`);
     mkdirSync(dir, { recursive: true });
-    writeFileSync(filePath, SKILL_TEMPLATE(name, clean(input.description) || 'Project skill.'), 'utf8');
+    writeFileSync(filePath, createSkillDocument({ name, description, body }), 'utf8');
+    contextMod.invalidateSkillsCache?.(getCwd());
     return { name, filePath };
   }
 
-  return { skillsStatus, skillContent, skillToolContent, addProjectSkill };
+  function saveSkillDocument(input = {}) {
+    const originalName = validateSkillName(input.originalName);
+    const name = validateSkillName(input.name);
+    const description = validateSkillDescription(input.description);
+    const body = String(input.instructions || input.body || '');
+    const resource = contextMod.loadSkillResource?.(originalName, getCwd());
+    if (!resource?.filePath) throw new Error(`skill not found: ${originalName}`);
+    const resourcePath = resolve(resource.filePath);
+    const resourceRelative = relative(globalSkillsRoot(), resourcePath);
+    if (!resourceRelative || resourceRelative.startsWith('..') || isAbsolute(resourceRelative)) {
+      throw new Error(`plugin skill is read-only: ${originalName}`);
+    }
+    const collision = skillsStatus().skills.find((skill) =>
+      skill.name === name && skill.filePath !== resource.filePath);
+    if (collision) throw new Error(`skill already exists: ${name}`);
+
+    const currentDir = dirname(resource.filePath);
+    if (basename(currentDir) !== originalName) {
+      throw new Error(`skill folder does not match its name: ${originalName}`);
+    }
+    const nextDir = join(dirname(currentDir), name);
+    if (nextDir !== currentDir && existsSync(nextDir)) {
+      throw new Error(`skill folder already exists: ${name}`);
+    }
+    const source = readFileSync(resource.filePath, 'utf8');
+    const updated = updateSkillDocument(source, { name, description, body });
+    let filePath = resource.filePath;
+    if (nextDir !== currentDir) {
+      renameSync(currentDir, nextDir);
+      filePath = join(nextDir, 'SKILL.md');
+      try {
+        writeFileSync(filePath, updated, 'utf8');
+      } catch (error) {
+        renameSync(nextDir, currentDir);
+        throw error;
+      }
+    } else {
+      writeFileSync(filePath, updated, 'utf8');
+    }
+    contextMod.invalidateSkillsCache?.(getCwd());
+    return { originalName, name, filePath };
+  }
+
+  function invalidateSkills() {
+    contextMod.invalidateSkillsCache?.(getCwd());
+  }
+
+  return {
+    skillsStatus,
+    skillContent,
+    skillToolContent,
+    addGlobalSkill,
+    saveSkillDocument,
+    invalidateSkills,
+  };
 }