icoa-cli 2.19.51 → 2.19.53

package/dist/commands/exam.js

@@ -172,6 +172,115 @@ function printTimeRemaining() {
         }
     }
 }
+// One-shot urgent warnings: show the first time we cross a threshold, then
+// never again in the same session. Tracked on ExamState so it survives REPL
+// restarts and resume. Called from printQuestion so it fires naturally as the
+// user navigates (no background timer needed).
+function printTimeWarningIfNeeded(state) {
+    const deadline = getExamDeadline();
+    if (!deadline)
+        return;
+    const remainingMs = deadline.getTime() - Date.now();
+    if (remainingMs <= 0)
+        return;
+    const minutes = remainingMs / 60000;
+    const shown = new Set(state.shownWarnings || []);
+    let warn = null;
+    if (minutes <= 1 && !shown.has('t1')) {
+        warn = {
+            key: 't1',
+            text: [
+                chalk.red.bold('  ⚠  LESS THAN 1 MINUTE LEFT'),
+                chalk.red('  Submit now with: ') + chalk.bold('exam submit'),
+            ],
+        };
+    }
+    else if (minutes <= 5 && !shown.has('t5')) {
+        warn = {
+            key: 't5',
+            text: [
+                chalk.red.bold('  ⚠  5 minutes remaining'),
+                chalk.yellow('  Wrap up and submit: ') + chalk.bold('exam submit'),
+            ],
+        };
+    }
+    else if (minutes <= 10 && !shown.has('t10')) {
+        warn = {
+            key: 't10',
+            text: [
+                chalk.yellow.bold('  ⏰ 10 minutes remaining'),
+                chalk.gray('  Review unanswered questions: ') + chalk.white('exam review'),
+            ],
+        };
+    }
+    if (!warn)
+        return;
+    console.log();
+    console.log(chalk.red('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    for (const line of warn.text)
+        console.log(line);
+    console.log(chalk.red('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    shown.add(warn.key);
+    state.shownWarnings = Array.from(shown);
+    saveExamState(state);
+}
+// Pacing hints at Q10 (time check) and Q30 (section complete). Real exam only.
+// Keyed by question number so they fire once per exam on any render.
+function printPacingHint(state, currentQ) {
+    if (state.session.examId === 'demo-free')
+        return;
+    const shown = new Set(state.shownWarnings || []);
+    const total = Number(state.session.questionCount || 40);
+    const deadline = getExamDeadline();
+    // Q10: gentle time check (only if exam is 40+ questions, not 10 demo)
+    if (currentQ === 10 && total >= 40 && !shown.has('p10')) {
+        const remainingMin = deadline ? Math.max(0, Math.round((deadline.getTime() - Date.now()) / 60000)) : null;
+        console.log();
+        console.log(chalk.gray('  ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄'));
+        console.log(chalk.cyan('  ⏱  Time check  ') + chalk.gray(`— you're 1/4 through the exam`));
+        if (remainingMin !== null) {
+            console.log(chalk.gray(`     ${remainingMin} minutes left. Keep the pace steady.`));
+        }
+        console.log(chalk.gray('  ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄'));
+        shown.add('p10');
+        state.shownWarnings = Array.from(shown);
+        saveExamState(state);
+    }
+    // Q30: MCQ section complete milestone
+    if (currentQ === 30 && total >= 40 && !shown.has('p30')) {
+        const answered = Object.keys(state.answers || {}).length;
+        const mcqAnswered = Object.keys(state.answers || {}).filter((n) => Number(n) <= 30).length;
+        console.log();
+        console.log(chalk.green('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log(chalk.bold.green('  ✓  MCQ section complete — well done!'));
+        console.log(chalk.gray(`     ${mcqAnswered}/30 multiple-choice answered`));
+        console.log(chalk.white('  ↓  Practical section begins at Q31.'));
+        console.log(chalk.gray('     Budget ~2 min per practical question. You can come back with: next / prev.'));
+        console.log(chalk.green('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        shown.add('p30');
+        state.shownWarnings = Array.from(shown);
+        saveExamState(state);
+    }
+}
+// Bookmark / flag-for-review helpers
+function isBookmarked(state, n) {
+    return Array.isArray(state.bookmarks) && state.bookmarks.includes(n);
+}
+function toggleBookmark(state, n) {
+    const arr = Array.isArray(state.bookmarks) ? [...state.bookmarks] : [];
+    const idx = arr.indexOf(n);
+    if (idx >= 0) {
+        arr.splice(idx, 1);
+        state.bookmarks = arr;
+        saveExamState(state);
+        return false;
+    }
+    arr.push(n);
+    arr.sort((a, b) => a - b);
+    state.bookmarks = arr;
+    saveExamState(state);
+    return true;
+}
 function printHowToPlay() {
     console.log(chalk.gray('  ─────────────────────────────────────────'));
     console.log(chalk.white(`  ${t('howToPlay')}`));
@@ -235,6 +344,9 @@ function printQuestion(q, answer) {
     const help = getHelpState(state);
     const eliminated = help.eliminated[q.number] || [];
     const isPractical = q.type === 'ai4ctf' || q.type === 'ctf4ai' || (q.options && !q.options.A && !q.options.B);
+    // Pacing hints (Q10 time check, Q30 section complete) — real exam only
+    if (state)
+        printPacingHint(state, q.number);
     // Show practical section intro once when first entering Q31+
     if (isPractical && !_practicalIntroShown && state?.session.examId !== 'demo-free') {
         _practicalIntroShown = true;
@@ -254,8 +366,15 @@ function printQuestion(q, answer) {
         console.log(chalk.cyan('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
         console.log();
     }
+    // Urgent countdown warnings (10 / 5 / 1 minutes remaining)
+    if (state)
+        printTimeWarningIfNeeded(state);
     // Progress bar
     printQuestionProgress(q.number, total, answered);
+    // Bookmark indicator — yellow ★ after the progress line if current q is marked
+    if (state && isBookmarked(state, q.number)) {
+        console.log(chalk.yellow('  ★ Marked for review'));
+    }
     // Easter egg (position calculated by percentage of total)
     const egg = getEasterEgg(q.number, total);
     if (egg) {
@@ -325,7 +444,9 @@ function printQuestion(q, answer) {
     }
     console.log(chalk.yellow('    next') + chalk.gray(' / ') + chalk.yellow('prev') + chalk.gray(`    ${t('htpNav')}`));
     console.log(chalk.yellow(`    exam q 1..${total}`) + chalk.gray(`   ${t('htpJump')}`));
+    console.log(chalk.yellow('    mark') + chalk.gray(`          ${t('htpMark')}`));
     console.log(chalk.yellow('    exam review') + chalk.gray(`   ${t('htpReview')}`));
+    console.log(chalk.bold.yellow('    exam submit') + chalk.gray(`   ${t('htpSubmit')}`));
     console.log(chalk.yellow('    back') + chalk.gray(`          ${t('htpBack')}`));
     console.log(chalk.yellow('    lang') + chalk.gray(`          ${t('htpLang')}`));
     console.log(chalk.gray('  ─────────────────────────────────────────'));
@@ -528,6 +649,65 @@ export function registerExamCommand(program) {
             console.log();
         }
     });
+    // ─── exam mark [n] ───
+    // Flag the current (or given) question for review later. Toggles on/off.
+    exam
+        .command('mark [n]')
+        .description('Flag a question to review later (toggles)')
+        .action((n) => {
+        logCommand(`exam mark ${n || ''}`);
+        const state = getExamState();
+        if (!state) {
+            printError('No exam in progress.');
+            return;
+        }
+        const total = state.questions.length;
+        const targetN = n ? parseInt(n, 10) : (state._lastQ || 1);
+        if (isNaN(targetN) || targetN < 1 || targetN > total) {
+            printError(`Invalid question number. Use 1..${total}.`);
+            return;
+        }
+        const nowMarked = toggleBookmark(state, targetN);
+        console.log();
+        if (nowMarked) {
+            console.log(chalk.yellow(`  ★ Q${targetN} flagged for review.`));
+        }
+        else {
+            console.log(chalk.gray(`  ☆ Q${targetN} unflagged.`));
+        }
+        const all = Array.isArray(state.bookmarks) ? state.bookmarks : [];
+        if (all.length > 0) {
+            console.log(chalk.gray(`  Currently flagged: ${all.map((x) => `Q${x}`).join(', ')}`));
+        }
+        console.log(chalk.gray('  See all flagged questions in: ') + chalk.white('exam review'));
+        console.log();
+    });
+    // ─── exam unmark [n] ───
+    exam
+        .command('unmark [n]')
+        .description('Remove review flag from a question')
+        .action((n) => {
+        logCommand(`exam unmark ${n || ''}`);
+        const state = getExamState();
+        if (!state) {
+            printError('No exam in progress.');
+            return;
+        }
+        const total = state.questions.length;
+        const targetN = n ? parseInt(n, 10) : (state._lastQ || 1);
+        if (isNaN(targetN) || targetN < 1 || targetN > total) {
+            printError(`Invalid question number. Use 1..${total}.`);
+            return;
+        }
+        if (!isBookmarked(state, targetN)) {
+            console.log(chalk.gray(`  Q${targetN} was not flagged.`));
+            return;
+        }
+        toggleBookmark(state, targetN);
+        console.log();
+        console.log(chalk.gray(`  ☆ Q${targetN} unflagged.`));
+        console.log();
+    });
     // ─── exam next ───
     exam
         .command('next')
@@ -807,13 +987,27 @@ export function registerExamCommand(program) {
         console.log();
         const cols = 6;
         let line = '  ';
+        const marks = Array.isArray(state.bookmarks) ? state.bookmarks : [];
         for (const q of state.questions) {
             const ans = state.answers[q.number];
+            const isMarked = marks.includes(q.number);
+            const star = isMarked ? '★' : ' ';
             if (ans) {
-                line += chalk.green(`Q${String(q.number).padStart(2)} [${ans}]  `);
+                // Answered + marked → bold yellow; answered only → green; unanswered + marked → yellow; unanswered → dim yellow
+                if (isMarked) {
+                    line += chalk.bold.yellow(`Q${String(q.number).padStart(2)}${star}[${ans}] `);
+                }
+                else {
+                    line += chalk.green(`Q${String(q.number).padStart(2)} [${ans}]  `);
+                }
             }
             else {
-                line += chalk.yellow(`Q${String(q.number).padStart(2)} [ ]  `);
+                if (isMarked) {
+                    line += chalk.bold.yellow(`Q${String(q.number).padStart(2)}${star}[ ]  `);
+                }
+                else {
+                    line += chalk.yellow(`Q${String(q.number).padStart(2)} [ ]  `);
+                }
             }
             if (q.number % cols === 0) {
                 console.log(line);
@@ -834,16 +1028,26 @@ export function registerExamCommand(program) {
                 .join(', ');
             printKeyValue('Unanswered', chalk.yellow(`${unanswered} (Q${missing})`));
         }
+        if (marks.length > 0) {
+            printKeyValue('Flagged for review', chalk.bold.yellow(`★ ${marks.length}`) + chalk.gray(` (${marks.map((x) => `Q${x}`).join(', ')})`));
+        }
         console.log();
-        console.log(chalk.gray('  Ready? Use "exam submit" to submit for grading.'));
+        if (marks.length > 0) {
+            console.log(chalk.gray('  Jump to a flagged question: ') + chalk.white(`exam q ${marks[0]}`));
+        }
+        console.log(chalk.gray('  Ready? Use ') + chalk.bold.cyan('exam submit') + chalk.gray(' to submit for grading.'));
     });
-    // ─── exam submit ───
+    // ─── exam submit [confirm] ───
     exam
-        .command('submit')
-        .description('Submit exam for grading')
-        .action(async () => {
-        logCommand('exam submit');
+        .command('submit [confirmArg]')
+        .description('Submit exam for grading (use: "exam submit confirm" for real exams)')
+        .action(async (confirmArg) => {
+        logCommand(`exam submit ${confirmArg || ''}`);
         const state = getExamState();
+        if (state && confirmArg === 'confirm') {
+            state._submitConfirmed = true;
+            saveExamState(state);
+        }
         if (!state) {
             printError('No exam in progress.');
             return;
@@ -865,16 +1069,46 @@ export function registerExamCommand(program) {
             }
             return;
         }
-        // Demo: submit directly. Real exam: show warning first.
+        // Demo: submit directly. Real exam: require typed confirmation.
         if (state.session.examId !== 'demo-free') {
-            console.log();
-            console.log(chalk.yellow(`  Submitting ${answered}/${total} answers.`));
-            if (unanswered > 0) {
-                console.log(chalk.yellow(`  ${unanswered} unanswered.`));
+            const confirmedAlready = state._submitConfirmed === true;
+            const deadline = getExamDeadline();
+            const expired = !!(deadline && new Date() >= deadline);
+            if (!confirmedAlready && !expired) {
+                // First press of `exam submit` — show a clear preflight summary and
+                // require the user to run `exam submit confirm` to proceed. Typing
+                // out "confirm" is the deliberate action that prevents accidental
+                // submissions while an exam is still in progress.
+                console.log();
+                console.log(chalk.red('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+                console.log(chalk.bold.red('  ⚠  FINAL SUBMISSION — please confirm'));
+                console.log(chalk.red('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+                console.log();
+                console.log(chalk.white(`  You will submit ${chalk.bold.green(`${answered}/${total}`)} answers.`));
+                if (unanswered > 0) {
+                    const missingList = state.questions
+                        .filter((q) => !state.answers[q.number])
+                        .map((q) => `Q${q.number}`)
+                        .join(', ');
+                    console.log(chalk.yellow(`  ${unanswered} unanswered: ${missingList}`));
+                }
+                const marks = Array.isArray(state.bookmarks) ? state.bookmarks : [];
+                if (marks.length > 0) {
+                    console.log(chalk.yellow(`  ★ ${marks.length} still flagged for review: ${marks.map((x) => `Q${x}`).join(', ')}`));
+                }
+                console.log();
+                console.log(chalk.white('  Answers are ') + chalk.bold.red('final') + chalk.white(' — you cannot change them after submit.'));
+                console.log();
+                console.log(chalk.bold.white('  To confirm:  ') + chalk.bold.cyan('exam submit confirm'));
+                console.log(chalk.white('  To go back:  ') + chalk.cyan('exam review') + chalk.gray('  or  ') + chalk.cyan('back'));
+                console.log();
+                return;
+            }
+            // Clear the flag so a subsequent re-entry requires re-confirmation.
+            if (confirmedAlready) {
+                delete state._submitConfirmed;
+                saveExamState(state);
             }
-            console.log(chalk.gray('  You cannot change answers after this.'));
-            console.log(chalk.gray('  Type "back" now to cancel, or wait...'));
-            await sleep(2000);
         }
         console.log();
         // Demo exam: grade locally
@@ -1054,6 +1288,10 @@ export function registerExamCommand(program) {
                         answers: state.answers,
                         interactions: state.interactions || [],
                         aiUsage: state.aiUsage || { ai4ctf: 0, ctf4ai: 0 },
+                        // Flagged-for-review questions (display numbers). Server maps
+                        // these to original pool numbers for cross-session aggregation
+                        // so the exam center can spot high-flag-rate questions.
+                        bookmarks: state.bookmarks || [],
                     }),
                     signal: AbortSignal.timeout(15000),
                 });
@@ -1074,12 +1312,97 @@ export function registerExamCommand(program) {
             await sleep(300);
             drawProgress(100, 'Complete!');
             console.log();
+            // Capture stats from state BEFORE we clear it for the debrief display.
+            const preSubmit = {
+                answered: Object.keys(state.answers).length,
+                total: state.session.questionCount,
+                bookmarks: Array.isArray(state.bookmarks) ? state.bookmarks.length : 0,
+                help: getHelpState(state),
+                aiUsage: state.aiUsage || { ai4ctf: 0, ctf4ai: 0 },
+                interactions: (state.interactions || []).length,
+                durationMin: state.session.durationMinutes || 0,
+                confirmedAt: state.session.confirmedAt || state.session.startedAt,
+            };
             clearExamState();
+            const elapsedSec = Math.max(0, Math.round((Date.now() - new Date(preSubmit.confirmedAt).getTime()) / 1000));
+            const elapsedMin = Math.floor(elapsedSec / 60);
+            const elapsedS = elapsedSec % 60;
+            // ─── Student debrief — qualitative only ───
+            // National Selection: student sees pass/fail and directional feedback.
+            // Numeric scores go to the country's exam center who decides the real
+            // selection bar. This respects national autonomy — each country picks
+            // who advances based on their own criteria (top N, percentile, etc.).
             console.log();
-            printHeader('Exam Result');
-            printKeyValue('Score', chalk.bold(`${result.score}/${result.total}`));
-            printKeyValue('Percentage', chalk.bold(`${result.percentage}%`));
-            printKeyValue('Status', result.passed ? chalk.green.bold('PASSED') : chalk.red.bold('NOT PASSED'));
+            console.log(chalk.cyan('  ═════════════════════════════════════════════'));
+            console.log();
+            console.log(chalk.bold.white('   ██╗ ██████╗ ██████╗  █████╗'));
+            console.log(chalk.bold.white('   ██║██╔════╝██╔═══██╗██╔══██╗'));
+            console.log(chalk.bold.white('   ██║██║     ██║   ██║███████║'));
+            console.log(chalk.bold.white('   ██║██║     ██║   ██║██╔══██║'));
+            console.log(chalk.bold.white('   ██║╚██████╗╚██████╔╝██║  ██║'));
+            console.log(chalk.bold.white('   ╚═╝ ╚═════╝ ╚═════╝ ╚═╝  ╚═╝'));
+            console.log();
+            const statusLine = result.passed
+                ? chalk.green.bold('   ✓  Submission accepted — baseline met')
+                : chalk.yellow.bold('   ○  Submission accepted');
+            console.log(statusLine);
+            console.log();
+            console.log(chalk.white('   Your answers have been recorded and sent to your national'));
+            console.log(chalk.white('   exam center. Final scoring and selection are decided by'));
+            console.log(chalk.white('   the organizer in your country.'));
+            console.log();
+            console.log(chalk.cyan('  ─────────────────────────────────────────────'));
+            console.log();
+            // Your run — personal stats only, no score
+            console.log(chalk.bold.white('  Your run'));
+            const unanswered = preSubmit.total - preSubmit.answered;
+            console.log('    ' + chalk.gray('Answered:  ') + chalk.white(`${preSubmit.answered}/${preSubmit.total}`)
+                + (unanswered > 0 ? chalk.gray(`  ·  ${unanswered} skipped`) : ''));
+            console.log('    ' + chalk.gray('Time used: ') + chalk.white(`${elapsedMin}m ${elapsedS}s`)
+                + chalk.gray(`  of ${preSubmit.durationMin}m total`));
+            if (preSubmit.bookmarks > 0) {
+                console.log('    ' + chalk.gray('Flagged:   ') + chalk.yellow(`★ ${preSubmit.bookmarks}`));
+            }
+            console.log();
+            // Qualitative category feedback: "stronger" vs "area to grow" based on
+            // relative rank, not absolute percentages. Never reveals numbers.
+            const catStats = result.categoryStats;
+            if (catStats && Object.keys(catStats).length >= 2) {
+                const ranked = Object.entries(catStats)
+                    .filter(([, s]) => s.total > 0)
+                    .map(([cat, s]) => ({ cat, pct: s.correct / s.total }))
+                    .sort((a, b) => b.pct - a.pct);
+                const topCount = Math.min(2, Math.ceil(ranked.length / 3));
+                const bottomCount = Math.min(2, Math.ceil(ranked.length / 3));
+                const strong = ranked.slice(0, topCount).map((r) => r.cat);
+                const grow = ranked.slice(-bottomCount).map((r) => r.cat);
+                // Only show if there's actual variation (avoid "strong: X, grow: X")
+                const overlap = strong.some((s) => grow.includes(s));
+                if (!overlap) {
+                    console.log(chalk.bold.white('  Directional feedback'));
+                    console.log('    ' + chalk.green('Stronger here:  ') + chalk.white(strong.join(', ')));
+                    console.log('    ' + chalk.yellow('Room to grow:   ') + chalk.white(grow.join(', ')));
+                    console.log(chalk.gray('    (relative to other categories — numeric scores go to your exam center)'));
+                    console.log();
+                }
+            }
+            // Assistance usage — personal, fine to show
+            console.log(chalk.bold.white('  Assistance used'));
+            console.log('    ' + chalk.gray('Help:      ') + chalk.white(`${preSubmit.help.used}/${preSubmit.help.max}`));
+            console.log('    ' + chalk.gray('AI tokens: ') + chalk.white(`${preSubmit.aiUsage.ai4ctf} AI4CTF`) + chalk.gray('  ·  ') + chalk.white(`${preSubmit.aiUsage.ctf4ai} CTF4AI`));
+            console.log();
+            console.log(chalk.cyan('  ─────────────────────────────────────────────'));
+            console.log();
+            // Next steps
+            console.log(chalk.bold.white('  What next'));
+            console.log(chalk.gray('  · Your national organizer will announce selection results.'));
+            console.log(chalk.gray('  · Keep sharpening: ') + chalk.white('demo') + chalk.gray(' is free, unlimited practice.'));
+            console.log(chalk.gray('  · Reference guides for 38 tools: ') + chalk.white('ref'));
+            console.log();
+            console.log(chalk.yellow('  ICOA 2026 · Sydney, Australia · Jun 27 – Jul 2'));
+            console.log(chalk.cyan.underline('  https://icoa2026.au'));
+            console.log();
+            console.log(chalk.cyan('  ═════════════════════════════════════════════'));
             console.log();
         }
         catch (err) {

package/dist/lib/i18n.d.ts

@@ -141,6 +141,8 @@ export declare const EN: {
     enterExam: string;
     htpJump: string;
     htpReview: string;
+    htpSubmit: string;
+    htpMark: string;
     nextLabel: string;
     reportRetryCta: string;
     reportRetryWrongN: string;

package/dist/lib/i18n.js

@@ -155,6 +155,8 @@ export const EN = {
     // Exam help footer (v2.19.26)
     htpJump: 'jump to a specific question',
     htpReview: 'check progress',
+    htpSubmit: 'submit your answers for grading',
+    htpMark: 'flag this question to review later',
     // Stage 1 → Stage 2 handoff (v2.19.28)
     nextLabel: 'Next:',
     // Final report retry/back menu (v2.19.28)

package/dist/repl.js

@@ -413,19 +413,43 @@ export async function startRepl(program, resumeMode) {
             realExit(0);
             return;
         }
-        // "back" — return to main menu (clear exam state for demo, keep for real)
+        // "back" — return to main menu.
+        //   Real exam:       show "Exam paused", preserve state (server timer is ticking).
+        //   Active demo:     show pause message, keep state so `exam q N` can resume.
+        //   Stale demo:      auto-clear and show menu (demo from a previous session the
+        //                    user long abandoned — hanging state makes the menu lie).
+        //   Nothing:         show selection menu.
+        // A demo is "active" if `startedAt` is within the last 30 minutes. That window
+        // covers an intentional "back to check something and come right back" case but
+        // clears anything left over from a prior session.
         if (input === 'back') {
             const state = getExamState();
-            if (state) {
+            const isRealExam = state && state.session.examId !== 'demo-free';
+            const isActiveDemo = state && state.session.examId === 'demo-free' && (() => {
+                const started = new Date(state.session.startedAt || 0).getTime();
+                return Date.now() - started < 30 * 60 * 1000;
+            })();
+            if (isRealExam) {
                 console.log();
                 console.log(chalk.gray('  Exam paused. Your progress is saved.'));
                 console.log(chalk.white('  Resume: exam q 1') + chalk.gray('  ·  ') + chalk.white('exam review') + chalk.gray('  ·  ') + chalk.white('exam submit'));
                 console.log();
             }
+            else if (isActiveDemo) {
+                const answered = Object.keys(state.answers).length;
+                const total = state.session.questionCount;
+                console.log();
+                console.log(chalk.gray(`  Demo paused (${answered}/${total} answered). Resume with: `) + chalk.white(`exam q 1`));
+                console.log(chalk.gray('  Or type ') + chalk.white('demo') + chalk.gray(' to restart.'));
+                console.log();
+            }
             else {
-                // No active exam — typically this is the "post-report back" choice
-                // after the user has finished the 3-stage demo flow. Report it as a
-                // distinct event so the admin can count retry vs back decisions.
+                // Stale demo state from a past session — clear it so the menu reflects
+                // reality. Demo is free-practice, user can always restart.
+                if (state && state.session.examId === 'demo-free') {
+                    const { clearExamState } = await import('./lib/exam-state.js');
+                    clearExamState('demo-free');
+                }
                 const cfg = getConfig();
                 fetch('https://practice.icoa2026.au/api/icoa/demo-stats', {
                     method: 'POST',
@@ -437,8 +461,6 @@ export async function startRepl(program, resumeMode) {
                     }),
                     signal: AbortSignal.timeout(5000),
                 }).catch(() => { });
-                // Show the National Selection menu so the user always knows what
-                // commands are available (demo / exam setup / exam <token>).
                 if (mode === 'selection') {
                     printSelectionMenu();
                 }
@@ -607,8 +629,8 @@ export async function startRepl(program, resumeMode) {
         }
         const cmd = input.split(/\s+/)[0].toLowerCase();
         // ─── Mode-based command filtering ───
-        const selectionCommands = ['exam', 'demo', 'retry', 'nations', 'next', 'prev', 'continue', 'setup', 'lang', 'ref', 'ai4ctf', 'ctf4ai'];
-        const organizerCommands = ['join', 'exam', 'demo', 'retry', 'next', 'prev', 'logout', 'setup', 'lang', 'ref', 'ctf'];
+        const selectionCommands = ['exam', 'demo', 'retry', 'nations', 'next', 'prev', 'continue', 'setup', 'lang', 'ref', 'ai4ctf', 'ctf4ai', 'mark', 'unmark', 'review', 'submit'];
+        const organizerCommands = ['join', 'exam', 'demo', 'retry', 'next', 'prev', 'logout', 'setup', 'lang', 'ref', 'ctf', 'mark', 'unmark', 'review', 'submit'];
         if (mode === 'selection' && !selectionCommands.includes(cmd)) {
             console.log(chalk.gray('  Not available in Selection mode.'));
             if (examState) {
@@ -715,7 +737,12 @@ export async function startRepl(program, resumeMode) {
             return;
         }
         processing = true;
-        const args = mapCommand(input);
+        // During an exam, `submit` must mean "submit my exam", not "submit a CTF
+        // flag". The `mapCommand` shortcut table always points `submit` at CTF,
+        // which silently fails in Selection mode and leaves users stuck. Route
+        // to exam submit here instead.
+        const submitInExam = examState && (input.toLowerCase() === 'submit');
+        const args = submitInExam ? ['exam', 'submit'] : mapCommand(input);
         // Pause REPL readline for commands that read stdin (join)
         const needsPause = args[0] === 'ctf' && args[1] === 'join';
         if (needsPause)
@@ -792,6 +819,9 @@ function mapCommand(input) {
         'nations': ['exam', 'nations'],
         'next': ['exam', 'next'],
         'prev': ['exam', 'prev'],
+        'mark': ['exam', 'mark', ...rest],
+        'unmark': ['exam', 'unmark', ...rest],
+        'review': ['exam', 'review'],
         'logout': ['ctf', 'logout'],
         'join': ['ctf', 'join', ...rest],
         'activate': ['ctf', 'activate', ...rest],

package/dist/types/index.d.ts

@@ -184,6 +184,8 @@ export interface ExamState {
         ai4ctf: number;
         ctf4ai: number;
     };
+    bookmarks?: number[];
+    shownWarnings?: string[];
 }
 export interface ExamResult {
     examId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icoa-cli",
-  "version": "2.19.51",
+  "version": "2.19.53",
   "description": "ICOA CLI — The world's first CLI-native CTF competition terminal",
   "type": "module",
   "bin": {