npm - checkbox-cli - Versions diffs - 2.0.1 → 3.0.1 - Mend

checkbox-cli 2.0.1 → 3.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/checkbox.js CHANGED Viewed

@@ -1,16 +1,12 @@
 #!/usr/bin/env node
 /**
- * Checkbox CLI — Beautiful, interactive compliance management from your terminal.
+ * Checkbox CLI v3.0.0 — Full-featured compliance management from your terminal.
+ *
+ * Every capability available in the Checkbox web app is accessible here:
+ * tasks, plans, tables, documents, dashboards, forms, team management, and more.
  *
  * First-time users: just run `checkbox` and follow the guided setup.
  * Returning users: `checkbox` opens the interactive menu.
- *
- * Direct commands (for scripts & automation):
- *   checkbox plans             — List your compliance plans
- *   checkbox tasks             — Browse tasks
- *   checkbox complete <id>     — Complete a task
- *   checkbox status            — Workspace overview
- *   checkbox setup             — Re-run the setup wizard
  */
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
@@ -20,7 +16,7 @@ import { join } from 'path';
 // ── Config ──────────────────────────────────────────────────────────
 const CONFIG_DIR = join(homedir(), '.checkbox');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
-const VERSION = '2.0.1';
+const VERSION = '3.0.1';
 function loadConfig() {
     try {
         if (!existsSync(CONFIG_FILE))
@@ -58,10 +54,9 @@ function resolveConfig() {
     return fileCfg;
 }
 // ── API ─────────────────────────────────────────────────────────────
-/** Extract a human-readable error message from any API error shape */
 function extractError(obj) {
     if (!obj)
-        return 'Unknown error';
+        return '';
     if (typeof obj === 'string')
         return obj;
     if (typeof obj.error === 'string')
@@ -83,9 +78,14 @@ function api(cfg) {
             headers,
             body: JSON.stringify(body),
         });
-        const json = await res.json().catch(() => null);
+        const text = await res.text().catch(() => '');
+        let json = null;
+        try {
+            json = JSON.parse(text);
+        }
+        catch { }
         if (!res.ok) {
-            throw new Error(extractError(json) || `Request failed (${res.status})`);
+            throw new Error(extractError(json) || text || `Request failed (${res.status})`);
         }
         if (json && json.success === false) {
             throw new Error(extractError(json) || 'Request failed');
@@ -94,9 +94,14 @@ function api(cfg) {
     }
     async function get(path) {
         const res = await fetch(`${cfg.apiUrl}${path}`, { headers });
-        const json = await res.json().catch(() => null);
+        const text = await res.text().catch(() => '');
+        let json = null;
+        try {
+            json = JSON.parse(text);
+        }
+        catch { }
         if (!res.ok) {
-            throw new Error(extractError(json) || `Request failed (${res.status})`);
+            throw new Error(extractError(json) || text || `Request failed (${res.status})`);
         }
         if (json && json.success === false) {
             throw new Error(extractError(json) || 'Request failed');
@@ -105,35 +110,46 @@ function api(cfg) {
     }
     return { post, get };
 }
-// ── Query helpers ───────────────────────────────────────────────────
-// The actual query types are: list_entities, get_entity, list_my_organizations,
-// get_task_states, workspace_graph, entity_discovery, schema_discovery,
-// permission_discovery, list_approvals.
-// There is NO list_plans or list_tasks — use list_entities with entity_type.
-async function listEntities(post, orgId, entityType) {
-    const res = await post('/api/v2/query', {
-        type: 'list_entities',
-        organization_id: orgId,
-        payload: { entity_type: entityType, organization_id: orgId },
-    });
-    // list_entities returns { success, data: [...], meta }
-    return Array.isArray(res.data) ? res.data : [];
+// ── Data Helpers ────────────────────────────────────────────────────
+async function listEntities(post, orgId, entityType, filters) {
+    try {
+        const res = await post('/api/v2/query', {
+            type: 'list_entities',
+            organization_id: orgId,
+            payload: { entity_type: entityType, organization_id: orgId, ...filters },
+        });
+        return Array.isArray(res.data) ? res.data : [];
+    }
+    catch (err) {
+        p.log.error(err.message || `Could not load ${entityType}`);
+        return [];
+    }
 }
 async function searchEntities(post, orgId, search, limit = 20) {
-    // entity_discovery returns { success, data: { organization_id, entities: [...] } }
-    const res = await post('/api/v2/introspection/entities', {
-        organization_id: orgId,
-        search,
-        limit,
-    });
-    return res.data?.entities || [];
+    try {
+        const res = await post('/api/v2/introspection/entities', {
+            organization_id: orgId,
+            search,
+            limit,
+        });
+        return res.data?.entities || [];
+    }
+    catch (err) {
+        p.log.error(err.message || 'Search failed');
+        return [];
+    }
 }
 async function getWorkspaceNodes(post, orgId) {
-    // workspace returns { success, data: { organization_id, nodes: [...], edges: [...] } }
-    const res = await post('/api/v2/introspection/workspace', {
-        organization_id: orgId,
-    });
-    return res.data?.nodes || [];
+    try {
+        const res = await post('/api/v2/introspection/workspace', {
+            organization_id: orgId,
+        });
+        return res.data?.nodes || [];
+    }
+    catch (err) {
+        p.log.error(err.message || 'Could not load workspace');
+        return [];
+    }
 }
 // ── Formatters ──────────────────────────────────────────────────────
 function truncate(s, max) {
@@ -145,6 +161,106 @@ function formatDate(iso) {
 function pad(s, n) {
     return s.padEnd(n);
 }
+// ── UI Helpers ──────────────────────────────────────────────────────
+async function pickEntity(post, orgId, entityType, label, filters) {
+    const s = p.spinner();
+    s.start(`Loading ${label}...`);
+    try {
+        const items = await listEntities(post, orgId, entityType, filters);
+        s.stop(`${items.length} ${label}`);
+        if (items.length === 0) {
+            p.log.info(`No ${label} found.`);
+            return null;
+        }
+        const selected = await p.select({
+            message: `Choose a ${label.replace(/s$/, '')}`,
+            options: [
+                ...items.slice(0, 50).map((e) => ({
+                    value: e.id,
+                    label: truncate(e.name || 'Untitled', 60),
+                    hint: e.metadata?.frequency || '',
+                })),
+                ...(items.length > 50 ? [{ value: '__more', label: pc.dim(`\u2026${items.length - 50} more (use search)`) }] : []),
+                { value: '__back', label: pc.dim('\u2190 Back') },
+            ],
+        });
+        if (p.isCancel(selected) || selected === '__back' || selected === '__more')
+            return null;
+        return items.find((e) => e.id === selected) || null;
+    }
+    catch (err) {
+        s.stop(pc.red('Failed'));
+        p.log.error(err.message || `Could not load ${label}`);
+        return null;
+    }
+}
+async function txt(message, required = false, placeholder) {
+    const val = await p.text({
+        message,
+        placeholder,
+        validate: required ? (v) => { if (!v)
+            return 'This field is required'; } : undefined,
+    });
+    if (p.isCancel(val))
+        return null;
+    return val || null;
+}
+async function sel(message, options) {
+    const val = await p.select({ message, options });
+    if (p.isCancel(val))
+        return null;
+    return val;
+}
+async function yn(message, initial = false) {
+    const val = await p.confirm({ message, initialValue: initial });
+    if (p.isCancel(val))
+        return null;
+    return val;
+}
+async function cmd(post, orgId, type, payload, label = 'Working...') {
+    const s = p.spinner();
+    s.start(label);
+    try {
+        const body = { type, payload };
+        if (orgId)
+            body.organization_id = orgId;
+        const res = await post('/api/v2/commands', body);
+        s.stop(pc.green('Done!'));
+        return res;
+    }
+    catch (err) {
+        s.stop(pc.red('Failed'));
+        p.log.error(err.message || 'Something went wrong');
+        return null;
+    }
+}
+async function cmdNoOrg(post, type, payload, label = 'Working...') {
+    const s = p.spinner();
+    s.start(label);
+    try {
+        const res = await post('/api/v2/commands', { type, payload });
+        s.stop(pc.green('Done!'));
+        return res;
+    }
+    catch (err) {
+        s.stop(pc.red('Failed'));
+        p.log.error(err.message || 'Something went wrong');
+        return null;
+    }
+}
+async function qry(post, orgId, type, payload = {}) {
+    try {
+        return await post('/api/v2/query', {
+            type,
+            organization_id: orgId,
+            payload: { ...payload, organization_id: orgId },
+        });
+    }
+    catch (err) {
+        p.log.error(err.message || 'Query failed');
+        return null;
+    }
+}
 // ── Setup Wizard ────────────────────────────────────────────────────
 async function runSetup(existingConfig) {
     p.intro(pc.bgCyan(pc.black(' Checkbox Setup ')));
@@ -236,7 +352,9 @@ async function runSetup(existingConfig) {
     p.outro(pc.green('Setup complete! Run `checkbox` to get started.'));
     return cfg;
 }
-// ── Interactive Menu ────────────────────────────────────────────────
+// ══════════════════════════════════════════════════════════════════════
+//  MAIN MENU
+// ══════════════════════════════════════════════════════════════════════
 async function interactiveMenu(cfg) {
     const { post } = api(cfg);
     console.log();
@@ -247,14 +365,19 @@ async function interactiveMenu(cfg) {
     const action = await p.select({
         message: 'What would you like to do?',
         options: [
-            { value: 'plans', label: 'View plans', hint: 'see your compliance plans' },
-            { value: 'tasks', label: 'Browse tasks', hint: 'view and complete tasks' },
-            { value: 'status', label: 'Workspace overview', hint: 'summary of your workspace' },
-            { value: 'search', label: 'Search', hint: 'find anything in your workspace' },
-            { value: 'complete', label: 'Complete a task', hint: 'mark a task as done' },
-            { value: 'create-task', label: 'Create a task', hint: 'add a new task' },
-            { value: 'switch', label: 'Switch workspace', hint: 'change organization' },
-            { value: 'setup', label: 'Settings', hint: 'API key, workspace config' },
+            { value: 'tasks', label: 'My Tasks', hint: 'view, complete, create, and manage tasks' },
+            { value: 'plans', label: 'Plans', hint: 'compliance plans, goals, rules, requirements' },
+            { value: 'tables', label: 'Data Tables', hint: 'manage tables and records' },
+            { value: 'documents', label: 'Documents', hint: 'files, folders, and attachments' },
+            { value: 'assets', label: 'Assets', hint: 'photos, locations, checklists' },
+            { value: 'automation', label: 'Rules & Automation', hint: 'validation rules, triggers' },
+            { value: 'dashboards', label: 'Dashboards & Sharing', hint: 'dashboards, shares, reports' },
+            { value: 'forms', label: 'Forms', hint: 'public data collection forms' },
+            { value: 'approvals', label: 'Approvals', hint: 'review and manage approvals' },
+            { value: 'team', label: 'Team', hint: 'invite members, manage roles' },
+            { value: 'organization', label: 'Organization', hint: 'settings, branding, membership' },
+            { value: 'overview', label: 'Workspace Overview', hint: 'search and status' },
+            { value: 'settings', label: 'Settings', hint: 'API key, switch workspace' },
         ],
     });
     if (p.isCancel(action)) {
@@ -262,371 +385,1898 @@ async function interactiveMenu(cfg) {
         return;
     }
     switch (action) {
-        case 'plans': return menuPlans(cfg, post);
-        case 'tasks': return menuTasks(cfg, post);
-        case 'status': return menuStatus(cfg, post);
-        case 'search': return menuSearch(cfg, post);
-        case 'complete': return menuComplete(cfg, post);
-        case 'create-task': return menuCreateTask(cfg, post);
-        case 'switch': return menuSwitch(cfg, post);
-        case 'setup':
+        case 'tasks': return mTasks(cfg, post);
+        case 'plans': return mPlans(cfg, post);
+        case 'tables': return mTables(cfg, post);
+        case 'documents': return mDocs(cfg, post);
+        case 'assets': return mAssets(cfg, post);
+        case 'automation': return mAutomation(cfg, post);
+        case 'dashboards': return mDashboards(cfg, post);
+        case 'forms': return mForms(cfg, post);
+        case 'approvals': return mApprovals(cfg, post);
+        case 'team': return mTeam(cfg, post);
+        case 'organization': return mOrg(cfg, post);
+        case 'overview': return mOverview(cfg, post);
+        case 'settings':
             await runSetup(cfg);
             return;
     }
 }
-// ── Plans ───────────────────────────────────────────────────────────
-async function menuPlans(cfg, post) {
-    const s = p.spinner();
-    s.start('Loading plans...');
-    try {
-        const plans = await listEntities(post, cfg.orgId, 'plan');
-        s.stop(`Found ${plans.length} plan${plans.length === 1 ? '' : 's'}`);
-        if (plans.length === 0) {
-            p.log.info('No plans yet. Create one at checkbox.my');
-            return interactiveMenu(cfg);
-        }
-        const lines = plans.map((plan) => {
-            const name = truncate(plan.name || 'Untitled', 40);
-            const meta = plan.metadata || {};
-            const created = meta.created_at ? formatDate(meta.created_at) : '';
-            return `${pc.cyan(pad(name, 42))} ${pc.dim(created)}`;
-        });
-        p.note(lines.join('\n'), `Plans in ${cfg.orgName}`);
-        const selected = await p.select({
-            message: 'Select a plan to view its tasks',
-            options: [
-                ...plans.map((plan) => ({
-                    value: plan.id,
-                    label: plan.name || 'Untitled',
-                })),
-                { value: '__back', label: pc.dim('Back to menu') },
-            ],
-        });
-        if (p.isCancel(selected) || selected === '__back') {
-            return interactiveMenu(cfg);
+// ══════════════════════════════════════════════════════════════════════
+//  TASKS — 9 commands + send_nudge + create_corrective_action + queries
+// ══════════════════════════════════════════════════════════════════════
+async function mTasks(cfg, post) {
+    const a = await sel('My Tasks', [
+        { value: 'today', label: "Today's tasks", hint: 'see what needs to be done' },
+        { value: 'all', label: 'All tasks', hint: 'browse all tasks' },
+        { value: 'complete', label: 'Complete a task' },
+        { value: 'reopen', label: 'Reopen a completed task' },
+        { value: 'create', label: 'Create a new task' },
+        { value: 'edit', label: 'Edit a task' },
+        { value: 'delete', label: 'Delete a task' },
+        { value: 'validate', label: 'Submit proof', hint: 'photo, document, location, checklist' },
+        { value: 'approval', label: 'Request approval for a task' },
+        { value: 'answer', label: 'Answer a conditional question' },
+        { value: 'nudge', label: 'Send a reminder', hint: 'nudge someone about a task' },
+        { value: 'corrective', label: 'Corrective action', hint: 'for a missed task' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
+        return interactiveMenu(cfg);
+    switch (a) {
+        case 'today': {
+            const s = p.spinner();
+            s.start('Loading...');
+            const today = new Date().toISOString().split('T')[0];
+            const res = await qry(post, cfg.orgId, 'get_task_states', { date: today });
+            const states = Array.isArray(res?.data) ? res.data : [];
+            s.stop(`${states.length} tasks today`);
+            if (states.length > 0) {
+                const lines = states.map((t) => {
+                    const icon = t.status === 'completed' ? pc.green('\u2713') : t.status === 'missed' ? pc.red('\u2717') : pc.yellow('\u25CB');
+                    return `  ${icon} ${pc.cyan(truncate(t.task_name || t.name || 'Untitled', 50))}  ${pc.dim(t.frequency || '')}`;
+                });
+                p.note(lines.join('\n'), `Today (${today})`);
+            }
+            else {
+                p.log.info('No tasks scheduled for today.');
+            }
+            return mTasks(cfg, post);
+        }
+        case 'all': {
+            const s = p.spinner();
+            s.start('Loading tasks...');
+            const tasks = await listEntities(post, cfg.orgId, 'task');
+            s.stop(`${tasks.length} tasks`);
+            if (tasks.length > 0) {
+                const lines = tasks.map((t) => `  ${pc.cyan(pad(truncate(t.name || 'Untitled', 50), 52))} ${pc.dim(t.metadata?.frequency || '')}`);
+                p.note(lines.join('\n'), 'All Tasks');
+            }
+            return mTasks(cfg, post);
+        }
+        case 'complete': {
+            const t = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (t)
+                await cmd(post, cfg.orgId, 'complete_task', { task_id: t.id }, `Completing "${t.name}"...`);
+            return mTasks(cfg, post);
+        }
+        case 'reopen': {
+            const t = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (t)
+                await cmd(post, cfg.orgId, 'uncomplete_task', { task_id: t.id }, `Reopening "${t.name}"...`);
+            return mTasks(cfg, post);
+        }
+        case 'create': {
+            const name = await txt('Task name', true, 'e.g. Daily safety walkthrough');
+            if (!name)
+                return mTasks(cfg, post);
+            const frequency = await sel('How often?', [
+                { value: 'daily', label: 'Daily' },
+                { value: 'weekly', label: 'Weekly' },
+                { value: 'monthly', label: 'Monthly' },
+                { value: 'yearly', label: 'Yearly' },
+                { value: 'one-time', label: 'One time' },
+            ]);
+            if (!frequency)
+                return mTasks(cfg, post);
+            const payload = { name, frequency };
+            const addPlan = await yn('Add to a plan?');
+            if (addPlan) {
+                const plan = await pickEntity(post, cfg.orgId, 'plan', 'plans');
+                if (plan)
+                    payload.plan_id = plan.id;
+            }
+            const more = await yn('Add more details? (description, time, reminders, etc.)');
+            if (more) {
+                const desc = await txt('Description');
+                if (desc)
+                    payload.description = desc;
+                const priv = await yn('Private task?');
+                if (priv)
+                    payload.is_private = true;
+                const time = await txt('Scheduled time (HH:MM)', false, '09:00');
+                if (time)
+                    payload.time = time;
+                const reminder = await sel('Reminder', [
+                    { value: 'none', label: 'No reminder' },
+                    { value: 'notification', label: 'Push notification' },
+                    { value: 'email', label: 'Email' },
+                ]);
+                if (reminder && reminder !== 'none') {
+                    payload.reminder_mode = reminder;
+                    const mins = await txt('Minutes before', false, '30');
+                    if (mins)
+                        payload.reminder_minutes = parseInt(mins, 10);
+                }
+                const approval = await yn('Requires approval?');
+                if (approval)
+                    payload.approval_required = true;
+                const cond = await txt('Conditional question (blank to skip)', false, 'e.g. Is the equipment available?');
+                if (cond)
+                    payload.conditional_question = cond;
+            }
+            await cmd(post, cfg.orgId, 'create_task', payload, 'Creating task...');
+            return mTasks(cfg, post);
+        }
+        case 'edit': {
+            const t = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (!t)
+                return mTasks(cfg, post);
+            p.log.info(`Editing: ${pc.cyan(t.name)} ${pc.dim('(leave blank to skip)')}`);
+            const updates = {};
+            const n = await txt('New name');
+            if (n === null)
+                return mTasks(cfg, post);
+            if (n)
+                updates.name = n;
+            const f = await sel('New frequency', [
+                { value: '__skip', label: pc.dim('Keep current') },
+                { value: 'daily', label: 'Daily' }, { value: 'weekly', label: 'Weekly' },
+                { value: 'monthly', label: 'Monthly' }, { value: 'yearly', label: 'Yearly' },
+                { value: 'one-time', label: 'One time' },
+            ]);
+            if (f && f !== '__skip')
+                updates.frequency = f;
+            const d = await txt('New description');
+            if (d)
+                updates.description = d;
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_task', { task_id: t.id, updates }, 'Updating...');
+            }
+            else
+                p.log.info('No changes.');
+            return mTasks(cfg, post);
+        }
+        case 'delete': {
+            const t = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (!t)
+                return mTasks(cfg, post);
+            const sure = await yn(`Delete "${t.name}"? This cannot be undone.`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_task', { task_id: t.id }, 'Deleting...');
+            return mTasks(cfg, post);
+        }
+        case 'validate': {
+            const t = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (!t)
+                return mTasks(cfg, post);
+            const vtype = await sel('Proof type', [
+                { value: 'photo', label: 'Photo' },
+                { value: 'document', label: 'Document' },
+                { value: 'geolocation', label: 'Location check-in' },
+                { value: 'checklist', label: 'Checklist' },
+                { value: 'table', label: 'Table record' },
+            ]);
+            if (!vtype)
+                return mTasks(cfg, post);
+            let vid = null;
+            let data = {};
+            if (vtype === 'photo') {
+                const ph = await pickEntity(post, cfg.orgId, 'photo', 'photo assets');
+                if (!ph)
+                    return mTasks(cfg, post);
+                vid = ph.id;
+                const url = await txt('Photo URL', true);
+                if (!url)
+                    return mTasks(cfg, post);
+                data = { url };
+            }
+            else if (vtype === 'document') {
+                const doc = await pickEntity(post, cfg.orgId, 'document', 'documents');
+                if (!doc)
+                    return mTasks(cfg, post);
+                vid = doc.id;
+                const url = await txt('Document URL', true);
+                if (!url)
+                    return mTasks(cfg, post);
+                data = { url };
+            }
+            else if (vtype === 'geolocation') {
+                const area = await pickEntity(post, cfg.orgId, 'geolocation_area', 'location areas');
+                if (!area)
+                    return mTasks(cfg, post);
+                vid = area.id;
+                const lat = await txt('Your latitude', true);
+                const lng = await txt('Your longitude', true);
+                if (!lat || !lng)
+                    return mTasks(cfg, post);
+                data = { latitude: parseFloat(lat), longitude: parseFloat(lng) };
+            }
+            else if (vtype === 'checklist') {
+                const cl = await pickEntity(post, cfg.orgId, 'checklist', 'checklists');
+                if (!cl)
+                    return mTasks(cfg, post);
+                vid = cl.id;
+                data = { completed: true };
+            }
+            else if (vtype === 'table') {
+                const tbl = await pickEntity(post, cfg.orgId, 'table', 'tables');
+                if (!tbl)
+                    return mTasks(cfg, post);
+                vid = tbl.id;
+                const rid = await txt('Record ID', true);
+                if (!rid)
+                    return mTasks(cfg, post);
+                data = { record_id: rid };
+            }
+            if (vid) {
+                await cmd(post, cfg.orgId, 'submit_validation', {
+                    task_id: t.id, validation_type: vtype, validation_id: vid, data,
+                }, 'Submitting proof...');
+            }
+            return mTasks(cfg, post);
+        }
+        case 'approval': {
+            const t = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (!t)
+                return mTasks(cfg, post);
+            const payload = { task_id: t.id };
+            const specify = await yn('Specify an approver?');
+            if (specify) {
+                const aid = await txt('Approver user ID', true);
+                if (aid)
+                    payload.approver_id = aid;
+            }
+            await cmd(post, cfg.orgId, 'request_approval', payload, 'Requesting approval...');
+            return mTasks(cfg, post);
+        }
+        case 'answer': {
+            const t = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (!t)
+                return mTasks(cfg, post);
+            const answer = await sel(`Answer for "${t.name}"`, [
+                { value: 'yes', label: 'Yes' }, { value: 'no', label: 'No' },
+            ]);
+            if (answer)
+                await cmd(post, cfg.orgId, 'answer_conditional', { task_id: t.id, answer }, 'Submitting answer...');
+            return mTasks(cfg, post);
+        }
+        case 'nudge': {
+            const t = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (!t)
+                return mTasks(cfg, post);
+            const rid = await txt('Who should get the reminder? (user ID)', true);
+            if (rid)
+                await cmd(post, cfg.orgId, 'send_nudge', { task_id: t.id, receiver_id: rid }, 'Sending reminder...');
+            return mTasks(cfg, post);
+        }
+        case 'corrective': {
+            const hid = await txt('Task history ID (from a missed task)', true);
+            if (!hid)
+                return mTasks(cfg, post);
+            const desc = await txt('What happened?', true);
+            if (!desc)
+                return mTasks(cfg, post);
+            const action = await txt('What was done to fix it?', true);
+            if (!action)
+                return mTasks(cfg, post);
+            await cmd(post, cfg.orgId, 'create_corrective_action', {
+                task_history_id: hid, description: desc, action_taken: action,
+            }, 'Recording corrective action...');
+            return mTasks(cfg, post);
         }
-        return menuPlanTasks(cfg, post, selected, plans.find((pl) => pl.id === selected)?.name || '');
     }
-    catch (err) {
-        s.stop(pc.red('Failed'));
-        p.log.error(err.message || 'Could not load plans');
+    return mTasks(cfg, post);
+}
+// ══════════════════════════════════════════════════════════════════════
+//  PLANS — plan + goal + rule + requirement CRUD (12 commands)
+// ══════════════════════════════════════════════════════════════════════
+async function mPlans(cfg, post) {
+    const a = await sel('Plans', [
+        { value: 'list', label: 'View plans' },
+        { value: 'create', label: 'Create a plan' },
+        { value: 'edit', label: 'Edit a plan' },
+        { value: 'delete', label: 'Delete a plan' },
+        { value: 'goals', label: 'Manage goals', hint: 'within a plan' },
+        { value: 'rules', label: 'Manage rules', hint: 'within a goal' },
+        { value: 'reqs', label: 'Manage requirements', hint: 'within a rule' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
         return interactiveMenu(cfg);
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading plans...');
+            const plans = await listEntities(post, cfg.orgId, 'plan');
+            s.stop(`${plans.length} plans`);
+            if (plans.length > 0) {
+                const lines = plans.map((pl) => {
+                    const progress = pl.metadata?.progress != null ? `${pl.metadata.progress}%` : '';
+                    const status = pl.metadata?.status || '';
+                    return `  ${pc.cyan(pad(truncate(pl.name || 'Untitled', 40), 42))} ${pc.dim(pad(status, 10))} ${pc.dim(progress)}`;
+                });
+                p.note(lines.join('\n'), 'Plans');
+            }
+            return mPlans(cfg, post);
+        }
+        case 'create': {
+            const name = await txt('Plan name', true);
+            if (!name)
+                return mPlans(cfg, post);
+            const payload = { name };
+            const desc = await txt('Description');
+            if (desc)
+                payload.description = desc;
+            const priv = await yn('Private plan?');
+            if (priv)
+                payload.is_private = true;
+            const addGoals = await yn('Add goals now?');
+            if (addGoals) {
+                const goals = [];
+                let more = true;
+                while (more) {
+                    const gn = await txt('Goal name', true);
+                    if (!gn)
+                        break;
+                    goals.push({ name: gn });
+                    more = !!(await yn('Add another goal?'));
+                }
+                if (goals.length > 0)
+                    payload.goals = goals;
+            }
+            await cmd(post, cfg.orgId, 'create_plan', payload, 'Creating plan...');
+            return mPlans(cfg, post);
+        }
+        case 'edit': {
+            const plan = await pickEntity(post, cfg.orgId, 'plan', 'plans');
+            if (!plan)
+                return mPlans(cfg, post);
+            p.log.info(`Editing: ${pc.cyan(plan.name)}`);
+            const updates = {};
+            const n = await txt('New name (blank to skip)');
+            if (n === null)
+                return mPlans(cfg, post);
+            if (n)
+                updates.name = n;
+            const d = await txt('New description (blank to skip)');
+            if (d)
+                updates.description = d;
+            const st = await sel('Status', [
+                { value: '__skip', label: pc.dim('Keep current') },
+                { value: 'active', label: 'Active' }, { value: 'draft', label: 'Draft' }, { value: 'archived', label: 'Archived' },
+            ]);
+            if (st && st !== '__skip')
+                updates.status = st;
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_plan', { plan_id: plan.id, updates }, 'Updating plan...');
+            }
+            else
+                p.log.info('No changes.');
+            return mPlans(cfg, post);
+        }
+        case 'delete': {
+            const plan = await pickEntity(post, cfg.orgId, 'plan', 'plans');
+            if (!plan)
+                return mPlans(cfg, post);
+            const sure = await yn(`Delete "${plan.name}" and everything inside it? This cannot be undone.`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_plan', { plan_id: plan.id }, 'Deleting plan...');
+            return mPlans(cfg, post);
+        }
+        case 'goals': return mGoals(cfg, post);
+        case 'rules': return mPlanRules(cfg, post);
+        case 'reqs': return mReqs(cfg, post);
     }
+    return mPlans(cfg, post);
 }
-async function menuPlanTasks(cfg, post, planId, planName) {
-    const s = p.spinner();
-    s.start('Loading tasks...');
-    try {
-        // Search entities by plan — use entity_discovery with search for plan-specific tasks
-        // Or query list_entities for tasks and filter by parent_id
-        const res = await post('/api/v2/query', {
-            type: 'list_entities',
-            organization_id: cfg.orgId,
-            payload: { entity_type: 'task', organization_id: cfg.orgId },
-        });
-        const allTasks = Array.isArray(res.data) ? res.data : [];
-        // Filter tasks that belong to this plan via parent_id chain
-        const tasks = allTasks.filter((t) => t.parent_id === planId || t.metadata?.plan_id === planId);
-        s.stop(`${tasks.length} task${tasks.length === 1 ? '' : 's'} in ${pc.cyan(planName)}`);
-        if (tasks.length === 0) {
-            p.log.info('No tasks found for this plan.');
-            return interactiveMenu(cfg);
-        }
-        const lines = tasks.map((t) => {
-            const name = truncate(t.name || 'Untitled', 50);
-            const freq = t.metadata?.frequency || '';
-            return `  ${pc.cyan(pad(name, 52))} ${pc.dim(freq)}`;
-        });
-        p.note(lines.join('\n'), planName);
-        return interactiveMenu(cfg);
+async function mGoals(cfg, post) {
+    const a = await sel('Goals', [
+        { value: 'list', label: 'View goals in a plan' },
+        { value: 'create', label: 'Add a goal to a plan' },
+        { value: 'edit', label: 'Edit a goal' },
+        { value: 'delete', label: 'Delete a goal' },
+        { value: '__back', label: pc.dim('\u2190 Back') },
+    ]);
+    if (!a || a === '__back')
+        return mPlans(cfg, post);
+    switch (a) {
+        case 'list': {
+            const plan = await pickEntity(post, cfg.orgId, 'plan', 'plans');
+            if (!plan)
+                return mGoals(cfg, post);
+            const s = p.spinner();
+            s.start('Loading goals...');
+            const goals = await listEntities(post, cfg.orgId, 'goal', { plan_id: plan.id });
+            s.stop(`${goals.length} goals in "${plan.name}"`);
+            if (goals.length > 0) {
+                const lines = goals.map((g) => `  ${pc.cyan(g.name || 'Untitled')}`);
+                p.note(lines.join('\n'), plan.name);
+            }
+            return mGoals(cfg, post);
+        }
+        case 'create': {
+            const plan = await pickEntity(post, cfg.orgId, 'plan', 'plans');
+            if (!plan)
+                return mGoals(cfg, post);
+            const name = await txt('Goal name', true);
+            if (!name)
+                return mGoals(cfg, post);
+            await cmd(post, cfg.orgId, 'create_goal', { plan_id: plan.id, name }, 'Creating goal...');
+            return mGoals(cfg, post);
+        }
+        case 'edit': {
+            const goal = await pickEntity(post, cfg.orgId, 'goal', 'goals');
+            if (!goal)
+                return mGoals(cfg, post);
+            const name = await txt('New name', true);
+            if (!name)
+                return mGoals(cfg, post);
+            await cmd(post, cfg.orgId, 'update_goal', { goal_id: goal.id, updates: { name } }, 'Updating goal...');
+            return mGoals(cfg, post);
+        }
+        case 'delete': {
+            const goal = await pickEntity(post, cfg.orgId, 'goal', 'goals');
+            if (!goal)
+                return mGoals(cfg, post);
+            const sure = await yn(`Delete "${goal.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_goal', { goal_id: goal.id }, 'Deleting goal...');
+            return mGoals(cfg, post);
+        }
     }
-    catch (err) {
-        s.stop(pc.red('Failed'));
-        p.log.error(err.message || 'Could not load tasks');
-        return interactiveMenu(cfg);
+    return mGoals(cfg, post);
+}
+async function mPlanRules(cfg, post) {
+    const a = await sel('Rules (within goals)', [
+        { value: 'list', label: 'View rules in a goal' },
+        { value: 'create', label: 'Add a rule to a goal' },
+        { value: 'edit', label: 'Edit a rule' },
+        { value: 'delete', label: 'Delete a rule' },
+        { value: '__back', label: pc.dim('\u2190 Back') },
+    ]);
+    if (!a || a === '__back')
+        return mPlans(cfg, post);
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading rules...');
+            const rules = await listEntities(post, cfg.orgId, 'rule');
+            s.stop(`${rules.length} rules`);
+            if (rules.length > 0) {
+                const lines = rules.slice(0, 50).map((r) => `  ${pc.cyan(truncate(r.name || 'Untitled', 60))}`);
+                p.note(lines.join('\n'), 'Rules');
+            }
+            return mPlanRules(cfg, post);
+        }
+        case 'create': {
+            const plan = await pickEntity(post, cfg.orgId, 'plan', 'plans');
+            if (!plan)
+                return mPlanRules(cfg, post);
+            const goal = await pickEntity(post, cfg.orgId, 'goal', 'goals', { plan_id: plan.id });
+            if (!goal)
+                return mPlanRules(cfg, post);
+            const name = await txt('Rule name', true);
+            if (!name)
+                return mPlanRules(cfg, post);
+            await cmd(post, cfg.orgId, 'create_rule', { plan_id: plan.id, goal_id: goal.id, name }, 'Creating rule...');
+            return mPlanRules(cfg, post);
+        }
+        case 'edit': {
+            const rule = await pickEntity(post, cfg.orgId, 'rule', 'rules');
+            if (!rule)
+                return mPlanRules(cfg, post);
+            const name = await txt('New name', true);
+            if (!name)
+                return mPlanRules(cfg, post);
+            await cmd(post, cfg.orgId, 'update_rule', { rule_id: rule.id, updates: { name } }, 'Updating rule...');
+            return mPlanRules(cfg, post);
+        }
+        case 'delete': {
+            const rule = await pickEntity(post, cfg.orgId, 'rule', 'rules');
+            if (!rule)
+                return mPlanRules(cfg, post);
+            const sure = await yn(`Delete "${rule.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_rule', { rule_id: rule.id }, 'Deleting rule...');
+            return mPlanRules(cfg, post);
+        }
     }
+    return mPlanRules(cfg, post);
 }
-// ── Tasks ───────────────────────────────────────────────────────────
-async function menuTasks(cfg, post) {
-    const s = p.spinner();
-    s.start('Loading tasks...');
-    try {
-        const tasks = await listEntities(post, cfg.orgId, 'task');
-        s.stop(`Found ${tasks.length} task${tasks.length === 1 ? '' : 's'}`);
-        if (tasks.length === 0) {
-            p.log.info('No tasks yet.');
-            return interactiveMenu(cfg);
+async function mReqs(cfg, post) {
+    const a = await sel('Requirements', [
+        { value: 'list', label: 'View requirements' },
+        { value: 'create', label: 'Add a requirement' },
+        { value: 'edit', label: 'Edit a requirement' },
+        { value: 'delete', label: 'Delete a requirement' },
+        { value: '__back', label: pc.dim('\u2190 Back') },
+    ]);
+    if (!a || a === '__back')
+        return mPlans(cfg, post);
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading requirements...');
+            const reqs = await listEntities(post, cfg.orgId, 'requirement');
+            s.stop(`${reqs.length} requirements`);
+            if (reqs.length > 0) {
+                const lines = reqs.slice(0, 50).map((r) => `  ${pc.cyan(truncate(r.name || 'Untitled', 60))}`);
+                p.note(lines.join('\n'), 'Requirements');
+            }
+            return mReqs(cfg, post);
         }
-        const selected = await p.select({
-            message: 'Select a task',
-            options: [
-                ...tasks.slice(0, 25).map((t) => ({
-                    value: t.id,
-                    label: truncate(t.name || 'Untitled', 60),
-                    hint: t.metadata?.frequency || '',
-                })),
-                ...(tasks.length > 25 ? [{ value: '__more', label: pc.dim(`...and ${tasks.length - 25} more`) }] : []),
-                { value: '__back', label: pc.dim('Back to menu') },
-            ],
-        });
-        if (p.isCancel(selected) || selected === '__back' || selected === '__more') {
-            return interactiveMenu(cfg);
+        case 'create': {
+            const plan = await pickEntity(post, cfg.orgId, 'plan', 'plans');
+            if (!plan)
+                return mReqs(cfg, post);
+            const rule = await pickEntity(post, cfg.orgId, 'rule', 'rules', { plan_id: plan.id });
+            if (!rule)
+                return mReqs(cfg, post);
+            const name = await txt('Requirement name', true);
+            if (!name)
+                return mReqs(cfg, post);
+            const payload = { plan_id: plan.id, rule_id: rule.id, name };
+            const desc = await txt('Description');
+            if (desc)
+                payload.description = desc;
+            await cmd(post, cfg.orgId, 'create_requirement', payload, 'Creating requirement...');
+            return mReqs(cfg, post);
         }
-        const task = tasks.find((t) => t.id === selected);
-        if (task) {
-            const meta = task.metadata || {};
-            const lines = [
-                `${pad('Name', 14)} ${pc.cyan(task.name || 'Untitled')}`,
-                `${pad('Frequency', 14)} ${meta.frequency || pc.dim('none')}`,
-                `${pad('Assigned to', 14)} ${meta.assigned_to || pc.dim('unassigned')}`,
-                `${pad('ID', 14)} ${pc.dim(task.id)}`,
-            ];
-            p.note(lines.join('\n'), task.name || 'Task');
-            const action = await p.select({
-                message: 'What would you like to do?',
-                options: [
-                    { value: 'complete', label: 'Complete this task' },
-                    { value: 'back', label: pc.dim('Back to menu') },
-                ],
-            });
-            if (action === 'complete' && !p.isCancel(action)) {
-                await doComplete(cfg, post, task.id, task.name);
+        case 'edit': {
+            const req = await pickEntity(post, cfg.orgId, 'requirement', 'requirements');
+            if (!req)
+                return mReqs(cfg, post);
+            const updates = {};
+            const n = await txt('New name (blank to skip)');
+            if (n === null)
+                return mReqs(cfg, post);
+            if (n)
+                updates.name = n;
+            const d = await txt('New description (blank to skip)');
+            if (d)
+                updates.description = d;
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_requirement', { requirement_id: req.id, updates }, 'Updating...');
             }
+            return mReqs(cfg, post);
+        }
+        case 'delete': {
+            const req = await pickEntity(post, cfg.orgId, 'requirement', 'requirements');
+            if (!req)
+                return mReqs(cfg, post);
+            const sure = await yn(`Delete "${req.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_requirement', { requirement_id: req.id }, 'Deleting...');
+            return mReqs(cfg, post);
         }
-        return interactiveMenu(cfg);
-    }
-    catch (err) {
-        s.stop(pc.red('Failed'));
-        p.log.error(err.message || 'Could not load tasks');
-        return interactiveMenu(cfg);
     }
+    return mReqs(cfg, post);
 }
-// ── Status ──────────────────────────────────────────────────────────
-async function menuStatus(cfg, post) {
-    const s = p.spinner();
-    s.start('Loading workspace...');
-    try {
-        const nodes = await getWorkspaceNodes(post, cfg.orgId);
-        s.stop('Workspace loaded');
-        // Count nodes by type
-        const counts = {};
-        for (const node of nodes) {
-            const t = node.type || 'unknown';
-            counts[t] = (counts[t] || 0) + 1;
-        }
-        const lines = [
-            `${pad('Workspace', 16)} ${pc.cyan(cfg.orgName)}`,
-            '',
-            `${pad('Plans', 16)} ${pc.bold(String(counts.plan || 0))}`,
-            `${pad('Tasks', 16)} ${pc.bold(String(counts.task || 0))}`,
-            `${pad('Requirements', 16)} ${pc.bold(String(counts.requirement || 0))}`,
-            `${pad('Goals', 16)} ${pc.bold(String(counts.goal || 0))}`,
-            `${pad('Rules', 16)} ${pc.bold(String(counts.rule || 0))}`,
-            `${pad('Documents', 16)} ${pc.bold(String(counts.document || 0))}`,
-            `${pad('Tables', 16)} ${pc.bold(String(counts.table || 0))}`,
-        ];
-        p.note(lines.join('\n'), 'Workspace Overview');
-    }
-    catch (err) {
-        s.stop(pc.red('Failed'));
-        p.log.error(err.message || 'Could not load workspace');
+// ══════════════════════════════════════════════════════════════════════
+//  DATA TABLES — 7 commands
+// ══════════════════════════════════════════════════════════════════════
+async function mTables(cfg, post) {
+    const a = await sel('Data Tables', [
+        { value: 'list', label: 'View tables' },
+        { value: 'create', label: 'Create a table' },
+        { value: 'edit', label: 'Edit a table' },
+        { value: 'delete', label: 'Delete a table' },
+        { value: 'add-record', label: 'Add a record', hint: 'add data to a table' },
+        { value: 'edit-record', label: 'Edit a record' },
+        { value: 'delete-record', label: 'Delete a record' },
+        { value: 'bulk-delete', label: 'Bulk delete records' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
+        return interactiveMenu(cfg);
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading tables...');
+            const tables = await listEntities(post, cfg.orgId, 'table');
+            s.stop(`${tables.length} tables`);
+            if (tables.length > 0) {
+                const lines = tables.map((t) => `  ${pc.cyan(truncate(t.name || 'Untitled', 50))}  ${pc.dim(t.id)}`);
+                p.note(lines.join('\n'), 'Tables');
+            }
+            return mTables(cfg, post);
+        }
+        case 'create': {
+            const name = await txt('Table name', true);
+            if (!name)
+                return mTables(cfg, post);
+            const desc = await txt('Description');
+            const payload = { name };
+            if (desc)
+                payload.description = desc;
+            // Build schema interactively
+            const fields = [];
+            p.log.info('Define your table columns:');
+            let addMore = true;
+            while (addMore) {
+                const fn = await txt('Column name', true);
+                if (!fn)
+                    break;
+                const ft = await sel('Column type', [
+                    { value: 'text', label: 'Text' }, { value: 'number', label: 'Number' },
+                    { value: 'date', label: 'Date' }, { value: 'select', label: 'Dropdown' },
+                    { value: 'checkbox', label: 'Checkbox' }, { value: 'file', label: 'File' },
+                ]);
+                if (!ft)
+                    break;
+                const req = await yn('Required?');
+                fields.push({ name: fn, type: ft, ...(req ? { required: true } : {}) });
+                addMore = !!(await yn('Add another column?'));
+            }
+            if (fields.length > 0)
+                payload.schema = fields;
+            await cmd(post, cfg.orgId, 'create_table', payload, 'Creating table...');
+            return mTables(cfg, post);
+        }
+        case 'edit': {
+            const table = await pickEntity(post, cfg.orgId, 'table', 'tables');
+            if (!table)
+                return mTables(cfg, post);
+            const updates = {};
+            const n = await txt('New name (blank to skip)');
+            if (n === null)
+                return mTables(cfg, post);
+            if (n)
+                updates.name = n;
+            const d = await txt('New description (blank to skip)');
+            if (d)
+                updates.description = d;
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_table', { table_id: table.id, updates }, 'Updating table...');
+            }
+            return mTables(cfg, post);
+        }
+        case 'delete': {
+            const table = await pickEntity(post, cfg.orgId, 'table', 'tables');
+            if (!table)
+                return mTables(cfg, post);
+            const sure = await yn(`Delete "${table.name}" and all its data? This cannot be undone.`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_table', { table_id: table.id }, 'Deleting table...');
+            return mTables(cfg, post);
+        }
+        case 'add-record': {
+            const table = await pickEntity(post, cfg.orgId, 'table', 'tables');
+            if (!table)
+                return mTables(cfg, post);
+            p.log.info(`Adding record to: ${pc.cyan(table.name)}`);
+            p.log.info(pc.dim('Enter field values. Leave blank to skip optional fields.'));
+            const data = {};
+            // Get schema fields from metadata
+            const schema = table.metadata?.schema || [];
+            if (Array.isArray(schema) && schema.length > 0) {
+                for (const field of schema) {
+                    const val = await txt(`${field.name || field.label || 'Field'}`, !!field.required);
+                    if (val === null)
+                        return mTables(cfg, post);
+                    if (val)
+                        data[field.name || field.label] = val;
+                }
+            }
+            else {
+                p.log.info('Could not load table schema. Enter field name/value pairs:');
+                let addMore = true;
+                while (addMore) {
+                    const fn = await txt('Field name', true);
+                    if (!fn)
+                        break;
+                    const fv = await txt('Value', true);
+                    if (!fv)
+                        break;
+                    data[fn] = fv;
+                    addMore = !!(await yn('Add another field?'));
+                }
+            }
+            if (Object.keys(data).length > 0) {
+                await cmd(post, cfg.orgId, 'create_table_record', { table_id: table.id, data }, 'Adding record...');
+            }
+            return mTables(cfg, post);
+        }
+        case 'edit-record': {
+            const table = await pickEntity(post, cfg.orgId, 'table', 'tables');
+            if (!table)
+                return mTables(cfg, post);
+            const record = await pickEntity(post, cfg.orgId, 'table_record', 'records', { table_id: table.id });
+            if (!record)
+                return mTables(cfg, post);
+            const updates = {};
+            let addMore = true;
+            while (addMore) {
+                const fn = await txt('Field to update');
+                if (!fn)
+                    break;
+                const fv = await txt('New value', true);
+                if (!fv)
+                    break;
+                updates[fn] = fv;
+                addMore = !!(await yn('Update another field?'));
+            }
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_table_record', { record_id: record.id, updates }, 'Updating record...');
+            }
+            return mTables(cfg, post);
+        }
+        case 'delete-record': {
+            const table = await pickEntity(post, cfg.orgId, 'table', 'tables');
+            if (!table)
+                return mTables(cfg, post);
+            const record = await pickEntity(post, cfg.orgId, 'table_record', 'records', { table_id: table.id });
+            if (!record)
+                return mTables(cfg, post);
+            const sure = await yn('Delete this record?');
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_table_record', { record_id: record.id }, 'Deleting record...');
+            return mTables(cfg, post);
+        }
+        case 'bulk-delete': {
+            const table = await pickEntity(post, cfg.orgId, 'table', 'tables');
+            if (!table)
+                return mTables(cfg, post);
+            const ids = await txt('Record IDs to delete (comma-separated)', true);
+            if (!ids)
+                return mTables(cfg, post);
+            const recordIds = ids.split(',').map(s => s.trim()).filter(Boolean);
+            const sure = await yn(`Delete ${recordIds.length} records? This cannot be undone.`);
+            if (sure) {
+                await cmd(post, cfg.orgId, 'bulk_delete_table_records', { table_id: table.id, record_ids: recordIds }, 'Deleting records...');
+            }
+            return mTables(cfg, post);
+        }
     }
-    return interactiveMenu(cfg);
+    return mTables(cfg, post);
 }
-// ── Search ──────────────────────────────────────────────────────────
-async function menuSearch(cfg, post) {
-    const query = await p.text({
-        message: 'Search for...',
-        placeholder: 'task name, plan, document...',
-        validate: (v) => {
-            if (!v)
-                return 'Enter a search term';
-        },
-    });
-    if (p.isCancel(query))
+// ══════════════════════════════════════════════════════════════════════
+//  DOCUMENTS — 6 commands
+// ══════════════════════════════════════════════════════════════════════
+async function mDocs(cfg, post) {
+    const a = await sel('Documents', [
+        { value: 'list', label: 'View documents' },
+        { value: 'create', label: 'Create a document or folder' },
+        { value: 'edit', label: 'Edit a document' },
+        { value: 'delete', label: 'Delete a document' },
+        { value: 'attach', label: 'Attach files', hint: 'upload files to a document' },
+        { value: 'edit-file', label: 'Edit a file attachment' },
+        { value: 'delete-file', label: 'Remove a file attachment' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
         return interactiveMenu(cfg);
-    const s = p.spinner();
-    s.start('Searching...');
-    try {
-        const entities = await searchEntities(post, cfg.orgId, query);
-        s.stop(`Found ${entities.length} result${entities.length === 1 ? '' : 's'}`);
-        if (entities.length === 0) {
-            p.log.info('No results found.');
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading documents...');
+            const docs = await listEntities(post, cfg.orgId, 'document');
+            s.stop(`${docs.length} documents`);
+            if (docs.length > 0) {
+                const lines = docs.map((d) => `  ${pc.cyan(truncate(d.name || 'Untitled', 50))}  ${pc.dim(d.id)}`);
+                p.note(lines.join('\n'), 'Documents');
+            }
+            return mDocs(cfg, post);
+        }
+        case 'create': {
+            const name = await txt('Name', true);
+            if (!name)
+                return mDocs(cfg, post);
+            const isFolder = await yn('Is this a folder?');
+            const payload = { name };
+            if (isFolder)
+                payload.is_folder = true;
+            const url = isFolder ? null : await txt('File URL (blank to skip)');
+            if (url)
+                payload.file_url = url;
+            await cmd(post, cfg.orgId, 'create_document', payload, 'Creating...');
+            return mDocs(cfg, post);
+        }
+        case 'edit': {
+            const doc = await pickEntity(post, cfg.orgId, 'document', 'documents');
+            if (!doc)
+                return mDocs(cfg, post);
+            const updates = {};
+            const n = await txt('New name (blank to skip)');
+            if (n === null)
+                return mDocs(cfg, post);
+            if (n)
+                updates.name = n;
+            const url = await txt('New file URL (blank to skip)');
+            if (url)
+                updates.file_url = url;
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_document', { document_id: doc.id, updates }, 'Updating...');
+            }
+            return mDocs(cfg, post);
+        }
+        case 'delete': {
+            const doc = await pickEntity(post, cfg.orgId, 'document', 'documents');
+            if (!doc)
+                return mDocs(cfg, post);
+            const sure = await yn(`Delete "${doc.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_document', { document_id: doc.id }, 'Deleting...');
+            return mDocs(cfg, post);
+        }
+        case 'attach': {
+            const doc = await pickEntity(post, cfg.orgId, 'document', 'documents');
+            if (!doc)
+                return mDocs(cfg, post);
+            const entries = [];
+            let addMore = true;
+            while (addMore) {
+                const url = await txt('File URL', true);
+                if (!url)
+                    break;
+                const name = await txt('File name (blank for auto)');
+                entries.push({ document_url: url, ...(name ? { name } : {}) });
+                addMore = !!(await yn('Attach another file?'));
+            }
+            if (entries.length > 0) {
+                await cmd(post, cfg.orgId, 'create_document_completion', { document_id: doc.id, entries }, 'Attaching files...');
+            }
+            return mDocs(cfg, post);
+        }
+        case 'edit-file': {
+            const comp = await pickEntity(post, cfg.orgId, 'document_completion', 'file attachments');
+            if (!comp)
+                return mDocs(cfg, post);
+            const updates = {};
+            const n = await txt('New file name (blank to skip)');
+            if (n)
+                updates.name = n;
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_document_completion', { completion_id: comp.id, updates }, 'Updating...');
+            }
+            return mDocs(cfg, post);
         }
-        else {
-            const lines = entities.map((e) => {
-                const type = pad(e.entity_type || 'unknown', 14);
-                const name = truncate(e.name || 'Untitled', 50);
-                return `  ${pc.dim(type)} ${pc.cyan(name)}`;
-            });
-            p.note(lines.join('\n'), `Results for "${query}"`);
+        case 'delete-file': {
+            const comp = await pickEntity(post, cfg.orgId, 'document_completion', 'file attachments');
+            if (!comp)
+                return mDocs(cfg, post);
+            const sure = await yn('Remove this file attachment?');
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_document_completion', { completion_id: comp.id }, 'Removing...');
+            return mDocs(cfg, post);
         }
     }
-    catch (err) {
-        s.stop(pc.red('Failed'));
-        p.log.error(err.message || 'Search failed');
+    return mDocs(cfg, post);
+}
+// ══════════════════════════════════════════════════════════════════════
+//  ASSETS — photos (3) + geolocation (3) + checklists (3) = 9 commands
+// ══════════════════════════════════════════════════════════════════════
+async function mAssets(cfg, post) {
+    const a = await sel('Assets', [
+        { value: 'photos', label: 'Photos', hint: 'photo validation assets' },
+        { value: 'locations', label: 'Locations', hint: 'geofenced areas for check-ins' },
+        { value: 'checklists', label: 'Checklists', hint: 'checklist templates' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
+        return interactiveMenu(cfg);
+    switch (a) {
+        case 'photos': return mPhotos(cfg, post);
+        case 'locations': return mGeo(cfg, post);
+        case 'checklists': return mChecklists(cfg, post);
     }
-    return interactiveMenu(cfg);
+    return mAssets(cfg, post);
 }
-// ── Complete Task ───────────────────────────────────────────────────
-async function menuComplete(cfg, post) {
-    const s = p.spinner();
-    s.start('Loading tasks...');
-    try {
-        const tasks = await listEntities(post, cfg.orgId, 'task');
-        s.stop(`${tasks.length} task${tasks.length === 1 ? '' : 's'} available`);
-        if (tasks.length === 0) {
-            p.log.info('No tasks to complete.');
-            return interactiveMenu(cfg);
+async function mPhotos(cfg, post) {
+    const a = await sel('Photos', [
+        { value: 'list', label: 'View photo assets' },
+        { value: 'create', label: 'Create a photo asset' },
+        { value: 'edit', label: 'Edit a photo asset' },
+        { value: 'delete', label: 'Delete a photo asset' },
+        { value: '__back', label: pc.dim('\u2190 Back') },
+    ]);
+    if (!a || a === '__back')
+        return mAssets(cfg, post);
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading...');
+            const items = await listEntities(post, cfg.orgId, 'photo');
+            s.stop(`${items.length} photo assets`);
+            if (items.length > 0) {
+                const lines = items.map((i) => `  ${pc.cyan(i.name || 'Untitled')}`);
+                p.note(lines.join('\n'), 'Photos');
+            }
+            return mPhotos(cfg, post);
         }
-        const selected = await p.select({
-            message: 'Which task did you complete?',
-            options: [
-                ...tasks.slice(0, 30).map((t) => ({
-                    value: t.id,
-                    label: truncate(t.name || 'Untitled', 60),
-                    hint: t.metadata?.frequency || '',
-                })),
-                { value: '__back', label: pc.dim('Back to menu') },
-            ],
-        });
-        if (p.isCancel(selected) || selected === '__back') {
-            return interactiveMenu(cfg);
+        case 'create': {
+            const name = await txt('Photo asset name', true);
+            if (!name)
+                return mPhotos(cfg, post);
+            const desc = await txt('Description');
+            const payload = { name };
+            if (desc)
+                payload.description = desc;
+            await cmd(post, cfg.orgId, 'create_photo', payload, 'Creating...');
+            return mPhotos(cfg, post);
+        }
+        case 'edit': {
+            const photo = await pickEntity(post, cfg.orgId, 'photo', 'photo assets');
+            if (!photo)
+                return mPhotos(cfg, post);
+            const updates = {};
+            const n = await txt('New name (blank to skip)');
+            if (n)
+                updates.name = n;
+            const d = await txt('New description (blank to skip)');
+            if (d)
+                updates.description = d;
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_photo', { photo_id: photo.id, updates }, 'Updating...');
+            }
+            return mPhotos(cfg, post);
+        }
+        case 'delete': {
+            const photo = await pickEntity(post, cfg.orgId, 'photo', 'photo assets');
+            if (!photo)
+                return mPhotos(cfg, post);
+            const sure = await yn(`Delete "${photo.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_photo', { photo_id: photo.id }, 'Deleting...');
+            return mPhotos(cfg, post);
         }
-        const task = tasks.find((t) => t.id === selected);
-        await doComplete(cfg, post, selected, task?.name || '');
     }
-    catch (err) {
-        s.stop(pc.red('Failed'));
-        p.log.error(err.message || 'Could not load tasks');
+    return mPhotos(cfg, post);
+}
+async function mGeo(cfg, post) {
+    const a = await sel('Locations', [
+        { value: 'list', label: 'View location areas' },
+        { value: 'create', label: 'Create a location area' },
+        { value: 'edit', label: 'Edit a location area' },
+        { value: 'delete', label: 'Delete a location area' },
+        { value: '__back', label: pc.dim('\u2190 Back') },
+    ]);
+    if (!a || a === '__back')
+        return mAssets(cfg, post);
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading...');
+            const items = await listEntities(post, cfg.orgId, 'geolocation_area');
+            s.stop(`${items.length} location areas`);
+            if (items.length > 0) {
+                const lines = items.map((i) => `  ${pc.cyan(i.name || 'Untitled')}`);
+                p.note(lines.join('\n'), 'Location Areas');
+            }
+            return mGeo(cfg, post);
+        }
+        case 'create': {
+            const label = await txt('Area name', true, 'e.g. Main warehouse');
+            if (!label)
+                return mGeo(cfg, post);
+            const lat = await txt('Latitude', true, 'e.g. 25.7617');
+            if (!lat)
+                return mGeo(cfg, post);
+            const lng = await txt('Longitude', true, 'e.g. -80.1918');
+            if (!lng)
+                return mGeo(cfg, post);
+            const radius = await txt('Radius in meters', true, '100');
+            if (!radius)
+                return mGeo(cfg, post);
+            await cmd(post, cfg.orgId, 'create_geolocation_area', {
+                label, latitude: parseFloat(lat), longitude: parseFloat(lng), radius: parseFloat(radius),
+            }, 'Creating location area...');
+            return mGeo(cfg, post);
+        }
+        case 'edit': {
+            const area = await pickEntity(post, cfg.orgId, 'geolocation_area', 'location areas');
+            if (!area)
+                return mGeo(cfg, post);
+            const updates = {};
+            const n = await txt('New name (blank to skip)');
+            if (n)
+                updates.label = n;
+            const lat = await txt('New latitude (blank to skip)');
+            if (lat)
+                updates.latitude = parseFloat(lat);
+            const lng = await txt('New longitude (blank to skip)');
+            if (lng)
+                updates.longitude = parseFloat(lng);
+            const r = await txt('New radius (blank to skip)');
+            if (r)
+                updates.radius = parseFloat(r);
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_geolocation_area', { area_id: area.id, updates }, 'Updating...');
+            }
+            return mGeo(cfg, post);
+        }
+        case 'delete': {
+            const area = await pickEntity(post, cfg.orgId, 'geolocation_area', 'location areas');
+            if (!area)
+                return mGeo(cfg, post);
+            const sure = await yn(`Delete "${area.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_geolocation_area', { area_id: area.id }, 'Deleting...');
+            return mGeo(cfg, post);
+        }
     }
-    return interactiveMenu(cfg);
+    return mGeo(cfg, post);
 }
-async function doComplete(cfg, post, taskId, taskName) {
-    const s = p.spinner();
-    s.start('Completing task...');
-    try {
-        await post('/api/v2/commands', {
-            type: 'complete_task',
-            organization_id: cfg.orgId,
-            payload: { task_id: taskId },
-        });
-        s.stop(pc.green(`Done! "${taskName}" completed`));
+async function mChecklists(cfg, post) {
+    const a = await sel('Checklists', [
+        { value: 'list', label: 'View checklists' },
+        { value: 'create', label: 'Create a checklist' },
+        { value: 'edit', label: 'Edit a checklist' },
+        { value: 'delete', label: 'Delete a checklist' },
+        { value: '__back', label: pc.dim('\u2190 Back') },
+    ]);
+    if (!a || a === '__back')
+        return mAssets(cfg, post);
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading...');
+            const items = await listEntities(post, cfg.orgId, 'checklist');
+            s.stop(`${items.length} checklists`);
+            if (items.length > 0) {
+                const lines = items.map((i) => `  ${pc.cyan(i.name || 'Untitled')}`);
+                p.note(lines.join('\n'), 'Checklists');
+            }
+            return mChecklists(cfg, post);
+        }
+        case 'create': {
+            const name = await txt('Checklist name', true);
+            if (!name)
+                return mChecklists(cfg, post);
+            const desc = await txt('Description');
+            const items = [];
+            p.log.info('Add checklist items:');
+            let addMore = true;
+            while (addMore) {
+                const item = await txt('Item', true);
+                if (!item)
+                    break;
+                items.push(item);
+                addMore = !!(await yn('Add another item?'));
+            }
+            const payload = { name, items };
+            if (desc)
+                payload.description = desc;
+            await cmd(post, cfg.orgId, 'create_checklist', payload, 'Creating checklist...');
+            return mChecklists(cfg, post);
+        }
+        case 'edit': {
+            const cl = await pickEntity(post, cfg.orgId, 'checklist', 'checklists');
+            if (!cl)
+                return mChecklists(cfg, post);
+            const updates = {};
+            const n = await txt('New name (blank to skip)');
+            if (n)
+                updates.name = n;
+            const d = await txt('New description (blank to skip)');
+            if (d)
+                updates.description = d;
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_checklist', { checklist_id: cl.id, updates }, 'Updating...');
+            }
+            return mChecklists(cfg, post);
+        }
+        case 'delete': {
+            const cl = await pickEntity(post, cfg.orgId, 'checklist', 'checklists');
+            if (!cl)
+                return mChecklists(cfg, post);
+            const sure = await yn(`Delete "${cl.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_checklist', { checklist_id: cl.id }, 'Deleting...');
+            return mChecklists(cfg, post);
+        }
     }
-    catch (err) {
-        s.stop(pc.red('Failed'));
-        p.log.error(err.message || 'Could not complete task');
+    return mChecklists(cfg, post);
+}
+// ══════════════════════════════════════════════════════════════════════
+//  RULES & AUTOMATION — validation rules (4) + trigger rules (3)
+// ══════════════════════════════════════════════════════════════════════
+async function mAutomation(cfg, post) {
+    const a = await sel('Rules & Automation', [
+        { value: 'val-list', label: 'View validation rules' },
+        { value: 'val-create', label: 'Create a validation rule', hint: 'require proof for a task' },
+        { value: 'val-edit', label: 'Edit a validation rule' },
+        { value: 'val-batch', label: 'Reorder validation rules' },
+        { value: 'val-delete', label: 'Delete a validation rule' },
+        { value: 'trig-list', label: 'View trigger rules' },
+        { value: 'trig-create', label: 'Create a trigger rule', hint: 'automate task activation' },
+        { value: 'trig-edit', label: 'Edit a trigger rule' },
+        { value: 'trig-delete', label: 'Delete a trigger rule' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
+        return interactiveMenu(cfg);
+    switch (a) {
+        case 'val-list': {
+            const s = p.spinner();
+            s.start('Loading...');
+            const items = await listEntities(post, cfg.orgId, 'validation_rule');
+            s.stop(`${items.length} validation rules`);
+            if (items.length > 0) {
+                const lines = items.map((i) => `  ${pc.cyan(truncate(i.name || 'Untitled', 50))}  ${pc.dim(i.metadata?.rule_type || '')}`);
+                p.note(lines.join('\n'), 'Validation Rules');
+            }
+            return mAutomation(cfg, post);
+        }
+        case 'val-create': {
+            const task = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (!task)
+                return mAutomation(cfg, post);
+            const name = await txt('Rule name', true, 'e.g. Require photo proof');
+            if (!name)
+                return mAutomation(cfg, post);
+            const ruleType = await sel('Rule type', [
+                { value: 'proof_required', label: 'Proof required', hint: 'photo, document, location, etc.' },
+                { value: 'field_constraint', label: 'Field constraint', hint: 'validate a data field' },
+                { value: 'approval_required', label: 'Approval required', hint: 'needs manager sign-off' },
+                { value: 'time_window', label: 'Time window', hint: 'must be done within a time range' },
+                { value: 'record_exists', label: 'Record exists', hint: 'verify data was entered' },
+                { value: 'cross_field', label: 'Cross-field validation' },
+                { value: 'aggregate', label: 'Aggregate check' },
+            ]);
+            if (!ruleType)
+                return mAutomation(cfg, post);
+            const condition = {};
+            if (ruleType === 'proof_required') {
+                const proofType = await sel('What kind of proof?', [
+                    { value: 'photo', label: 'Photo' }, { value: 'document', label: 'Document' },
+                    { value: 'geolocation', label: 'Location' }, { value: 'checklist', label: 'Checklist' },
+                ]);
+                if (proofType)
+                    condition.proof_type = proofType;
+            }
+            else if (ruleType === 'time_window') {
+                const start = await txt('Start time (HH:MM)', false, '08:00');
+                const end = await txt('End time (HH:MM)', false, '17:00');
+                if (start)
+                    condition.start_time = start;
+                if (end)
+                    condition.end_time = end;
+            }
+            await cmd(post, cfg.orgId, 'create_validation_rule', {
+                task_id: task.id, name, rule_type: ruleType, condition,
+            }, 'Creating validation rule...');
+            return mAutomation(cfg, post);
+        }
+        case 'val-edit': {
+            const rule = await pickEntity(post, cfg.orgId, 'validation_rule', 'validation rules');
+            if (!rule)
+                return mAutomation(cfg, post);
+            const updates = {};
+            const n = await txt('New name (blank to skip)');
+            if (n)
+                updates.name = n;
+            const enabled = await sel('Status', [
+                { value: '__skip', label: pc.dim('Keep current') },
+                { value: 'true', label: 'Enabled' }, { value: 'false', label: 'Disabled' },
+            ]);
+            if (enabled && enabled !== '__skip')
+                updates.enabled = enabled === 'true';
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_validation_rule', { id: rule.id, updates }, 'Updating...');
+            }
+            return mAutomation(cfg, post);
+        }
+        case 'val-batch': {
+            const task = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (!task)
+                return mAutomation(cfg, post);
+            const s = p.spinner();
+            s.start('Loading rules...');
+            const rules = await listEntities(post, cfg.orgId, 'validation_rule', { task_id: task.id });
+            s.stop(`${rules.length} rules`);
+            if (rules.length === 0) {
+                p.log.info('No validation rules for this task.');
+                return mAutomation(cfg, post);
+            }
+            const batch = [];
+            for (let i = 0; i < rules.length; i++) {
+                const r = rules[i];
+                p.log.info(`${i + 1}. ${r.name || 'Untitled'}`);
+                const pos = await txt(`New position for "${r.name}" (blank to keep ${i + 1})`);
+                if (pos)
+                    batch.push({ id: r.id, updates: { position: parseInt(pos, 10) } });
+            }
+            if (batch.length > 0) {
+                await cmd(post, cfg.orgId, 'batch_update_validation_rules', { batch }, 'Updating order...');
+            }
+            return mAutomation(cfg, post);
+        }
+        case 'val-delete': {
+            const rule = await pickEntity(post, cfg.orgId, 'validation_rule', 'validation rules');
+            if (!rule)
+                return mAutomation(cfg, post);
+            const sure = await yn(`Delete "${rule.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_validation_rule', { id: rule.id }, 'Deleting...');
+            return mAutomation(cfg, post);
+        }
+        case 'trig-list': {
+            const s = p.spinner();
+            s.start('Loading...');
+            const items = await listEntities(post, cfg.orgId, 'trigger_rule');
+            s.stop(`${items.length} trigger rules`);
+            if (items.length > 0) {
+                const lines = items.map((i) => `  ${pc.cyan(truncate(i.name || 'Untitled', 50))}  ${pc.dim(i.metadata?.event_type || '')}`);
+                p.note(lines.join('\n'), 'Trigger Rules');
+            }
+            return mAutomation(cfg, post);
+        }
+        case 'trig-create': {
+            const task = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+            if (!task)
+                return mAutomation(cfg, post);
+            const name = await txt('Trigger name', true, 'e.g. Activate when record added');
+            if (!name)
+                return mAutomation(cfg, post);
+            const eventType = await sel('What triggers this?', [
+                { value: 'record_created', label: 'New record added to a table' },
+                { value: 'record_updated', label: 'Record updated in a table' },
+                { value: 'task_completed', label: 'Another task completed' },
+                { value: 'task_missed', label: 'A task was missed' },
+                { value: 'approval_resolved', label: 'An approval was resolved' },
+            ]);
+            if (!eventType)
+                return mAutomation(cfg, post);
+            const sourceType = await sel('Source type', [
+                { value: 'table', label: 'Table' }, { value: 'task', label: 'Task' },
+                { value: 'approval', label: 'Approval' },
+            ]);
+            if (!sourceType)
+                return mAutomation(cfg, post);
+            const payload = { task_id: task.id, name, event_type: eventType, source_entity_type: sourceType };
+            const source = await pickEntity(post, cfg.orgId, sourceType, `${sourceType}s`);
+            if (source)
+                payload.source_entity_id = source.id;
+            await cmd(post, cfg.orgId, 'create_trigger_rule', payload, 'Creating trigger rule...');
+            return mAutomation(cfg, post);
+        }
+        case 'trig-edit': {
+            const rule = await pickEntity(post, cfg.orgId, 'trigger_rule', 'trigger rules');
+            if (!rule)
+                return mAutomation(cfg, post);
+            const updates = {};
+            const n = await txt('New name (blank to skip)');
+            if (n)
+                updates.name = n;
+            const enabled = await sel('Status', [
+                { value: '__skip', label: pc.dim('Keep current') },
+                { value: 'true', label: 'Enabled' }, { value: 'false', label: 'Disabled' },
+            ]);
+            if (enabled && enabled !== '__skip')
+                updates.enabled = enabled === 'true';
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_trigger_rule', { id: rule.id, updates }, 'Updating...');
+            }
+            return mAutomation(cfg, post);
+        }
+        case 'trig-delete': {
+            const rule = await pickEntity(post, cfg.orgId, 'trigger_rule', 'trigger rules');
+            if (!rule)
+                return mAutomation(cfg, post);
+            const sure = await yn(`Delete "${rule.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_trigger_rule', { id: rule.id }, 'Deleting...');
+            return mAutomation(cfg, post);
+        }
     }
+    return mAutomation(cfg, post);
 }
-// ── Create Task ─────────────────────────────────────────────────────
-async function menuCreateTask(cfg, post) {
-    const s = p.spinner();
-    s.start('Loading plans...');
-    let plans = [];
-    try {
-        plans = await listEntities(post, cfg.orgId, 'plan');
-        s.stop('');
+// ══════════════════════════════════════════════════════════════════════
+//  DASHBOARDS & SHARING — dashboards (3) + shares (5) = 8 commands
+// ══════════════════════════════════════════════════════════════════════
+async function mDashboards(cfg, post) {
+    const a = await sel('Dashboards & Sharing', [
+        { value: 'list', label: 'View dashboards' },
+        { value: 'create', label: 'Create a dashboard' },
+        { value: 'edit', label: 'Edit a dashboard' },
+        { value: 'delete', label: 'Delete a dashboard' },
+        { value: 'share', label: 'Share a dashboard', hint: 'public link, password, invite' },
+        { value: 'unshare', label: 'Stop sharing a dashboard' },
+        { value: 'invite', label: 'Invite people to a shared dashboard' },
+        { value: 'uninvite', label: 'Remove an invite' },
+        { value: 'regen', label: 'Regenerate share link' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
+        return interactiveMenu(cfg);
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading dashboards...');
+            const items = await listEntities(post, cfg.orgId, 'dashboard');
+            s.stop(`${items.length} dashboards`);
+            if (items.length > 0) {
+                const lines = items.map((d) => `  ${pc.cyan(truncate(d.name || 'Untitled', 50))}  ${pc.dim(d.id)}`);
+                p.note(lines.join('\n'), 'Dashboards');
+            }
+            return mDashboards(cfg, post);
+        }
+        case 'create': {
+            const title = await txt('Dashboard title', true);
+            if (!title)
+                return mDashboards(cfg, post);
+            const desc = await txt('Description');
+            const payload = { title };
+            if (desc)
+                payload.description = desc;
+            await cmd(post, cfg.orgId, 'create_dashboard', payload, 'Creating dashboard...');
+            return mDashboards(cfg, post);
+        }
+        case 'edit': {
+            const dash = await pickEntity(post, cfg.orgId, 'dashboard', 'dashboards');
+            if (!dash)
+                return mDashboards(cfg, post);
+            const updates = {};
+            const t = await txt('New title (blank to skip)');
+            if (t)
+                updates.title = t;
+            const d = await txt('New description (blank to skip)');
+            if (d)
+                updates.description = d;
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_dashboard', { dashboard_id: dash.id, updates }, 'Updating...');
+            }
+            return mDashboards(cfg, post);
+        }
+        case 'delete': {
+            const dash = await pickEntity(post, cfg.orgId, 'dashboard', 'dashboards');
+            if (!dash)
+                return mDashboards(cfg, post);
+            const sure = await yn(`Delete "${dash.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_dashboard', { dashboard_id: dash.id }, 'Deleting...');
+            return mDashboards(cfg, post);
+        }
+        case 'share': {
+            const dash = await pickEntity(post, cfg.orgId, 'dashboard', 'dashboards');
+            if (!dash)
+                return mDashboards(cfg, post);
+            const shareType = await sel('How should this be shared?', [
+                { value: 'public', label: 'Public link', hint: 'anyone with the link can view' },
+                { value: 'password', label: 'Password protected' },
+                { value: 'login', label: 'Login required', hint: 'must be signed in' },
+                { value: 'invite', label: 'Invite only', hint: 'only invited emails' },
+            ]);
+            if (!shareType)
+                return mDashboards(cfg, post);
+            const payload = { dashboard_id: dash.id, share_type: shareType };
+            if (shareType === 'password') {
+                const pw = await txt('Set a password', true);
+                if (pw)
+                    payload.password = pw;
+            }
+            const branding = await sel('Branding', [
+                { value: 'branded', label: 'Show your logo and colors' },
+                { value: 'minimal', label: 'Minimal / clean' },
+            ]);
+            if (branding)
+                payload.branding_mode = branding;
+            await cmd(post, cfg.orgId, 'upsert_dashboard_share', payload, 'Setting up sharing...');
+            return mDashboards(cfg, post);
+        }
+        case 'unshare': {
+            const dash = await pickEntity(post, cfg.orgId, 'dashboard', 'dashboards');
+            if (!dash)
+                return mDashboards(cfg, post);
+            const sure = await yn(`Stop sharing "${dash.name}"? Anyone with the link will lose access.`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_dashboard_share', { dashboard_id: dash.id }, 'Revoking share...');
+            return mDashboards(cfg, post);
+        }
+        case 'invite': {
+            const dash = await pickEntity(post, cfg.orgId, 'dashboard', 'dashboards');
+            if (!dash)
+                return mDashboards(cfg, post);
+            const emailsRaw = await txt('Email addresses (comma-separated)', true);
+            if (!emailsRaw)
+                return mDashboards(cfg, post);
+            const emails = emailsRaw.split(',').map(e => e.trim()).filter(Boolean);
+            await cmd(post, cfg.orgId, 'invite_dashboard_share', { dashboard_id: dash.id, emails }, 'Sending invitations...');
+            return mDashboards(cfg, post);
+        }
+        case 'uninvite': {
+            const dash = await pickEntity(post, cfg.orgId, 'dashboard', 'dashboards');
+            if (!dash)
+                return mDashboards(cfg, post);
+            const inviteId = await txt('Invite ID to remove', true);
+            if (!inviteId)
+                return mDashboards(cfg, post);
+            await cmd(post, cfg.orgId, 'delete_dashboard_share_invite', { dashboard_id: dash.id, invite_id: inviteId }, 'Removing invite...');
+            return mDashboards(cfg, post);
+        }
+        case 'regen': {
+            const dash = await pickEntity(post, cfg.orgId, 'dashboard', 'dashboards');
+            if (!dash)
+                return mDashboards(cfg, post);
+            const sure = await yn('Regenerate the share link? The old link will stop working.');
+            if (sure)
+                await cmd(post, cfg.orgId, 'regenerate_dashboard_share', { dashboard_id: dash.id }, 'Regenerating link...');
+            return mDashboards(cfg, post);
+        }
     }
-    catch {
-        s.stop('');
+    return mDashboards(cfg, post);
+}
+// ══════════════════════════════════════════════════════════════════════
+//  FORMS — 3 commands
+// ══════════════════════════════════════════════════════════════════════
+async function mForms(cfg, post) {
+    const a = await sel('Public Forms', [
+        { value: 'list', label: 'View forms' },
+        { value: 'create', label: 'Create a form' },
+        { value: 'edit', label: 'Edit a form' },
+        { value: 'delete', label: 'Delete a form' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
+        return interactiveMenu(cfg);
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading forms...');
+            const items = await listEntities(post, cfg.orgId, 'public_form');
+            s.stop(`${items.length} forms`);
+            if (items.length > 0) {
+                const lines = items.map((f) => `  ${pc.cyan(truncate(f.name || 'Untitled', 50))}  ${pc.dim(f.id)}`);
+                p.note(lines.join('\n'), 'Forms');
+            }
+            return mForms(cfg, post);
+        }
+        case 'create': {
+            const table = await pickEntity(post, cfg.orgId, 'table', 'tables');
+            if (!table)
+                return mForms(cfg, post);
+            const title = await txt('Form title', true);
+            if (!title)
+                return mForms(cfg, post);
+            const payload = { table_id: table.id, title };
+            const desc = await txt('Description');
+            if (desc)
+                payload.description = desc;
+            const access = await sel('Who can see submitted data?', [
+                { value: 'own', label: 'Only their own submissions' },
+                { value: 'all', label: 'All submissions' },
+                { value: 'none', label: 'No one (admin only)' },
+            ]);
+            if (access)
+                payload.submission_access = access;
+            const share = await sel('Sharing', [
+                { value: 'public', label: 'Public link' },
+                { value: 'password', label: 'Password protected' },
+                { value: 'invite', label: 'Invite only' },
+            ]);
+            if (share)
+                payload.share_type = share;
+            if (share === 'password') {
+                const pw = await txt('Password', true);
+                if (pw)
+                    payload.password = pw;
+            }
+            await cmd(post, cfg.orgId, 'create_public_form', payload, 'Creating form...');
+            return mForms(cfg, post);
+        }
+        case 'edit': {
+            const form = await pickEntity(post, cfg.orgId, 'public_form', 'forms');
+            if (!form)
+                return mForms(cfg, post);
+            const updates = {};
+            const t = await txt('New title (blank to skip)');
+            if (t)
+                updates.title = t;
+            const d = await txt('New description (blank to skip)');
+            if (d)
+                updates.description = d;
+            const active = await sel('Active?', [
+                { value: '__skip', label: pc.dim('Keep current') },
+                { value: 'true', label: 'Active (accepting submissions)' },
+                { value: 'false', label: 'Inactive (closed)' },
+            ]);
+            if (active && active !== '__skip')
+                updates.is_active = active === 'true';
+            if (Object.keys(updates).length > 0) {
+                await cmd(post, cfg.orgId, 'update_public_form', { form_id: form.id, updates }, 'Updating form...');
+            }
+            return mForms(cfg, post);
+        }
+        case 'delete': {
+            const form = await pickEntity(post, cfg.orgId, 'public_form', 'forms');
+            if (!form)
+                return mForms(cfg, post);
+            const sure = await yn(`Delete "${form.name}"?`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'delete_public_form', { form_id: form.id }, 'Deleting form...');
+            return mForms(cfg, post);
+        }
     }
-    const result = await p.group({
-        name: () => p.text({
-            message: 'Task name',
-            placeholder: 'e.g. Daily safety walkthrough',
-            validate: (v) => {
-                if (!v)
-                    return 'Task name is required';
-            },
-        }),
-        planId: () => {
-            if (plans.length === 0)
-                return Promise.resolve(undefined);
-            return p.select({
-                message: 'Add to which plan?',
-                options: [
-                    { value: undefined, label: pc.dim('No plan (standalone task)') },
-                    ...plans.map((plan) => ({
-                        value: plan.id,
-                        label: plan.name || 'Untitled',
-                    })),
-                ],
-            });
-        },
-        frequency: () => p.select({
-            message: 'How often?',
-            options: [
-                { value: 'daily', label: 'Daily' },
-                { value: 'weekly', label: 'Weekly' },
-                { value: 'monthly', label: 'Monthly' },
-                { value: 'one-time', label: 'One-time' },
-            ],
-        }),
-    }, {
-        onCancel: () => {
-            p.cancel('Cancelled.');
-            return;
-        },
-    });
-    if (!result.name)
+    return mForms(cfg, post);
+}
+// ══════════════════════════════════════════════════════════════════════
+//  APPROVALS — resolve_approval + list_approvals query
+// ══════════════════════════════════════════════════════════════════════
+async function mApprovals(cfg, post) {
+    const a = await sel('Approvals', [
+        { value: 'list', label: 'View pending approvals' },
+        { value: 'all', label: 'View all approvals', hint: 'including resolved' },
+        { value: 'resolve', label: 'Approve or reject' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
         return interactiveMenu(cfg);
-    const spinner = p.spinner();
-    spinner.start('Creating task...');
-    try {
-        const payload = {
-            name: result.name,
-            organization_id: cfg.orgId,
-            frequency: result.frequency || 'daily',
-        };
-        if (result.planId)
-            payload.plan_id = result.planId;
-        await post('/api/v2/commands', {
-            type: 'create_task',
-            organization_id: cfg.orgId,
-            payload,
-        });
-        spinner.stop(pc.green(`Task "${result.name}" created!`));
+    switch (a) {
+        case 'list': {
+            const s = p.spinner();
+            s.start('Loading approvals...');
+            const res = await qry(post, cfg.orgId, 'list_approvals', { status: 'pending' });
+            const items = Array.isArray(res?.data) ? res.data : [];
+            s.stop(`${items.length} pending approvals`);
+            if (items.length > 0) {
+                const lines = items.map((ap) => {
+                    const target = ap.target_name || ap.target_id || '';
+                    return `  ${pc.yellow('\u25CB')} ${pc.cyan(truncate(target, 40))}  ${pc.dim(ap.id)}`;
+                });
+                p.note(lines.join('\n'), 'Pending Approvals');
+            }
+            return mApprovals(cfg, post);
+        }
+        case 'all': {
+            const s = p.spinner();
+            s.start('Loading approvals...');
+            const res = await qry(post, cfg.orgId, 'list_approvals', { status: 'all' });
+            const items = Array.isArray(res?.data) ? res.data : [];
+            s.stop(`${items.length} approvals`);
+            if (items.length > 0) {
+                const lines = items.map((ap) => {
+                    const icon = ap.status === 'approved' ? pc.green('\u2713') : ap.status === 'rejected' ? pc.red('\u2717') : pc.yellow('\u25CB');
+                    const target = ap.target_name || ap.target_id || '';
+                    return `  ${icon} ${pc.cyan(truncate(target, 40))}  ${pc.dim(ap.status || '')}`;
+                });
+                p.note(lines.join('\n'), 'All Approvals');
+            }
+            return mApprovals(cfg, post);
+        }
+        case 'resolve': {
+            const approval = await pickEntity(post, cfg.orgId, 'approval', 'approvals');
+            if (!approval)
+                return mApprovals(cfg, post);
+            const resolution = await sel('Decision', [
+                { value: 'approved', label: 'Approve' },
+                { value: 'rejected', label: 'Reject' },
+            ]);
+            if (!resolution)
+                return mApprovals(cfg, post);
+            const note = await txt('Add a note (optional)');
+            const payload = { approval_id: approval.id, resolution };
+            if (note)
+                payload.resolution_note = note;
+            await cmd(post, cfg.orgId, 'resolve_approval', payload, resolution === 'approved' ? 'Approving...' : 'Rejecting...');
+            return mApprovals(cfg, post);
+        }
     }
-    catch (err) {
-        spinner.stop(pc.red('Failed'));
-        p.log.error(err.message || 'Could not create task');
+    return mApprovals(cfg, post);
+}
+// ══════════════════════════════════════════════════════════════════════
+//  TEAM — 4 commands
+// ══════════════════════════════════════════════════════════════════════
+async function mTeam(cfg, post) {
+    const a = await sel('Team', [
+        { value: 'invite', label: 'Invite a member' },
+        { value: 'revoke', label: 'Revoke an invitation' },
+        { value: 'role', label: 'Change a member\u2019s role' },
+        { value: 'remove', label: 'Remove a member' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
+        return interactiveMenu(cfg);
+    switch (a) {
+        case 'invite': {
+            const email = await txt('Email address', true);
+            if (!email)
+                return mTeam(cfg, post);
+            const role = await sel('Role', [
+                { value: 'user', label: 'Member', hint: 'can complete tasks and view data' },
+                { value: 'admin', label: 'Admin', hint: 'can manage plans, tables, and team' },
+                { value: 'super_admin', label: 'Owner', hint: 'full control' },
+            ]);
+            if (!role)
+                return mTeam(cfg, post);
+            await cmd(post, cfg.orgId, 'invite_member', { email, role }, 'Sending invitation...');
+            return mTeam(cfg, post);
+        }
+        case 'revoke': {
+            const invId = await txt('Invitation ID', true);
+            if (!invId)
+                return mTeam(cfg, post);
+            await cmd(post, cfg.orgId, 'revoke_invitation', { invitation_id: invId }, 'Revoking invitation...');
+            return mTeam(cfg, post);
+        }
+        case 'role': {
+            const userId = await txt('Member user ID', true);
+            if (!userId)
+                return mTeam(cfg, post);
+            const role = await sel('New role', [
+                { value: 'user', label: 'Member' },
+                { value: 'admin', label: 'Admin' },
+                { value: 'super_admin', label: 'Owner' },
+            ]);
+            if (!role)
+                return mTeam(cfg, post);
+            await cmd(post, cfg.orgId, 'update_member_role', { user_id: userId, role }, 'Updating role...');
+            return mTeam(cfg, post);
+        }
+        case 'remove': {
+            const userId = await txt('Member user ID', true);
+            if (!userId)
+                return mTeam(cfg, post);
+            const sure = await yn('Remove this member? They will lose access to the workspace.');
+            if (sure)
+                await cmd(post, cfg.orgId, 'remove_member', { user_id: userId }, 'Removing member...');
+            return mTeam(cfg, post);
+        }
     }
-    return interactiveMenu(cfg);
+    return mTeam(cfg, post);
 }
-// ── Switch Workspace ────────────────────────────────────────────────
-async function menuSwitch(cfg, post) {
-    const s = p.spinner();
-    s.start('Loading workspaces...');
-    try {
-        const res = await post('/api/v2/query', {
-            type: 'list_my_organizations',
-            payload: {},
-        });
-        const orgs = Array.isArray(res.data) ? res.data : [];
-        s.stop(`${orgs.length} workspace${orgs.length === 1 ? '' : 's'}`);
-        const selected = await p.select({
-            message: 'Switch to workspace',
-            options: orgs.map((o) => ({
+// ══════════════════════════════════════════════════════════════════════
+//  ORGANIZATION — 6 commands
+// ══════════════════════════════════════════════════════════════════════
+async function mOrg(cfg, post) {
+    const a = await sel('Organization', [
+        { value: 'branding', label: 'Update branding', hint: 'name, logo, accent color' },
+        { value: 'create', label: 'Create a new organization' },
+        { value: 'join', label: 'Join an organization' },
+        { value: 'accept', label: 'Accept an invitation' },
+        { value: 'leave', label: 'Leave this organization' },
+        { value: 'delete', label: 'Delete this organization', hint: 'owner only, irreversible' },
+        { value: 'switch', label: 'Switch workspace' },
+        { value: 'permissions', label: 'View my permissions' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
+        return interactiveMenu(cfg);
+    switch (a) {
+        case 'branding': {
+            const updates = { organization_id: cfg.orgId };
+            const name = await txt('Organization name (blank to skip)');
+            if (name)
+                updates.name = name;
+            const color = await txt('Accent color (blank to skip)', false, '#6366f1');
+            if (color)
+                updates.accent_color = color;
+            const logo = await txt('Logo URL (blank to skip)');
+            if (logo)
+                updates.logo_url = logo;
+            if (Object.keys(updates).length > 1) {
+                await cmd(post, cfg.orgId, 'update_organization_branding', updates, 'Updating branding...');
+            }
+            return mOrg(cfg, post);
+        }
+        case 'create': {
+            const name = await txt('Organization name', true);
+            if (!name)
+                return mOrg(cfg, post);
+            const payload = { name };
+            const color = await txt('Accent color', false, '#6366f1');
+            if (color)
+                payload.accent_color = color;
+            await cmdNoOrg(post, 'create_organization', payload, 'Creating organization...');
+            return mOrg(cfg, post);
+        }
+        case 'join': {
+            const orgId = await txt('Organization ID', true);
+            if (!orgId)
+                return mOrg(cfg, post);
+            await cmdNoOrg(post, 'join_organization', { organization_id: orgId }, 'Joining...');
+            return mOrg(cfg, post);
+        }
+        case 'accept': {
+            const token = await txt('Invitation token', true);
+            if (!token)
+                return mOrg(cfg, post);
+            await cmdNoOrg(post, 'accept_invitation', { token }, 'Accepting invitation...');
+            return mOrg(cfg, post);
+        }
+        case 'leave': {
+            const sure = await yn(`Leave "${cfg.orgName}"? You will lose access.`);
+            if (sure)
+                await cmd(post, cfg.orgId, 'leave_organization', {}, 'Leaving organization...');
+            return mOrg(cfg, post);
+        }
+        case 'delete': {
+            const sure1 = await yn(`DELETE "${cfg.orgName}"? This permanently destroys ALL data.`);
+            if (!sure1)
+                return mOrg(cfg, post);
+            const sure2 = await yn('Are you absolutely sure? This CANNOT be undone.');
+            if (sure2)
+                await cmd(post, cfg.orgId, 'delete_organization', {}, 'Deleting organization...');
+            return mOrg(cfg, post);
+        }
+        case 'switch': {
+            const s = p.spinner();
+            s.start('Loading workspaces...');
+            const res = await qry(post, cfg.orgId, 'list_my_organizations');
+            const orgs = Array.isArray(res?.data) ? res.data : [];
+            s.stop(`${orgs.length} workspaces`);
+            const selected = await sel('Switch to', orgs.map((o) => ({
                 value: o.id,
                 label: o.name,
                 hint: o.id === cfg.orgId ? pc.green('current') : o.role,
-            })),
-        });
-        if (p.isCancel(selected))
-            return interactiveMenu(cfg);
-        const org = orgs.find((o) => o.id === selected);
-        cfg.orgId = selected;
-        cfg.orgName = org?.name || '';
-        saveConfig(cfg);
-        p.log.success(`Switched to ${pc.cyan(cfg.orgName)}`);
+            })));
+            if (selected) {
+                const org = orgs.find((o) => o.id === selected);
+                cfg.orgId = selected;
+                cfg.orgName = org?.name || '';
+                saveConfig(cfg);
+                p.log.success(`Switched to ${pc.cyan(cfg.orgName)}`);
+            }
+            return mOrg(cfg, post);
+        }
+        case 'permissions': {
+            const s = p.spinner();
+            s.start('Checking permissions...');
+            try {
+                const res = await post('/api/v2/introspection/permissions', { organization_id: cfg.orgId });
+                s.stop('');
+                const data = res.data || res;
+                if (data.role)
+                    p.log.info(`Your role: ${pc.cyan(data.role)}`);
+                if (data.capabilities) {
+                    const allowed = Object.entries(data.capabilities).filter(([, v]) => v).map(([k]) => k);
+                    const denied = Object.entries(data.capabilities).filter(([, v]) => !v).map(([k]) => k);
+                    if (allowed.length > 0)
+                        p.log.info(`${pc.green('Allowed')}: ${allowed.length} capabilities`);
+                    if (denied.length > 0)
+                        p.log.info(`${pc.red('Denied')}: ${denied.length} capabilities`);
+                }
+                else {
+                    console.log(JSON.stringify(data, null, 2));
+                }
+            }
+            catch (err) {
+                s.stop(pc.red('Failed'));
+                p.log.error(err.message);
+            }
+            return mOrg(cfg, post);
+        }
     }
-    catch (err) {
-        s.stop(pc.red('Failed'));
-        p.log.error(err.message || 'Could not load workspaces');
+    return mOrg(cfg, post);
+}
+// ══════════════════════════════════════════════════════════════════════
+//  WORKSPACE OVERVIEW — search, status, entity details, schema
+// ══════════════════════════════════════════════════════════════════════
+async function mOverview(cfg, post) {
+    const a = await sel('Workspace', [
+        { value: 'status', label: 'Workspace status', hint: 'summary of everything' },
+        { value: 'search', label: 'Search', hint: 'find anything in your workspace' },
+        { value: 'details', label: 'View entity details', hint: 'look up any item by type' },
+        { value: 'schema', label: 'View entity schemas', hint: 'see available fields per type' },
+        { value: '__back', label: pc.dim('\u2190 Back to main menu') },
+    ]);
+    if (!a || a === '__back')
+        return interactiveMenu(cfg);
+    switch (a) {
+        case 'status': {
+            const s = p.spinner();
+            s.start('Loading workspace...');
+            const nodes = await getWorkspaceNodes(post, cfg.orgId);
+            s.stop('Workspace loaded');
+            const counts = {};
+            for (const node of nodes) {
+                const t = node.type || 'unknown';
+                counts[t] = (counts[t] || 0) + 1;
+            }
+            const lines = [
+                `${pad('Workspace', 16)} ${pc.cyan(cfg.orgName)}`,
+                '',
+                `${pad('Plans', 16)} ${pc.bold(String(counts.plan || 0))}`,
+                `${pad('Tasks', 16)} ${pc.bold(String(counts.task || 0))}`,
+                `${pad('Requirements', 16)} ${pc.bold(String(counts.requirement || 0))}`,
+                `${pad('Goals', 16)} ${pc.bold(String(counts.goal || 0))}`,
+                `${pad('Rules', 16)} ${pc.bold(String(counts.rule || 0))}`,
+                `${pad('Documents', 16)} ${pc.bold(String(counts.document || 0))}`,
+                `${pad('Tables', 16)} ${pc.bold(String(counts.table || 0))}`,
+                `${pad('Dashboards', 16)} ${pc.bold(String(counts.dashboard || 0))}`,
+                `${pad('Photos', 16)} ${pc.bold(String(counts.photo || 0))}`,
+                `${pad('Locations', 16)} ${pc.bold(String(counts.geolocation_area || 0))}`,
+                `${pad('Checklists', 16)} ${pc.bold(String(counts.checklist || 0))}`,
+            ];
+            p.note(lines.join('\n'), 'Workspace Overview');
+            return mOverview(cfg, post);
+        }
+        case 'search': {
+            const query = await txt('Search for...', true, 'task name, plan, document...');
+            if (!query)
+                return mOverview(cfg, post);
+            const s = p.spinner();
+            s.start('Searching...');
+            const entities = await searchEntities(post, cfg.orgId, query);
+            s.stop(`${entities.length} results`);
+            if (entities.length > 0) {
+                const lines = entities.map((e) => `  ${pc.dim(pad(e.entity_type || '', 18))} ${pc.cyan(truncate(e.name || 'Untitled', 50))}`);
+                p.note(lines.join('\n'), `Results for "${query}"`);
+            }
+            else {
+                p.log.info('No results found.');
+            }
+            return mOverview(cfg, post);
+        }
+        case 'details': {
+            const entityType = await sel('What type of item?', [
+                { value: 'plan', label: 'Plan' }, { value: 'task', label: 'Task' },
+                { value: 'table', label: 'Table' }, { value: 'document', label: 'Document' },
+                { value: 'dashboard', label: 'Dashboard' }, { value: 'goal', label: 'Goal' },
+                { value: 'rule', label: 'Rule' }, { value: 'requirement', label: 'Requirement' },
+                { value: 'photo', label: 'Photo' }, { value: 'geolocation_area', label: 'Location area' },
+                { value: 'checklist', label: 'Checklist' }, { value: 'public_form', label: 'Form' },
+            ]);
+            if (!entityType)
+                return mOverview(cfg, post);
+            const entity = await pickEntity(post, cfg.orgId, entityType, `${entityType}s`);
+            if (!entity)
+                return mOverview(cfg, post);
+            // Fetch full details
+            const s = p.spinner();
+            s.start('Loading details...');
+            const res = await qry(post, cfg.orgId, 'get_entity', { entity_type: entityType, id: entity.id });
+            s.stop('');
+            if (res?.data) {
+                const data = res.data;
+                const lines = Object.entries(data.metadata || data).map(([k, v]) => {
+                    if (v === null || v === undefined)
+                        return null;
+                    const val = typeof v === 'object' ? JSON.stringify(v) : String(v);
+                    return `  ${pc.dim(pad(k, 24))} ${truncate(val, 60)}`;
+                }).filter(Boolean);
+                p.note(lines.join('\n'), entity.name || 'Details');
+            }
+            return mOverview(cfg, post);
+        }
+        case 'schema': {
+            const entityType = await sel('Schema for which type?', [
+                { value: 'plan', label: 'Plan' }, { value: 'task', label: 'Task' },
+                { value: 'table', label: 'Table' }, { value: 'document', label: 'Document' },
+                { value: 'dashboard', label: 'Dashboard' }, { value: 'goal', label: 'Goal' },
+                { value: 'rule', label: 'Rule' }, { value: 'requirement', label: 'Requirement' },
+            ]);
+            if (!entityType)
+                return mOverview(cfg, post);
+            const s = p.spinner();
+            s.start('Loading schema...');
+            try {
+                const res = await post('/api/v2/introspection/schema', {
+                    organization_id: cfg.orgId, entity_type: entityType,
+                });
+                s.stop('');
+                const schema = res.data || res;
+                console.log(JSON.stringify(schema, null, 2));
+            }
+            catch (err) {
+                s.stop(pc.red('Failed'));
+                p.log.error(err.message);
+            }
+            return mOverview(cfg, post);
+        }
     }
-    return interactiveMenu(cfg);
+    return mOverview(cfg, post);
+}
+// ══════════════════════════════════════════════════════════════════════
+//  DIRECT COMMANDS (non-interactive, for scripts & power users)
+// ══════════════════════════════════════════════════════════════════════
+function getFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    return args[idx + 1];
 }
-// ── Direct Commands (non-interactive) ───────────────────────────────
 async function directPlans(cfg) {
     const { post } = api(cfg);
     const s = p.spinner();
@@ -637,11 +2287,8 @@ async function directPlans(cfg) {
         p.log.info('No plans found.');
         return;
     }
-    const lines = plans.map((plan) => {
-        const name = truncate(plan.name || 'Untitled', 40);
-        return `  ${pc.cyan(pad(name, 42))} ${pc.dim(plan.id)}`;
-    });
-    p.note(lines.join('\n'), `${plans.length} plan${plans.length === 1 ? '' : 's'}`);
+    const lines = plans.map((pl) => `  ${pc.cyan(pad(truncate(pl.name || 'Untitled', 40), 42))} ${pc.dim(pl.id)}`);
+    p.note(lines.join('\n'), `${plans.length} plans`);
 }
 async function directTasks(cfg) {
     const { post } = api(cfg);
@@ -653,23 +2300,12 @@ async function directTasks(cfg) {
         p.log.info('No tasks found.');
         return;
     }
-    const lines = tasks.map((t) => {
-        const name = truncate(t.name || 'Untitled', 50);
-        const freq = t.metadata?.frequency || '';
-        return `  ${pc.cyan(pad(name, 52))} ${pc.dim(freq)}  ${pc.dim(t.id)}`;
-    });
-    p.note(lines.join('\n'), `${tasks.length} task${tasks.length === 1 ? '' : 's'}`);
+    const lines = tasks.map((t) => `  ${pc.cyan(pad(truncate(t.name || 'Untitled', 50), 52))} ${pc.dim(t.metadata?.frequency || '')}  ${pc.dim(t.id)}`);
+    p.note(lines.join('\n'), `${tasks.length} tasks`);
 }
 async function directComplete(cfg, taskId) {
     const { post } = api(cfg);
-    const s = p.spinner();
-    s.start('Completing task...');
-    await post('/api/v2/commands', {
-        type: 'complete_task',
-        organization_id: cfg.orgId,
-        payload: { task_id: taskId },
-    });
-    s.stop(pc.green('Task completed!'));
+    await cmd(post, cfg.orgId, 'complete_task', { task_id: taskId }, 'Completing task...');
 }
 async function directStatus(cfg) {
     const { post } = api(cfg);
@@ -683,8 +2319,7 @@ async function directStatus(cfg) {
         counts[t] = (counts[t] || 0) + 1;
     }
     const lines = [
-        `${pad('Workspace', 16)} ${pc.cyan(cfg.orgName)}`,
-        '',
+        `${pad('Workspace', 16)} ${pc.cyan(cfg.orgName)}`, '',
         `${pad('Plans', 16)} ${pc.bold(String(counts.plan || 0))}`,
         `${pad('Tasks', 16)} ${pc.bold(String(counts.task || 0))}`,
         `${pad('Requirements', 16)} ${pc.bold(String(counts.requirement || 0))}`,
@@ -703,13 +2338,11 @@ async function directSearch(cfg, term) {
     s.stop('');
     if (entities.length === 0) {
         p.log.info('No results found.');
+        return;
     }
-    else {
-        const lines = entities.map((e) => `  ${pc.dim(pad(e.entity_type || '', 14))} ${pc.cyan(truncate(e.name || '', 50))}  ${pc.dim(e.id)}`);
-        p.note(lines.join('\n'), `${entities.length} result${entities.length === 1 ? '' : 's'} for "${term}"`);
-    }
+    const lines = entities.map((e) => `  ${pc.dim(pad(e.entity_type || '', 14))} ${pc.cyan(truncate(e.name || '', 50))}  ${pc.dim(e.id)}`);
+    p.note(lines.join('\n'), `${entities.length} results for "${term}"`);
 }
-// Raw passthrough for power users
 async function directRaw(cfg, type, args) {
     const { post } = api(cfg);
     const payloadRaw = args[0];
@@ -733,12 +2366,6 @@ async function directQuery(cfg, type, args) {
     });
     console.log(JSON.stringify(res, null, 2));
 }
-function getFlag(args, flag) {
-    const idx = args.indexOf(flag);
-    if (idx === -1 || idx + 1 >= args.length)
-        return undefined;
-    return args[idx + 1];
-}
 // ── Main ────────────────────────────────────────────────────────────
 async function main() {
     const args = process.argv.slice(2);
@@ -756,19 +2383,19 @@ async function main() {
         console.log();
         p.intro(pc.bgCyan(pc.black(' Checkbox CLI ')) + pc.dim(` v${VERSION}`));
         p.note([
-            `${pc.cyan('checkbox')}               Interactive menu`,
-            `${pc.cyan('checkbox setup')}          Setup wizard (API key & workspace)`,
+            `${pc.cyan('checkbox')}               Interactive menu (all features)`,
+            `${pc.cyan('checkbox setup')}          Setup wizard`,
             `${pc.cyan('checkbox plans')}          List your plans`,
             `${pc.cyan('checkbox tasks')}          List your tasks`,
             `${pc.cyan('checkbox complete <id>')}  Complete a task`,
             `${pc.cyan('checkbox status')}         Workspace overview`,
             `${pc.cyan('checkbox search <term>')}  Search your workspace`,
             '',
-            pc.dim('Advanced (for automation):'),
-            `${pc.dim('checkbox cmd <type> [json] [--org <id>]')}`,
-            `${pc.dim('checkbox query <type> [json] [--org <id>]')}`,
+            pc.dim('Automation & scripting:'),
+            `${pc.dim('checkbox cmd <type> [json] [--org <id>]')}   Run any command`,
+            `${pc.dim('checkbox query <type> [json] [--org <id>]')} Run any query`,
         ].join('\n'), 'Commands');
-        p.outro(pc.dim('Run `checkbox setup` to get started'));
+        p.outro(pc.dim('Run `checkbox` with no arguments for the full interactive menu'));
         return;
     }
     const cfg = resolveConfig();
@@ -778,14 +2405,12 @@ async function main() {
     }
     try {
         switch (sub) {
-            case 'plans':
-                return await directPlans(cfg);
-            case 'tasks':
-                return await directTasks(cfg);
+            case 'plans': return await directPlans(cfg);
+            case 'tasks': return await directTasks(cfg);
             case 'complete':
                 if (!rest[0]) {
                     const { post } = api(cfg);
-                    return await menuComplete(cfg, post);
+                    return await mTasks(cfg, post);
                 }
                 return await directComplete(cfg, rest[0]);
             case 'status':
@@ -794,11 +2419,11 @@ async function main() {
             case 'search':
                 if (!rest[0]) {
                     const { post } = api(cfg);
-                    return await menuSearch(cfg, post);
+                    return await mOverview(cfg, post);
                 }
                 return await directSearch(cfg, rest.join(' '));
             case 'switch':
-                return await menuSwitch(cfg, api(cfg).post);
+                return await mOrg(cfg, api(cfg).post);
             case 'cmd':
             case 'command':
                 return await directRaw(cfg, rest[0], rest.slice(1));