mdboard 1.2.0 → 1.3.0

package/src/core/agent-scanner.js

@@ -0,0 +1,260 @@
+/**
+ * mdboard — Agent configuration scanner
+ *
+ * Scans projectDir for agent/AI configuration files and returns
+ * suggestions for autocomplete in the AI properties UI.
+ *
+ * Supported agents:
+ *   Claude Code, Codex CLI, Gemini CLI, Cursor, VS Code Copilot,
+ *   Windsurf, Cline, KiloCode, OpenClaw
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function safeReadFile(filePath) {
+  try { return fs.readFileSync(filePath, 'utf-8'); } catch { return null; }
+}
+
+function safeDirEntries(dir) {
+  try { return fs.readdirSync(dir).filter(e => !e.startsWith('.')); } catch { return []; }
+}
+
+function safeDirEntriesRecursive(dir, prefix) {
+  const results = [];
+  for (const entry of safeDirEntries(dir)) {
+    const full = path.join(dir, entry);
+    const rel = prefix ? prefix + '/' + entry : entry;
+    try {
+      if (fs.statSync(full).isDirectory()) {
+        if (fs.existsSync(path.join(full, 'SKILL.md'))) {
+          results.push(rel);
+        }
+        results.push(...safeDirEntriesRecursive(full, rel));
+      } else if (entry.endsWith('.md')) {
+        results.push(rel);
+      }
+    } catch { /* skip */ }
+  }
+  return results;
+}
+
+/** Push value to array if not already present */
+function pushUnique(arr, value) {
+  if (arr.indexOf(value) === -1) arr.push(value);
+}
+
+/** Collect .md files from a directory into an array (non-recursive) */
+function collectMdFiles(dir, arr, prefix) {
+  for (const entry of safeDirEntries(dir)) {
+    if (entry.endsWith('.md') || entry.endsWith('.mdc') || entry.endsWith('.agent.md')) {
+      pushUnique(arr, prefix ? prefix + '/' + entry : entry);
+    }
+  }
+}
+
+/** Collect all files from a directory into an array (non-recursive) */
+function collectAllFiles(dir, arr, prefix) {
+  for (const entry of safeDirEntries(dir)) {
+    const full = path.join(dir, entry);
+    try {
+      if (!fs.statSync(full).isDirectory()) {
+        pushUnique(arr, prefix ? prefix + '/' + entry : entry);
+      }
+    } catch { /* skip */ }
+  }
+}
+
+/** Extract mcpServers keys from a JSON file */
+function extractMcpServersFromJson(filePath, arr) {
+  const content = safeReadFile(filePath);
+  if (!content) return;
+  try {
+    const parsed = JSON.parse(content);
+    const servers = parsed.mcpServers || parsed;
+    if (servers && typeof servers === 'object' && !Array.isArray(servers)) {
+      for (const key of Object.keys(servers)) {
+        if (key !== '$schema' && key !== 'mcpServers') pushUnique(arr, key);
+      }
+    }
+  } catch { /* invalid JSON */ }
+}
+
+/** Check if a file exists and push to context */
+function checkContextFile(projectDir, relativePath, arr) {
+  if (fs.existsSync(path.join(projectDir, relativePath))) {
+    pushUnique(arr, relativePath);
+  }
+}
+
+/**
+ * Scan projectDir for agent configuration files across all supported agents.
+ *
+ * @param {string} projectDir - Root of the repo
+ * @returns {{ skills: string[], agents: string[], mcps: string[], commands: string[], context: string[] }}
+ */
+function scanAgentConfigs(projectDir) {
+  const result = { skills: [], agents: [], mcps: [], commands: [], context: [] };
+
+  // ─── SKILLS ───────────────────────────────────────────────
+
+  // Claude Code: .claude/skills/ — .md files and subdirs with SKILL.md
+  result.skills = safeDirEntriesRecursive(path.join(projectDir, '.claude', 'skills'), '');
+
+  // Codex CLI: .codex/skills/, .agents/skills/
+  for (const dir of ['.codex/skills', '.agents/skills']) {
+    const entries = safeDirEntriesRecursive(path.join(projectDir, ...dir.split('/')), '');
+    for (const e of entries) pushUnique(result.skills, e);
+  }
+
+  // ─── AGENTS ───────────────────────────────────────────────
+
+  // Claude Code: .claude/agents/*.md
+  collectMdFiles(path.join(projectDir, '.claude', 'agents'), result.agents, '');
+
+  // Cursor: .cursor/agents/*.md
+  collectMdFiles(path.join(projectDir, '.cursor', 'agents'), result.agents, '');
+
+  // VS Code Copilot: .github/agents/*.md
+  collectMdFiles(path.join(projectDir, '.github', 'agents'), result.agents, '');
+
+  // ─── MCP SERVERS ──────────────────────────────────────────
+
+  // Claude Code: .mcp.json (project-level)
+  extractMcpServersFromJson(path.join(projectDir, '.mcp.json'), result.mcps);
+
+  // Claude Code: .claude/settings.local.json — enabledMcpjsonServers
+  const settingsJson = safeReadFile(path.join(projectDir, '.claude', 'settings.local.json'));
+  if (settingsJson) {
+    try {
+      const parsed = JSON.parse(settingsJson);
+      if (Array.isArray(parsed.enabledMcpjsonServers)) {
+        for (const srv of parsed.enabledMcpjsonServers) {
+          if (typeof srv === 'string') pushUnique(result.mcps, srv);
+        }
+      }
+    } catch { /* invalid JSON */ }
+  }
+
+  // Cursor: .cursor/mcp.json
+  extractMcpServersFromJson(path.join(projectDir, '.cursor', 'mcp.json'), result.mcps);
+
+  // VS Code Copilot: .vscode/mcp.json
+  extractMcpServersFromJson(path.join(projectDir, '.vscode', 'mcp.json'), result.mcps);
+
+  // KiloCode: .kilocode/mcp.json
+  extractMcpServersFromJson(path.join(projectDir, '.kilocode', 'mcp.json'), result.mcps);
+
+  // Gemini CLI: .gemini/settings.json — mcpServers
+  const geminiSettings = safeReadFile(path.join(projectDir, '.gemini', 'settings.json'));
+  if (geminiSettings) {
+    try {
+      const parsed = JSON.parse(geminiSettings);
+      if (parsed.mcpServers && typeof parsed.mcpServers === 'object') {
+        for (const key of Object.keys(parsed.mcpServers)) {
+          pushUnique(result.mcps, key);
+        }
+      }
+    } catch { /* invalid JSON */ }
+  }
+
+  // Codex CLI: .codex/config.toml — [mcp_servers.<name>]
+  const codexConfig = safeReadFile(path.join(projectDir, '.codex', 'config.toml'));
+  if (codexConfig) {
+    const mcpMatches = codexConfig.matchAll(/\[mcp_servers\.(\w[\w-]*)\]/g);
+    for (const m of mcpMatches) pushUnique(result.mcps, m[1]);
+  }
+
+  // ─── COMMANDS ─────────────────────────────────────────────
+
+  // Claude Code: .claude/commands/
+  collectAllFiles(path.join(projectDir, '.claude', 'commands'), result.commands, '');
+
+  // Gemini CLI: .gemini/commands/ (.toml files)
+  collectAllFiles(path.join(projectDir, '.gemini', 'commands'), result.commands, '');
+
+  // VS Code Copilot: .github/prompts/ (.prompt.md files)
+  collectAllFiles(path.join(projectDir, '.github', 'prompts'), result.commands, '');
+
+  // Windsurf: .windsurf/workflows/
+  collectAllFiles(path.join(projectDir, '.windsurf', 'workflows'), result.commands, '');
+
+  // CLAUDE.md — parse dev commands section
+  const claudeMd = safeReadFile(path.join(projectDir, 'CLAUDE.md'))
+    || safeReadFile(path.join(projectDir, '.claude', 'CLAUDE.md'));
+  if (claudeMd) {
+    const lines = claudeMd.split('\n');
+    let inCommands = false;
+    for (const line of lines) {
+      if (/^#+\s*.*(command|script|dev)/i.test(line)) {
+        inCommands = true;
+        continue;
+      }
+      if (inCommands && /^#+\s/.test(line)) {
+        inCommands = false;
+        continue;
+      }
+      if (inCommands) {
+        const match = line.match(/^[-*]\s*`([^`]+)`/);
+        if (match) pushUnique(result.commands, match[1]);
+      }
+    }
+  }
+
+  // ─── CONTEXT / RULES ─────────────────────────────────────
+
+  // Claude Code
+  checkContextFile(projectDir, 'CLAUDE.md', result.context);
+  checkContextFile(projectDir, '.claude/CLAUDE.md', result.context);
+  checkContextFile(projectDir, 'CLAUDE.local.md', result.context);
+  collectMdFiles(path.join(projectDir, '.claude', 'rules'), result.context, '.claude/rules');
+
+  // Cursor
+  checkContextFile(projectDir, '.cursorrules', result.context);
+  for (const entry of safeDirEntries(path.join(projectDir, '.cursor', 'rules'))) {
+    pushUnique(result.context, '.cursor/rules/' + entry);
+  }
+
+  // Codex CLI
+  checkContextFile(projectDir, 'AGENTS.md', result.context);
+  checkContextFile(projectDir, 'AGENTS.override.md', result.context);
+
+  // Gemini CLI
+  checkContextFile(projectDir, 'GEMINI.md', result.context);
+
+  // Windsurf
+  checkContextFile(projectDir, '.windsurfrules', result.context);
+  for (const entry of safeDirEntries(path.join(projectDir, '.windsurf', 'rules'))) {
+    pushUnique(result.context, '.windsurf/rules/' + entry);
+  }
+
+  // Cline
+  checkContextFile(projectDir, '.clinerules', result.context);
+  // .clinerules/ as directory
+  for (const entry of safeDirEntries(path.join(projectDir, '.clinerules'))) {
+    pushUnique(result.context, '.clinerules/' + entry);
+  }
+
+  // KiloCode
+  checkContextFile(projectDir, '.kilocoderules', result.context);
+  for (const entry of safeDirEntries(path.join(projectDir, '.kilocode', 'rules'))) {
+    pushUnique(result.context, '.kilocode/rules/' + entry);
+  }
+
+  // VS Code Copilot
+  checkContextFile(projectDir, '.github/copilot-instructions.md', result.context);
+  for (const entry of safeDirEntries(path.join(projectDir, '.github', 'instructions'))) {
+    pushUnique(result.context, '.github/instructions/' + entry);
+  }
+
+  // OpenClaw
+  checkContextFile(projectDir, 'SOUL.md', result.context);
+  checkContextFile(projectDir, 'IDENTITY.md', result.context);
+  checkContextFile(projectDir, 'USER.md', result.context);
+  checkContextFile(projectDir, 'TOOLS.md', result.context);
+  checkContextFile(projectDir, 'MEMORY.md', result.context);
+
+  return result;
+}
+
+module.exports = { scanAgentConfigs };

package/{config.js → src/core/config.js}

@@ -13,7 +13,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const defaults = require('./defaults.json');
+const defaults = require('../../defaults.json');
 
 function deepMerge(target, source) {
   const result = { ...target };
@@ -70,4 +70,29 @@ function loadConfig(projectDir, explicitPath) {
   return config;
 }
 
-module.exports = { loadConfig, deepMerge };
+function resolveTheme(projectDir, explicitPath) {
+  const candidates = [];
+
+  if (explicitPath) {
+    candidates.push(path.resolve(explicitPath));
+  }
+
+  if (projectDir) {
+    candidates.push(path.join(projectDir, 'project', 'mdboard.json'));
+    candidates.push(path.join(projectDir, 'mdboard.json'));
+  }
+
+  const globalPath = path.join(os.homedir(), '.config', 'mdboard', 'mdboard.json');
+  candidates.push(globalPath);
+
+  for (const p of candidates) {
+    const data = tryReadJson(p);
+    if (data && data.theme) {
+      return data.theme;
+    }
+  }
+
+  return null;
+}
+
+module.exports = { loadConfig, deepMerge, resolveTheme };

package/src/core/history.js

@@ -0,0 +1,130 @@
+/**
+ * mdboard — Project History
+ *
+ * Persistent history of visited projects stored in
+ * ~/.config/mdboard/history.json.  Allows switching between
+ * projects without restarting the server.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'mdboard');
+const HISTORY_FILE = path.join(CONFIG_DIR, 'history.json');
+const MAX_ENTRIES = 50;
+
+/**
+ * Read the history file.
+ * @returns {Array<{path:string, name:string, lastOpened:string}>}
+ */
+function readHistory() {
+  try {
+    const raw = fs.readFileSync(HISTORY_FILE, 'utf-8');
+    const data = JSON.parse(raw);
+    return Array.isArray(data) ? data : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Write history to disk.
+ * @param {Array} entries
+ */
+function writeHistory(entries) {
+  try {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(entries, null, 2), 'utf-8');
+  } catch {
+    // Non-critical — silently ignore write failures
+  }
+}
+
+/**
+ * Register (or update) a project in the history.
+ * Moves the entry to the front of the list.
+ *
+ * @param {string} projectDir - Absolute path to the project directory
+ * @param {string} name - Human-friendly project name
+ */
+function registerProject(projectDir, name) {
+  const absPath = path.resolve(projectDir);
+  let entries = readHistory();
+
+  // Remove existing entry for this path
+  entries = entries.filter(e => e.path !== absPath);
+
+  // Prepend new entry
+  entries.unshift({
+    path: absPath,
+    name: name || path.basename(absPath),
+    lastOpened: new Date().toISOString(),
+  });
+
+  // Enforce limit
+  if (entries.length > MAX_ENTRIES) {
+    entries = entries.slice(0, MAX_ENTRIES);
+  }
+
+  writeHistory(entries);
+}
+
+/**
+ * Get the history list with a `isCurrent` flag.
+ *
+ * @param {string} currentProjectDir - The currently-active project dir
+ * @returns {Array<{path:string, name:string, lastOpened:string, isCurrent:boolean}>}
+ */
+function getHistory(currentProjectDir) {
+  const absCurrentDir = currentProjectDir ? path.resolve(currentProjectDir) : null;
+  const entries = readHistory();
+
+  return entries.map(e => ({
+    ...e,
+    isCurrent: e.path === absCurrentDir,
+  }));
+}
+
+/**
+ * Detect whether a directory looks like a valid mdboard project.
+ * A project has either a `project/` subdirectory or a `workspace.json`
+ * with sources.
+ *
+ * @param {string} dir - Directory to check
+ * @returns {boolean}
+ */
+function isValidProject(dir) {
+  try {
+    const absDir = path.resolve(dir);
+
+    // Check for project/ sub-directory
+    if (fs.existsSync(path.join(absDir, 'project'))) return true;
+
+    // Check for workspace.json with sources
+    const wsPath = path.join(absDir, 'workspace.json');
+    if (fs.existsSync(wsPath)) {
+      const raw = fs.readFileSync(wsPath, 'utf-8');
+      const ws = JSON.parse(raw);
+      if (ws && Array.isArray(ws.sources) && ws.sources.length > 0) return true;
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove an entry from the history.
+ *
+ * @param {string} projectPath - Absolute path to remove
+ */
+function removeFromHistory(projectPath) {
+  const absPath = path.resolve(projectPath);
+  let entries = readHistory();
+  entries = entries.filter(e => e.path !== absPath);
+  writeHistory(entries);
+}
+
+module.exports = { readHistory, registerProject, getHistory, isValidProject, removeFromHistory };

package/{scanner.js → src/core/scanner.js}

@@ -18,7 +18,7 @@ function createModel() {
     sprints: [],
     boards: [],
     reviews: [],
-    metrics: null,
+    notes: [],
   };
 }
 
@@ -55,7 +55,7 @@ function isTaskFile(filename, config) {
  * @param {string} sourcePath - Absolute path to the project/ directory
  * @param {object} config - mdboard config object
  * @param {object} sourceMeta - { name, label, color, type, readonly }
- * @returns {object} - { project, milestones, epics, tasks, sprints, boards, reviews, metrics }
+ * @returns {object} - { project, milestones, epics, tasks, sprints, boards, reviews }
  */
 function scanSource(sourcePath, config, sourceMeta) {
   const result = {
@@ -66,7 +66,7 @@ function scanSource(sourcePath, config, sourceMeta) {
     sprints: [],
     boards: [],
     reviews: [],
-    metrics: null,
+    notes: [],
   };
 
   if (!fs.existsSync(sourcePath)) return result;
@@ -99,12 +99,6 @@ function scanSource(sourcePath, config, sourceMeta) {
     result.project = tag({ ...parsed.frontmatter, content: parsed.content, _file: 'PROJECT.md' });
   }
 
-  const metricsMd = safeReadFile(path.join(sourcePath, 'metrics.md'));
-  if (metricsMd) {
-    const parsed = parseFrontmatter(metricsMd);
-    result.metrics = tag({ ...parsed.frontmatter, content: parsed.content, _file: 'metrics.md' });
-  }
-
   const msDir = config.entities.milestone.dir;
   const epicDir = config.entities.epic.dir;
   const taskDir = config.entities.task.dir;
@@ -200,6 +194,30 @@ function scanSource(sourcePath, config, sourceMeta) {
     }
   }
 
+  // ── Notes: scan project/notes/*.md ──
+  const notesDir = path.join(sourcePath, 'notes');
+  if (fs.existsSync(notesDir)) {
+    for (const file of safeDirEntries(notesDir)) {
+      if (!file.endsWith('.md')) continue;
+      const noteContent = safeReadFile(path.join(notesDir, file));
+      if (noteContent) {
+        const parsed = parseFrontmatter(noteContent);
+        const slug = file.replace(/\.md$/, '');
+        result.notes.push(tag({
+          id: slug,
+          title: parsed.frontmatter.title || slug,
+          created: parsed.frontmatter.created || null,
+          updated: parsed.frontmatter.updated || null,
+          content: parsed.content,
+          _file: 'notes/' + file,
+          ...Object.fromEntries(
+            Object.entries(parsed.frontmatter).filter(([k]) => k !== 'title' && k !== 'created' && k !== 'updated')
+          ),
+        }));
+      }
+    }
+  }
+
   return result;
 }
 
@@ -260,7 +278,7 @@ function mergeResults(model, results) {
     model.sprints.push(...r.sprints);
     model.boards.push(...r.boards);
     model.reviews.push(...r.reviews);
-    if (r.metrics && !model.metrics) model.metrics = r.metrics;
+    if (r.notes) model.notes.push(...r.notes);
   }
 }
 
@@ -322,6 +340,7 @@ function createTask(sourcePath, config, data, existingTasks) {
   if (data.assigned) fm.assigned = data.assigned;
   if (data.sprint) fm.sprint = data.sprint;
   if (data.links) fm.links = data.links;
+  if (data.ai) fm.ai = data.ai;
   fm.created = new Date().toISOString().split('T')[0];
 
   const yaml = serializeYaml(fm);
@@ -360,6 +379,7 @@ function createMilestone(sourcePath, config, data, existingMilestones) {
   };
   if (data.deadline) fm.deadline = data.deadline;
   if (data.tracks) fm.tracks = data.tracks;
+  if (data.ai) fm.ai = data.ai;
   fm.created = new Date().toISOString().split('T')[0];
 
   const yaml = serializeYaml(fm);
@@ -404,6 +424,7 @@ function createEpic(sourcePath, config, data, existingEpics) {
   };
   if (data.priority) fm.priority = data.priority;
   if (data.dependencies) fm.dependencies = data.dependencies;
+  if (data.ai) fm.ai = data.ai;
   fm.created = new Date().toISOString().split('T')[0];
 
   const yaml = serializeYaml(fm);
@@ -460,7 +481,8 @@ function createSprint(sourcePath, config, data, existingSprints) {
 }
 
 /**
- * Archive an item by moving its file/directory to project/archive/.
+ * Delete an item by removing its file.
+ * Git history preserves the file for recovery if needed.
  *
  * @param {string} sourcePath - Absolute path to project/ dir
  * @param {object} item - The item with _file property
@@ -472,20 +494,118 @@ function archiveItem(sourcePath, item) {
   const srcPath = path.join(sourcePath, item._file);
   if (!fs.existsSync(srcPath)) throw new Error('Source file not found: ' + item._file);
 
-  const archiveDir = path.join(sourcePath, 'archive');
-  fs.mkdirSync(archiveDir, { recursive: true });
+  fs.unlinkSync(srcPath);
+  return true;
+}
+
+/**
+ * Create a new note markdown file in notes/.
+ *
+ * @param {string} sourcePath - Absolute path to project/ dir
+ * @param {object} data - { title, content }
+ * @param {object[]} existingNotes - Current notes to check slug uniqueness
+ * @returns {object} - { id, file }
+ */
+function createNote(sourcePath, data, existingNotes) {
+  const title = data.title || 'Untitled';
+  let slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+  if (!slug) slug = 'note';
+
+  // Ensure unique slug
+  const existingIds = new Set(existingNotes.map(n => n.id || n._originalId));
+  let finalSlug = slug;
+  let counter = 1;
+  while (existingIds.has(finalSlug)) {
+    finalSlug = slug + '-' + counter;
+    counter++;
+  }
+
+  const dir = path.join(sourcePath, 'notes');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
 
-  const basename = path.basename(srcPath);
-  const timestamp = Date.now();
-  const destName = timestamp + '-' + basename;
-  const destPath = path.join(archiveDir, destName);
+  const today = new Date().toISOString().split('T')[0];
+  const fm = { title: title, created: today, updated: today };
+  const yaml = serializeYaml(fm);
+  const content = data.content || '';
+  const filePath = path.join(dir, finalSlug + '.md');
+  fs.writeFileSync(filePath, '---\n' + yaml + '\n---\n\n' + content + '\n', 'utf-8');
 
-  fs.renameSync(srcPath, destPath);
-  return true;
+  return { id: finalSlug, file: 'notes/' + finalSlug + '.md' };
+}
+
+// ── Agentic AI properties ──────────────────────────────────────────
+
+const AI_FIELDS = ['skills', 'agents', 'mcps', 'commands', 'context'];
+
+function extractAiProps(item) {
+  const result = {};
+  if (!item || !item.ai || typeof item.ai !== 'object') return result;
+  for (const field of AI_FIELDS) {
+    const val = item.ai[field];
+    if (val != null) {
+      result[field] = Array.isArray(val) ? val : [val];
+    }
+  }
+  return result;
+}
+
+function mergeAiProps(layers) {
+  const merged = {};
+  for (const layer of layers) {
+    for (const field of AI_FIELDS) {
+      const arr = layer[field];
+      if (!arr || arr.length === 0) continue;
+      if (!merged[field]) merged[field] = [];
+      for (const v of arr) {
+        if (merged[field].indexOf(v) === -1) merged[field].push(v);
+      }
+    }
+  }
+  return merged;
+}
+
+function computeAgentProps(model) {
+  const projectAi = model.project ? extractAiProps(model.project) : {};
+
+  for (const ms of model.milestones) {
+    const msOwn = extractAiProps(ms);
+    const msResolved = mergeAiProps([projectAi, msOwn]);
+    ms._ai = Object.keys(msResolved).length > 0 ? msResolved : null;
+    ms._aiOwn = Object.keys(msOwn).length > 0 ? msOwn : null;
+  }
+
+  for (const epic of model.epics) {
+    const epicOwn = extractAiProps(epic);
+    const parentMs = model.milestones.find(m =>
+      m._dir === epic._milestone && (!epic._source || m._source === epic._source)
+    );
+    const msAi = parentMs ? extractAiProps(parentMs) : {};
+    const epicResolved = mergeAiProps([projectAi, msAi, epicOwn]);
+    epic._ai = Object.keys(epicResolved).length > 0 ? epicResolved : null;
+    epic._aiOwn = Object.keys(epicOwn).length > 0 ? epicOwn : null;
+  }
+
+  for (const task of model.tasks) {
+    const taskOwn = extractAiProps(task);
+    const parentEpic = model.epics.find(e =>
+      e._dir === task._epic && e._milestone === task._milestone &&
+      (!task._source || e._source === task._source)
+    );
+    const parentMs = model.milestones.find(m =>
+      m._dir === task._milestone && (!task._source || m._source === task._source)
+    );
+    const msAi = parentMs ? extractAiProps(parentMs) : {};
+    const epicAi = parentEpic ? extractAiProps(parentEpic) : {};
+    const taskResolved = mergeAiProps([projectAi, msAi, epicAi, taskOwn]);
+    task._ai = Object.keys(taskResolved).length > 0 ? taskResolved : null;
+    task._aiOwn = Object.keys(taskOwn).length > 0 ? taskOwn : null;
+  }
 }
 
 module.exports = {
-  createModel, scanSource, computeProgress, isTaskFile,
+  createModel, scanSource, computeProgress, computeAgentProps, isTaskFile,
   safeReadFile, safeDirEntries, updateMarkdownFile, mergeResults,
-  getNextId, createTask, createMilestone, createEpic, createSprint, archiveItem
+  getNextId, createTask, createMilestone, createEpic, createSprint, createNote, archiveItem
 };

package/{yaml.js → src/core/yaml.js}

@@ -117,7 +117,11 @@ function serializeYaml(obj) {
     } else if (typeof value === 'object') {
       lines.push(key + ':');
       for (const [k, v] of Object.entries(value)) {
-        lines.push('  ' + k + ': ' + serializeValue(v));
+        if (Array.isArray(v)) {
+          lines.push('  ' + k + ': ' + (v.length === 0 ? '[]' : '[' + v.map(sv => serializeValue(sv)).join(', ') + ']'));
+        } else {
+          lines.push('  ' + k + ': ' + serializeValue(v));
+        }
       }
     } else {
       lines.push(key + ': ' + serializeValue(value));