@minions-tasks/cli 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 /**
  * @minions-tasks/cli — CLI for Minions Tasks
+ *
+ * Uses minions-sdk's JsonFileStorageAdapter for sharded, atomic file storage:
+ *   <rootDir>/<id[0..1]>/<id[2..3]>/<id>.json
  */
 export {};

package/dist/index.js

@@ -1,32 +1,33 @@
 #!/usr/bin/env node
 /**
  * @minions-tasks/cli — CLI for Minions Tasks
+ *
+ * Uses minions-sdk's JsonFileStorageAdapter for sharded, atomic file storage:
+ *   <rootDir>/<id[0..1]>/<id[2..3]>/<id>.json
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from 'fs';
-import { join, resolve } from 'path';
-import { randomUUID } from 'crypto';
+import { createMinion, updateMinion, softDelete, TypeRegistry, } from 'minions-sdk';
+import { JsonFileStorageAdapter } from 'minions-sdk/node';
 import { customTypes } from '@minions-tasks/sdk';
 const program = new Command();
-const STORE_DIR = resolve(process.env.MINIONS_STORE || '.minions');
-function ensureStore() {
-    if (!existsSync(STORE_DIR)) {
-        mkdirSync(STORE_DIR, { recursive: true });
-    }
+const STORE_DIR = process.env.MINIONS_STORE || '.minions';
+const registry = new TypeRegistry();
+for (const t of customTypes) {
+    registry.register(t);
 }
-function getTypeDir(slug) {
-    const dir = join(STORE_DIR, slug);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
+let _storage = null;
+async function getStorage() {
+    if (!_storage) {
+        _storage = await JsonFileStorageAdapter.create(STORE_DIR);
     }
-    return dir;
+    return _storage;
 }
 function findType(slug) {
-    const type = customTypes.find(t => t.slug === slug);
+    const type = registry.getBySlug(slug);
     if (!type) {
         console.error(chalk.red(`Unknown type: ${slug}`));
-        console.error(chalk.dim(`Available types: ${customTypes.map(t => t.slug).join(', ')}`));
+        console.error(chalk.dim(`Available: ${customTypes.map(t => t.slug).join(', ')}`));
         process.exit(1);
     }
     return type;
@@ -34,7 +35,7 @@ function findType(slug) {
 program
     .name('tasks')
     .description('Task and work management across agents, humans, and workflows')
-    .version('0.3.0');
+    .version('0.5.0');
 // ─── info ──────────────────────────────────────────────────
 program
     .command('info')
@@ -60,7 +61,7 @@ types
     for (const type of customTypes) {
         const fieldCount = type.schema.length;
         console.log(`  ${type.icon}  ${chalk.bold(type.name)} ${chalk.dim(`(${type.slug})`)}`);
-        console.log(`     ${chalk.dim(type.description)}`);
+        console.log(`     ${chalk.dim(type.description || '')}`);
         console.log(`     ${chalk.dim(`${fieldCount} fields: ${type.schema.map(f => f.name).join(', ')}`)}`);
         console.log('');
     }
@@ -71,12 +72,13 @@ types
     .action((slug) => {
     const type = findType(slug);
     console.log(`\n  ${type.icon}  ${chalk.bold(type.name)}`);
-    console.log(`  ${chalk.dim(type.description)}`);
+    console.log(`  ${chalk.dim(type.description || '')}`);
     console.log(`  ${chalk.dim(`ID: ${type.id}  Slug: ${type.slug}`)}\n`);
     console.log(chalk.bold('  Fields:\n'));
     for (const field of type.schema) {
         const typeColor = field.type === 'string' ? 'green' : field.type === 'number' ? 'yellow' : field.type === 'boolean' ? 'blue' : 'magenta';
-        console.log(`    ${chalk.dim('•')} ${chalk.bold(field.name)}  ${chalk[typeColor](field.type)}`);
+        const req = field.required ? chalk.red('*') : ' ';
+        console.log(`    ${req} ${chalk.bold(field.name)}  ${chalk[typeColor](field.type)}${field.description ? `  ${chalk.dim(field.description)}` : ''}`);
     }
     console.log('');
 });
@@ -86,42 +88,37 @@ program
     .description('Create a new Minion of the specified type')
     .option('-d, --data <json>', 'Field data as JSON string')
     .option('-f, --file <path>', 'Read field data from a JSON file')
-    .option('-t, --title <title>', 'Shortcut: set the title field')
-    .option('-s, --status <status>', 'Shortcut: set the status field')
-    .option('-p, --priority <priority>', 'Shortcut: set the priority field')
-    .action((typeSlug, opts) => {
+    .option('-t, --title <title>', 'Minion title')
+    .option('-s, --status <status>', 'Status: active, todo, in_progress, completed, cancelled')
+    .option('-p, --priority <priority>', 'Priority: low, medium, high, urgent')
+    .option('--tags <tags>', 'Comma-separated tags')
+    .action(async (typeSlug, opts) => {
     const type = findType(typeSlug);
-    ensureStore();
+    const storage = await getStorage();
     let fields = {};
     if (opts.file) {
+        const { readFileSync } = await import('fs');
         fields = JSON.parse(readFileSync(opts.file, 'utf-8'));
     }
     else if (opts.data) {
         fields = JSON.parse(opts.data);
     }
-    // Apply shortcut flags
-    if (opts.title)
-        fields.title = opts.title;
-    if (opts.status)
-        fields.status = opts.status;
-    if (opts.priority)
-        fields.priority = opts.priority;
-    const minion = {
-        id: randomUUID(),
-        type: type.slug,
-        typeName: type.name,
+    const title = opts.title || fields.title || fields.name || type.name;
+    const tags = opts.tags ? opts.tags.split(',').map((t) => t.trim()) : undefined;
+    const { minion } = createMinion({
+        title,
         fields,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-    };
-    const dir = getTypeDir(type.slug);
-    const filePath = join(dir, `${minion.id}.json`);
-    writeFileSync(filePath, JSON.stringify(minion, null, 2));
+        status: opts.status || 'active',
+        priority: opts.priority,
+        tags,
+        createdBy: 'cli',
+    }, type);
+    await storage.set(minion);
+    const hex = minion.id.replace(/-/g, '');
     console.log(chalk.green(`\n  ✔ Created ${type.icon} ${type.name}`));
     console.log(`  ${chalk.dim('ID:')}    ${minion.id}`);
-    console.log(`  ${chalk.dim('File:')}  ${filePath}`);
-    if (fields.title)
-        console.log(`  ${chalk.dim('Title:')} ${fields.title}`);
+    console.log(`  ${chalk.dim('Title:')} ${minion.title}`);
+    console.log(`  ${chalk.dim('Path:')}  ${STORE_DIR}/${hex.slice(0, 2)}/${hex.slice(2, 4)}/${minion.id}.json`);
     console.log('');
 });
 // ─── list ──────────────────────────────────────────────────
@@ -129,37 +126,36 @@ program
     .command('list [type]')
     .alias('ls')
     .description('List all Minions, optionally filtered by type')
+    .option('--status <status>', 'Filter by status')
     .option('--json', 'Output as JSON')
-    .action((typeSlug, opts) => {
-    ensureStore();
-    const slugs = typeSlug ? [typeSlug] : customTypes.map(t => t.slug);
-    const allMinions = [];
-    for (const slug of slugs) {
-        const dir = join(STORE_DIR, slug);
-        if (!existsSync(dir))
-            continue;
-        const files = readdirSync(dir).filter(f => f.endsWith('.json'));
-        for (const file of files) {
-            const minion = JSON.parse(readFileSync(join(dir, file), 'utf-8'));
-            allMinions.push(minion);
-        }
+    .option('-n, --limit <n>', 'Max results', parseInt)
+    .action(async (typeSlug, opts) => {
+    const storage = await getStorage();
+    const filter = {};
+    if (typeSlug) {
+        const type = findType(typeSlug);
+        filter.minionTypeId = type.id;
     }
+    if (opts.status)
+        filter.status = opts.status;
+    if (opts.limit)
+        filter.limit = opts.limit;
+    const minions = await storage.list(filter);
     if (opts.json) {
-        console.log(JSON.stringify(allMinions, null, 2));
+        console.log(JSON.stringify(minions, null, 2));
         return;
     }
-    if (allMinions.length === 0) {
+    if (minions.length === 0) {
         console.log(chalk.dim('\n  No Minions found.\n'));
         return;
     }
-    console.log(chalk.bold(`\n  ${allMinions.length} Minion(s):\n`));
-    for (const m of allMinions) {
-        const type = customTypes.find(t => t.slug === m.type);
+    console.log(chalk.bold(`\n  ${minions.length} Minion(s):\n`));
+    for (const m of minions) {
+        const type = registry.getById(m.minionTypeId) || registry.getBySlug(m.minionTypeId);
         const icon = type?.icon || '?';
-        const title = m.fields?.title || m.fields?.name || m.fields?.label || chalk.dim('(untitled)');
-        const status = m.fields?.status ? chalk.dim(`[${m.fields.status}]`) : '';
-        console.log(`  ${icon}  ${chalk.bold(title)} ${status}`);
-        console.log(`     ${chalk.dim(m.id)} ${chalk.dim(m.type)}`);
+        const status = m.status ? chalk.dim(`[${m.status}]`) : '';
+        console.log(`  ${icon}  ${chalk.bold(m.title)} ${status}`);
+        console.log(`     ${chalk.dim(m.id)} ${chalk.dim(type?.slug || m.minionTypeId)}`);
     }
     console.log('');
 });
@@ -168,139 +164,270 @@ program
     .command('show <id>')
     .description('Show a Minion by ID')
     .option('--json', 'Output as JSON')
-    .action((id, opts) => {
-    ensureStore();
-    // Search across all type directories
-    for (const type of customTypes) {
-        const filePath = join(STORE_DIR, type.slug, `${id}.json`);
-        if (existsSync(filePath)) {
-            const minion = JSON.parse(readFileSync(filePath, 'utf-8'));
-            if (opts.json) {
-                console.log(JSON.stringify(minion, null, 2));
-                return;
-            }
-            console.log(`\n  ${type.icon}  ${chalk.bold(minion.fields?.title || minion.fields?.name || type.name)}`);
-            console.log(`  ${chalk.dim(`Type: ${minion.type}  ID: ${minion.id}`)}`);
-            console.log(`  ${chalk.dim(`Created: ${minion.createdAt}`)}\n`);
-            console.log(chalk.bold('  Fields:\n'));
-            for (const [key, value] of Object.entries(minion.fields || {})) {
-                console.log(`    ${chalk.dim('•')} ${chalk.bold(key)}: ${value}`);
-            }
-            console.log('');
-            return;
-        }
+    .action(async (id, opts) => {
+    const storage = await getStorage();
+    const minion = await storage.get(id);
+    if (!minion) {
+        console.error(chalk.red(`\n  Minion not found: ${id}\n`));
+        process.exit(1);
     }
-    console.error(chalk.red(`\n  Minion not found: ${id}\n`));
-    process.exit(1);
+    if (opts.json) {
+        console.log(JSON.stringify(minion, null, 2));
+        return;
+    }
+    const type = registry.getById(minion.minionTypeId) || registry.getBySlug(minion.minionTypeId);
+    console.log(`\n  ${type?.icon || '?'}  ${chalk.bold(minion.title)}`);
+    console.log(`  ${chalk.dim(`Type: ${type?.slug || minion.minionTypeId}  ID: ${minion.id}`)}`);
+    console.log(`  ${chalk.dim(`Status: ${minion.status || '-'}  Priority: ${minion.priority || '-'}`)}`);
+    console.log(`  ${chalk.dim(`Created: ${minion.createdAt}  Updated: ${minion.updatedAt}`)}`);
+    if (minion.tags?.length)
+        console.log(`  ${chalk.dim(`Tags: ${minion.tags.join(', ')}`)}`);
+    console.log(chalk.bold('\n  Fields:\n'));
+    for (const [key, value] of Object.entries(minion.fields || {})) {
+        console.log(`    ${chalk.dim('•')} ${chalk.bold(key)}: ${value}`);
+    }
+    console.log('');
 });
 // ─── update ────────────────────────────────────────────────
 program
     .command('update <id>')
     .description('Update fields on an existing Minion')
     .option('-d, --data <json>', 'Fields to update as JSON')
-    .option('-s, --status <status>', 'Shortcut: update status')
-    .option('-p, --priority <priority>', 'Shortcut: update priority')
-    .action((id, opts) => {
-    ensureStore();
-    for (const type of customTypes) {
-        const filePath = join(STORE_DIR, type.slug, `${id}.json`);
-        if (existsSync(filePath)) {
-            const minion = JSON.parse(readFileSync(filePath, 'utf-8'));
-            let updates = {};
-            if (opts.data)
-                updates = JSON.parse(opts.data);
-            if (opts.status)
-                updates.status = opts.status;
-            if (opts.priority)
-                updates.priority = opts.priority;
-            minion.fields = { ...minion.fields, ...updates };
-            minion.updatedAt = new Date().toISOString();
-            writeFileSync(filePath, JSON.stringify(minion, null, 2));
-            console.log(chalk.green(`\n  ✔ Updated ${type.icon} ${minion.fields?.title || type.name}`));
-            for (const [key, value] of Object.entries(updates)) {
-                console.log(`    ${chalk.dim('•')} ${key} → ${value}`);
-            }
-            console.log('');
-            return;
-        }
+    .option('-s, --status <status>', 'Update status')
+    .option('-p, --priority <priority>', 'Update priority')
+    .option('-t, --title <title>', 'Update title')
+    .option('--tags <tags>', 'Replace tags (comma-separated)')
+    .action(async (id, opts) => {
+    const storage = await getStorage();
+    const existing = await storage.get(id);
+    if (!existing) {
+        console.error(chalk.red(`\n  Minion not found: ${id}\n`));
+        process.exit(1);
     }
-    console.error(chalk.red(`\n  Minion not found: ${id}\n`));
-    process.exit(1);
+    const updates = {};
+    if (opts.data)
+        updates.fields = { ...existing.fields, ...JSON.parse(opts.data) };
+    if (opts.status)
+        updates.status = opts.status;
+    if (opts.priority)
+        updates.priority = opts.priority;
+    if (opts.title)
+        updates.title = opts.title;
+    if (opts.tags)
+        updates.tags = opts.tags.split(',').map((t) => t.trim());
+    const typeDef = registry.getById(existing.minionTypeId) || registry.getBySlug(existing.minionTypeId);
+    if (!typeDef) {
+        console.error(chalk.red(`\n  Minion type not found: ${existing.minionTypeId}\n`));
+        process.exit(1);
+    }
+    const { minion: updated } = updateMinion(existing, { ...updates, updatedBy: 'cli' }, typeDef);
+    await storage.set(updated);
+    const type = registry.getById(updated.minionTypeId) || registry.getBySlug(updated.minionTypeId);
+    console.log(chalk.green(`\n  ✔ Updated ${type?.icon || '?'} ${updated.title}`));
 });
 // ─── delete ────────────────────────────────────────────────
 program
     .command('delete <id>')
-    .description('Delete a Minion by ID (sets status to cancelled if possible)')
-    .option('--hard', 'Permanently delete the file')
-    .action((id, opts) => {
-    ensureStore();
-    const { unlinkSync } = require('fs');
-    for (const type of customTypes) {
-        const filePath = join(STORE_DIR, type.slug, `${id}.json`);
-        if (existsSync(filePath)) {
-            if (opts.hard) {
-                unlinkSync(filePath);
-                console.log(chalk.yellow(`\n  🗑  Permanently deleted ${id}\n`));
-            }
-            else {
-                const minion = JSON.parse(readFileSync(filePath, 'utf-8'));
-                minion.fields.status = 'cancelled';
-                minion.updatedAt = new Date().toISOString();
-                writeFileSync(filePath, JSON.stringify(minion, null, 2));
-                console.log(chalk.yellow(`\n  ✔ Cancelled ${type.icon} ${minion.fields?.title || type.name}`));
-                console.log(chalk.dim(`    Use --hard to permanently delete\n`));
-            }
-            return;
+    .description('Soft-delete a Minion')
+    .option('--hard', 'Permanently remove from disk')
+    .action(async (id, opts) => {
+    const storage = await getStorage();
+    const existing = await storage.get(id);
+    if (!existing) {
+        console.error(chalk.red(`\n  Minion not found: ${id}\n`));
+        process.exit(1);
+    }
+    if (opts.hard) {
+        await storage.delete(id);
+        console.log(chalk.yellow(`\n  🗑  Permanently deleted ${id}\n`));
+    }
+    else {
+        const deleted = softDelete(existing, 'cli');
+        await storage.set(deleted);
+        console.log(chalk.yellow(`\n  ✔ Soft-deleted ${existing.title}`));
+        console.log(chalk.dim(`    Use --hard to permanently remove\n`));
+    }
+});
+// ─── search ────────────────────────────────────────────────
+program
+    .command('search <query>')
+    .description('Full-text search across all Minions')
+    .option('--json', 'Output as JSON')
+    .action(async (query, opts) => {
+    const storage = await getStorage();
+    const results = await storage.search(query);
+    if (opts.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    if (results.length === 0) {
+        console.log(chalk.dim(`\n  No results for "${query}".\n`));
+        return;
+    }
+    console.log(chalk.bold(`\n  ${results.length} result(s) for "${query}":\n`));
+    for (const m of results) {
+        const type = registry.getById(m.minionTypeId) || registry.getBySlug(m.minionTypeId);
+        const icon = type?.icon || '?';
+        const status = m.status ? chalk.dim(`[${m.status}]`) : '';
+        console.log(`  ${icon}  ${chalk.bold(m.title)} ${status}`);
+        console.log(`     ${chalk.dim(m.id)} ${chalk.dim(type?.slug || m.minionTypeId)}`);
+    }
+    console.log('');
+});
+// ─── blocked ───────────────────────────────────────────────
+program
+    .command('blocked')
+    .description('List all tasks with status "blocked" and their blockers')
+    .action(async () => {
+    const storage = await getStorage();
+    const taskType = findType('task');
+    const depType = registry.getBySlug('task-dependency');
+    const blockedTasks = (await storage.list({ minionTypeId: taskType.id }))
+        .filter(t => t.fields?.status === 'blocked' || t.status === 'in_progress');
+    // Also check status field in fields for tasks
+    const allBlocked = (await storage.list({ minionTypeId: taskType.id }))
+        .filter(t => {
+        const fieldStatus = t.fields?.status;
+        return fieldStatus === 'blocked' || t.status === 'in_progress';
+    });
+    if (allBlocked.length === 0) {
+        console.log(chalk.green('\n  ✔ No blocked tasks.\n'));
+        return;
+    }
+    const deps = depType ? await storage.list({ minionTypeId: depType.id }) : [];
+    console.log(chalk.bold(`\n  🚫 ${allBlocked.length} blocked/in-progress task(s):\n`));
+    for (const t of allBlocked) {
+        console.log(`  ✅  ${chalk.bold(t.title)}`);
+        console.log(`     ${chalk.dim(t.id)}`);
+        const taskDeps = deps.filter(d => d.fields?.taskId === t.id);
+        for (const d of taskDeps) {
+            console.log(`     ${chalk.red('→')} blocked by ${chalk.dim(d.fields.dependsOnTaskId)} (${d.fields.type})`);
         }
+        console.log('');
+    }
+});
+// ─── complete ──────────────────────────────────────────────
+program
+    .command('complete <id>')
+    .description('Mark a task as done and create a task-outcome')
+    .option('-r, --result <result>', 'Outcome: success, partial, failed', 'success')
+    .option('--summary <summary>', 'What was accomplished')
+    .option('--lessons <lessons>', 'Lessons for agent learning loop')
+    .action(async (id, opts) => {
+    const storage = await getStorage();
+    const task = await storage.get(id);
+    if (!task) {
+        console.error(chalk.red(`\n  Task not found: ${id}\n`));
+        process.exit(1);
+    }
+    // Update task status
+    const typeDef = registry.getById(task.minionTypeId) || registry.getBySlug(task.minionTypeId);
+    if (!typeDef) {
+        console.error(chalk.red(`\n  Minion type not found: ${task.minionTypeId}\n`));
+        process.exit(1);
     }
-    console.error(chalk.red(`\n  Minion not found: ${id}\n`));
-    process.exit(1);
+    const { minion: completed } = updateMinion(task, {
+        fields: { ...task.fields, status: 'done', completedAt: new Date().toISOString() },
+        status: 'completed',
+        updatedBy: 'cli',
+    }, typeDef);
+    await storage.set(completed);
+    // Create task-outcome
+    const outcomeType = findType('task-outcome');
+    const { minion: outcome } = createMinion({
+        title: `Outcome: ${task.title}`,
+        fields: {
+            taskId: id,
+            result: opts.result,
+            summary: opts.summary || '',
+            artifactIds: '',
+            lessons: opts.lessons || '',
+        },
+        createdBy: 'cli',
+    }, outcomeType);
+    await storage.set(outcome);
+    console.log(chalk.green(`\n  ✔ Completed ✅ ${task.title}`));
+    console.log(`  ${chalk.dim('Result:')}  ${opts.result}`);
+    console.log(`  ${chalk.dim('Outcome:')} ${outcome.id}\n`);
+});
+// ─── assign ────────────────────────────────────────────────
+program
+    .command('assign <taskId> <assigneeId>')
+    .description('Assign a task to a person or agent')
+    .option('--type <type>', 'Assignee type: human or agent', 'agent')
+    .option('--role <role>', 'Role: owner, collaborator, reviewer, observer', 'owner')
+    .action(async (taskId, assigneeId, opts) => {
+    const storage = await getStorage();
+    const task = await storage.get(taskId);
+    if (!task) {
+        console.error(chalk.red(`\n  Task not found: ${taskId}\n`));
+        process.exit(1);
+    }
+    const assignType = findType('task-assignment');
+    const { minion: assignment } = createMinion({
+        title: `Assignment: ${task.title} → ${assigneeId}`,
+        fields: {
+            taskId,
+            assigneeId,
+            assigneeType: opts.type,
+            assignedAt: new Date().toISOString(),
+            assignedBy: 'cli',
+            role: opts.role,
+        },
+        createdBy: 'cli',
+    }, assignType);
+    await storage.set(assignment);
+    console.log(chalk.green(`\n  ✔ Assigned task to ${assigneeId}`));
+    console.log(`  ${chalk.dim('Task:')} ${taskId}`);
+    console.log(`  ${chalk.dim('Role:')} ${opts.role}`);
+    console.log(`  ${chalk.dim('ID:')}   ${assignment.id}\n`);
+});
+// ─── comment ───────────────────────────────────────────────
+program
+    .command('comment <taskId> <body>')
+    .description('Add a comment to a task')
+    .option('--author <id>', 'Author ID', 'cli')
+    .option('--type <type>', 'Author type: human or agent', 'agent')
+    .action(async (taskId, body, opts) => {
+    const storage = await getStorage();
+    const commentType = findType('task-comment');
+    const { minion: comment } = createMinion({
+        title: `Comment on ${taskId}`,
+        fields: {
+            taskId,
+            authorId: opts.author,
+            authorType: opts.type,
+            body,
+            createdAt: new Date().toISOString(),
+            resolvedAt: '',
+        },
+        createdBy: opts.author,
+    }, commentType);
+    await storage.set(comment);
+    console.log(chalk.green(`\n  ✔ Comment added to task ${taskId}`));
+    console.log(`  ${chalk.dim('ID:')} ${comment.id}\n`);
 });
 // ─── validate ──────────────────────────────────────────────
 program
     .command('validate <file>')
     .description('Validate a JSON file against its MinionType schema')
-    .action((file) => {
+    .action(async (file) => {
+    const { readFileSync } = await import('fs');
+    const { validateFields } = await import('minions-sdk');
     const data = JSON.parse(readFileSync(file, 'utf-8'));
-    const type = customTypes.find(t => t.slug === data.type);
+    const type = registry.getById(data.minionTypeId) || registry.getBySlug(data.minionTypeId);
     if (!type) {
-        console.error(chalk.red(`\n  Unknown type: ${data.type}\n`));
+        console.error(chalk.red(`\n  Unknown type: ${data.minionTypeId}\n`));
         process.exit(1);
     }
-    const errors = [];
-    const schemaFields = type.schema.map(f => f.name);
-    const dataFields = Object.keys(data.fields || {});
-    // Check for missing fields
-    for (const f of schemaFields) {
-        if (!(f in (data.fields || {}))) {
-            errors.push(`Missing field: ${f}`);
-        }
-    }
-    // Check for unknown fields
-    for (const f of dataFields) {
-        if (!schemaFields.includes(f)) {
-            errors.push(`Unknown field: ${f}`);
-        }
-    }
-    // Check field types
-    for (const field of type.schema) {
-        const value = data.fields?.[field.name];
-        if (value === undefined)
-            continue;
-        if (field.type === 'number' && typeof value !== 'number') {
-            errors.push(`Field ${field.name} should be number, got ${typeof value}`);
-        }
-        if (field.type === 'boolean' && typeof value !== 'boolean') {
-            errors.push(`Field ${field.name} should be boolean, got ${typeof value}`);
-        }
-    }
-    if (errors.length === 0) {
+    const result = validateFields(data.fields, type.schema);
+    if (result.valid) {
         console.log(chalk.green(`\n  ✔ Valid ${type.icon} ${type.name}\n`));
     }
     else {
-        console.log(chalk.red(`\n  ✘ ${errors.length} validation error(s):\n`));
-        for (const err of errors) {
-            console.log(`    ${chalk.red('•')} ${err}`);
+        console.log(chalk.red(`\n  ✘ ${result.errors.length} validation error(s):\n`));
+        for (const err of result.errors) {
+            console.log(`    ${chalk.red('•')} ${err.field}: ${err.message}`);
         }
         console.log('');
         process.exit(1);
@@ -310,20 +437,16 @@ program
 program
     .command('stats')
     .description('Show statistics about stored Minions')
-    .action(() => {
-    ensureStore();
+    .action(async () => {
+    const storage = await getStorage();
     console.log(chalk.bold('\n  Minion Statistics:\n'));
     let total = 0;
     for (const type of customTypes) {
-        const dir = join(STORE_DIR, type.slug);
-        if (!existsSync(dir)) {
-            console.log(`  ${type.icon}  ${type.name.padEnd(22)} ${chalk.dim('0')}`);
-            continue;
-        }
-        const count = readdirSync(dir).filter(f => f.endsWith('.json')).length;
+        const minions = await storage.list({ minionTypeId: type.id });
+        const count = minions.length;
         total += count;
         const bar = chalk.cyan('█'.repeat(Math.min(count, 30)));
-        console.log(`  ${type.icon}  ${type.name.padEnd(22)} ${String(count).padStart(4)}  ${bar}`);
+        console.log(`  ${type.icon}  ${(type.name || '').padEnd(22)} ${String(count).padStart(4)}  ${count > 0 ? bar : chalk.dim('0')}`);
     }
     console.log(`\n  ${chalk.bold('Total:')} ${total} Minion(s)`);
     console.log(`  ${chalk.dim(`Store: ${STORE_DIR}`)}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minions-tasks/cli",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "CLI for minions-tasks — Task and work management across agents, humans, and workflows",
   "license": "MIT",
   "repository": {
@@ -27,8 +27,8 @@
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "inquirer": "^13.2.5",
-    "minions-sdk": "^0.2.2",
-    "@minions-tasks/sdk": "0.3.0"
+    "minions-sdk": "^0.2.3",
+    "@minions-tasks/sdk": "0.5.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",