mixdog 0.9.151 → 0.9.153

package/src/runtime/agent/orchestrator/config.mjs

@@ -1,6 +1,7 @@
 import { resolvePluginData } from '../../shared/plugin-paths.mjs';
 import { readSection, updateSection, updateSectionAsync, getAgentApiKey, AGENT_PROVIDER_ENV } from '../../shared/config.mjs';
 import {
+    DEFAULT_DISABLED_AGENT_IDS,
     agentRouteStorageNeedsMigration,
     canonicalizeAgentRouteStorage,
 } from '../../shared/agent-route-config.mjs';
@@ -147,7 +148,7 @@ export const DEFAULT_PRESETS = Object.freeze([
     Object.freeze({ id: 'opus-mid', name: 'OPUS MID', type: 'agent', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('opus'), effort: 'medium', tools: 'full' }),
     Object.freeze({ id: 'opus-high', name: 'OPUS HIGH', type: 'agent', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('opus'), effort: 'high', tools: 'full' }),
 ]);
-function buildDefaultConfig(options = {}) {
+export function buildDefaultConfig(options = {}) {
     const detectCredentials = options.detectCredentials !== false;
     const providers = {};
     // API providers — enabled if env key exists
@@ -196,36 +197,17 @@ function buildDefaultConfig(options = {}) {
     // Local providers — opt-in via setup UI after HTTP ping confirms server is running
     providers.ollama = { enabled: false, baseURL: 'http://localhost:11434/v1' };
     providers.lmstudio = { enabled: false, baseURL: 'http://localhost:1234/v1' };
-    return { providers, workflow: { active: 'default' } };
+    return {
+        providers,
+        disabledAgents: [...DEFAULT_DISABLED_AGENT_IDS],
+        workflow: { active: 'default' },
+    };
 }
 
 function hasKeys(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length > 0;
 }
 
-// Process-local write intent for project MCP overrides. A loaded config contains
-// snapshots for every project, but only entries toggled by this process may
-// override a newer value read from disk inside the save lock.
-const dirtyMcpProjectOverrides = new Map();
-let mcpProjectOverrideDirtySeq = 0;
-function mcpProjectOverrideDirtyKey(projectKey, serverName) {
-    return `${String(projectKey)}\u0000${String(serverName)}`;
-}
-export function markMcpProjectOverrideDirty(projectKey, serverName, enabled) {
-    const pairKey = mcpProjectOverrideDirtyKey(projectKey, serverName);
-    dirtyMcpProjectOverrides.set(pairKey, {
-        enabled: enabled !== false,
-        seq: ++mcpProjectOverrideDirtySeq,
-    });
-}
-function clearDurablySavedMcpProjectOverrides(appliedDirty) {
-    for (const { pairKey, seq } of appliedDirty) {
-        if (dirtyMcpProjectOverrides.get(pairKey)?.seq === seq) {
-            dirtyMcpProjectOverrides.delete(pairKey);
-        }
-    }
-}
-
 function normalizeWebSearchRoute(route) {
     if (!route || typeof route !== 'object' || Array.isArray(route))
         return null;
@@ -435,6 +417,7 @@ function canonicalizeLegacyAgentStorage(value = {}) {
     delete next.capabilities;
     delete next.defaultProvider;
     delete next.guide;
+    delete next.mcpProjectOverrides;
     return next;
 }
 
@@ -451,6 +434,7 @@ function agentConfigStorageNeedsMigration(value = {}) {
         || Object.prototype.hasOwnProperty.call(value || {}, 'searchRoute')
         || Object.prototype.hasOwnProperty.call(value || {}, 'capabilities')
         || Object.prototype.hasOwnProperty.call(value || {}, 'defaultProvider')
+        || Object.prototype.hasOwnProperty.call(value || {}, 'mcpProjectOverrides')
         || presets.some((preset) => !normalizePreset(preset))
         || (modules && typeof modules === 'object' && Object.prototype.hasOwnProperty.call(modules, 'memory'))
         || normalizedFields.some((key) => JSON.stringify(value?.[key]) !== JSON.stringify(canonical?.[key]));
@@ -560,9 +544,6 @@ export function loadConfig(options = {}) {
             const loaded = canonicalizeAgentRouteStorage({
                 providers: mergedProviders,
                 mcpServers,
-                mcpProjectOverrides: raw.mcpProjectOverrides && typeof raw.mcpProjectOverrides === 'object' && !Array.isArray(raw.mcpProjectOverrides)
-                    ? raw.mcpProjectOverrides
-                    : {},
                 presets: normalizedPresets,
                 default: raw.default || null,
                 maintenance: { ...DEFAULT_MAINTENANCE, ...normalizedMaint },
@@ -628,7 +609,6 @@ export function loadConfig(options = {}) {
     return {
         ...defaults,
         mcpServers: {},
-        mcpProjectOverrides: {},
         presets: DEFAULT_PRESETS.map(p => ({ ...p })),
         default: null,
         maintenance: { ...DEFAULT_MAINTENANCE },
@@ -691,7 +671,7 @@ export async function patchSkillsDisabledAsync(disabledNames) {
     return nextSkills;
 }
 
-function buildAgentSaveBuilder(config, appliedDirty) {
+function buildAgentSaveBuilder(config) {
     const canonicalRoutes = canonicalizeLegacyAgentStorage(config);
     // Strip ephemeral defaults from providers but preserve any unknown
     // per-provider subkey so future schema additions round-trip through the
@@ -745,42 +725,10 @@ function buildAgentSaveBuilder(config, appliedDirty) {
     // a concurrent instance survive the save (lost-update guard).
     return (existingRaw) => {
         const mcpServers = config.mcpServers || {};
-        const diskOverrides = existingRaw.mcpProjectOverrides && typeof existingRaw.mcpProjectOverrides === 'object'
-            ? existingRaw.mcpProjectOverrides
-            : {};
-        const memoryOverrides = config.mcpProjectOverrides && typeof config.mcpProjectOverrides === 'object'
-            ? config.mcpProjectOverrides
-            : {};
-        const mcpProjectOverrides = {};
-        for (const projectKey of new Set([...Object.keys(diskOverrides), ...Object.keys(memoryOverrides)])) {
-            const diskProject = diskOverrides[projectKey] && typeof diskOverrides[projectKey] === 'object'
-                ? diskOverrides[projectKey]
-                : {};
-            const memoryProject = memoryOverrides[projectKey] && typeof memoryOverrides[projectKey] === 'object'
-                ? memoryOverrides[projectKey]
-                : {};
-            // Disk wins for untouched snapshot entries. Only an override this
-            // process explicitly toggled may replace the in-lock disk value.
-            const mergedProject = { ...memoryProject, ...diskProject };
-            for (const serverName of Object.keys(memoryProject)) {
-                const pairKey = mcpProjectOverrideDirtyKey(projectKey, serverName);
-                const dirty = dirtyMcpProjectOverrides.get(pairKey);
-                if (dirty) {
-                    const appliedValue = { enabled: dirty.enabled };
-                    mergedProject[serverName] = appliedValue;
-                    appliedDirty.push({ pairKey, seq: dirty.seq, appliedValue });
-                }
-            }
-            for (const serverName of Object.keys(mergedProject)) {
-                if (!Object.prototype.hasOwnProperty.call(mcpServers, serverName)) delete mergedProject[serverName];
-            }
-            if (Object.keys(mergedProject).length > 0) mcpProjectOverrides[projectKey] = mergedProject;
-        }
         const next = {
             ...existingRaw,
             providers: persistedProviders,
             mcpServers,
-            mcpProjectOverrides,
             presets,
             default: config.default || null,
             maintenance: canonicalRoutes.maintenance,
@@ -810,19 +758,16 @@ function buildAgentSaveBuilder(config, appliedDirty) {
         delete next.capabilities;
         delete next.defaultProvider;
         delete next.guide;
+        delete next.mcpProjectOverrides;
         return next;
     };
 }
 export function saveConfig(config) {
-    const appliedDirty = [];
-    persistAgentConfig(buildAgentSaveBuilder(config, appliedDirty));
-    clearDurablySavedMcpProjectOverrides(appliedDirty);
+    persistAgentConfig(buildAgentSaveBuilder(config));
 }
 // Async twin used by the debounced config-save flush timer.
 export async function saveConfigAsync(config) {
-    const appliedDirty = [];
-    await persistAgentConfigAsync(buildAgentSaveBuilder(config, appliedDirty));
-    clearDurablySavedMcpProjectOverrides(appliedDirty);
+    await persistAgentConfigAsync(buildAgentSaveBuilder(config));
 }
 // --- Preset helpers ---
 // preset shape: { id, name, type: 'agent', provider, model, effort?, fast?, tools? }

package/src/runtime/agent/orchestrator/context/collect-skills.test.mjs

@@ -0,0 +1,153 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import {
+  collectSkillsCached,
+  invalidateSkillsCache,
+  loadSkillResource,
+} from './collect.mjs';
+
+test('discovers global standard skill folders and ignores project-local skills and reference Markdown', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-standard-skill-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = join(root, 'data');
+  try {
+    const cwd = join(root, 'project');
+    const skillDir = join(process.env.MIXDOG_DATA_DIR, 'skills', 'copied-skill');
+    const projectSkillDir = join(cwd, '.mixdog', 'skills', 'project-only');
+    mkdirSync(join(skillDir, 'references'), { recursive: true });
+    mkdirSync(join(skillDir, 'scripts'), { recursive: true });
+    mkdirSync(projectSkillDir, { recursive: true });
+    writeFileSync(join(skillDir, 'SKILL.md'), [
+      '---',
+      'name: copied-skill',
+      'description: >',
+      '  Use when a copied standard skill',
+      '  should be discovered.',
+      'metadata:',
+      '  source: external',
+      '---',
+      '',
+      '# Instructions',
+      '',
+      'Read `references/guide.md` and run `scripts/check.py` when needed.',
+      '',
+    ].join('\n'));
+    writeFileSync(join(skillDir, 'references', 'guide.md'), [
+      '---',
+      'name: not-a-skill',
+      'description: This reference must never become a skill.',
+      '---',
+      '',
+      '# Reference',
+      '',
+    ].join('\n'));
+    writeFileSync(join(skillDir, 'scripts', 'check.py'), 'print("ok")\n');
+    writeFileSync(join(projectSkillDir, 'SKILL.md'), [
+      '---',
+      'name: project-only',
+      'description: This project-local skill must be ignored.',
+      '---',
+      '',
+      '# Project instructions',
+      '',
+    ].join('\n'));
+
+    invalidateSkillsCache(cwd);
+    const copied = collectSkillsCached(cwd)
+      .find((skill) => skill.name === 'copied-skill');
+    assert.ok(copied);
+    assert.equal(copied.description,
+      'Use when a copied standard skill should be discovered.');
+    assert.equal(collectSkillsCached(cwd)
+      .some((skill) => skill.name === 'not-a-skill'), false);
+    assert.equal(collectSkillsCached(cwd)
+      .some((skill) => skill.name === 'project-only'), false);
+
+    const loaded = loadSkillResource('copied-skill', cwd);
+    assert.match(loaded.content, /^# Instructions/);
+    assert.equal(loaded.dir, skillDir);
+    assert.equal(existsSync(join(loaded.dir, 'references', 'guide.md')), true);
+    assert.equal(existsSync(join(loaded.dir, 'scripts', 'check.py')), true);
+  } finally {
+    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('loads skills only from globally enabled plugins', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-plugin-skill-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = join(root, 'data');
+  try {
+    const enabledRoot = join(root, 'enabled-plugin');
+    const disabledRoot = join(root, 'disabled-plugin');
+    const writeSkill = (pluginRoot, name) => {
+      const dir = join(pluginRoot, 'skills', name);
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, 'SKILL.md'), [
+        '---',
+        `name: ${name}`,
+        `description: Use when ${name} is needed.`,
+        '---',
+        '',
+        '# Instructions',
+        '',
+      ].join('\n'));
+    };
+    writeSkill(enabledRoot, 'enabled-plugin-skill');
+    writeSkill(disabledRoot, 'disabled-plugin-skill');
+    const registryDir = join(process.env.MIXDOG_DATA_DIR, 'plugins');
+    mkdirSync(registryDir, { recursive: true });
+    writeFileSync(join(registryDir, 'registry.json'), JSON.stringify({
+      plugins: [
+        { id: 'enabled', root: enabledRoot, enabled: true },
+        { id: 'disabled', root: disabledRoot, enabled: false },
+      ],
+    }));
+
+    invalidateSkillsCache();
+    const names = collectSkillsCached(join(root, 'any-project')).map((skill) => skill.name);
+    assert.equal(names.includes('enabled-plugin-skill'), true);
+    assert.equal(names.includes('disabled-plugin-skill'), false);
+  } finally {
+    invalidateSkillsCache();
+    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('requires a standard folder name that matches the manifest name', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-mismatched-skill-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = join(root, 'data');
+  try {
+    const cwd = join(root, 'project');
+    const skillDir = join(process.env.MIXDOG_DATA_DIR, 'skills', 'folder-name');
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, 'SKILL.md'), [
+      '---',
+      'name: different-name',
+      'description: Use when testing mismatched folders.',
+      '---',
+      '',
+      '# Instructions',
+      '',
+    ].join('\n'));
+
+    invalidateSkillsCache(cwd);
+    assert.equal(collectSkillsCached(cwd)
+      .some((skill) => skill.name === 'different-name'), false);
+  } finally {
+    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/runtime/agent/orchestrator/context/collect.mjs

@@ -1,12 +1,10 @@
 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { homedir } from 'os';
-import { dirname, join } from 'path';
+import { basename, dirname, join } from 'path';
 import { maxMtimeRecursive } from '../cache-mtime.mjs';
 import { resolvePluginData, mixdogRoot } from '../../../shared/plugin-paths.mjs';
-import {
-    parseMarkdownFrontmatter,
-    readMarkdownDocument,
-} from '../../../shared/markdown-frontmatter.mjs';
+import { readMarkdownDocument } from '../../../shared/markdown-frontmatter.mjs';
+import { parseSkillDocument } from '../../../shared/skill-document.mjs';
 import { loadConfig, normalizeSkillsConfig } from '../config.mjs';
 
 function skillsDisabled() {
@@ -14,8 +12,8 @@ function skillsDisabled() {
 }
 
 // --- mixdog asset roots (standalone CLI owns its own paths; never .claude) ---
-// Project-local:  <cwd>/.mixdog/<kind>
-// Data-local:     <mixdogData>/<kind>   (standalone default: ~/.mixdog/data/<kind>)
+// Skills are machine-global under <mixdogData>/skills. Project-local skill
+// directories are intentionally outside the runtime resolution chain.
 function mixdogHome() {
     return process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
 }
@@ -27,16 +25,8 @@ function mixdogGlobalDir(kind) {
         return join(process.env.MIXDOG_DATA_DIR || join(mixdogHome(), 'data'), kind);
     }
 }
-function mixdogProjectDir(projectDir, kind) {
-    return projectDir ? join(projectDir, '.mixdog', kind) : null;
-}
-/** Ordered asset search dirs for a kind: project-local first, then global. */
-function mixdogAssetDirs(projectDir, kind) {
-    const dirs = [];
-    const local = mixdogProjectDir(projectDir, kind);
-    if (local) dirs.push(local);
-    dirs.push(mixdogGlobalDir(kind));
-    return dirs;
+function mixdogAssetDirs(_projectDir, kind) {
+    return [mixdogGlobalDir(kind)];
 }
 /**
  * Absolute path to the plugin registry file, or null when the data dir is
@@ -70,6 +60,8 @@ function pluginSkillDirs() {
         return [];
     const dirs = [];
     for (const entry of registry.plugins) {
+        if (entry?.enabled === false)
+            continue;
         const root = entry && typeof entry.root === 'string' ? entry.root : null;
         if (!root || !existsSync(root))
             continue;
@@ -85,19 +77,11 @@ function pluginSkillDirs() {
  */
 export function collectSkills(cwd) {
     if (skillsDisabled()) return [];
-    // When cwd is null/missing (e.g. agent maintenance callers that pass
-    // cwd:null on purpose so provider-cache shards don't fork per caller
-    // workspace), skip project-scoped skills entirely — DO NOT fall back
-    // to process.cwd(), which would leak the MCP launch dir into the
-    // shard key and fragment the cache.
-    const projectDir = (typeof cwd === 'string' && cwd.length > 0) ? cwd : null;
+    void cwd;
     const skills = [];
-    // mixdog-owned only (never .claude): project-local <cwd>/.mixdog/skills
-    // first, then user-global. When cwd is missing, only the global dir is
-    // searched.
-    const dirs = mixdogAssetDirs(projectDir, 'skills');
-    // Plugin-provided skills load last so project-local and global mixdog
-    // skill dirs keep precedence; `seen` below dedupes by frontmatter name.
+    const dirs = mixdogAssetDirs(null, 'skills');
+    // Plugin-provided skills load last so user-global skills keep precedence;
+    // `seen` below dedupes by frontmatter name.
     dirs.push(...pluginSkillDirs());
     const seen = new Set();
     for (const dir of dirs) {
@@ -106,21 +90,27 @@ export function collectSkills(cwd) {
         try {
             const files = readdirSync(dir, { recursive: true });
             for (const f of files) {
-                if (!String(f).endsWith('.md'))
+                if (basename(String(f)) !== 'SKILL.md')
                     continue;
                 const filePath = join(dir, String(f));
                 const content = readSafe(filePath);
                 if (!content)
                     continue;
-                const fm = parseMarkdownFrontmatter(content);
-                if (!fm.name)
+                let skill;
+                try {
+                    skill = parseSkillDocument(content);
+                } catch {
                     continue;
-                if (seen.has(fm.name))
+                }
+                // Agent Skills requires the manifest name to match its folder.
+                if (basename(dirname(filePath)) !== skill.name)
                     continue;
-                seen.add(fm.name);
+                if (seen.has(skill.name))
+                    continue;
+                seen.add(skill.name);
                 skills.push({
-                    name: fm.name,
-                    description: fm.description || '',
+                    name: skill.name,
+                    description: skill.description,
                     filePath,
                 });
             }
@@ -167,10 +157,10 @@ const _mtimeCache = new Map();
 const _MTIME_TTL_MS = 2000;
 export function collectSkillsCached(cwd) {
     if (skillsDisabled()) return [];
-    const key = cwd ?? '';
-    const projectDir = (typeof cwd === 'string' && cwd.length > 0) ? cwd : null;
+    void cwd;
+    const key = 'global';
     // Same mixdog-owned dirs collectSkills() reads, used as the freshness gate.
-    const skillsDirs = mixdogAssetDirs(projectDir, 'skills');
+    const skillsDirs = mixdogAssetDirs(null, 'skills');
     skillsDirs.push(...pluginSkillDirs());
     // registry.json itself gates plugin add/remove: removal deletes the
     // plugin's skills dir (so no dir mtime advances), but saveRegistry()
@@ -200,6 +190,11 @@ export function collectSkillsCached(cwd) {
     }
     return skills;
 }
+export function invalidateSkillsCache(cwd) {
+    void cwd;
+    _skillsCache.clear();
+    _mtimeCache.clear();
+}
 /**
  * Load full skill content by name.
  */
@@ -209,7 +204,12 @@ function loadSkillContent(name, cwd) {
     if (!skill)
         return null;
     const content = readSafe(skill.filePath);
-    return content == null ? null : readMarkdownDocument(content).body;
+    if (content == null) return null;
+    try {
+        return parseSkillDocument(content).body;
+    } catch {
+        return null;
+    }
 }
 
 /**
@@ -226,11 +226,15 @@ export function loadSkillResource(name, cwd) {
     const content = readSafe(skill.filePath);
     if (content == null)
         return null;
-    return {
-        content: readMarkdownDocument(content).body,
-        dir: dirname(skill.filePath),
-        filePath: skill.filePath,
-    };
+    try {
+        return {
+            content: parseSkillDocument(content).body,
+            dir: dirname(skill.filePath),
+            filePath: skill.filePath,
+        };
+    } catch {
+        return null;
+    }
 }
 
 function escapeSkillXmlText(value) {