checkbox-cli 2.0.1 → 3.0.0

package/dist/checkbox.js

@@ -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.0';
 function loadConfig() {
     try {
         if (!existsSync(CONFIG_FILE))
@@ -58,7 +54,6 @@ function resolveConfig() {
     return fileCfg;
 }
 // ── API ─────────────────────────────────────────────────────────────
-/** Extract a human-readable error message from any API error shape */
 function extractError(obj) {
     if (!obj)
         return 'Unknown error';
@@ -84,43 +79,33 @@ function api(cfg) {
             body: JSON.stringify(body),
         });
         const json = await res.json().catch(() => null);
-        if (!res.ok) {
+        if (!res.ok)
             throw new Error(extractError(json) || `Request failed (${res.status})`);
-        }
-        if (json && json.success === false) {
+        if (json && json.success === false)
             throw new Error(extractError(json) || 'Request failed');
-        }
         return json;
     }
     async function get(path) {
         const res = await fetch(`${cfg.apiUrl}${path}`, { headers });
         const json = await res.json().catch(() => null);
-        if (!res.ok) {
+        if (!res.ok)
             throw new Error(extractError(json) || `Request failed (${res.status})`);
-        }
-        if (json && json.success === false) {
+        if (json && json.success === false)
             throw new Error(extractError(json) || 'Request failed');
-        }
         return json;
     }
     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) {
+// ── Data Helpers ────────────────────────────────────────────────────
+async function listEntities(post, orgId, entityType, filters) {
     const res = await post('/api/v2/query', {
         type: 'list_entities',
         organization_id: orgId,
-        payload: { entity_type: entityType, organization_id: orgId },
+        payload: { entity_type: entityType, organization_id: orgId, ...filters },
     });
-    // list_entities returns { success, data: [...], meta }
     return Array.isArray(res.data) ? res.data : [];
 }
 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,
@@ -129,7 +114,6 @@ async function searchEntities(post, orgId, search, limit = 20) {
     return res.data?.entities || [];
 }
 async function getWorkspaceNodes(post, orgId) {
-    // workspace returns { success, data: { organization_id, nodes: [...], edges: [...] } }
     const res = await post('/api/v2/introspection/workspace', {
         organization_id: orgId,
     });
@@ -145,6 +129,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 +320,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 +333,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 +353,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 mReqs(cfg, post);
+}
+// ══════════════════════════════════════════════════════════════════════
+//  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 mTables(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');
-    }
-    return interactiveMenu(cfg);
-}
-// ── 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 +2255,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 +2268,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 +2287,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 +2306,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 +2334,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 +2351,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 +2373,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 +2387,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));