mixdog 0.9.151 → 0.9.152

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

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict';
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import * as contextMod from '../runtime/agent/orchestrator/context/collect.mjs';
+import { parseSkillDocument } from '../runtime/shared/skill-document.mjs';
+import { createSkillsApi } from './skills-api.mjs';
+
+test('edits existing skills without dropping optional metadata or sibling resources', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-skill-edit-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = join(root, 'data');
+  try {
+    const cwd = join(root, 'project');
+    const originalDir = join(process.env.MIXDOG_DATA_DIR, 'skills', 'existing-skill');
+    mkdirSync(join(originalDir, 'scripts'), { recursive: true });
+    writeFileSync(join(originalDir, 'SKILL.md'), [
+      '---',
+      'name: existing-skill',
+      'description: Use when editing an existing skill.',
+      'license: MIT',
+      'metadata:',
+      '  author: example',
+      'allowed-tools:',
+      '  - shell',
+      '---',
+      '',
+      '# Original instructions',
+      '',
+    ].join('\n'));
+    writeFileSync(join(originalDir, 'scripts', 'check.py'), 'print("ok")\n');
+
+    const api = createSkillsApi({ contextMod, getCwd: () => cwd });
+    const saved = api.saveSkillDocument({
+      originalName: 'existing-skill',
+      name: 'renamed-skill',
+      description: 'Use when the renamed skill is needed.',
+      instructions: '# Updated instructions',
+    });
+    const renamedDir = join(process.env.MIXDOG_DATA_DIR, 'skills', 'renamed-skill');
+    const parsed = parseSkillDocument(readFileSync(saved.filePath, 'utf8'));
+
+    assert.equal(existsSync(originalDir), false);
+    assert.equal(saved.filePath, join(renamedDir, 'SKILL.md'));
+    assert.equal(existsSync(join(renamedDir, 'scripts', 'check.py')), true);
+    assert.equal(parsed.name, 'renamed-skill');
+    assert.equal(parsed.description, 'Use when the renamed skill is needed.');
+    assert.equal(parsed.body, '# Updated instructions\n');
+    assert.equal(parsed.frontmatter.license, 'MIT');
+    assert.deepEqual(parsed.frontmatter.metadata, { author: 'example' });
+    assert.deepEqual(parsed.frontmatter['allowed-tools'], ['shell']);
+    assert.ok(api.skillsStatus().skills.some((skill) => skill.name === 'renamed-skill'));
+  } finally {
+    contextMod.invalidateSkillsCache(join(root, 'project'));
+    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('creates new global skills with all three standard fields', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-skill-create-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = join(root, 'data');
+  try {
+    const cwd = join(root, 'project');
+    const api = createSkillsApi({ contextMod, getCwd: () => cwd });
+    const created = api.addGlobalSkill({
+      name: 'new-skill',
+      description: 'Use when creating a standard skill.',
+      instructions: '# Instructions\n\nDo the work.',
+    });
+    const parsed = parseSkillDocument(readFileSync(created.filePath, 'utf8'));
+
+    assert.equal(parsed.name, 'new-skill');
+    assert.equal(parsed.description, 'Use when creating a standard skill.');
+    assert.equal(parsed.body, '# Instructions\n\nDo the work.\n');
+    assert.equal(created.filePath, join(process.env.MIXDOG_DATA_DIR, 'skills', 'new-skill', 'SKILL.md'));
+    assert.throws(() => api.addGlobalSkill({
+      name: 'Invalid_Name',
+      description: 'Use when invalid.',
+      instructions: '# Instructions',
+    }), /lowercase letters/);
+  } finally {
+    contextMod.invalidateSkillsCache(join(root, 'project'));
+    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/session-runtime/tool-catalog-schema.mjs

@@ -141,11 +141,6 @@ export function parseToolSelection(value) {
     .filter(Boolean);
 }
 
-export function parseToolSearchQuerySelection(query) {
-  const match = clean(query).match(/^select\s*:\s*(.+)$/i);
-  return match ? parseToolSelection(match[1]) : [];
-}
-
 export function routeToolRank(name) {
   const index = ROUTE_TOOL_ORDER.indexOf(clean(name));
   return index === -1 ? Number.MAX_SAFE_INTEGER : index;

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

@@ -25,9 +25,9 @@ import {
   MEASURED_TOOL_USAGE,
   READONLY_TOOL_NAMES,
 } from './tool-catalog-data.mjs';
-import { toolKind, measuredToolUsage, parseToolSelection, parseToolSearchQuerySelection, routeToolRank, sortedCatalogByMeasuredUsage, activeToolForSurface, deferredProviderMode, nativeProviderFamily } from './tool-catalog-schema.mjs';
+import { toolKind, measuredToolUsage, parseToolSelection, routeToolRank, sortedCatalogByMeasuredUsage, activeToolForSurface, deferredProviderMode, nativeProviderFamily } from './tool-catalog-schema.mjs';
 import { filterModelEditTools } from '../runtime/shared/edit-tool-dialect.mjs';
-export { toolKind, toolSchemaBucket, estimateToolSchemaBreakdown, measuredToolUsage, parseToolSelection, parseToolSearchQuerySelection, sortedCatalogByMeasuredUsage } from './tool-catalog-schema.mjs';
+export { toolKind, toolSchemaBucket, estimateToolSchemaBreakdown, measuredToolUsage, parseToolSelection, sortedCatalogByMeasuredUsage } from './tool-catalog-schema.mjs';
 export { resolveProviderRequestTools, snapshotProviderRequestTools } from './provider-request-snapshot.mjs';
 export {
   DEFERRED_DEFAULT_FULL_TOOLS,
@@ -686,18 +686,9 @@ export function selectDeferredTools(session, names, mode) {
   return { added, already, blocked, missing, native };
 }
 
-// Collect the exact deferred-tool names to load, honoring back-compat inputs:
-//   names[]            → primary loader input
-//   select / "select:" → legacy alias (parseToolSelection strips the prefix)
-//   query "select:a,b" → legacy query-side loader
-// A free-text `query` is NOT a search anymore: it yields no names, and the
-// caller is steered back to names[].
+// Collect the exact deferred-tool names requested by the loader.
 function parseLoadToolNames(args = {}) {
-  const fromNames = parseToolSelection(args.names);
-  if (fromNames.length) return fromNames;
-  const fromSelect = parseToolSelection(args.select);
-  if (fromSelect.length) return fromSelect;
-  return parseToolSearchQuerySelection(args.query);
+  return parseToolSelection(args.names);
 }
 
 // Split live MCP servers into "still connecting" (pending) and "failed" so the

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

@@ -121,17 +121,15 @@ test('shared tool rules keep workflow and shell-boundary anchors', () => {
   // Advisory drift check: update these anchors when the rule text
   // intentionally changes.
   const full = buildSharedToolContent({ PLUGIN_ROOT: join(process.cwd(), 'src') });
-  assert.match(full, /Minimize tool turns through maximal useful parallelism/i);
-  assert.match(full, /In each round, issue every necessary non-overlapping call whose inputs are\s+already known/i);
-  assert.match(full, /Determine the required outcome and its gaps/i);
-  assert.match(full, /gather only what is missing, act, then verify the affected facets/i);
-  assert.match(full, /Investigate, build, and verify only what the requested outcome requires, at\s+the level it requires/i);
+  assert.match(full, /Determine the required outcome and missing evidence/i);
+  assert.match(full, /Before exploration or implementation, consult prior work, current external\s+information, or repository state only when needed/i);
+  assert.match(full, /Minimize tool turns by batching only calls that are independently necessary/i);
+  assert.match(full, /A call whose necessity or scope can change after\s+another result waits for that result/i);
+  assert.match(full, /Respect tool\/schema limits, never omit required fanout/i);
   assert.match(full, /A check runs at the strictness the task requires; never raise a tool's own\s+severity beyond it/i);
-  assert.match(full, /Cost is counted in\s+rounds, not calls/i);
-  assert.match(full, /defer a call only when its target or arguments require an\s+earlier result/i);
   assert.match(full, /Route each evidence facet once to its primary owner/i);
-  assert.match(full, /enumeration is not a prerequisite when that operation's/i);
-  assert.match(full, /apply\s+one analysis to many targets as one parameterized call/i);
+  assert.match(full, /A summary,\s+overview, or enumeration is not a prerequisite to an operation whose complete\s+inputs are already known/i);
+  assert.match(full, /apply one analysis\s+to many targets as one parameterized call/i);
   assert.match(full, /Evidence or artifacts available only through program execution, calculation,\s+data transformation, generated output, or unsupported-format decoding→`shell`/i);
   assert.match(full, /an already-open shell is never a routing reason/i);
   assert.match(full, /Route the missing evidence to its primary owner/i);
@@ -144,9 +142,9 @@ test('shared tool rules keep workflow and shell-boundary anchors', () => {
   assert.match(full, /literal, regex, or text location→`grep`;\s+known-file content, range, or image→`read`/i);
   assert.match(full, /is never re-found, re-derived, or\s+re-verified at any granularity/i);
   assert.match(full, /Mine each returned result fully before opening the next round/i);
-  assert.match(full, /Evidence that determines the answer, edit, or deliverable ends retrieval/i);
+  assert.match(full, /Stop exploring once sufficient evidence determines the next action required\s+by the request/i);
   assert.match(full, /Enter Verification only after all planned work is complete/i);
-  assert.match(full, /use an umbrella suite only when the user explicitly requests it\s+or a documented project or release process requires it/i);
+  assert.match(full, /Use an umbrella suite only when explicitly requested or required by the\s+documented project or release process/i);
   assert.match(full, /If verification fails, collect all failures, leave Verification/i);
   assert.match(full, /A successful verification closes the task unless later changes affect it/i);
   assert.doesNotMatch(full, /affected failed checks once/i);
@@ -235,6 +233,30 @@ test('modelStandaloneTools hides agent and disabled web-search/memory tools', ()
   assert.deepEqual(modelStandaloneTools().map((tool) => tool.name), ['read']);
 });
 
+test('activateTools refreshes a stale session catalog before selecting new runtime tools', () => {
+  const read = { name: 'read', annotations: { readOnlyHint: true } };
+  const updateGoal = { name: 'update_goal', annotations: { readOnlyHint: false } };
+  const session = {
+    provider: 'grok-oauth',
+    messages: [{ role: 'system', content: '# Existing session' }],
+    tools: [read],
+    deferredToolCatalog: [read],
+    deferredCallableTools: ['read'],
+    deferredSelectedTools: ['read'],
+    deferredToolBp2Applied: true,
+  };
+  const surface = surfaceFor({ session, standalone: [read, updateGoal] });
+  const result = surface.activateTools(['update_goal']);
+  assert.deepEqual(result.missing, []);
+  assert.equal(
+    new Set([
+      ...session.tools.map((tool) => tool.name),
+      ...(session.deferredCallableTools || []),
+    ]).has('update_goal'),
+    true,
+  );
+});
+
 test('empty session refresh strips denied tools and BP1 routes', async () => {
   const session = {
     id: 'sess_empty',

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

@@ -81,8 +81,20 @@ export function createToolSurface({
     return surface;
   }
 
+  function activateTools(names) {
+    const session = getSession();
+    if (!session) return null;
+    const surfaceMode = deferredSurfaceModeForLead(mode);
+    applyDeferredToolSurface(session, surfaceMode, modelStandaloneTools(), {
+      provider: getRoute().provider,
+      model: getRoute().model,
+    });
+    return selectDeferredTools(session, names, surfaceMode);
+  }
+
   return {
     modelStandaloneTools,
+    activateTools,
     invalidatePreSessionToolSurface() {
       preSessionSurface = null;
     },

package/src/standalone/agent-dispatch-broker.mjs

@@ -34,11 +34,9 @@ function dispatchSignature(agent, params) {
  * The memory process keeps PG, embeddings, and recall, and forwards only
  * cycle LLM calls here. The broker owns admission (fair scheduler), callId
  * idempotency, and cancellation; actual agent execution is delegated through
- * dispatchAgent to the recyclable session runtime worker so orchestrator and
- * provider churn never accumulates in the permanent daemon process. A
- * singleton is NOT a serial lane: every call gets its own AbortController and
- * the fair scheduler starts calls in parallel unless an operator explicitly
- * configures a finite active limit.
+ * dispatchAgent to the session runtime host. A singleton is NOT a serial lane:
+ * every call gets its own AbortController and the fair scheduler starts calls
+ * in parallel unless an operator explicitly configures a finite active limit.
  */
 export function createAgentDispatchBroker({
   dispatchAgent,
@@ -99,10 +97,8 @@ export function createAgentDispatchBroker({
     const run = async () => {
       if (controller.signal.aborted) throw abortError(controller.signal);
       const timeout = Number(params.timeout);
-      // Execution happens in the recyclable session runtime worker, not in
-      // this permanent daemon process: provider/orchestrator churn from
-      // memory-cycle agents returns to the OS at the worker's next memory
-      // recycle instead of accumulating in daemon commit forever.
+      // The host owns whether execution is in-process or isolated; the broker
+      // keeps scheduling, cancellation, and call identity transport-neutral.
       return dispatchAgent({
         dispatchId: id,
         agent,

package/src/standalone/agent-tool/notify.mjs

@@ -50,15 +50,13 @@ export function createNotify(mgr, { notifySessionCompletion } = {}) {
 
   function workerNotifyFn(workerSessionId, notifyContext = {}) {
     const workerId = clean(workerSessionId);
-    const ownerSessionId = clean(notifyContext?.callerSessionId || notifyContext?.sessionId);
     return (text, meta = {}) => {
-      const ownerDelivered = ownerSessionId
-        ? notifyOwner(ownerSessionId, text, meta)
-        : false;
-      const workerDelivered = workerId && workerId !== ownerSessionId
-        ? enqueueCompletionMessage(workerId, text, meta)
-        : ownerDelivered;
-      return ownerSessionId ? ownerDelivered : workerDelivered;
+      // Tool completions produced inside a Subagent belong to that Subagent's
+      // session. Mirroring them to the owner made every promoted shell command
+      // appear as a second Lead-level completion card. Agent task completion
+      // has its own owner delivery path below; only that terminal handoff
+      // crosses the parent boundary.
+      return workerId ? enqueueCompletionMessage(workerId, text, meta) : false;
     };
   }
 

package/src/standalone/agent-tool/notify.test.mjs

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createNotify } from './notify.mjs';
+
+test('Subagent tool completion stays in the worker session', () => {
+  const queued = [];
+  const ownerDeliveries = [];
+  const { workerNotifyFn } = createNotify({
+    enqueuePendingMessage(sessionId, message) {
+      queued.push({ sessionId, message });
+      return 1;
+    },
+  }, {
+    notifySessionCompletion(sessionId, text, meta) {
+      ownerDeliveries.push({ sessionId, text, meta });
+      return true;
+    },
+  });
+
+  const delivered = workerNotifyFn('sess_worker', {
+    callerSessionId: 'sess_lead',
+  })(
+    'Async shell task job_test (completed, exit 0) finished.\n\nresult',
+    {
+      type: 'shell_task_result',
+      execution_surface: 'shell',
+      execution_id: 'job_test',
+      status: 'completed',
+    },
+  );
+
+  assert.equal(delivered, true);
+  assert.equal(ownerDeliveries.length, 0);
+  assert.equal(queued.length, 1);
+  assert.equal(queued[0].sessionId, 'sess_worker');
+});

package/src/standalone/daemon.mjs

@@ -59,7 +59,7 @@ import { createChannelSessionRouter } from './channel-session-router.mjs';
 import { createSessionTransport } from './session-transport.mjs';
 import { createSessionService } from './session-service.mjs';
 import { createSessionProtocolClient } from './session-protocol.mjs';
-import { createSessionRuntimeHost } from './session-runtime-host.mjs';
+import { createDaemonSessionRuntimeHost } from './session-runtime-host-factory.mjs';
 import { getStandaloneMemoryRuntime } from './memory-runtime-proxy.mjs';
 import {
   compareRuntimeVersions,
@@ -244,10 +244,10 @@ const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
 eventLoopDelay.enable();
 let eventLoopLagTimer = null;
 
-function startMemoryRuntimeEarly() {
-  // Start the isolated memory process immediately after singleton ownership is
-  // established. Do not await it: daemon front-door readiness remains
-  // independent while PG/embedding cold-start overlaps all other boot work.
+function registerMemoryRuntimeLazy() {
+  // Register the shared proxy immediately so daemon shutdown owns its
+  // lifecycle, but keep the isolated process off the startup path. A real
+  // memory call or the post-connect idle warmup starts the exact singleton.
   if (process.env.MIXDOG_DAEMON_SKIP_MEMORY === '1') {
     log('memory runtime skipped (MIXDOG_DAEMON_SKIP_MEMORY=1)');
     return;
@@ -259,9 +259,7 @@ function startMemoryRuntimeEarly() {
       dataDir: DATA_DIR,
       cwd: CWD,
     });
-    void memoryRuntime.init()
-      .then(() => log('memory runtime ready in isolated process'))
-      .catch((e) => log(`memory.start failed (non-fatal): ${e?.message || e}`));
+    log('memory runtime registered for lazy start');
   } catch (e) { log(`memory.start setup failed (non-fatal): ${e?.message || e}`); }
 }
 
@@ -414,11 +412,10 @@ async function main() {
     process.exit(0);
   }
   process.on('exit', () => { try { releaseSingletonOwner(OWNER_PATH, process.pid); } catch {} });
-  startMemoryRuntimeEarly();
+  registerMemoryRuntimeLazy();
   agentDispatchBroker = createAgentDispatchBroker({
-    // Memory-cycle agents execute inside the recyclable session runtime
-    // worker: this permanent daemon never loads the orchestrator graph for
-    // them, so its commit stays flat across cycles.
+    // Memory-cycle agents use the same lazy provider/orchestrator graph as
+    // session actors; it stays unloaded until a real cycle requests it.
     dispatchAgent: (payload, options) => {
       if (!sessionRuntimeHost) throw new Error('session runtime host is not ready');
       return sessionRuntimeHost.agentDispatch(payload, options);
@@ -580,10 +577,14 @@ async function main() {
   };
   let sessionRuntimePrewarmStarted = false;
   let sessionRuntimePrewarmPromise = null;
-  sessionRuntimeHost = createSessionRuntimeHost({
+  sessionRuntimeHost = createDaemonSessionRuntimeHost({
     cwd: CWD,
     log,
   });
+  // Codex-style runtime: daemon routing and independent async session actors
+  // share one V8 isolate and module graph. CPU-heavy work stays in bounded
+  // native helpers/worker pools instead of duplicating the whole runtime.
+  log(`session runtime mode=${sessionRuntimeHost.status.mode}`);
   function prewarmSessionRuntime() {
     if (sessionRuntimePrewarmPromise) return sessionRuntimePrewarmPromise;
     sessionRuntimePrewarmStarted = true;
@@ -592,7 +593,7 @@ async function main() {
       .catch((error) => log(`image pipeline prewarm failed (non-fatal): ${error?.message || error}`));
     sessionRuntimePrewarmPromise = sessionRuntimeHost.prewarm()
       .then(() => {
-        log('session runtime worker/agent-loop/keychain/memory prewarm ready');
+        log('session runtime/agent-loop/keychain prewarm ready');
         return true;
       })
       .catch((error) => {
@@ -605,6 +606,8 @@ async function main() {
   }
   sessionService = createSessionService({
     createSessionRuntime: (options) => sessionRuntimeHost.create(options),
+    subscribeExternalSessionStates: (listener) =>
+      sessionRuntimeHost.subscribeAgentSessionStates(listener),
     sessionExists: async (sessionId) => {
       const store = await desktopRuntime.loadSessionStore();
       return store.storedSessionExists?.(sessionId) === true;
@@ -670,7 +673,9 @@ async function main() {
       ...eventLoopStatus(),
     }),
     onClientsEmpty: () => { maybeSelfShutdown('no live session clients'); },
-    onClientRegistered: () => { void prewarmSessionRuntime(); },
+    onClientRegistered: () => {
+      void prewarmSessionRuntime();
+    },
     onClientDropped: (token) => { try { sessionService.releaseClient(token); } catch {} },
     onUpgradeRequested: requestDaemonReplacement,
   });
@@ -720,6 +725,17 @@ async function main() {
     if (status.eventLoopP99Ms >= 250) {
       log(`event-loop lag p95=${status.eventLoopP95Ms}ms p99=${status.eventLoopP99Ms}ms max=${status.eventLoopMaxMs}ms`);
     }
+    // Legacy external runtime hosts may still report shard-local lag. The
+    // production in-process host is already covered by daemon loop telemetry.
+    const shards = sessionRuntimeHost?.status?.shards || [];
+    const lagging = shards.filter((shard) => Number(shard?.lag?.p99Ms) >= 250 || shard?.degraded);
+    if (lagging.length > 0) {
+      log(`session runtime shard lag ${lagging.map((shard) => (
+        `#${shard.index}${shard.degraded ? '(quarantined)' : ''}`
+        + ` p95=${shard.lag?.p95Ms ?? -1}ms p99=${shard.lag?.p99Ms ?? -1}ms`
+        + ` max=${shard.lag?.maxMs ?? -1}ms runtimes=${shard.runtimes}`
+      )).join(' ')}`);
+    }
     eventLoopDelay.reset();
   }, 30_000);
   eventLoopLagTimer.unref?.();

package/src/standalone/hook-bus/config.mjs

@@ -81,6 +81,7 @@ function pluginHookConfigEntries(dataDir) {
   }
   const entries = [];
   for (const plugin of plugins || []) {
+    if (plugin?.enabled === false) continue;
     const root = String(plugin?.root || '').trim();
     if (!root || !existsSync(root)) continue;
     const id = cleanHookId(plugin.id || plugin.name || plugin.title || root.split(/[\\/]/).pop());

package/src/standalone/plugin-admin.mjs

@@ -242,6 +242,7 @@ function enrichEntry(entry) {
   const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || displayNameFromUrl(entry.source);
   return {
     ...entry,
+    enabled: entry.enabled !== false,
     name,
     title: clean(manifest.title) || clean(manifest.displayName) || clean(entry.title) || name,
     version: clean(manifest.version) || clean(entry.version) || null,
@@ -280,6 +281,7 @@ export function addPlugin(sourceInput, { dataDir = resolvePluginData(), name } =
       title: clean(manifest.title) || clean(manifest.displayName) || clean(name) || displayNameFromUrl(normalized.displaySource),
       version: clean(manifest.version) || null,
       description: clean(manifest.description),
+      enabled: true,
       installedAt: nowIso(),
       updatedAt: nowIso(),
     };
@@ -338,6 +340,21 @@ export function updatePlugin(idOrName, { dataDir = resolvePluginData() } = {}) {
   });
 }
 
+export function setPluginEnabled(idOrName, enabled, { dataDir = resolvePluginData() } = {}) {
+  const key = clean(idOrName);
+  if (!key) throw new Error('plugin id/name is required');
+  return mutateRegistry(dataDir, (registry) => {
+    const index = pluginIndex(registry, key);
+    if (index < 0) throw new Error(`plugin not registered: ${key}`);
+    const next = {
+      ...registry.plugins[index],
+      enabled: enabled !== false,
+    };
+    registry.plugins[index] = next;
+    return enrichEntry(next);
+  });
+}
+
 export function removePlugin(idOrName, { dataDir = resolvePluginData() } = {}) {
   const key = clean(idOrName);
   if (!key) throw new Error('plugin id/name is required');

package/src/standalone/plugin-admin.test.mjs

@@ -18,7 +18,9 @@ import {
   _publishManagedPluginRoot,
   addPlugin,
   listRegisteredPlugins,
+  setPluginEnabled,
 } from './plugin-admin.mjs';
+import { hookConfigEntries } from './hook-bus/config.mjs';
 
 test('plugin registry persists atomically with owner-only permissions', () => {
   const root = mkdtempSync(join(tmpdir(), 'mixdog-plugin-registry-'));
@@ -33,6 +35,11 @@ test('plugin registry persists atomically with owner-only permissions', () => {
     const registry = JSON.parse(readFileSync(registryPath, 'utf8'));
     assert.equal(registry.plugins.length, 1);
     assert.equal(listRegisteredPlugins({ dataDir })[0].name, 'local-test');
+    assert.equal(listRegisteredPlugins({ dataDir })[0].enabled, true);
+    assert.equal(hookConfigEntries(dataDir, root).some((entry) => entry.sourceType === 'plugin'), true);
+    setPluginEnabled('local-test', false, { dataDir });
+    assert.equal(listRegisteredPlugins({ dataDir })[0].enabled, false);
+    assert.equal(hookConfigEntries(dataDir, root).some((entry) => entry.sourceType === 'plugin'), false);
     if (process.platform !== 'win32') {
       assert.equal(statSync(registryPath).mode & 0o777, 0o600);
     }

package/src/standalone/provider-admin.mjs

@@ -44,6 +44,7 @@ import {
 
 const API_PROVIDERS = Object.freeze([
   Object.freeze({ id: 'opencode-go', name: 'OpenCode Go API', env: 'OPENCODE_API_KEY', url: 'https://opencode.ai' }),
+  Object.freeze({ id: 'openrouter', name: 'OpenRouter', env: 'OPENROUTER_API_KEY', url: 'https://openrouter.ai/keys' }),
   Object.freeze({ id: 'openai', name: 'OpenAI API', env: 'OPENAI_API_KEY', url: 'https://platform.openai.com/api-keys' }),
   Object.freeze({ id: 'anthropic', name: 'Anthropic API', env: 'ANTHROPIC_API_KEY', url: 'https://console.anthropic.com/settings/keys' }),
   Object.freeze({ id: 'gemini', name: 'Gemini API', env: 'GEMINI_API_KEY', url: 'https://aistudio.google.com/apikey' }),

package/src/standalone/session-protocol.mjs

@@ -15,6 +15,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getCompactionSettings',
   'getDisabledSkills',
   'getMediaJob',
+  'getMcpServerConfig',
   'getOnboardingStatus',
   'getOAuthProviderLoginStatus',
   'getOutputStyle',
@@ -79,6 +80,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'deleteWorkflow',
   'enablePluginMcp',
   'forgetProviderAuth',
+  'goalControl',
   'inheritFrom',
   'loginOAuthProvider',
   'loginOpenCodeGoUsage',
@@ -107,10 +109,12 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'runScheduleNow',
   'runUpdateNow',
   'saveAgentDefinition',
+  'saveMcpServer',
   'saveOpenAIUsageSessionKey',
   'saveOpenCodeGoUsageAuth',
   'saveProviderApiKey',
   'saveSchedule',
+  'saveSkill',
   'saveWebhook',
   'saveWorkflowPack',
   'selectTools',
@@ -129,6 +133,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setMemoryToolsEnabled',
   'setModel',
   'setOutputStyle',
+  'setPluginEnabled',
   'setProfile',
   'setProgressHint',
   'setRecapEnabled',