@memoring/cli 0.12.1 → 0.15.0

package/dist/commands/plan-exams.js

@@ -0,0 +1,122 @@
+import { apiFetch } from '../api.js';
+import { fail, green, printJson, printTable, stringFlag } from './shared.js';
+import { formatPercent, integerFlag, object, positiveId, readJson } from './plan-shared.js';
+function examBody(parsed) {
+    const file = stringFlag(parsed.flags, 'file');
+    if (file) {
+        return object(readJson(file), 'a prova deve ser um objeto JSON.');
+    }
+    const name = stringFlag(parsed.flags, 'name');
+    const examDate = stringFlag(parsed.flags, 'date');
+    if (!name || !examDate) {
+        fail('informe --file prova.json ou --name, --date, --total e --correct.');
+    }
+    const planId = integerFlag(parsed.flags, 'plan-id', { min: 1 });
+    const totalQuestions = integerFlag(parsed.flags, 'total', { required: true, min: 1 });
+    const correctAnswers = integerFlag(parsed.flags, 'correct', { required: true, min: 0 });
+    const subjectsRaw = stringFlag(parsed.flags, 'subjects');
+    let subjectResults;
+    if (subjectsRaw !== undefined) {
+        try {
+            subjectResults = JSON.parse(subjectsRaw);
+        }
+        catch (error) {
+            fail(`--subjects deve ser um array JSON válido: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        ...(planId !== undefined ? { planId } : {}),
+        name,
+        examDate,
+        totalQuestions,
+        correctAnswers,
+        ...(subjectResults !== undefined ? { subjectResults } : {}),
+    };
+}
+function validateExam(value) {
+    if (typeof value.name !== 'string' || value.name.trim() === '') {
+        fail('a prova precisa de name não vazio.');
+    }
+    if (typeof value.examDate !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value.examDate) || Number.isNaN(Date.parse(`${value.examDate}T00:00:00Z`))) {
+        fail('examDate deve estar no formato YYYY-MM-DD.');
+    }
+    for (const [field, min] of [['totalQuestions', 1], ['correctAnswers', 0]]) {
+        const fieldValue = value[field];
+        if (typeof fieldValue !== 'number' || !Number.isInteger(fieldValue) || fieldValue < min) {
+            fail(`${field} deve ser um inteiro >= ${min}.`);
+        }
+    }
+    if (value.correctAnswers > value.totalQuestions) {
+        fail('correctAnswers não pode superar totalQuestions.');
+    }
+    if (value.planId !== undefined && value.planId !== null &&
+        (typeof value.planId !== 'number' || !Number.isInteger(value.planId) || value.planId < 1)) {
+        fail('planId deve ser um inteiro positivo.');
+    }
+    if (value.subjectResults !== undefined && !Array.isArray(value.subjectResults)) {
+        fail('subjectResults deve ser um array.');
+    }
+    return value;
+}
+export async function examsCommand(parsed, rest) {
+    const [sub, ...args] = rest;
+    switch (sub) {
+        case 'list': {
+            const exams = (await apiFetch('/planning/exams'));
+            if (parsed.flags.json) {
+                printJson(exams);
+                return;
+            }
+            if (exams.length === 0) {
+                process.stdout.write('Nenhuma prova registrada.\n');
+                return;
+            }
+            printTable(exams.map((exam) => ({
+                id: `#${String(exam.id)}`,
+                name: exam.name,
+                date: exam.examDate,
+                result: `${String(exam.correctAnswers)}/${String(exam.totalQuestions)}`,
+                accuracy: formatPercent(exam.accuracyPercent),
+                plan: exam.planId ? `#${String(exam.planId)}` : '—',
+            })), [
+                { key: 'id', label: 'ID' },
+                { key: 'name', label: 'PROVA' },
+                { key: 'date', label: 'DATA' },
+                { key: 'result', label: 'ACERTOS' },
+                { key: 'accuracy', label: 'DESEMPENHO' },
+                { key: 'plan', label: 'PLANO' },
+            ]);
+            return;
+        }
+        case 'create': {
+            const body = validateExam(examBody(parsed));
+            const exam = await apiFetch('/planning/exams', { method: 'POST', body });
+            if (parsed.flags.json) {
+                printJson(exam);
+                return;
+            }
+            const created = object(exam, 'resposta inválida ao criar prova.');
+            process.stdout.write(green(`Prova "${String(created.name)}" registrada (#${String(created.id)}).\n`));
+            return;
+        }
+        case 'delete': {
+            const examId = positiveId(args[0], 'examId');
+            await apiFetch(`/planning/exams/${examId}`, { method: 'DELETE' });
+            if (parsed.flags.json) {
+                printJson({ deleted: true, examId });
+                return;
+            }
+            process.stdout.write(green(`Prova #${examId} excluída.\n`));
+            return;
+        }
+        default:
+            process.stdout.write('Uso: memoring plan exams <list|create|delete>\n' +
+                '  list\n' +
+                '  create --file prova.json\n' +
+                '  create --name "Simulado 1" --date YYYY-MM-DD --total N --correct N [--plan-id N] [--subjects JSON]\n' +
+                '  delete <examId>\n');
+            if (sub) {
+                process.exitCode = 1;
+            }
+    }
+}

package/dist/commands/plan-goal.js

@@ -0,0 +1,131 @@
+import { apiFetch } from '../api.js';
+import { createDraftHandoff, deleteDraftAfterCreation, readPlanningDraft, requireReviewed, } from './planDrafts.js';
+import { fail, printJson, stringFlag } from './shared.js';
+import { formatPercent, integerFlag, normalized, printActivity, printGoal, } from './plan-shared.js';
+import { ERROR_REASONS } from './plan-analyze.js';
+export async function goalCommand(sub, planId, parsed) {
+    let details;
+    if (sub === 'current') {
+        details = (await apiFetch(`/planning/plans/${planId}/goals/current`));
+    }
+    else if (parsed.flags.web) {
+        if (parsed.flags.draft !== undefined || parsed.flags.activities !== undefined) {
+            fail('next --web não aceita --draft nem --activities; a Meta será definida na revisão web.');
+        }
+        await createDraftHandoff('GOAL', planId, {}, parsed);
+        return;
+    }
+    else {
+        let reviewedDraft = null;
+        let activityTarget;
+        if (parsed.flags.draft !== undefined) {
+            if (parsed.flags.activities !== undefined) {
+                fail('use --draft ou --activities, não os dois.');
+            }
+            reviewedDraft = await readPlanningDraft(stringFlag(parsed.flags, 'draft'));
+            requireReviewed(reviewedDraft, 'GOAL', planId);
+            const value = reviewedDraft.payload.activityTarget;
+            if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1 || value > 200) {
+                fail('o payload revisado precisa de activityTarget inteiro entre 1 e 200.');
+            }
+            activityTarget = value;
+        }
+        else {
+            activityTarget = integerFlag(parsed.flags, 'activities', { required: true, min: 1, max: 200 });
+        }
+        details = (await apiFetch(`/planning/plans/${planId}/goals`, {
+            method: 'POST',
+            body: { activityTarget },
+        }));
+        if (reviewedDraft) {
+            await deleteDraftAfterCreation(reviewedDraft);
+        }
+    }
+    if (parsed.flags.json) {
+        printJson(details);
+        return;
+    }
+    if (!details) {
+        process.stdout.write(`Nenhuma Meta ativa no planejamento #${planId}. Gere uma com \`memoring plan next ${planId} --activities N\`.\n`);
+        return;
+    }
+    printGoal(details, sub === 'next' ? 'Meta gerada' : 'Meta atual');
+}
+function errorReason(raw) {
+    const key = normalized(raw);
+    const aliases = {
+        UNKNOWN: 'UNKNOWN',
+        DESCONHECIDO: 'UNKNOWN',
+        NAO_IDENTIFICADO: 'UNKNOWN',
+        FORGETTING: 'FORGETTING',
+        ESQUECIMENTO: 'FORGETTING',
+        CONCEPTUAL_CONFUSION: 'CONCEPTUAL_CONFUSION',
+        CONFUSAO_CONCEITUAL: 'CONCEPTUAL_CONFUSION',
+        INATTENTION: 'INATTENTION',
+        DESATENCAO: 'INATTENTION',
+        INTERPRETATION: 'INTERPRETATION',
+        INTERPRETACAO: 'INTERPRETATION',
+        TIME_SHORTAGE: 'TIME_SHORTAGE',
+        FALTA_DE_TEMPO: 'TIME_SHORTAGE',
+    };
+    const reason = aliases[key];
+    if (!reason) {
+        fail(`motivo de erro desconhecido: ${raw}. Use ${ERROR_REASONS.join(', ')}.`);
+    }
+    return reason;
+}
+function parseErrors(raw, incorrectCount) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    const entries = raw.split(/[,;]/).map((entry) => entry.trim()).filter(Boolean);
+    if (entries.length === 0) {
+        fail('--errors vazio; use motivo:N separado por vírgulas.');
+    }
+    const seen = new Set();
+    const errors = entries.map((entry) => {
+        const match = /^(.+):(\d+)$/.exec(entry);
+        if (!match) {
+            fail(`--errors inválido em ${JSON.stringify(entry)}; use motivo:N (ex.: FORGETTING:2).`);
+        }
+        const reason = errorReason(match[1]);
+        const errorCount = Number(match[2]);
+        if (errorCount < 1) {
+            fail(`a contagem de ${reason} deve ser pelo menos 1.`);
+        }
+        if (seen.has(reason)) {
+            fail(`o motivo ${reason} aparece mais de uma vez em --errors.`);
+        }
+        seen.add(reason);
+        return { reason, errorCount };
+    });
+    const classified = errors.reduce((sum, error) => sum + error.errorCount, 0);
+    if (classified > incorrectCount) {
+        fail(`a soma de --errors (${classified}) não pode superar os ${incorrectCount} erros da atividade.`);
+    }
+    return errors;
+}
+export async function recordResult(activityId, parsed) {
+    const questionCount = integerFlag(parsed.flags, 'total', { required: true, min: 1 });
+    const correctCount = integerFlag(parsed.flags, 'correct', { required: true, min: 0 });
+    const actualSeconds = integerFlag(parsed.flags, 'seconds', { min: 0 });
+    if (correctCount > questionCount) {
+        fail('--correct não pode superar --total.');
+    }
+    const errors = parseErrors(stringFlag(parsed.flags, 'errors'), questionCount - correctCount);
+    const activity = (await apiFetch(`/planning/activities/${activityId}/result`, {
+        method: 'POST',
+        body: {
+            questionCount,
+            correctCount,
+            ...(actualSeconds !== undefined ? { actualSeconds } : {}),
+            ...(errors !== undefined ? { errors } : {}),
+        },
+    }));
+    if (parsed.flags.json) {
+        printJson(activity);
+        return;
+    }
+    printActivity(activity, 'Resultado registrado');
+    process.stdout.write(`  ${correctCount}/${questionCount} corretas (${formatPercent((100 * correctCount) / questionCount)}).\n`);
+}

package/dist/commands/plan-shared.js

@@ -0,0 +1,133 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { dim, fail, green, printTable, stringFlag } from './shared.js';
+export const STATUS_LABELS = {
+    ACTIVE: 'Ativo',
+    ARCHIVED: 'Arquivado',
+    COMPLETED: 'Concluída',
+    PENDING: 'Pendente',
+    IN_PROGRESS: 'Em andamento',
+    POSTPONED: 'Adiada',
+    DISMISSED: 'Dispensada',
+    CANCELLED: 'Cancelada',
+};
+// PlanStatus da web usa COMPLETED no masculino ("planejamento concluído");
+// STATUS_LABELS acima atende atividades/Metas ("concluída").
+export const PLAN_STATUS_LABELS = {
+    ...STATUS_LABELS,
+    COMPLETED: 'Concluído',
+};
+export const TYPE_LABELS = {
+    THEORY: 'Teoria',
+    MAPPING: 'Mapeamento',
+    REVIEW: 'Revisão',
+    QUESTIONS: 'Questões',
+    TEST: 'Teste',
+    REINFORCEMENT: 'Reforço',
+};
+export const MATURITY_LABELS = {
+    BEGINNER: 'Iniciante',
+    INTERMEDIATE: 'Intermediário',
+    ADVANCED: 'Avançado',
+};
+export const ERROR_LABELS = {
+    UNKNOWN: 'Não identificado',
+    FORGETTING: 'Esquecimento',
+    CONCEPTUAL_CONFUSION: 'Confusão conceitual',
+    INATTENTION: 'Desatenção',
+    INTERPRETATION: 'Interpretação',
+    TIME_SHORTAGE: 'Falta de tempo',
+};
+export function object(value, message) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        fail(message);
+    }
+    return value;
+}
+export function readJson(file) {
+    try {
+        const raw = file === '-' ? readFileSync(0, 'utf8') : readFileSync(resolve(file), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        fail(`não foi possível ler JSON de ${file === '-' ? 'stdin' : file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function positiveId(raw, label) {
+    if (raw === undefined || !/^\d+$/.test(raw) || Number(raw) < 1 || !Number.isSafeInteger(Number(raw))) {
+        fail(`${label} deve ser um inteiro positivo.`);
+    }
+    return Number(raw);
+}
+export function integerFlag(flags, name, options) {
+    const raw = stringFlag(flags, name);
+    if (raw === undefined) {
+        if (options.required) {
+            fail(`--${name} é obrigatório.`);
+        }
+        return undefined;
+    }
+    if (!/^-?\d+$/.test(raw)) {
+        fail(`--${name} deve ser um inteiro.`);
+    }
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value < options.min || (options.max !== undefined && value > options.max)) {
+        fail(`--${name} deve estar entre ${options.min} e ${options.max ?? '∞'}.`);
+    }
+    return value;
+}
+export function normalized(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .trim()
+        .replace(/[\s-]+/g, '_')
+        .toUpperCase();
+}
+export function formatPercent(value) {
+    return typeof value === 'number' ? `${value.toFixed(2).replace('.', ',')}%` : '—';
+}
+export function formatSeconds(value) {
+    if (typeof value !== 'number') {
+        return '—';
+    }
+    if (value < 60) {
+        return `${Math.round(value)}s`;
+    }
+    const minutes = Math.floor(value / 60);
+    const seconds = Math.round(value % 60);
+    return minutes < 60 ? `${minutes}min${seconds ? ` ${seconds}s` : ''}` : `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, '0')}`;
+}
+export function printActivity(activity, heading = 'Atividade atualizada') {
+    process.stdout.write(green(`${heading}: #${activity.id} — ${activity.title}\n`));
+    process.stdout.write(`  tipo: ${TYPE_LABELS[activity.type] ?? activity.type}  status: ${STATUS_LABELS[activity.status] ?? activity.status}  estimativa: ${activity.estimatedMinutes}min\n`);
+    if (activity.command) {
+        process.stdout.write(`  ${activity.command}\n`);
+    }
+}
+export function printGoal(details, heading) {
+    process.stdout.write(green(`${heading}: Meta #${details.goal.number} (id ${details.goal.id}) — alvo de ${details.goal.activityTarget} atividades.\n`));
+    if (details.activities.length === 0) {
+        process.stdout.write('Nenhuma atividade nesta Meta.\n');
+        return;
+    }
+    printTable(details.activities.map((activity) => ({
+        id: `#${activity.id}`,
+        type: TYPE_LABELS[activity.type] ?? activity.type,
+        title: activity.title,
+        status: STATUS_LABELS[activity.status] ?? activity.status,
+        minutes: `${activity.estimatedMinutes}min`,
+        questions: activity.questionTarget ?? activity.questionCount ?? '—',
+    })), [
+        { key: 'id', label: 'ID' },
+        { key: 'type', label: 'TIPO' },
+        { key: 'title', label: 'ATIVIDADE' },
+        { key: 'status', label: 'STATUS' },
+        { key: 'minutes', label: 'ESTIMATIVA' },
+        { key: 'questions', label: 'QUESTÕES' },
+    ]);
+    const first = details.activities.find((activity) => activity.status === 'PENDING' || activity.status === 'IN_PROGRESS');
+    if (first) {
+        process.stdout.write(dim(`\nPróxima: memoring plan start ${first.id}\n`));
+    }
+}

package/dist/commands/plan.js

@@ -0,0 +1,219 @@
+import { apiFetch } from '../api.js';
+import { deleteDraftAfterCreation, readPlanningDraft, requireReviewed, reviewDraft, } from './planDrafts.js';
+import { PLAN_SCHEMA, analyze, planBody, planPayload } from './plan-analyze.js';
+import { diagnostics } from './plan-diagnostics.js';
+import { examsCommand } from './plan-exams.js';
+import { goalCommand, recordResult } from './plan-goal.js';
+import { MATURITY_LABELS, PLAN_STATUS_LABELS, STATUS_LABELS, formatPercent, object, positiveId, printActivity, } from './plan-shared.js';
+import { bold, fail, green, printJson, printTable, stringFlag } from './shared.js';
+/**
+ * `memoring plan` — dispatcher dos subcomandos do Planejamento. O módulo
+ * ficou grande demais como arquivo único; cada família coesa vive no seu
+ * próprio módulo: `plan-analyze` (schema/analyze/create payload), `plan-goal`
+ * (current/next/start/complete/postpone/dismiss/cancel/result), `plan-exams`,
+ * `plan-diagnostics` e `plan-shared` (rótulos, parsers e impressão).
+ */
+function printHelp() {
+    process.stdout.write(`Uso: memoring plan <subcomando> [argumentos] [flags]
+
+  schema                         contrato JSON editável do planejamento e das provas
+  analyze <pdfs...>              analisa PDFs no backend e aguarda a proposta
+         [--out proposta.json]   salva o rascunho (com --json, imprime só o rascunho)
+         [--web] [--no-open]     envia a proposta para revisão web, sem criar o plano
+  review <draftId> [--wait]      lê o rascunho; --wait aguarda REVIEWED
+         [--timeout N] [--out f] timeout em segundos; exporta o payload já REVIEWED
+  create --file proposta.json    cria o planejamento após sua revisão no arquivo
+  create --draft <uuid>          cria somente de um rascunho PLAN REVIEWED e o exclui
+  list                           lista planejamentos
+  show <planId>                  detalha disciplinas e assuntos
+  current <planId>               mostra a Meta ativa
+  next <planId> --activities N   gera a próxima Meta (activityTarget obrigatório)
+  next <planId> --web            cria handoff de Meta para revisão web, sem gerar a Meta
+  next <planId> --draft <uuid>   gera de um rascunho GOAL REVIEWED e o exclui
+  start|complete|postpone|dismiss|cancel <activityId>
+                                 transições de uma atividade
+                                 (cancel = redução definitiva de escopo:
+                                 encerra na Meta e nunca é recomposta)
+  result <activityId> --total N --correct N [--seconds N]
+         [--errors motivo:N,...] registra desempenho e motivos dos erros
+  tec-result <activityId>        importa resultado do caderno TEC já disponível
+  performance|error-patterns|comparison|journey <planId>
+                                 diagnósticos do planejamento
+  coordinates                    coordenadas do método de planejamento
+  exams list                     lista provas
+  exams create --file prova.json registra prova (ou use --name/--date/--total/--correct)
+  exams delete <examId>          exclui prova
+
+Maturidades: BEGINNER (Iniciante), INTERMEDIATE (Intermediário), ADVANCED (Avançado).
+Motivos de erro: UNKNOWN, FORGETTING, CONCEPTUAL_CONFUSION, INATTENTION, INTERPRETATION, TIME_SHORTAGE (aliases em PT-BR também são aceitos).
+`);
+}
+export async function planCommand(parsed) {
+    const [sub, ...rest] = parsed._;
+    switch (sub) {
+        case 'schema':
+            printJson(PLAN_SCHEMA);
+            return;
+        case 'analyze':
+            await analyze(parsed, rest);
+            return;
+        case 'review':
+        case 'draft':
+            await reviewDraft(parsed, rest[0]);
+            return;
+        case 'create': {
+            const file = stringFlag(parsed.flags, 'file');
+            if (file && parsed.flags.draft !== undefined) {
+                fail('use --file ou --draft, não os dois.');
+            }
+            let body;
+            let reviewedDraft = null;
+            if (parsed.flags.draft !== undefined) {
+                reviewedDraft = await readPlanningDraft(stringFlag(parsed.flags, 'draft'));
+                requireReviewed(reviewedDraft, 'PLAN');
+                body = planPayload(reviewedDraft.payload);
+            }
+            else if (file) {
+                body = planBody(file);
+            }
+            else {
+                fail('informe a proposta revisada: memoring plan create --file proposta.json ou --draft <uuid>.');
+            }
+            const details = (await apiFetch('/planning/plans', { method: 'POST', body }));
+            if (reviewedDraft) {
+                await deleteDraftAfterCreation(reviewedDraft);
+            }
+            if (parsed.flags.json) {
+                printJson(details);
+                return;
+            }
+            const plan = object(details.plan, 'resposta inválida ao criar planejamento.');
+            process.stdout.write(green(`Planejamento "${String(plan.name)}" criado (#${String(plan.id)}).\n`));
+            process.stdout.write(`Gere a primeira Meta: memoring plan next ${String(plan.id)} --activities N\n`);
+            return;
+        }
+        case 'list': {
+            const plans = (await apiFetch('/planning/plans'));
+            if (parsed.flags.json) {
+                printJson(plans);
+                return;
+            }
+            if (plans.length === 0) {
+                process.stdout.write('Nenhum planejamento. Analise PDFs com `memoring plan analyze <pdfs...>`.\n');
+                return;
+            }
+            printTable(plans.map((plan) => ({
+                id: `#${String(plan.id)}`,
+                name: plan.name,
+                status: PLAN_STATUS_LABELS[String(plan.status)] ?? plan.status,
+                subjects: plan.activeSubjectLimit,
+                weekly: plan.weeklyMinutes ? `${String(plan.weeklyMinutes)}min` : '—',
+            })), [
+                { key: 'id', label: 'ID' },
+                { key: 'name', label: 'PLANEJAMENTO' },
+                { key: 'status', label: 'STATUS' },
+                { key: 'subjects', label: 'DISCIPLINAS ATIVAS' },
+                { key: 'weekly', label: 'TEMPO SEMANAL' },
+            ]);
+            return;
+        }
+        case 'show': {
+            const planId = positiveId(rest[0], 'planId');
+            const details = (await apiFetch(`/planning/plans/${planId}`));
+            if (parsed.flags.json) {
+                printJson(details);
+                return;
+            }
+            const plan = object(details.plan, 'resposta inválida ao consultar planejamento.');
+            process.stdout.write(bold(`${String(plan.name)} (#${planId}) — ${PLAN_STATUS_LABELS[String(plan.status)] ?? String(plan.status)}\n`));
+            if (plan.objective) {
+                process.stdout.write(`${String(plan.objective)}\n`);
+            }
+            const programs = Array.isArray(details.programs) ? details.programs : [];
+            const topics = Array.isArray(details.topics) ? details.topics : [];
+            for (const program of programs) {
+                process.stdout.write(`\n${String(program.subjectName)} — ${MATURITY_LABELS[String(program.maturity)] ?? String(program.maturity)}\n`);
+                const programTopics = topics.filter((topic) => topic.programId === program.id);
+                printTable(programTopics.map((topic) => ({
+                    id: `#${String(topic.id)}`,
+                    title: topic.title,
+                    pages: topic.pageFrom ? `${String(topic.pageFrom)}${topic.pageTo !== topic.pageFrom ? `–${String(topic.pageTo)}` : ''}` : '—',
+                    minutes: `${String(topic.estimatedMinutes)}min`,
+                    status: STATUS_LABELS[String(topic.status)] ?? topic.status,
+                })), [
+                    { key: 'id', label: 'ID' },
+                    { key: 'title', label: 'ASSUNTO' },
+                    { key: 'pages', label: 'PÁGINAS' },
+                    { key: 'minutes', label: 'ESTIMATIVA' },
+                    { key: 'status', label: 'STATUS' },
+                ]);
+            }
+            return;
+        }
+        case 'current':
+        case 'next':
+            await goalCommand(sub, positiveId(rest[0], 'planId'), parsed);
+            return;
+        case 'start':
+        case 'complete':
+        case 'postpone':
+        case 'dismiss':
+        case 'cancel': {
+            const activityId = positiveId(rest[0], 'activityId');
+            const activity = (await apiFetch(`/planning/activities/${activityId}/${sub}`, { method: 'POST' }));
+            if (parsed.flags.json) {
+                printJson(activity);
+            }
+            else {
+                printActivity(activity);
+            }
+            return;
+        }
+        case 'result':
+            await recordResult(positiveId(rest[0], 'activityId'), parsed);
+            return;
+        case 'tec-result': {
+            const activityId = positiveId(rest[0], 'activityId');
+            const result = (await apiFetch(`/planning/activities/${activityId}/tec-result`, { method: 'POST' }));
+            if (parsed.flags.json) {
+                printJson(result);
+                return;
+            }
+            process.stdout.write(green(`Resultado TEC importado para a atividade #${activityId}.\n`));
+            process.stdout.write(`  ${String(result.correctCount)}/${String(result.questionCount)} corretas (${formatPercent(result.accuracyPercent)}); ` +
+                `${String(result.errorCount)} erros.\n`);
+            return;
+        }
+        case 'performance':
+        case 'error-patterns':
+        case 'comparison':
+        case 'journey':
+            await diagnostics(sub, positiveId(rest[0], 'planId'), parsed.flags.json === true);
+            return;
+        case 'coordinates': {
+            const guides = (await apiFetch('/planning/coordinates'));
+            if (parsed.flags.json) {
+                printJson(guides);
+                return;
+            }
+            for (const guide of guides) {
+                process.stdout.write(bold(`${String(guide.title)}\n`));
+                process.stdout.write(`${String(guide.description)}\n`);
+                const actions = Array.isArray(guide.actions) ? guide.actions : [];
+                for (const action of actions) {
+                    process.stdout.write(`  • ${String(action)}\n`);
+                }
+                process.stdout.write('\n');
+            }
+            return;
+        }
+        case 'exams':
+            await examsCommand(parsed, rest);
+            return;
+        default:
+            printHelp();
+            if (sub) {
+                process.exitCode = 1;
+            }
+    }
+}