moodle-cli 0.9.1 → 0.9.3

package/dist/moodle.js

@@ -11,7 +11,10 @@ var fields = (keys) => Object.fromEntries(keys.map((key) => [key, s]));
 var file = z.object({ name: s, url: s, requires_authentication: z.boolean().optional() });
 var activityFields = { id, name: s, type: s, unit_id: n, section_id: n, hidden: z.boolean().optional(), due: s, due_at: n, files: z.array(file).optional() };
 var activityListSchema = z.object({ ...activityFields, section: s, unit_code: s, description: s });
-var activitySchema = z.object({ ...activityFields, ...fields(["url", "target_url", "section", "unit_code", "description", "submission_status", "grading_status", "grade", "due_pretty", "opens_pretty", "closes_pretty", "attempts_allowed", "availability", "time_remaining", "content_text"]), files: z.array(file).optional() });
+var criterion = z.object({ name: s, level: s, score: s, remark: s });
+var attemptSummary = { id, status: s, started: s, completed: s, duration: s, marks: s, grade: s };
+var question = z.object({ number: id, type: s, state: s, mark: s, text: s, response: s, correct: s, feedback: s });
+var activitySchema = z.object({ ...activityFields, ...fields(["url", "target_url", "section", "unit_code", "description", "submission_status", "grading_status", "grade", "graded_on", "graded_by", "feedback_comments", "due_pretty", "opens_pretty", "closes_pretty", "attempts_allowed", "time_limit", "availability", "time_remaining", "content_text"]), criteria: z.array(criterion).optional(), attempts: z.array(z.object({ ...attemptSummary, number: id })).optional(), files: z.array(file).optional() });
 var sectionSchema = z.object({ id, name: s, activity_count: id, hidden: z.boolean().optional(), positional: z.boolean().optional(), activities: z.array(activityListSchema).optional() });
 var current = z.object({ id, name: s, estimated: z.boolean().optional() });
 var unitSchema = z.object({ id, code: s, name: s, start: s, end: s, start_at: n, end_at: n, hidden: z.boolean().optional(), current_section: current.optional() });
@@ -25,25 +28,30 @@ var receiptSchema = z.object({ id, name: s, unit_id: n, url: s, action: z.enum([
 var input = (shape) => z.object(shape).strict();
 var list = (key, value) => z.object({ [key]: z.array(value).optional(), total: id });
 var intentContracts = {
-  home: { when: "dashboard", command: "moodle", what: "Today, timezone, due items and unread counts.", instead: "due for longer deadline lists", refs: "days defaults to 14", then: "unit or item", cost: "small dashboard", input: input({ days: z.number().int().min(1).max(365).default(14) }), output: z.object({ home: z.object({ today: z.string(), timezone: z.string(), timezone_source: s, name: s, siteurl: s, units: z.array(unitSchema).optional(), due: z.array(dueSchema).optional(), total: id, unread: counts.optional(), errors: z.array(z.string()).optional() }) }) },
+  home: { when: "dashboard", command: "moodle", what: "Today's date and timezone, items due soon, unread counts and the current section of each unit.", instead: "due for longer deadline lists", refs: "days defaults to 14", then: "unit or item", cost: "small dashboard", input: input({ days: z.number().int().min(1).max(365).default(14) }), output: z.object({ home: z.object({ today: z.string(), timezone: z.string(), timezone_source: s, name: s, siteurl: s, units: z.array(unitSchema).optional(), due: z.array(dueSchema).optional(), total: id, unread: counts.optional(), errors: z.array(z.string()).optional() }) }) },
   due: { when: "deadlines", command: "moodle due [UNIT] --days 14", what: "Items due in a date window.", instead: "item for submission details", refs: "unit code, name, id or URL", then: "item with activity_id", cost: "up to 20 rows by default", input: input({ unit: ref.optional(), days: z.number().int().min(1).max(365).default(14), limit }), output: list("due", dueSchema) },
   units: { when: "unit names", command: "moodle units", what: "Enrolled units with ids, codes and names.", instead: "unit for sections", refs: "none", then: "unit with a name or id", cost: "small list", input: input({ limit: limit.default(200) }), output: list("units", unitSchema) },
   unit: { when: "a unit or section", command: "moodle UNIT [SECTION]", what: "Section index and current section; section argument returns activities and files.", instead: "find for a named item", refs: "unit code, name, id or URL; section number or name", then: "item or file with activity id", cost: "index about 4 KB; section about 0.5 KB", input: input({ unit: ref, section: ref.optional() }), output: z.object({ unit: unitSchema, sections: z.array(sectionSchema).optional(), total: id }) },
   find: { when: "find slides or a task", command: 'moodle find "QUERY" [UNIT]', what: "Ranked sections, activities and discussion subjects.", instead: "search_forums for post text; due for deadlines", refs: "query and optional unit code, name, id or URL", then: "item or file with id", cost: "up to 20 rows by default", input: input({ query: z.string().trim().min(1), unit: ref.optional(), types: z.array(z.string()).optional(), limit }), output: list("results", activityListSchema) },
-  item: { when: "submission or item detail", command: 'moodle UNIT "TASK"', what: "Activity due dates, status, grades, files, or latest forum threads.", instead: "file for binary content", refs: "id, same-site URL, or UNIT TASK phrase", then: "file with id or files URL", cost: "one item", input: input({ ref }), output: z.object({ item: activitySchema, threads: z.array(z.object({ id, name: s })).optional(), total: n }) },
-  grades: { when: "my grades", command: "moodle grades [UNIT]", what: "Grades across units or in one unit.", instead: "item for submission status", refs: "optional unit code, name, id or URL", then: "item for an ungraded task", cost: "graded_only narrows output", input: input({ unit: ref.optional(), graded_only: z.boolean().default(false) }), output: list("grades", gradeSchema) },
+  item: { when: "submission or item detail", command: 'moodle UNIT "TASK"', what: "One activity in full: due date, status, grade, marker feedback with rubric or marking-guide rows and feedback files, attached files, quiz attempts, or a forum's latest threads.", instead: "file for binary content; attempt for quiz answers", refs: "id, same-site URL, or UNIT TASK phrase", then: "file with a file id, or attempt with an attempt id", cost: "one item", input: input({ ref }), output: z.object({ item: activitySchema, threads: z.array(z.object({ id, name: s })).optional(), total: n }) },
+  attempt: { when: "a quiz attempt", command: "moodle attempt ID", what: "Each question with your response, and mark, correct answer and feedback when the site shows them.", instead: "item for the attempt list", refs: "attempt id or review URL", then: "item with quiz_id", cost: "one attempt", input: input({ attempt: ref }), output: z.object({ attempt: z.object({ ...attemptSummary, quiz_id: n, unit_id: n, url: s, questions: z.array(question).optional() }) }) },
+  grades: { when: "my grades", command: "moodle grades [UNIT]", what: "Gradebook rows across units or in one unit, with grade, range, percentage and grader feedback.", instead: "item for submission status and rubric detail", refs: "optional unit code, name, id or URL", then: "item for an ungraded task", cost: "graded_only narrows output", input: input({ unit: ref.optional(), graded_only: z.boolean().default(false) }), output: list("grades", gradeSchema) },
   news: { when: "announcements", command: "moodle news [UNIT]", what: "Latest announcement threads with first-post text.", instead: "search_forums for other discussions", refs: "optional unit code, name, id or URL", then: "thread with discussion id", cost: "up to 5 announcements by default", input: input({ unit: ref.optional(), limit: limit.default(5) }), output: list("news", z.object({ id, name: s, unit_id: id, unit_code: s, forum_id: id, post: postSchema.optional() })) },
   thread: { when: "discussion posts", command: "moodle threads show ID", what: "A discussion and a page of compact posts, with attachment links.", instead: "news for announcements", refs: "discussion_id; offset and limit", then: "increase offset while posts_total exceeds returned", cost: "up to 20 posts by default", input: input({ discussion_id: z.number().int().positive(), limit, offset: z.number().int().nonnegative().default(0) }), output: z.object({ thread: z.object({ id, name: s, unit_id: id, forum_id: id, url: s, posts: z.array(postSchema).optional(), posts_total: id, offset: id }) }) },
   search_forums: { when: "forum post text", command: 'moodle forums search "QUERY" --unit UNIT', what: "Matching posts with unit and forum name maps.", instead: "find for activity names", refs: "query, optional unit or courseId and forumId", then: "thread with discussion_id", cost: "bounded forum scan; total covers scanned scope", input: input({ query: z.string().trim().min(1), unit: ref.optional(), courseId: z.number().int().positive().optional(), forumId: z.number().int().positive().optional(), limit, includePostText: z.boolean().default(true), titlesOnly: z.boolean().default(false), unreadOnly: z.boolean().default(false), sortBy: z.enum(["relevance", "recent"]).default("relevance"), maxForums: limit.default(20), maxDiscussionsPerForum: limit.default(50) }), output: z.object({ results: z.array(searchSchema).optional(), total: id, forums: z.record(z.string(), z.string()).optional(), units: z.record(z.string(), z.string()).optional(), scope: z.object({ max_forums: id, max_discussions_per_forum: id }) }) },
   submit: { when: "upload assignment files", command: 'moodle submit "UNIT TASK" FILE... [--final]', what: "Upload local files into an assignment; returns the receipt Moodle shows afterwards.", instead: "item for status only", refs: "assignment id, same-site URL or UNIT TASK phrase; local file paths", then: "dry_run (default) only plans; show the plan to the person, then rerun with dry_run false; final submits for grading and cannot be undone", cost: "writes to Moodle", input: input({ ref, files: z.array(z.string().trim().min(1)).max(20).default([]), final: z.boolean().default(false), replace: z.boolean().default(false), accept_statement: z.boolean().default(false), dry_run: z.boolean().default(true) }), output: z.object({ submission: receiptSchema }) },
-  file: { when: "download a file", command: 'moodle get "UNIT TASK" --to DIR', what: "One authenticated file as embedded content, at most 16 MiB.", instead: "item for file choices", refs: "resource id, same-site URL, or UNIT TASK phrase", then: "read the returned resource", cost: "binary content up to 16 MiB", input: input({ ref }), output: z.object({ file: z.object({ name: z.string(), mime_type: z.string(), bytes: id, uri: z.string() }) }) }
+  file: { when: "download a file", command: 'moodle get "UNIT TASK" --to DIR', what: "One authenticated file: an image as image content, anything else as embedded binary, at most 16 MiB.", instead: "item for file choices", refs: "resource id, same-site URL, or UNIT TASK phrase", then: "read the returned image or resource", cost: "binary content up to 16 MiB", input: input({ ref }), output: z.object({ file: z.object({ name: z.string(), mime_type: z.string(), bytes: id, uri: z.string() }) }) }
 };
 function humanDescription(name) {
   return intentContracts[name].what;
 }
 function intentDescription(name) {
   const c = intentContracts[name];
-  return `${c.what} Use when: ${c.when}. Not for: ${c.instead}. Refs: ${c.refs}. Then: ${c.then}. Cost: ${c.cost}.`;
+  const alternatives = c.instead.split("; ").map((rule) => {
+    const [tool, ...purpose] = rule.split(" for ");
+    return `for ${purpose.join(" for ")} call ${tool}`;
+  }).join("; ");
+  return `${c.what} Use it for ${c.when}; ${alternatives}. Input: ${c.refs}. Next: ${c.then}. Cost: ${c.cost}.`;
 }
 
 // src/results.ts
@@ -182,11 +190,17 @@ import { join as join5 } from "path";
 // src/constants.ts
 var PACKAGE_NAME = "moodle-cli";
 var NPM_LATEST_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var GITHUB_RELEASES_URL = "https://github.com/bunizao/moodle-cli/releases/latest";
 var AJAX_SERVICE_PATH = "/lib/ajax/service.php";
 var DASHBOARD_PATH = "/my/";
 var COURSE_PATH = "/course/view.php";
 var ASSIGN_VIEW_PATH = "/mod/assign/view.php";
 var QUIZ_VIEW_PATH = "/mod/quiz/view.php";
+var QUIZ_REVIEW_PATH = "/mod/quiz/review.php";
+var QUIZ_START_PATH = "/mod/quiz/startattempt.php";
+var QUIZ_ATTEMPT_PATH = "/mod/quiz/attempt.php";
+var QUIZ_SUMMARY_PATH = "/mod/quiz/summary.php";
+var QUIZ_PROCESS_PATH = "/mod/quiz/processattempt.php";
 var RESOURCE_VIEW_PATH = "/mod/resource/view.php";
 var URL_VIEW_PATH = "/mod/url/view.php";
 var PAGE_VIEW_PATH = "/mod/page/view.php";
@@ -381,16 +395,16 @@ async function findChromiumBrowser(options = {}) {
   if (options.browserPath) {
     return { name: "Chromium", path: options.browserPath };
   }
-  const platform = options.platform ?? process.platform;
+  const platform2 = options.platform ?? process.platform;
   const env = options.env ?? process.env;
-  if (platform === "linux") {
+  if (platform2 === "linux") {
     for (const candidate of LINUX_BROWSERS) {
-      const resolved = resolveFromPath(candidate.path, env, platform);
+      const resolved = resolveFromPath(candidate.path, env, platform2);
       if (resolved) return { name: candidate.name, path: resolved };
     }
     return null;
   }
-  const candidates = platform === "win32" ? windowsBrowsers(env) : MAC_BROWSERS;
+  const candidates = platform2 === "win32" ? windowsBrowsers(env) : MAC_BROWSERS;
   for (const candidate of candidates) {
     if (await isExecutable(candidate.path)) return candidate;
   }
@@ -547,9 +561,9 @@ async function isExecutable(path5) {
     return false;
   }
 }
-function resolveFromPath(name, env, platform) {
+function resolveFromPath(name, env, platform2) {
   if (name.includes("/")) return null;
-  const separator = platform === "win32" ? ";" : ":";
+  const separator = platform2 === "win32" ? ";" : ":";
   for (const dir of (env.PATH ?? "").split(separator).filter(Boolean)) {
     const candidate = join2(dir, name);
     try {
@@ -841,6 +855,14 @@ function createDeploymentCredentials(createToken) {
 function isUnavailable(error) {
   return error instanceof CredentialBackendUnavailableError;
 }
+async function readCredentialsForReport(read) {
+  try {
+    return { value: await read(), available: true };
+  } catch (error) {
+    if (!isUnavailable(error)) throw error;
+    return { value: null, available: false };
+  }
+}
 
 // src/mcp/credentials/node-store.ts
 var SERVICE = "moodle-cli-mcp";
@@ -1252,13 +1274,13 @@ var PrivateFileCredentialBackend = class {
   }
 };
 function createDefaultCredentialStore(options = {}) {
-  const platform = options.platform ?? process.platform;
+  const platform2 = options.platform ?? process.platform;
   const runner = options.runner ?? new NodeCredentialCommandRunner();
-  const preferred = platform === "darwin" ? new MacOSKeychainCredentialBackend(runner) : platform === "linux" ? new LinuxSecretServiceCredentialBackend(runner) : platform === "win32" ? new WindowsCredentialManagerBackend(runner) : new UnavailableCredentialBackend(`${platform} credential store`);
+  const preferred = platform2 === "darwin" ? new MacOSKeychainCredentialBackend(runner) : platform2 === "linux" ? new LinuxSecretServiceCredentialBackend(runner) : platform2 === "win32" ? new WindowsCredentialManagerBackend(runner) : new UnavailableCredentialBackend(`${platform2} credential store`);
   const home = options.homeDirectory ?? homedir3();
-  const fallbackDirectory = platform === "win32" ? windowsPath.join(home, "AppData", "Local", "moodle-cli", "credentials") : join3(home, ".config", "moodle-cli", "mcp", "credentials");
-  const fallback = platform === "win32" ? new WindowsDpapiFileCredentialBackend(fallbackDirectory, runner) : new PrivateFileCredentialBackend(fallbackDirectory);
-  return new SafeCredentialStore(preferred, fallback, platform !== "win32");
+  const fallbackDirectory = platform2 === "win32" ? windowsPath.join(home, "AppData", "Local", "moodle-cli", "credentials") : join3(home, ".config", "moodle-cli", "mcp", "credentials");
+  const fallback = platform2 === "win32" ? new WindowsDpapiFileCredentialBackend(fallbackDirectory, runner) : new PrivateFileCredentialBackend(fallbackDirectory);
+  return new SafeCredentialStore(preferred, fallback, platform2 !== "win32");
 }
 function parseCredentials(value) {
   const parsed = JSON.parse(value);
@@ -1764,11 +1786,11 @@ async function defaultBrowserCookieProvider(baseUrl, options = {}) {
 }
 async function braveProfilePaths(options = {}) {
   const home = options.homeDir ?? homedir5();
-  const platform = options.platform ?? process.platform;
-  const roots = platform === "linux" ? [
+  const platform2 = options.platform ?? process.platform;
+  const roots = platform2 === "linux" ? [
     join5(home, ".config/BraveSoftware/Brave-Browser"),
     join5(home, ".var/app/com.brave.Browser/config/BraveSoftware/Brave-Browser")
-  ] : platform === "win32" ? [join5(home, "AppData/Local/BraveSoftware/Brave-Browser/User Data")] : platform === "darwin" ? [join5(home, "Library/Application Support/BraveSoftware/Brave-Browser")] : [];
+  ] : platform2 === "win32" ? [join5(home, "AppData/Local/BraveSoftware/Brave-Browser/User Data")] : platform2 === "darwin" ? [join5(home, "Library/Application Support/BraveSoftware/Brave-Browser")] : [];
   const profiles = [];
   for (const root of roots) {
     try {
@@ -1802,8 +1824,8 @@ var MINIMUM_NODE_FOR_BROWSER_COOKIES = "22.13.0";
 function cookieAccessBlocked(warnings) {
   return warnings.some((warning) => COOKIE_ACCESS_DENIED.test(warning) || COOKIE_SQLITE_UNAVAILABLE.test(warning));
 }
-function cookieAccessHint(warnings, platform = process.platform, unreadable = [], env = process.env) {
-  const grant = platform === "darwin" ? [
+function cookieAccessHint(warnings, platform2 = process.platform, unreadable = [], env = process.env) {
+  const grant = platform2 === "darwin" ? [
     `Grant Full Disk Access to ${hostApplicationName(env) ?? "the application running this command"}, then restart it:`,
     `  open "${FULL_DISK_ACCESS_PANE}"`
   ].join("\n") : "Run this command as the user that owns the browser profile, or grant it read access to the browser cookie store.";
@@ -1835,9 +1857,9 @@ function cookieDiagnostics(warnings, unreadable) {
   ];
   return lines.length ? ["", "Cookie store diagnostics:", ...lines] : [];
 }
-function authFailureHint(baseUrl, cookieWarnings = [], platform = process.platform, unreadable = [], env = process.env) {
+function authFailureHint(baseUrl, cookieWarnings = [], platform2 = process.platform, unreadable = [], env = process.env) {
   if (cookieAccessBlocked(cookieWarnings) || unreadable.length) {
-    return cookieAccessHint(cookieWarnings, platform, unreadable, env);
+    return cookieAccessHint(cookieWarnings, platform2, unreadable, env);
   }
   return [
     `Log in to ${loginUrl(baseUrl)} in your browser, then rerun the command.`,
@@ -2444,8 +2466,8 @@ function buildKeepalivePlist(programArguments2, intervalMinutes, logPath) {
   ].join("\n");
 }
 async function installKeepalive(options = {}) {
-  const platform = options.platform ?? process.platform;
-  if (platform !== "darwin") {
+  const platform2 = options.platform ?? process.platform;
+  if (platform2 !== "darwin") {
     throw new Error(
       "Automatic keepalive install requires macOS launchd. Add a cron entry instead: */30 * * * * moodle auth keepalive --json"
     );
@@ -2556,8 +2578,8 @@ async function doctor(options = {}) {
 }
 
 // src/cli.ts
-import { rm as rm7, readdir as readdir4 } from "fs/promises";
-import { homedir as homedir15 } from "os";
+import { readFile as readFile11, rm as rm8, readdir as readdir4 } from "fs/promises";
+import { homedir as homedir16 } from "os";
 
 // src/mcp/renewal/decision.ts
 function decideRenewal(snapshot) {
@@ -2674,6 +2696,19 @@ var RenewalInstaller = class {
     }
   }
 };
+function describeRenewalJob(platform2, homeDirectory, profile, intervalMinutes = 30) {
+  const schedule = `silent check every ${intervalMinutes} minutes`;
+  if (platform2 === "darwin") {
+    const label2 = `com.moodle-cli.mcp-renewal.${profile}`;
+    return { scheduler: "launchd agent", label: label2, schedule, log: `${trimEnd(homeDirectory, "/")}/Library/Logs/${label2}.log` };
+  }
+  if (platform2 === "linux") {
+    const label2 = `moodle-cli-mcp-renewal-${profile}`;
+    return { scheduler: "systemd user timer", label: label2, schedule, log: `journalctl --user -u ${label2}` };
+  }
+  const label = `Moodle CLI MCP Renewal (${profile})`;
+  return { scheduler: "Task Scheduler task", label, schedule, log: "Task Scheduler history" };
+}
 function buildRenewalInstallPlan(options) {
   validateOptions(options);
   const intervalMinutes = options.intervalMinutes ?? 30;
@@ -2883,13 +2918,13 @@ var NodeRenewalInstallerIO = class {
   }
 };
 function createDefaultRenewalInstaller(profile, options = {}) {
-  const platform = options.platform ?? process.platform;
-  if (!isSupportedPlatform(platform)) {
-    throw new Error(`Moodle MCP renewal is not supported on ${platform}`);
+  const platform2 = options.platform ?? process.platform;
+  if (!isSupportedPlatform(platform2)) {
+    throw new Error(`Moodle MCP renewal is not supported on ${platform2}`);
   }
   const runtime = runtimeCommand(options.executable, options.executableArgs);
   const plan = buildRenewalInstallPlan({
-    platform,
+    platform: platform2,
     profile,
     executable: runtime.command,
     executableArgs: runtime.args,
@@ -2915,8 +2950,8 @@ var DefaultRenewalIntegration = class {
   }
 };
 var NodeRenewalNotificationSender = class {
-  constructor(platform = process.platform) {
-    this.platform = platform;
+  constructor(platform2 = process.platform) {
+    this.platform = platform2;
   }
   platform;
   async send(notification) {
@@ -2960,11 +2995,11 @@ var NodeRenewalNotificationSender = class {
     }
   }
 };
-function notifyRenewalSignInRequired(platform = process.platform) {
-  return sendRenewalNotification("sign_in_required", new NodeRenewalNotificationSender(platform));
+function notifyRenewalSignInRequired(platform2 = process.platform) {
+  return sendRenewalNotification("sign_in_required", new NodeRenewalNotificationSender(platform2));
 }
-function isSupportedPlatform(platform) {
-  return platform === "darwin" || platform === "linux" || platform === "win32";
+function isSupportedPlatform(platform2) {
+  return platform2 === "darwin" || platform2 === "linux" || platform2 === "win32";
 }
 function isMissing2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
@@ -3006,6 +3041,7 @@ function createMoodleGateway(client, hooks = {}) {
       return limit2 === void 0 ? activities : activities.slice(0, limit2);
     },
     getActivity: ({ activityId }) => client.getActivity(activityId),
+    ...client.getQuizAttempt ? { getQuizAttempt: (attemptId) => client.getQuizAttempt(attemptId) } : {},
     getGrades: ({ courseId }) => client.getCourseGrades(courseId),
     async listForums({ courseId, limit: limit2 }) {
       const forums = await client.getForums(courseId);
@@ -3046,7 +3082,9 @@ function createMoodleGateway(client, hooks = {}) {
         name,
         mimeType: contentType(response),
         bytes: content.byteLength,
-        uri: publicFileUrl(response.url || target.url),
+        // The Moodle-origin URL, never the post-redirect CDN one: stripping query parameters from
+        // a signed CDN link leaves an address that can only ever answer MissingKey.
+        uri: publicFileUrl(target.url),
         blob: encodeBase64(content)
       };
     }
@@ -3411,6 +3449,15 @@ function createIntentService(gateway, now = () => Date.now()) {
         result = { item: { ...itemRow(activity), ...due }, threads: threads?.slice(0, 20).map((t) => ({ id: t.id, name: t.subject })), total: threads?.length };
         break;
       }
+      case "attempt": {
+        if (!gateway.getQuizAttempt) throw new ReferenceError("not_found", "This gateway cannot read quiz attempts.", []);
+        const raw = String(input2.attempt);
+        const id2 = raw.includes("://") ? Number(new URL(raw).searchParams.get("attempt")) : Number(raw);
+        if (!Number.isInteger(id2) || id2 <= 0) throw new ReferenceError("not_found", "Use a quiz attempt id or a review URL with ?attempt=.", []);
+        const { course_id, questions, ...attempt } = await gateway.getQuizAttempt(id2);
+        result = { attempt: { ...attempt, unit_id: course_id || void 0, questions } };
+        break;
+      }
       case "home":
       case "due": {
         const data = name === "due" && gateway.getDue ? { user: await user(), courses: await courses(), todo: await gateway.getDue(Number(input2.days)), errors: [] } : await overview(Number(input2.days));
@@ -3541,12 +3588,12 @@ function renderTerminalTable(columns, rows, options = {}) {
   const minimum = widths.reduce((n2, w, i) => n2 + (flexible.includes(i) ? 8 : w), 0) + columns.length * 3 + 1;
   const title = options.title ? [theme.subject(sanitizeTerminalText(options.title))] : [];
   if (width < 60 || minimum > width) {
-    const wrap = (line2) => Array.from(line2).reduce((lines, char) => {
+    const wrap2 = (line2) => Array.from(line2).reduce((lines, char) => {
       if (!lines.length || Array.from(lines.at(-1)).length >= width) lines.push("");
       lines[lines.length - 1] += char;
       return lines;
     }, []);
-    return [...title, ...clean.flatMap((row) => [...columns.flatMap((c, i) => wrap(`${c.label}: ${row[i]}`)), ""])].join("\n").trimEnd();
+    return [...title, ...clean.flatMap((row) => [...columns.flatMap((c, i) => wrap2(`${c.label}: ${row[i]}`)), ""])].join("\n").trimEnd();
   }
   while (widths.reduce((n2, v) => n2 + v, 0) + columns.length * 3 + 1 > width) {
     const index = flexible.reduce((best, i) => widths[i] > (widths[best] ?? 0) ? i : best, -1);
@@ -3670,9 +3717,20 @@ function renderScreen(data, options = {}) {
     const i = record(data.item);
     lines.push(`${text(i.name)} \xB7 ${text(i.type)} \xB7 #${i.id}`);
     for (const [k, v] of Object.entries(i)) if (!["id", "name", "type", "files"].includes(k) && !k.endsWith("_at") && typeof v !== "object") lines.push(`${k.replaceAll("_", " ")}: ${moment(v, now)}`);
+    for (const a of array(i.attempts)) lines.push(`Attempt ${a.number} \xB7 #${a.id}  ${[a.status, a.marks, a.grade, a.completed].map(text).filter(Boolean).join("  \xB7  ")}`);
+    for (const c of array(i.criteria)) lines.push(`${text(c.name)}  ${[c.score, c.level, c.remark].map(text).filter(Boolean).join("  \xB7  ")}`);
     for (const f of array(i.files)) lines.push(`File  ${text(f.name)}  ${text(f.url)}`);
     if (data.threads) rows(array(data.threads), "Threads");
     next = [`moodle get ${i.id} --to DIR`];
+  } else if (data.attempt) {
+    const a = record(data.attempt);
+    lines.push(`Attempt #${a.id} \xB7 ${[a.status, a.marks, a.grade].map(text).filter(Boolean).join(" \xB7 ")}`);
+    for (const q of array(a.questions)) {
+      lines.push("", `Q${q.number} \xB7 ${[q.type, q.state, q.mark].map(text).filter(Boolean).join(" \xB7 ")}`, text(q.text), `You: ${text(q.response)}`);
+      if (q.correct) lines.push(`Correct: ${text(q.correct)}`);
+      if (q.feedback) lines.push(`Feedback: ${text(q.feedback)}`);
+    }
+    next = [`moodle item ${a.quiz_id}`];
   } else if (data.thread) {
     const t = record(data.thread);
     lines.push(text(t.name));
@@ -3713,13 +3771,13 @@ function renderScreen(data, options = {}) {
 }
 
 // src/cli.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import {
   banner,
   colorEnabled as colorEnabled2,
   confirm,
   createProgram,
-  createTheme as createTheme3,
+  createTheme as createTheme5,
   createUi as createUi3,
   detectAudience,
   examples,
@@ -3734,7 +3792,7 @@ import {
   mutating,
   writeOutput
 } from "@bunizao/cli-kit";
-import { realpathSync as realpathSync3 } from "fs";
+import { realpathSync as realpathSync4 } from "fs";
 import path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -4038,6 +4096,8 @@ function parseGradeOverviewRows(html, baseUrl) {
   return rows;
 }
 function parseAssignmentHtml(html, assignmentId, baseUrl) {
+  const root = parse3(html);
+  const feedback = root.querySelector(".feedback");
   return {
     id: assignmentId,
     name: pageTitle(html),
@@ -4047,9 +4107,39 @@ function parseAssignmentHtml(html, assignmentId, baseUrl) {
     grading_status: findTableValue(html, "Grading status"),
     time_remaining: findTableValue(html, "Time remaining"),
     grade: findTableValue(html, "Grade"),
+    graded_on: feedback ? findTableValue(feedback.toString(), "Graded on") : "",
+    graded_by: feedback ? findTableValue(feedback.toString(), "Graded by") : "",
+    feedback_comments: feedback ? findTableValue(feedback.toString(), "Feedback comments") : "",
+    criteria: feedback ? parseFeedbackCriteria(feedback) : [],
+    file_entries: feedback ? parseFeedbackFiles(feedback, baseUrl) : [],
     url: `${baseUrl.replace(/\/$/, "")}/mod/assign/view.php?id=${assignmentId}`
   };
 }
+function parseFeedbackCriteria(feedback) {
+  const criteria = [];
+  for (const row of feedback.querySelectorAll("tr.criterion")) {
+    const level = row.querySelector("td.level.checked");
+    const name = cleanNodeText(row.querySelector(".criterionshortname") ?? row.querySelector("td.description"));
+    if (!name) continue;
+    criteria.push({
+      name,
+      level: cleanNodeText(level?.querySelector(".definition")),
+      score: cleanNodeText(row.querySelector("td.score") ?? level?.querySelector(".score")),
+      remark: cleanTableCell(row.querySelector("td.remark"))
+    });
+  }
+  return criteria;
+}
+function parseFeedbackFiles(feedback, baseUrl) {
+  const entries = [];
+  for (const link2 of feedback.querySelectorAll('a[href*="pluginfile.php"]')) {
+    const url = resolveUrl(baseUrl, link2.getAttribute("href") ?? "");
+    const label = cleanNodeText(link2);
+    const name = /\.\w{1,5}$/u.test(label) ? label : decodeURIComponent(new URL(url).pathname.split("/").at(-1) || "file");
+    if (!entries.some((entry) => entry.url === url)) entries.push(fileEntry(name, url, baseUrl));
+  }
+  return entries;
+}
 function parseQuizHtml(html, quizId, baseUrl) {
   const root = parse3(html);
   return {
@@ -4058,12 +4148,85 @@ function parseQuizHtml(html, quizId, baseUrl) {
     ...activityContext(html),
     opens_pretty: extractLabeledText(html, "Opens:"),
     closes_pretty: extractLabeledText(html, "Closes:"),
-    attempts_allowed: cleanText(root.textContent.match(/Attempts allowed:\s*([^\n]+)/i)?.[1] ?? ""),
+    attempts_allowed: labeledParagraph(root, "Attempts allowed:"),
+    time_limit: labeledParagraph(root, "Time limit:"),
     availability: cleanText(root.textContent.match(/This quiz is currently[^\n]+/i)?.[0] ?? ""),
     grade: findTableValue(html, "Grade"),
+    attempts: parseQuizAttempts(root, baseUrl),
     url: `${baseUrl.replace(/\/$/, "")}/mod/quiz/view.php?id=${quizId}`
   };
 }
+function labeledParagraph(root, label) {
+  for (const p of root.querySelectorAll("p")) {
+    const line = cleanNodeText(p);
+    if (line.startsWith(label)) return cleanText(line.slice(label.length));
+  }
+  return "";
+}
+function parseQuizAttempts(root, baseUrl) {
+  const attempts = [];
+  for (const table of root.querySelectorAll("table.quizreviewsummary")) {
+    const card = table.closest(".card") ?? table.parentNode;
+    const link2 = card?.querySelector('a[href*="/mod/quiz/review.php"]');
+    const reviewUrl = link2 ? resolveUrl(baseUrl, link2.getAttribute("href") ?? "") : "";
+    const id2 = numberQueryValue(reviewUrl, "attempt");
+    if (!link2 || id2 === null) continue;
+    const summary = tableValues(table);
+    const number = Number(cleanNodeText(card?.querySelector(".card-title")).match(/\d+/)?.[0] ?? attempts.length + 1);
+    attempts.push({ id: id2, number, status: summary.Status ?? "", started: summary.Started ?? "", completed: summary.Completed ?? "", duration: summary.Duration ?? "", marks: summary.Marks ?? "", grade: summary.Grade ?? "", review_url: reviewUrl });
+  }
+  return attempts;
+}
+function parseQuizReviewHtml(html, attemptId, baseUrl) {
+  const root = parse3(html);
+  const summary = tableValues(root.querySelector("table.quizreviewsummary"));
+  const form = root.querySelector("form.questionflagsaveform");
+  const url = `${baseUrl.replace(/\/$/, "")}/mod/quiz/review.php?attempt=${attemptId}`;
+  return {
+    id: attemptId,
+    quiz_id: numberQueryValue(form?.getAttribute("action") ?? "", "cmid") ?? 0,
+    course_id: parseCourseIdFromPageHtml(html) ?? 0,
+    status: summary.Status ?? "",
+    started: summary.Started ?? "",
+    completed: summary.Completed ?? "",
+    duration: summary.Duration ?? "",
+    marks: summary.Marks ?? "",
+    grade: summary.Grade ?? "",
+    questions: root.querySelectorAll("div.que").map(parseQuizQuestion),
+    url
+  };
+}
+function parseQuizQuestion(que) {
+  const answer = que.querySelector(".answer");
+  const picked = answer?.querySelectorAll("input:checked, input[checked]").map((input2) => {
+    const label = input2.getAttribute("aria-labelledby");
+    return cleanTableCell(label ? que.querySelector(`[id="${label}"]`) : input2.parentNode);
+  }).filter(Boolean) ?? [];
+  const typed = cleanText(que.querySelector('input[type="text"], input[type="number"]')?.getAttribute("value") ?? "");
+  const response = picked.length ? picked.join("; ") : typed || blockText(answer?.querySelector(".qtype_essay_response") ?? answer);
+  return {
+    number: Number(cleanNodeText(que.querySelector(".qno")) || 0),
+    type: que.classList.value[1] ?? "",
+    state: cleanNodeText(que.querySelector(".info .state")),
+    mark: cleanNodeText(que.querySelector(".info .grade")).replace(/^Mark\s+/u, ""),
+    text: blockText(que.querySelector(".qtext")),
+    response: response.replace(/\s*Word count: \d+$/u, ""),
+    correct: blockText(que.querySelector(".rightanswer")).replace(/^The correct answers? (?:is|are):?\s*/iu, "").replace(/^'(.*)'\.?$/u, "$1"),
+    feedback: blockText(que.querySelector(".outcome .feedback"))
+  };
+}
+function blockText(node) {
+  if (!node) return "";
+  return cleanTableCell(parse3(node.toString().replace(/<br\s*\/?>|<\/(?:p|div|li|h\d|tr)>/giu, "$& ")));
+}
+function tableValues(table) {
+  const values = {};
+  for (const row of table?.querySelectorAll("tr") ?? []) {
+    const cells = row.querySelectorAll("th, td");
+    if (cells.length >= 2) values[cleanNodeText(cells[0])] = cleanTableCell(cells[1]);
+  }
+  return values;
+}
 function parseResourceHtml(html, resourceId, baseUrl) {
   const root = parse3(html);
   const link2 = root.querySelector(".resourceworkaround a[href], .resourcecontent a[href], a.resourceworkaround[href]");
@@ -4243,12 +4406,12 @@ function parseForumGroupsHtml(html) {
   }
   const groups = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const option of select.querySelectorAll("option")) {
-    const groupId = safeInt(option.getAttribute("value"));
+  for (const option2 of select.querySelectorAll("option")) {
+    const groupId = safeInt(option2.getAttribute("value"));
     if (!groupId) {
       continue;
     }
-    const groupName = cleanNodeText(option);
+    const groupName = cleanNodeText(option2);
     const key = `${groupId}:${groupName}`;
     if (seen.has(key)) {
       continue;
@@ -4268,9 +4431,9 @@ function selectedGroupName(root, groupId) {
     return "";
   }
   for (const selector of ["select[name='groupinfo']", "select[name='group']"]) {
-    const option = root.querySelector(selector)?.querySelector(`option[value='${groupId}']`) ?? null;
-    if (option) {
-      return cleanNodeText(option);
+    const option2 = root.querySelector(selector)?.querySelector(`option[value='${groupId}']`) ?? null;
+    if (option2) {
+      return cleanNodeText(option2);
     }
   }
   return "";
@@ -4386,7 +4549,7 @@ function cleanTableCell(node) {
     return "";
   }
   const clone = parse3(node.toString());
-  for (const unwanted of clone.querySelectorAll(".action-menu, .dropdown, script, style")) {
+  for (const unwanted of clone.querySelectorAll(".action-menu, .dropdown, .hidden, .accesshide, script, style")) {
     unwanted.remove();
   }
   return cleanText(clone.textContent.replace("( Empty )", "(Empty)"));
@@ -4604,7 +4767,7 @@ function formFields(form) {
     }
     if (tag === "select") {
       const options = element.querySelectorAll("option");
-      const chosen = options.find((option) => option.hasAttribute("selected")) ?? options[0];
+      const chosen = options.find((option2) => option2.hasAttribute("selected")) ?? options[0];
       if (chosen) fields2.push([name, chosen.getAttribute("value") ?? cleanText(chosen.textContent)]);
       continue;
     }
@@ -4778,6 +4941,292 @@ function record2(value) {
   return isRecord4(value) ? value : {};
 }
 
+// src/moodle-quiz-core.ts
+import { parse as parse5 } from "node-html-parser";
+async function startQuizAttempt(deps, quizId, options = {}) {
+  if (!Number.isSafeInteger(quizId) || quizId <= 0) throw deps.usage("The quiz id must be a positive integer.");
+  const viewUrl = `${deps.baseUrl}${QUIZ_VIEW_PATH}?id=${quizId}`;
+  const viewHtml = await pageText2(deps, viewUrl);
+  const root = parse5(viewHtml);
+  if (/safeexambrowser|Safe Exam Browser/iu.test(viewHtml)) throw deps.usage("This quiz requires the Safe Exam Browser, which the CLI cannot provide.", "Open it in the browser Moodle asks for.");
+  const resume = formWithAction2(root, QUIZ_ATTEMPT_PATH) ?? root.querySelector(`a[href*="${QUIZ_ATTEMPT_PATH}?"]`);
+  if (resume) {
+    const target = resume.tagName.toLowerCase() === "form" ? `${resolveUrl(deps.baseUrl, resume.getAttribute("action") ?? "")}?${new URLSearchParams(formFields2(resume)).toString()}` : resolveUrl(deps.baseUrl, resume.getAttribute("href") ?? "");
+    const attempt = numberParam(target, "attempt");
+    if (attempt) return getAttemptPage(deps, attempt, quizId, 0);
+  }
+  const start = formWithAction2(root, QUIZ_START_PATH);
+  if (!start) {
+    const reason = cleanText(root.querySelector(".quizattempt, .quizinfo")?.textContent) || "the quiz page shows no attempt button";
+    throw deps.usage(`Moodle offers no new attempt: ${reason}`, `See ${viewUrl}`);
+  }
+  let response = await deps.request(resolveUrl(deps.baseUrl, start.getAttribute("action") ?? ""), postInit(formFields2(start)));
+  let html = await response.text();
+  if (!onPath(response.url, QUIZ_ATTEMPT_PATH)) {
+    const preflight = formWithAction2(parse5(html), QUIZ_START_PATH);
+    if (!preflight) throw deps.fail(`Moodle did not start the attempt: ${noticesOf2(html) || "it returned an unexpected page"}`);
+    const fields2 = [...formFields2(preflight).filter(([name]) => name !== "quizpassword"), ["submitbutton", "Start attempt"]];
+    if (preflight.querySelector("input[name=quizpassword]")) {
+      const password = options.password ? await options.password() : null;
+      if (!password) throw deps.usage("This quiz needs its access password to start.", "Run moodle quiz start again at a terminal to be asked for it, or pass --password.");
+      fields2.push(["quizpassword", password]);
+    }
+    response = await deps.request(resolveUrl(deps.baseUrl, preflight.getAttribute("action") ?? ""), postInit(fields2));
+    html = await response.text();
+    if (!onPath(response.url, QUIZ_ATTEMPT_PATH)) throw deps.fail(`Moodle did not start the attempt: ${noticesOf2(html) || "it returned the pre-flight form again"}`);
+  }
+  return withoutForm(parseAttemptPage(html, response.url, deps));
+}
+async function getAttemptPage(deps, attemptId, quizId, page) {
+  return withoutForm(await loadAttemptPage(deps, attemptId, quizId, page));
+}
+async function loadAttemptPage(deps, attemptId, quizId, page) {
+  const url = attemptUrl(deps.baseUrl, attemptId, quizId, page);
+  const response = await deps.request(url);
+  const html = await response.text();
+  if (onPath(response.url, QUIZ_REVIEW_PATH)) throw deps.usage(`Attempt ${attemptId} is already finished.`, `Its review is at ${response.url}`);
+  if (!onPath(response.url, QUIZ_ATTEMPT_PATH)) throw deps.fail(`Moodle did not show attempt ${attemptId}: ${noticesOf2(html) || "it redirected elsewhere"}`);
+  return parseAttemptPage(html, response.url, deps);
+}
+function withoutForm({ form: _form, ...page }) {
+  return page;
+}
+async function answerQuizQuestion(deps, request) {
+  const first2 = await loadAttemptPage(deps, request.attemptId, request.quizId, 0);
+  const entry = first2.navigation.find((item) => item.number === request.question.trim());
+  if (!entry) throw deps.usage(`Attempt ${request.attemptId} has no question ${request.question}.`, `Questions: ${first2.navigation.map((item) => item.number).join(", ")}`);
+  const page = entry.page === first2.page ? first2 : await loadAttemptPage(deps, request.attemptId, request.quizId, entry.page);
+  const question2 = page.questions.find((item) => item.slot === entry.slot);
+  if (!question2) throw deps.fail(`Page ${entry.page + 1} does not contain question ${request.question}.`);
+  const fields2 = encodeAnswer(deps, page.form, question2, request.value);
+  const replay = fields2.map(([name, value]) => name === "nextpage" ? [name, String(page.page)] : [name, value]);
+  const response = await deps.request(page.form.action, postInit(replay));
+  const html = await response.text();
+  if (!onPath(response.url, QUIZ_ATTEMPT_PATH)) throw deps.fail(`Moodle did not save the answer: ${noticesOf2(html) || "it left the attempt page"}`);
+  const after = parseAttemptPage(html, response.url, deps);
+  const saved = after.questions.find((item) => item.slot === question2.slot);
+  if (!saved || /not yet answered|not answered/iu.test(saved.state)) throw deps.fail(`Moodle accepted the post but still reports question ${request.question} as "${saved?.state || "missing"}".`);
+  return withoutForm(after);
+}
+async function getAttemptSummary(deps, attemptId, quizId) {
+  const { form: _form, ...summary } = await loadAttemptSummary(deps, attemptId, quizId);
+  return summary;
+}
+async function loadAttemptSummary(deps, attemptId, quizId) {
+  const url = `${deps.baseUrl}${QUIZ_SUMMARY_PATH}?attempt=${attemptId}&cmid=${quizId}`;
+  const response = await deps.request(url);
+  const html = await response.text();
+  if (onPath(response.url, QUIZ_REVIEW_PATH)) throw deps.usage(`Attempt ${attemptId} is already finished.`, `Its review is at ${response.url}`);
+  const root = parse5(html);
+  const rows = root.querySelectorAll("table.quizsummaryofattempt tbody tr").flatMap((row) => {
+    const cells = row.querySelectorAll("td");
+    if (cells.length < 2) return [];
+    const link2 = cells[0].querySelector("a")?.getAttribute("href") ?? "";
+    return [{ number: cleanText(cells[0].textContent), state: cleanText(cells[1].textContent), page: numberParam(link2, "page") ?? 0 }];
+  });
+  const finish = root.querySelector("form#frm-finishattempt") ?? formWithAction2(root, QUIZ_PROCESS_PATH);
+  if (!finish || !rows.length) throw deps.fail(`Moodle did not show the summary of attempt ${attemptId}: ${noticesOf2(html) || "the page has no finish button"}`);
+  const form = { action: resolveUrl(deps.baseUrl, finish.getAttribute("action") ?? ""), fields: formFields2(finish) };
+  return { attempt: attemptId, quiz_id: quizId, name: pageHeading(root), rows, url, form };
+}
+async function finishQuizAttempt(deps, attemptId, quizId) {
+  const summary = await loadAttemptSummary(deps, attemptId, quizId);
+  const response = await deps.request(summary.form.action, postInit(summary.form.fields));
+  const html = await response.text();
+  const receipt = { attempt: attemptId, quiz_id: quizId, name: summary.name, summary: summary.rows, url: response.url };
+  if (onPath(response.url, QUIZ_REVIEW_PATH)) {
+    receipt.review = parseQuizReviewHtml(html, attemptId, deps.baseUrl);
+    return receipt;
+  }
+  const quiz = parseQuizHtml(onPath(response.url, QUIZ_VIEW_PATH) ? html : await pageText2(deps, `${deps.baseUrl}${QUIZ_VIEW_PATH}?id=${quizId}`), quizId, deps.baseUrl);
+  const row = quiz.attempts.find((attempt) => attempt.id === attemptId);
+  if (row && /in progress/iu.test(row.status)) throw deps.fail(`Moodle accepted the finish request but still lists attempt ${attemptId} as ${row.status}; check the quiz in a browser.`);
+  receipt.url = quiz.url;
+  if (row) {
+    receipt.result = { status: row.status, marks: row.marks, grade: row.grade, completed: row.completed };
+    return receipt;
+  }
+  const probe2 = await deps.request(attemptUrl(deps.baseUrl, attemptId, quizId, 0));
+  if (onPath(probe2.url, QUIZ_ATTEMPT_PATH) && parse5(await probe2.text()).querySelector("form#responseform")) throw deps.fail(`Moodle accepted the finish request but attempt ${attemptId} is still open; check the quiz in a browser.`);
+  return receipt;
+}
+function parseAttemptPage(html, url, deps) {
+  const root = parse5(html);
+  const form = root.querySelector("form#responseform");
+  if (!form) throw deps.fail(`Moodle did not render an attempt page: ${noticesOf2(html) || "no response form found"}`);
+  const attempt = numberParam(url, "attempt") ?? Number(form.querySelector("input[name=attempt]")?.getAttribute("value"));
+  const quizId = numberParam(form.getAttribute("action") ?? "", "cmid") ?? numberParam(url, "cmid") ?? 0;
+  const page = Number(form.querySelector("input[name=thispage]")?.getAttribute("value") ?? numberParam(url, "page") ?? 0);
+  const navigation = root.querySelectorAll("a.qnbutton").map((button) => {
+    const title = button.getAttribute("title") ?? "";
+    const match = title.match(/^(?:Question|Information)?\s*(\S+)\s*-\s*(.+)$/u);
+    return {
+      slot: Number(button.getAttribute("id")?.replace(/^quiznavbutton/u, "") ?? 0),
+      number: match?.[1] ?? cleanText(button.textContent),
+      page: Number(button.getAttribute("data-quiz-page") ?? 0),
+      state: match?.[2] ?? ""
+    };
+  });
+  const questions = form.querySelectorAll("div.que").map(parseAttemptQuestion);
+  return {
+    attempt,
+    quiz_id: quizId,
+    name: pageHeading(root),
+    page,
+    pages: Math.max(page + 1, ...navigation.map((entry) => entry.page + 1)),
+    questions,
+    navigation,
+    url: attemptUrl(deps.baseUrl, attempt, quizId, page),
+    form: { action: resolveUrl(deps.baseUrl, form.getAttribute("action") ?? ""), fields: formFields2(form) }
+  };
+}
+function parseAttemptQuestion(que) {
+  const slot = Number(que.getAttribute("id")?.split("-").at(-1) ?? 0);
+  const base = {
+    slot,
+    number: cleanText(que.querySelector(".info .qno, .info .no")?.textContent).replace(/^Question\s*/iu, "") || "i",
+    type: que.classList.value[1] ?? "",
+    kind: "unsupported",
+    state: cleanText(que.querySelector(".info .state")?.textContent),
+    text: blockText(que.querySelector(".qtext"))
+  };
+  if (que.classList.contains("description")) return { ...base, number: "i", kind: "info" };
+  const inputs = que.querySelectorAll("input, textarea, select").filter((input2) => {
+    const name = input2.getAttribute("name") ?? "";
+    return name.startsWith("q") && !/_:(?:flagged|sequencecheck)$|_-seen$|_answerformat$/u.test(name) && !/^(?:hidden|submit)$/u.test(input2.getAttribute("type") ?? "");
+  });
+  const tag = (input2) => input2.tagName.toLowerCase();
+  const type = (input2) => tag(input2) === "input" ? (input2.getAttribute("type") ?? "text").toLowerCase() : tag(input2);
+  const isClearChoice = (input2) => type(input2) === "radio" && (input2.closest(".qtype_multichoice_clearchoice") !== null || input2.getAttribute("aria-hidden") === "true");
+  const radios = inputs.filter((input2) => type(input2) === "radio" && !isClearChoice(input2));
+  const boxes = inputs.filter((input2) => type(input2) === "checkbox");
+  const texts = inputs.filter((input2) => ["textarea", "text", "number"].includes(type(input2)));
+  const selects = inputs.filter((input2) => type(input2) === "select");
+  const others = inputs.length - radios.length - boxes.length - texts.length - selects.length - inputs.filter(isClearChoice).length;
+  const radioNames = new Set(radios.map((input2) => input2.getAttribute("name")));
+  const only = (group) => group.length === inputs.length - inputs.filter(isClearChoice).length && others === 0;
+  if (radios.length && radioNames.size === 1 && only(radios)) {
+    return { ...base, kind: "choice", field: radios[0].getAttribute("name"), options: radios.map((input2, index) => option(que, input2, index)) };
+  }
+  if (boxes.length && only(boxes)) return { ...base, kind: "multi", options: boxes.map((input2, index) => option(que, input2, index)) };
+  if (selects.length === 1 && only(selects)) {
+    const select = selects[0];
+    const name = select.getAttribute("name");
+    const choices = select.querySelectorAll("option").filter((item) => (item.getAttribute("value") ?? "") !== "");
+    return { ...base, kind: "choice", field: name, options: choices.map((item, index) => ({ key: String.fromCharCode(97 + index), field: name, value: item.getAttribute("value") ?? "", text: cleanText(item.textContent), chosen: item.hasAttribute("selected") })) };
+  }
+  if (texts.length === 1 && only(texts)) {
+    const text2 = texts[0];
+    const html = tag(text2) === "textarea";
+    return { ...base, kind: "text", field: text2.getAttribute("name"), answer: html ? blockText(parse5(text2.textContent)) : cleanText(text2.getAttribute("value") ?? "") };
+  }
+  return base;
+}
+function option(que, input2, index) {
+  const labelId = input2.getAttribute("aria-labelledby");
+  const id2 = input2.getAttribute("id");
+  const label = (labelId ? que.querySelector(`[id="${labelId}"]`) : null) ?? (id2 ? que.querySelector(`label[for="${id2}"]`) : null) ?? input2.parentNode;
+  const text2 = blockText(label) || label?.querySelectorAll("img").map((img) => cleanText(img.getAttribute("alt"))).filter(Boolean).join(" ") || "(image; see the quiz in a browser)";
+  return { key: String.fromCharCode(97 + index), field: input2.getAttribute("name") ?? "", value: input2.getAttribute("value") ?? "", text: text2, chosen: input2.hasAttribute("checked") };
+}
+function encodeAnswer(deps, form, question2, value) {
+  const raw = value.trim();
+  if (question2.kind === "info") throw deps.usage(`Question ${question2.number} is an information block; it takes no answer.`);
+  if (question2.kind === "unsupported" || !question2.field && question2.kind !== "multi") throw deps.usage(`Question ${question2.number} is a ${question2.type || "question"} type the CLI cannot answer.`, "Answer it in a browser; other questions can still be answered here.");
+  if (question2.kind === "text") {
+    if (!raw) throw deps.usage(`Question ${question2.number} needs a written answer.`);
+    const format = form.fields.find(([name]) => name === `${question2.field}format`)?.[1];
+    return [...form.fields.filter(([name]) => name !== question2.field), [question2.field, format === "1" ? paragraphs(value) : raw]];
+  }
+  const options = question2.options ?? [];
+  const picks = raw.split(",").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const match = options.find((item) => item.key === part.toLowerCase()) ?? options.find((item) => cleanText(item.text).toLowerCase() === part.toLowerCase());
+    if (!match) throw deps.usage(`Question ${question2.number} has no option '${part}'.`, `Choose from ${options.map((item) => item.key).join(", ")}.`);
+    return match;
+  });
+  if (!picks.length) throw deps.usage(`Question ${question2.number} needs an option letter.`, `Choose from ${options.map((item) => item.key).join(", ")}.`);
+  if (question2.kind === "choice") {
+    if (picks.length > 1) throw deps.usage(`Question ${question2.number} takes one option, not ${picks.length}.`);
+    return [...form.fields.filter(([name]) => name !== question2.field), [question2.field, picks[0].value]];
+  }
+  const chosen = new Set(picks.map((pick) => pick.key));
+  const boxNames = new Set(options.map((item) => item.field));
+  return [
+    ...form.fields.filter(([name]) => !boxNames.has(name)),
+    ...options.map((item) => [item.field, chosen.has(item.key) ? "1" : "0"])
+  ];
+}
+function noticesOf2(html) {
+  const root = parse5(html);
+  const texts = [];
+  for (const node of root.querySelectorAll(".alert, .errorbox, .error, #notice")) {
+    for (const junk of node.querySelectorAll("button, .close")) junk.remove();
+    const text2 = cleanText(node.textContent);
+    if (text2 && !texts.includes(text2)) texts.push(text2);
+  }
+  return texts.join(" ");
+}
+function formWithAction2(root, path5) {
+  return root.querySelectorAll("form").find((form) => onPath(form.getAttribute("action") ?? "", path5)) ?? null;
+}
+function formFields2(form) {
+  const fields2 = [];
+  for (const element of form.querySelectorAll("input, textarea, select")) {
+    const name = element.getAttribute("name");
+    if (!name) continue;
+    const tag = element.tagName.toLowerCase();
+    if (tag === "textarea") {
+      fields2.push([name, element.textContent]);
+      continue;
+    }
+    if (tag === "select") {
+      const options = element.querySelectorAll("option");
+      const chosen = options.find((item) => item.hasAttribute("selected")) ?? options[0];
+      if (chosen) fields2.push([name, chosen.getAttribute("value") ?? cleanText(chosen.textContent)]);
+      continue;
+    }
+    const type = (element.getAttribute("type") ?? "text").toLowerCase();
+    if (["submit", "button", "image", "file", "reset"].includes(type)) continue;
+    if ((type === "checkbox" || type === "radio") && !element.hasAttribute("checked")) continue;
+    fields2.push([name, element.getAttribute("value") ?? (type === "checkbox" ? "on" : "")]);
+  }
+  return fields2;
+}
+function postInit(fields2) {
+  return { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(fields2).toString() };
+}
+async function pageText2(deps, url) {
+  return (await deps.request(url)).text();
+}
+function attemptUrl(baseUrl, attempt, quizId, page) {
+  return `${baseUrl}${QUIZ_ATTEMPT_PATH}?attempt=${attempt}&cmid=${quizId}${page ? `&page=${page}` : ""}`;
+}
+function pageHeading(root) {
+  const heading = cleanText(root.querySelector(".page-header-headings h1, #page-header h1")?.textContent);
+  if (heading) return heading;
+  const title = cleanText(root.querySelector("title")?.textContent).replace(/\s*\(page \d+ of \d+\)/iu, "").split(" | ")[0].trim();
+  return title || cleanText(root.querySelector("h2")?.textContent);
+}
+function onPath(url, path5) {
+  try {
+    return new URL(url, "https://moodle.invalid").pathname.endsWith(path5);
+  } catch {
+    return false;
+  }
+}
+function numberParam(url, key) {
+  try {
+    const value = Number(new URL(url, "https://moodle.invalid").searchParams.get(key));
+    return Number.isSafeInteger(value) && value > 0 ? value : key === "page" && value === 0 ? 0 : null;
+  } catch {
+    return null;
+  }
+}
+function paragraphs(text2) {
+  const escaped = text2.trim().replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;");
+  return escaped.split(/\n\s*\n/u).map((block) => `<p>${block.trim().replace(/\n/gu, "<br>")}</p>`).join("");
+}
+
 // src/parsers.ts
 function schema(parser) {
   return { parse: parser };
@@ -5778,6 +6227,10 @@ var MoodleClientCore = class {
   async getQuiz(id2) {
     return parseQuizHtml(await this.get(QUIZ_VIEW_PATH, { id: id2 }), id2, this.baseUrl);
   }
+  async getQuizAttempt(attemptId) {
+    await this.ensureSession();
+    return parseQuizReviewHtml(await this.get(QUIZ_REVIEW_PATH, { attempt: attemptId, showall: 1 }), attemptId, this.baseUrl);
+  }
   async getResource(id2) {
     const url = `${this.baseUrl}${RESOURCE_VIEW_PATH}?id=${id2}`;
     const response = await this.requestAbsolute(url);
@@ -5826,6 +6279,32 @@ var MoodleClientCore = class {
       usage: (message, hint) => this.errors.usage ? this.errors.usage(message, hint) : new MoodleClientCoreError("usage", message, hint)
     }, request);
   }
+  /** Starts a new attempt, or resumes the one already in progress, and returns its first page. */
+  async startQuizAttempt(quizId, options = {}) {
+    return startQuizAttempt(await this.quizDeps(), quizId, options);
+  }
+  async getQuizAttemptPage(attemptId, quizId, page = 0) {
+    return getAttemptPage(await this.quizDeps(), attemptId, quizId, page);
+  }
+  async getQuizAttemptSummary(attemptId, quizId) {
+    return getAttemptSummary(await this.quizDeps(), attemptId, quizId);
+  }
+  async answerQuizQuestion(request) {
+    return answerQuizQuestion(await this.quizDeps(), request);
+  }
+  /** Submits the attempt for grading. Moodle treats this as final. */
+  async finishQuizAttempt(attemptId, quizId) {
+    return finishQuizAttempt(await this.quizDeps(), attemptId, quizId);
+  }
+  async quizDeps() {
+    await this.ensureSession();
+    return {
+      baseUrl: this.baseUrl,
+      request: (url, init, options) => this.requestAbsolute(url, init, options),
+      fail: (message, moodleErrorCode) => this.errors.api(message, moodleErrorCode),
+      usage: (message, hint) => this.errors.usage ? this.errors.usage(message, hint) : new MoodleClientCoreError("usage", message, hint)
+    };
+  }
   async getNewsForums(courseId) {
     const units = courseId === void 0 ? await this.getCourses() : (await this.getCourses()).filter((c) => c.id === courseId);
     const forums = [];
@@ -6294,6 +6773,202 @@ function authToClientSession(auth) {
   };
 }
 
+// src/update-check.ts
+import { spawn as spawn3, spawnSync as spawnSync3 } from "child_process";
+import { chmod as chmod4, mkdir as mkdir7, readFile as readFile7, rename as rename2, rm as rm5, writeFile as writeFile6 } from "fs/promises";
+import { realpathSync as realpathSync3 } from "fs";
+import { arch, homedir as homedir11, platform } from "os";
+import { join as join10 } from "path";
+
+// src/update-core.ts
+var PACKAGE_NAME2 = "moodle-cli";
+var LATEST_VERSION_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME2}/dist-tags`;
+var UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
+var UPDATE_RETRY_MS = 60 * 60 * 1e3;
+var GITHUB_REPOSITORY = "bunizao/moodle-cli";
+function compareVersions(a, b) {
+  const [aMain, aPre] = a.split("-", 2);
+  const [bMain, bPre] = b.split("-", 2);
+  const left = aMain.split(".").map(Number);
+  const right = bMain.split(".").map(Number);
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const diff = (left[index] ?? 0) - (right[index] ?? 0);
+    if (diff !== 0) return Math.sign(diff);
+  }
+  if (Boolean(aPre) === Boolean(bPre)) return (aPre ?? "").localeCompare(bPre ?? "");
+  return aPre ? -1 : 1;
+}
+function isNewerVersion(candidate, current2) {
+  return Boolean(candidate) && /^\d+\.\d+\.\d+/u.test(candidate) && compareVersions(candidate, current2) > 0;
+}
+async function fetchLatestVersion(fetchImpl = fetch, timeoutMs = 5e3) {
+  try {
+    const response = await fetchImpl(LATEST_VERSION_URL, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(timeoutMs) });
+    if (!response.ok) return null;
+    const tags = await response.json();
+    return typeof tags.latest === "string" ? tags.latest : null;
+  } catch {
+    return null;
+  }
+}
+function updateHint(current2, latest) {
+  return `moodle-cli ${latest} is available (running ${current2}). Run: moodle update`;
+}
+function standaloneUpdateHint(current2, latest) {
+  return `moodle-cli ${latest} is available (running ${current2}). Run: moodle update`;
+}
+var STANDALONE_TARGETS = /* @__PURE__ */ new Set(["darwin-arm64", "linux-x64"]);
+function standaloneAssetUrl(version, platform2, arch2) {
+  const target = `${platform2}-${arch2}`;
+  if (!STANDALONE_TARGETS.has(target)) return null;
+  return `https://github.com/${GITHUB_REPOSITORY}/releases/download/v${version}/moodle-${target}`;
+}
+
+// src/version.ts
+var VERSION = "0.9.3";
+
+// src/update-check.ts
+var UPDATE_CACHE_FILENAME = "update-check.json";
+var ENV_NO_UPDATE_CHECK = "MOODLE_NO_UPDATE_CHECK";
+function updateCachePath(homeDir = homedir11()) {
+  return join10(homeDir, CONFIG_DIR_NAME, UPDATE_CACHE_FILENAME);
+}
+async function readUpdateCache(homeDir) {
+  try {
+    const parsed = JSON.parse(await readFile7(updateCachePath(homeDir), "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function writeUpdateCache(cache, homeDir) {
+  const file2 = updateCachePath(homeDir);
+  await mkdir7(join10(file2, ".."), { recursive: true });
+  await writeFile6(file2, `${JSON.stringify(cache)}
+`, { mode: 384 });
+}
+async function refreshLatestVersion(options = {}) {
+  const latest = await fetchLatestVersion(options.fetchImpl);
+  const now = (options.now ?? Date.now)();
+  const cache = await readUpdateCache(options.homeDir);
+  await writeUpdateCache(latest ? { ...cache, latest, checked_at: now, failed_at: void 0 } : { ...cache, failed_at: now }, options.homeDir);
+  return latest;
+}
+function refreshDue(cache, now) {
+  if (now - (cache.checked_at ?? 0) < UPDATE_CHECK_TTL_MS) return false;
+  return now - (cache.failed_at ?? 0) >= UPDATE_RETRY_MS;
+}
+var QUIET_COMMANDS = /* @__PURE__ */ new Set(["update", "dev", "completion", "commands", "skills", "mcp", "doctor"]);
+function startupCheckApplies(args, env = process.env) {
+  if (env[ENV_NO_UPDATE_CHECK] || env.CI) return false;
+  const first2 = args.find((arg) => !arg.startsWith("-"));
+  return first2 === void 0 || !QUIET_COMMANDS.has(first2);
+}
+async function startupUpdateNotice(args, stderr, options = {}) {
+  const env = options.env ?? process.env;
+  if (!startupCheckApplies(args, env)) return;
+  const now = (options.now ?? Date.now)();
+  const cache = await readUpdateCache(options.homeDir);
+  if (isNewerVersion(cache.latest, VERSION) && now - (cache.notified_at ?? 0) >= UPDATE_CHECK_TTL_MS) {
+    stderr.write(`${selfCommand().args.length ? updateHint(VERSION, cache.latest) : standaloneUpdateHint(VERSION, cache.latest)}
+`);
+    await writeUpdateCache({ ...cache, notified_at: now }, options.homeDir);
+  }
+  if (refreshDue(cache, now)) spawnRefresh(env);
+}
+function spawnRefresh(env) {
+  const self = selfCommand();
+  try {
+    const child = spawn3(self.command, [...self.args, "update", "--check", "--quiet"], { detached: true, stdio: "ignore", env: { ...env, [ENV_NO_UPDATE_CHECK]: "1" } });
+    child.unref();
+  } catch {
+  }
+}
+function detectInstallKind(argv = process.argv, execPath = process.execPath) {
+  const self = selfCommand(argv, execPath);
+  if (!self.args.length) return "standalone";
+  let script = self.args[0];
+  try {
+    script = realpathSync3(script);
+  } catch {
+  }
+  return /[\\/]\.bun[\\/]/u.test(script) || /[\\/]bun[\\/]install[\\/]global[\\/]/u.test(script) ? "bun" : "npm";
+}
+function installCommand(kind) {
+  if (kind === "bun") return { command: findExecutable("bun") ?? "bun", args: ["add", "--global", "moodle-cli@latest"] };
+  if (kind === "npm") return { command: findExecutable("npm") ?? "npm", args: ["install", "-g", "moodle-cli@latest"] };
+  return null;
+}
+async function replaceStandalone(execPath, version, fetchImpl = fetch, host = { platform: platform(), arch: arch() }) {
+  const url = standaloneAssetUrl(version, host.platform, host.arch);
+  if (!url) return `No standalone build is published for ${host.platform}-${host.arch}. See ${GITHUB_RELEASES_URL}`;
+  const staging = `${execPath}.${process.pid}.download`;
+  try {
+    const response = await fetchImpl(url, { redirect: "follow" });
+    if (!response.ok) return `Download failed with HTTP ${response.status} for ${url}`;
+    await writeFile6(staging, new Uint8Array(await response.arrayBuffer()), { mode: 493 });
+    await chmod4(staging, 493);
+    await rename2(staging, execPath);
+    return null;
+  } catch (error) {
+    await rm5(staging, { force: true });
+    return `Could not replace ${execPath}: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+function readOutput(command, args) {
+  const result = spawnSync3(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  return result.status === 0 ? result.stdout : null;
+}
+async function runUpdate(options) {
+  const run = options.runCommand ?? ((command, args) => spawnSync3(command, args, { stdio: ["inherit", 2, "inherit"], env: options.env }));
+  const install = detectInstallKind(options.argv, options.execPath);
+  const latest = await refreshLatestVersion(options);
+  const report = { current: VERSION, latest, install, updated: false, deployed: false, ok: true, note: "" };
+  const newer = isNewerVersion(latest ?? void 0, VERSION);
+  const self = selfCommand(options.argv, options.execPath);
+  if (newer) {
+    const command = installCommand(install);
+    if (command) {
+      const result2 = run(command.command, command.args);
+      if (result2.status !== 0) {
+        report.ok = false;
+        report.note = `${command.command} exited with ${result2.status ?? "a signal"}; the package was not updated.`;
+        return report;
+      }
+    } else {
+      const failure = await replaceStandalone(options.execPath ?? process.execPath, latest, options.fetchImpl);
+      if (failure) {
+        report.ok = false;
+        report.note = `${standaloneUpdateHint(VERSION, latest)} ${failure}`;
+        return report;
+      }
+    }
+    const installed = (options.readOutput ?? readOutput)(self.command, [...self.args, "--version"])?.trim();
+    if (installed !== latest) {
+      report.ok = false;
+      report.note = `The installer finished but ${self.args[0] ?? self.command} reports ${installed || "no version"} instead of ${latest}; another moodle install may be on PATH.`;
+      return report;
+    }
+    report.updated = true;
+  }
+  const unreachable = latest === null ? "The npm registry could not be reached, so the installed version was not checked." : "";
+  if (options.workerBehind === void 0) {
+    report.ok = !unreachable;
+    report.note = unreachable || (newer ? `Updated to ${latest}.` : "Already up to date.");
+    return report;
+  }
+  if (!newer && !options.workerBehind) {
+    report.ok = !unreachable;
+    report.note = unreachable ? `${unreachable} The Worker is current.` : "Package and Worker are up to date.";
+    return report;
+  }
+  const result = run(self.command, [...self.args, "mcp", "deploy", "--yes"]);
+  report.deployed = result.status === 0;
+  report.ok = report.deployed && !unreachable;
+  report.note = [unreachable, report.deployed ? `Worker redeployed from ${newer ? latest : VERSION}.` : "Worker deploy failed; run moodle mcp deploy to retry."].filter(Boolean).join(" ");
+  return report;
+}
+
 // src/formatters.ts
 function formatUser(user) {
   return renderKeyValueTable([
@@ -6479,15 +7154,58 @@ function formatTimestamp(value) {
   const pad = (part) => String(part).padStart(2, "0");
   return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
 }
+function formatAttemptPage(page) {
+  const lines = [`${page.name}  attempt ${page.attempt}  page ${page.page + 1} of ${page.pages}`, ""];
+  for (const question2 of page.questions) lines.push(...attemptQuestionLines(question2), "");
+  const elsewhere = page.navigation.filter((entry) => entry.page !== page.page && entry.number !== "i");
+  if (elsewhere.length) lines.push(`Other pages: ${elsewhere.map((entry) => `Q${entry.number} p${entry.page + 1} (${entry.state.toLowerCase()})`).join(", ")}`);
+  return lines.join("\n").trimEnd();
+}
+function attemptQuestionLines(question2) {
+  const head = question2.kind === "info" ? "Information" : `Question ${question2.number}  ${question2.state}`;
+  const lines = [head, ...wrap(question2.text)];
+  for (const option2 of question2.options ?? []) {
+    const [first2, ...rest] = wrap(option2.text, 88);
+    lines.push(`  ${option2.chosen ? "[x]" : "[ ]"} ${option2.key})${first2.slice(1)}`, ...rest.map((line) => `     ${line}`));
+  }
+  if (question2.kind === "text") lines.push(`  Answer: ${question2.answer || "(empty)"}`);
+  if (question2.kind === "unsupported") lines.push(`  (${question2.type} questions can only be answered in a browser)`);
+  return lines;
+}
+function wrap(text2, width = 96) {
+  const lines = [];
+  let line = "";
+  for (const word of text2.split(/\s+/u).filter(Boolean)) {
+    if (line && line.length + word.length + 1 > width) {
+      lines.push(`  ${line}`);
+      line = word;
+    } else line = line ? `${line} ${word}` : word;
+  }
+  if (line || !lines.length) lines.push(`  ${line}`);
+  return lines;
+}
+function formatAttemptSummary(summary) {
+  return renderTerminalTable([{ label: "Question" }, { label: "Status" }], summary.rows.map((row) => [row.number, row.state]), { title: `${summary.name}  attempt ${summary.attempt}` });
+}
+function formatAttemptFinish(receipt) {
+  const result = receipt.review ? [["Status", receipt.review.status], ["Marks", receipt.review.marks], ["Grade", receipt.review.grade], ["Completed", receipt.review.completed]] : receipt.result ? [["Status", receipt.result.status], ["Marks", receipt.result.marks], ["Grade", receipt.result.grade], ["Completed", receipt.result.completed]] : [];
+  return renderKeyValueTable([
+    ["Quiz", receipt.name],
+    ["Attempt", String(receipt.attempt)],
+    ...result,
+    ["Answered", `${receipt.summary.filter((row) => !/not yet answered/iu.test(row.state)).length} of ${receipt.summary.length}`],
+    ["URL", receipt.url]
+  ], { title: "Attempt submitted" });
+}
 
 // src/download.ts
 import { createWriteStream } from "fs";
-import { link, lstat, rename as rename2, unlink } from "fs/promises";
+import { link, lstat, rename as rename3, unlink } from "fs/promises";
 import { randomUUID } from "crypto";
 import path2 from "path";
 import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
-import { parse as parse5 } from "node-html-parser";
+import { parse as parse6 } from "node-html-parser";
 var ACCEPTED_SOURCE_HINT = "Use a positive resource activity ID, a same-site resource URL, or a same-site pluginfile URL.";
 var FILE_SYSTEM_ERROR_CODES = /* @__PURE__ */ new Set([
   "EACCES",
@@ -6609,7 +7327,7 @@ async function responseOrWrapper(client, requestUrl, sourceUrl, targetName, sign
   };
 }
 function resourceLinks2(html, baseUrl) {
-  const root = parse5(html);
+  const root = parse6(html);
   const entries = root.querySelectorAll(".resourceworkaround a[href], .resourcecontent a[href], a.resourceworkaround[href]").map((linkNode) => ({
     name: linkNode.textContent.trim(),
     url: new URL(linkNode.getAttribute("href") ?? "", baseUrl).toString()
@@ -6625,7 +7343,7 @@ function isHtmlWrapper(response) {
   return type.includes("text/html") || type.includes("application/xhtml+xml");
 }
 function looksLikeLoginPage3(html) {
-  const root = parse5(html);
+  const root = parse6(html);
   return root.querySelector('form[action*="/login/"], input[name="password"], #page-login-index') !== null || /<title>\s*(?:log in|login)/iu.test(html);
 }
 function chooseUpstreamFilename(resolved) {
@@ -6699,7 +7417,7 @@ async function writeResponse(response, destination, force, signal) {
     const input2 = response.body ? Readable.fromWeb(response.body) : Readable.from([]);
     await pipeline(input2, counter, createWriteStream(temporaryPath, { flags: "wx" }), { signal });
     if (force) {
-      await rename2(temporaryPath, destination);
+      await rename3(temporaryPath, destination);
     } else {
       try {
         await link(temporaryPath, destination);
@@ -6756,7 +7474,7 @@ function isFileSystemError(error) {
 }
 
 // src/skills.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import { mkdirSync, readFileSync, writeFileSync, rmSync } from "fs";
 import path3 from "path";
 
@@ -6768,7 +7486,7 @@ function describeProgram(program) {
     name: program.name(),
     version: program.version() ?? "",
     description: program.description(),
-    commands: program.commands.filter((command) => command.name() !== "help").map((command) => describeCommand(command))
+    commands: program.commands.filter((command) => command.name() !== "help" && command.name() !== "dev").map((command) => describeCommand(command))
   };
 }
 function describeCommand(command, noun) {
@@ -6795,20 +7513,20 @@ function describeArgument(argument) {
     ...argument.argChoices ? { enumValues: argument.argChoices } : {}
   };
 }
-function describeOption(option) {
+function describeOption(option2) {
   return {
-    flags: option.flags,
-    description: option.description,
-    required: option.required,
-    variadic: option.variadic,
-    ...option.argChoices ? { enumValues: option.argChoices } : {}
+    flags: option2.flags,
+    description: option2.description,
+    required: option2.required,
+    variadic: option2.variadic,
+    ...option2.argChoices ? { enumValues: option2.argChoices } : {}
   };
 }
 function isMutating(command) {
   if (VERB_SET.has(command.name())) {
     return ["send", "submit", "set", "mark-read"].includes(command.name());
   }
-  return ["install", "uninstall", "login", "deploy", "connect", "pair", "revoke", "remove", "push"].includes(command.name());
+  return ["install", "uninstall", "login", "deploy", "connect", "pair", "revoke", "remove", "push", "update", "start", "answer", "finish"].includes(command.name());
 }
 
 // src/skills.ts
@@ -6839,7 +7557,7 @@ function buildSkillsAddCommand(extraArgs = [], launcher = "npx") {
   return ["npm", "exec", "--yes", "--", "skills", "add", SKILL_SOURCE, ...extraArgs];
 }
 function addSkill(extraArgs = [], options = {}) {
-  const runCommand = options.runCommand ?? spawnSync3;
+  const runCommand = options.runCommand ?? spawnSync4;
   const commandExists = options.commandExists ?? ((name) => isCommandAvailable(name, runCommand));
   const command = commandExists("npx") ? buildSkillsAddCommand(extraArgs, "npx") : commandExists("npm") ? buildSkillsAddCommand(extraArgs, "npm") : void 0;
   if (!command) {
@@ -6872,11 +7590,11 @@ function commandDescriptionRows(command, parentPath = []) {
       required: argument.required,
       variadic: argument.variadic
     })),
-    flags: command.options.map((option) => {
-      const names = option.flags.match(/-{1,2}[\w-]+/g) ?? [];
-      const name = names.find((value) => value.startsWith("--")) ?? names[0] ?? option.flags;
+    flags: command.options.map((option2) => {
+      const names = option2.flags.match(/-{1,2}[\w-]+/g) ?? [];
+      const name = names.find((value) => value.startsWith("--")) ?? names[0] ?? option2.flags;
       const alias = names.find((value) => value !== name);
-      return { name, alias, description: option.description, required: option.required };
+      return { name, alias, description: option2.description, required: option2.required };
     })
   };
   return [row, ...command.commands.flatMap((child) => commandDescriptionRows(child, path5))];
@@ -7155,9 +7873,6 @@ async function readAll(input2) {
   return chunks2.join("");
 }
 
-// src/version.ts
-var VERSION = "0.9.1";
-
 // src/forum.ts
 function parseDiscussionReference(value) {
   const raw = value.trim();
@@ -7310,10 +8025,11 @@ function resolveTopLevelUrl(baseUrlOrOptions, targetValue, resolveCourseIdForUrl
 }
 
 // src/mcp/cli.ts
+import { createTheme as createTheme4 } from "@bunizao/cli-kit";
 import { createHash as createHash3 } from "crypto";
-import { readFile as readFile9 } from "fs/promises";
-import { homedir as homedir14 } from "os";
-import { join as join13 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { homedir as homedir15 } from "os";
+import { join as join14 } from "path";
 import { createInterface } from "readline/promises";
 import { fileURLToPath } from "url";
 
@@ -7847,9 +8563,9 @@ function resolveConnection(options) {
 }
 
 // src/mcp/connectors/node-connectors.ts
-import { chmod as chmod4, mkdir as mkdir7, readFile as readFile7, rm as rm5, stat as stat3, writeFile as writeFile6 } from "fs/promises";
-import { homedir as homedir11 } from "os";
-import { dirname as dirname6, join as join10 } from "path";
+import { chmod as chmod5, mkdir as mkdir8, readFile as readFile8, rm as rm6, stat as stat3, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir12 } from "os";
+import { dirname as dirname6, join as join11 } from "path";
 var NodeConnectorFileSystem = class {
   async exists(path5) {
     try {
@@ -7863,20 +8579,20 @@ var NodeConnectorFileSystem = class {
     }
   }
   async readText(path5) {
-    return readFile7(path5, "utf8");
+    return readFile8(path5, "utf8");
   }
   async writePrivate(path5, content) {
-    await mkdir7(dirname6(path5), { recursive: true, mode: 448 });
-    await writeFile6(path5, content, { encoding: "utf8", mode: 384 });
-    await chmod4(path5, 384);
+    await mkdir8(dirname6(path5), { recursive: true, mode: 448 });
+    await writeFile7(path5, content, { encoding: "utf8", mode: 384 });
+    await chmod5(path5, 384);
   }
   async remove(path5) {
-    await rm5(path5, { force: true });
+    await rm6(path5, { force: true });
   }
 };
 function createDefaultClientConnectors(profile, options = {}) {
-  const home = options.homeDirectory ?? homedir11();
-  const platform = options.platform ?? process.platform;
+  const home = options.homeDirectory ?? homedir12();
+  const platform2 = options.platform ?? process.platform;
   const fileSystem = options.fileSystem ?? new NodeConnectorFileSystem();
   const runtime = runtimeCommand(options.command, options.commandArgs);
   const shared = {
@@ -7887,14 +8603,14 @@ function createDefaultClientConnectors(profile, options = {}) {
     endpoint: options.endpoint,
     accessToken: options.accessToken
   };
-  const claudeDesktop = platform === "darwin" ? join10(home, "Library", "Application Support", "Claude", "claude_desktop_config.json") : platform === "win32" ? join10(home, "AppData", "Roaming", "Claude", "claude_desktop_config.json") : join10(home, ".config", "Claude", "claude_desktop_config.json");
-  const vscodeUser = platform === "darwin" ? join10(home, "Library", "Application Support", "Code", "User", "mcp.json") : platform === "win32" ? join10(home, "AppData", "Roaming", "Code", "User", "mcp.json") : join10(home, ".config", "Code", "User", "mcp.json");
+  const claudeDesktop = platform2 === "darwin" ? join11(home, "Library", "Application Support", "Claude", "claude_desktop_config.json") : platform2 === "win32" ? join11(home, "AppData", "Roaming", "Claude", "claude_desktop_config.json") : join11(home, ".config", "Claude", "claude_desktop_config.json");
+  const vscodeUser = platform2 === "darwin" ? join11(home, "Library", "Application Support", "Code", "User", "mcp.json") : platform2 === "win32" ? join11(home, "AppData", "Roaming", "Code", "User", "mcp.json") : join11(home, ".config", "Code", "User", "mcp.json");
   return [
-    createCodexConnector({ ...shared, configPath: join10(home, ".codex", "config.toml"), detectionPath: join10(home, ".codex") }, fileSystem),
+    createCodexConnector({ ...shared, configPath: join11(home, ".codex", "config.toml"), detectionPath: join11(home, ".codex") }, fileSystem),
     createClaudeDesktopConnector({ ...shared, configPath: claudeDesktop, detectionPath: dirname6(claudeDesktop) }, fileSystem),
-    createClaudeCodeConnector({ ...shared, configPath: join10(home, ".claude.json"), detectionPath: join10(home, ".claude") }, fileSystem),
+    createClaudeCodeConnector({ ...shared, configPath: join11(home, ".claude.json"), detectionPath: join11(home, ".claude") }, fileSystem),
     createVsCodeConnector({ ...shared, configPath: vscodeUser, detectionPath: dirname6(vscodeUser) }, fileSystem),
-    createCursorConnector({ ...shared, configPath: join10(home, ".cursor", "mcp.json"), detectionPath: join10(home, ".cursor") }, fileSystem)
+    createCursorConnector({ ...shared, configPath: join11(home, ".cursor", "mcp.json"), detectionPath: join11(home, ".cursor") }, fileSystem)
   ];
 }
 var DefaultClientIntegration = class {
@@ -7934,6 +8650,8 @@ function isMissing3(error) {
 }
 
 // src/mcp/deployment/onboarding.ts
+import { createTheme as createTheme3 } from "@bunizao/cli-kit";
+var PLAIN = createTheme3(false);
 var ONBOARDING_STAGES = [
   { id: "validate_moodle_session", index: 1, label: "Validating Moodle session" },
   { id: "check_cloudflare_access", index: 2, label: "Checking Cloudflare access" },
@@ -8025,39 +8743,42 @@ var ONBOARDING_COPY = {
     "Wrangler will request Cloudflare authorization again."
   ].join("\n")
 };
-function formatOnboardingStage(stageId, status) {
+function formatOnboardingStage(stageId, status, theme = PLAIN) {
   const stage = ONBOARDING_STAGES.find((item) => item.id === stageId);
   if (!stage) {
     throw new Error(`Unknown onboarding stage: ${stageId}`);
   }
   const line = `[${stage.index}/8] ${stage.label}`;
-  return status === "completed" ? `\u2713 ${line}` : line;
+  return status === "completed" ? `${theme.tone("success", "\u2713")} ${line}` : line;
 }
-function successfulDeploymentCopy(input2) {
-  const connectedClients = input2.clients.length ? input2.clients.map((client) => `  \u2713 ${client}`).join("\n") : "  No supported clients detected";
+function successfulDeploymentCopy(input2, theme = PLAIN) {
+  const connectedClients = input2.clients.length ? input2.clients.map((client) => `  ${theme.tone("success", "\u2713")} ${client}`).join("\n") : `  ${theme.dim("No supported clients detected")}`;
+  const field = (label, value) => `  ${theme.dim(`${label}:`)} ${value}`;
   return [
-    "Moodle MCP is ready.",
+    theme.tone("success", "Moodle MCP is ready."),
     "",
-    "Endpoint",
-    `  ${input2.endpoint}`,
+    theme.subject("Endpoint"),
+    // The one line a person copies into a client, so it reads as an identifier, not a footnote.
+    `  ${theme.key(input2.endpoint)}`,
     "",
-    "Protocol",
-    "  MCP 2026-07-28",
-    "  Stateless legacy compatibility: 2025-11-25",
+    theme.subject("Protocol"),
+    `  ${theme.dim("MCP")} ${MODERN_PROTOCOL_VERSION}`,
+    `  ${theme.dim(`Stateless legacy compatibility: ${LEGACY_PROTOCOL_VERSION}`)}`,
     "",
-    "Moodle",
-    `  Site: ${input2.moodleSite}`,
-    `  User: ${input2.moodleUser}`,
-    "  Session: ready",
+    theme.subject("Moodle"),
+    field("Site", theme.target(input2.moodleSite)),
+    field("User", input2.moodleUser),
+    field("Session", theme.status("ready", { ready: "success" })),
     "",
-    "Renewal",
-    "  Installed on this computer",
-    "  Next check: within 30 minutes",
+    theme.subject("Renewal"),
+    // People did not ask for a scheduler, so the first thing to say is what they will
+    // notice: nothing, unless Moodle signs them out. The mechanics come last and dim.
+    "  A silent background check every 30 minutes; you never see it.",
+    `  If Moodle signs you out it re-uploads your browser cookie, or sends one notification to run ${theme.key("moodle mcp login")}.`,
+    ...input2.renewal ? [`  ${theme.dim(`${input2.renewal.scheduler} ${input2.renewal.label} \xB7 log ${input2.renewal.log} \xB7 remove with moodle mcp remove`)}`] : [],
     "",
-    "Connected clients",
-    connectedClients,
-    "",
-    "Run `moodle mcp status` at any time."
+    theme.subject("Connected clients"),
+    connectedClients
   ].join("\n");
 }
 
@@ -8363,24 +9084,27 @@ var ManagedMcpDeployment = class {
         profile,
         worker: null,
         credentialsStored: false,
+        credentialsAvailable: true,
         renewalInstalled: await this.dependencies.renewal.inspect(profile),
         clientsConnected: await this.dependencies.clients.inspect(profile),
         readiness: "unknown",
         readinessReasonCode: "NOT_DEPLOYED",
-        sessionRevision: null
+        sessionRevision: null,
+        recoveryActive: false
       };
     }
     const [worker, credentials, renewalInstalled, clientsConnected] = await Promise.all([
       this.dependencies.wrangler.inspect(receipt.accountId, receipt.workerName),
-      this.dependencies.credentials.read(profile),
+      // Reporting is not worth failing over: an unopenable keychain is reported, not thrown.
+      readCredentialsForReport(() => this.dependencies.credentials.read(profile)),
       this.dependencies.renewal.inspect(profile),
       this.dependencies.clients.inspect(profile)
     ]);
     let readiness = "unknown";
     let readinessReasonCode = null;
     let sessionRevision = null;
-    if (worker && credentials) {
-      const target = { endpoint: receipt.productionEndpoint, sessionSyncToken: credentials.sessionSyncToken };
+    if (worker && credentials.value) {
+      const target = { endpoint: receipt.productionEndpoint, sessionSyncToken: credentials.value.sessionSyncToken };
       await this.dependencies.worker.touchSession(target);
       const remoteReadiness = await this.dependencies.worker.getReadiness(target);
       readiness = remoteReadiness.status;
@@ -8391,12 +9115,14 @@ var ManagedMcpDeployment = class {
     return {
       profile,
       worker: resolvedWorker,
-      credentialsStored: credentials !== null,
+      credentialsStored: credentials.value !== null,
+      credentialsAvailable: credentials.available,
       renewalInstalled,
       clientsConnected,
       readiness,
       readinessReasonCode,
-      sessionRevision
+      sessionRevision,
+      recoveryActive: receipt.releaseDigest.endsWith("-recovery")
     };
   }
   async recover(profile) {
@@ -8664,10 +9390,10 @@ function asDeploymentError(error) {
 
 // src/mcp/wrangler.ts
 import { createUi as createUi2 } from "@bunizao/cli-kit";
-import { mkdir as mkdir8, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir9, writeFile as writeFile8 } from "fs/promises";
 import { existsSync } from "fs";
-import { homedir as homedir12 } from "os";
-import { join as join11 } from "path";
+import { homedir as homedir13 } from "os";
+import { join as join12 } from "path";
 async function resolveWrangler(runner, options = {}) {
   const env = options.env ?? process.env;
   const notice = options.notice ?? ((text2) => process.stderr.write(`${text2}
@@ -8678,8 +9404,8 @@ async function resolveWrangler(runner, options = {}) {
     if (version && sameMajorAtLeast(version, WRANGLER_VERSION)) return { command: existing, args: [] };
     notice(`Ignoring ${existing} (${version ?? "unknown version"}); Cloudflare management needs Wrangler ${WRANGLER_VERSION.split(".")[0]}.x.`);
   }
-  const root = join11(options.homeDir ?? homedir12(), ".config", "moodle-cli", "tools", `wrangler@${WRANGLER_VERSION}`);
-  const script = join11(root, "node_modules", "wrangler", "bin", "wrangler.js");
+  const root = join12(options.homeDir ?? homedir13(), ".config", "moodle-cli", "tools", `wrangler@${WRANGLER_VERSION}`);
+  const script = join12(root, "node_modules", "wrangler", "bin", "wrangler.js");
   const bun = findExecutable("bun", env);
   const node = findExecutable("node", env);
   if (!bun && !node) throw new Error("Cloudflare management needs Bun or Node 22.13+. Install either, then retry moodle mcp deploy.");
@@ -8695,8 +9421,8 @@ async function resolveWrangler(runner, options = {}) {
       }
     }
     notice(`Cloudflare management needs Wrangler ${WRANGLER_VERSION}; downloading once to ${root}.`);
-    await mkdir8(root, { recursive: true, mode: 448 });
-    await writeFile7(join11(root, "package.json"), '{ "private": true }\n');
+    await mkdir9(root, { recursive: true, mode: 448 });
+    await writeFile8(join12(root, "package.json"), '{ "private": true }\n');
     const result = await runner.run(bun ?? npm, bun ? ["install", "--cwd", root, "--no-save", `wrangler@${WRANGLER_VERSION}`] : ["install", "--prefix", root, "--no-save", "--package-lock=false", "--no-audit", "--no-fund", `wrangler@${WRANGLER_VERSION}`]);
     if (!existsSync(script)) {
       const output = `${result.stderr}
@@ -8716,18 +9442,18 @@ function sameMajorAtLeast(actual, pinned) {
 
 // src/mcp/deployment/node-adapters.ts
 import { isDeepStrictEqual } from "util";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
-import { chmod as chmod5, mkdir as mkdir9, mkdtemp, readFile as readFile8, rm as rm6, writeFile as writeFile8 } from "fs/promises";
-import { homedir as homedir13, tmpdir } from "os";
-import { basename, dirname as dirname7, join as join12 } from "path";
+import { chmod as chmod6, mkdir as mkdir10, mkdtemp, readFile as readFile9, rm as rm7, writeFile as writeFile9 } from "fs/promises";
+import { homedir as homedir14, tmpdir } from "os";
+import { basename, dirname as dirname7, join as join13 } from "path";
 var MODERN_MCP_VERSION = "2026-07-28";
 var WORKER_PROPAGATION_ATTEMPTS = 10;
 var WORKER_PROPAGATION_MAX_DELAY_MS = 4e3;
 var NodeDeploymentCommandRunner = class {
   async run(command, args, environment = {}) {
     return new Promise((resolve, reject) => {
-      const child = spawn3(command, args, {
+      const child = spawn4(command, args, {
         env: { ...process.env, ...environment },
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true
@@ -8961,7 +9687,7 @@ ${error.stderr}`)) {
   }
 };
 async function copyReleaseBundle(source, destination) {
-  await writeFile8(destination, await readFile8(source));
+  await writeFile9(destination, await readFile9(source));
 }
 var NodeReleaseMaterializer = class {
   constructor(options) {
@@ -8970,13 +9696,13 @@ var NodeReleaseMaterializer = class {
   options;
   async prepare(plan, credentials) {
     const temporaryRoot = this.options.temporaryRoot ?? tmpdir();
-    await mkdir9(temporaryRoot, { recursive: true });
-    const artifactDirectory = await mkdtemp(join12(temporaryRoot, "moodle-mcp-"));
-    await chmod5(artifactDirectory, 448);
-    const workerFile = join12(artifactDirectory, basename(this.options.workerBundlePath));
+    await mkdir10(temporaryRoot, { recursive: true });
+    const artifactDirectory = await mkdtemp(join13(temporaryRoot, "moodle-mcp-"));
+    await chmod6(artifactDirectory, 448);
+    const workerFile = join13(artifactDirectory, basename(this.options.workerBundlePath));
     await copyReleaseBundle(this.options.workerBundlePath, workerFile);
-    const wranglerConfigPath = join12(artifactDirectory, "wrangler.json");
-    const secretsFilePath = join12(artifactDirectory, "secrets.json");
+    const wranglerConfigPath = join13(artifactDirectory, "wrangler.json");
+    const secretsFilePath = join13(artifactDirectory, "secrets.json");
     const expectedHosts = endpointHosts(plan.intent.workerName, plan.existing?.productionEndpoint);
     const config = {
       $schema: "node_modules/wrangler/config-schema.json",
@@ -9016,18 +9742,18 @@ var NodeReleaseMaterializer = class {
     if (credentials.previousTokensExpireAt !== void 0 && Number.isFinite(credentials.previousTokensExpireAt)) {
       secrets.TOKEN_OVERLAP_EXPIRES_AT = String(credentials.previousTokensExpireAt);
     }
-    await writeFile8(wranglerConfigPath, `${JSON.stringify(config, null, 2)}
+    await writeFile9(wranglerConfigPath, `${JSON.stringify(config, null, 2)}
 `, { mode: 384 });
-    await writeFile8(secretsFilePath, `${JSON.stringify(secrets)}
+    await writeFile9(secretsFilePath, `${JSON.stringify(secrets)}
 `, { mode: 384 });
-    await chmod5(wranglerConfigPath, 384);
-    await chmod5(secretsFilePath, 384);
+    await chmod6(wranglerConfigPath, 384);
+    await chmod6(secretsFilePath, 384);
     let recoveryConfigPath;
     try {
-      const recoveryBundle = process.env.MOODLE_BUNDLED_RECOVERY ?? join12(dirname7(this.options.workerBundlePath), "recovery.js");
-      await copyReleaseBundle(recoveryBundle, join12(artifactDirectory, "recovery.js"));
-      recoveryConfigPath = join12(artifactDirectory, "wrangler-recovery.json");
-      await writeFile8(recoveryConfigPath, `${JSON.stringify({ ...config, main: "./recovery.js" })}
+      const recoveryBundle = process.env.MOODLE_BUNDLED_RECOVERY ?? join13(dirname7(this.options.workerBundlePath), "recovery.js");
+      await copyReleaseBundle(recoveryBundle, join13(artifactDirectory, "recovery.js"));
+      recoveryConfigPath = join13(artifactDirectory, "wrangler-recovery.json");
+      await writeFile9(recoveryConfigPath, `${JSON.stringify({ ...config, main: "./recovery.js" })}
 `, { mode: 384 });
     } catch (error) {
       if (!isMissing4(error) || plan.existing) throw error;
@@ -9035,7 +9761,7 @@ var NodeReleaseMaterializer = class {
     return { artifactDirectory, wranglerConfigPath, secretsFilePath, recoveryConfigPath, encryptionKeyId: config.vars.SESSION_KEY_ID, credentialId: config.vars.SESSION_CREDENTIAL_ID };
   }
   async cleanup(release) {
-    await rm6(release.artifactDirectory, { recursive: true, force: true });
+    await rm7(release.artifactDirectory, { recursive: true, force: true });
   }
 };
 var DefaultMoodleSessionSource = class {
@@ -9136,28 +9862,25 @@ var FetchManagedWorkerClient = class {
     }
     await this.mcpCall(input2.endpoint, input2.mcpAccessToken, "server/discover", {}, 1);
     await this.mcpCall(input2.endpoint, input2.mcpAccessToken, "tools/list", {}, 2);
-    const userResult = await this.mcpCall(
-      input2.endpoint,
-      input2.mcpAccessToken,
-      "tools/call",
-      { name: "get_user", arguments: {} },
-      3
-    );
-    const moodleUser = mcpUserFullname(userResult);
+    const homeResult = await this.mcpCall(input2.endpoint, input2.mcpAccessToken, "tools/call", { name: "home", arguments: {} }, 3);
+    const moodleUser = smokeMoodleUser(homeResult);
     if (!moodleUser) {
-      throw new DeploymentApplyError("MCP_SMOKE_FAILED", "MCP get_user check returned no Moodle user");
+      throw new DeploymentApplyError("MCP_SMOKE_FAILED", "MCP home check returned no Moodle user");
     }
-    const coursesResult = await this.mcpCall(input2.endpoint, input2.mcpAccessToken, "tools/call", { name: "list_courses", arguments: { limit: 1 } }, 4);
-    const courses = readableToolResult(coursesResult).courses;
-    if (!Array.isArray(courses)) throw new DeploymentApplyError("MCP_SMOKE_FAILED", "MCP list_courses returned no course list");
-    if (courses.length) {
-      const first2 = courses[0];
+    const unitsResult = await this.mcpCall(input2.endpoint, input2.mcpAccessToken, "tools/call", { name: "units", arguments: { limit: 1 } }, 4);
+    const units = readableToolResult(unitsResult).units;
+    if (!Array.isArray(units)) throw new DeploymentApplyError("MCP_SMOKE_FAILED", "MCP units returned no unit list");
+    if (units.length) {
+      const first2 = units[0];
       if (!isRecord9(first2) || !Number.isSafeInteger(first2.id) || Number(first2.id) <= 0) {
-        throw new DeploymentApplyError("MCP_SMOKE_FAILED", "MCP list_courses returned no usable course ID");
+        throw new DeploymentApplyError("MCP_SMOKE_FAILED", "MCP units returned no usable unit ID");
+      }
+      const detail = readableToolResult(await this.mcpCall(input2.endpoint, input2.mcpAccessToken, "tools/call", { name: "unit", arguments: { unit: first2.id } }, 5));
+      if (!isRecord9(detail.unit) || detail.unit.id !== first2.id) {
+        throw new DeploymentApplyError("MCP_SMOKE_FAILED", "MCP unit lookup did not match the listed unit");
       }
-      const detail = readableToolResult(await this.mcpCall(input2.endpoint, input2.mcpAccessToken, "tools/call", { name: "get_course", arguments: { courseId: first2.id } }, 5));
-      if (!isRecord9(detail.course) || !isRecord9(detail.course.course) || detail.course.course.id !== first2.id || !Array.isArray(detail.course.sections)) {
-        throw new DeploymentApplyError("MCP_SMOKE_FAILED", "MCP course lookup did not match the listed course");
+      if (detail.sections !== void 0 && !Array.isArray(detail.sections)) {
+        throw new DeploymentApplyError("MCP_SMOKE_FAILED", "MCP unit lookup returned an unusable section list");
       }
     }
     return { moodleUser };
@@ -9235,13 +9958,13 @@ var FetchManagedWorkerClient = class {
   }
 };
 var PrivateDeploymentReceiptStore = class {
-  constructor(baseDirectory = join12(homedir13(), ".config", "moodle-cli", "mcp", "deployments")) {
+  constructor(baseDirectory = join13(homedir14(), ".config", "moodle-cli", "mcp", "deployments")) {
     this.baseDirectory = baseDirectory;
   }
   baseDirectory;
   async read(profile) {
     try {
-      const parsed = JSON.parse(await readFile8(this.path(profile), "utf8"));
+      const parsed = JSON.parse(await readFile9(this.path(profile), "utf8"));
       return isReceipt(parsed) ? parsed : null;
     } catch (error) {
       if (isMissing4(error)) {
@@ -9252,24 +9975,24 @@ var PrivateDeploymentReceiptStore = class {
   }
   async write(receipt) {
     const path5 = this.path(receipt.profile);
-    await mkdir9(dirname7(path5), { recursive: true, mode: 448 });
-    await writeFile8(path5, `${JSON.stringify(receipt, null, 2)}
+    await mkdir10(dirname7(path5), { recursive: true, mode: 448 });
+    await writeFile9(path5, `${JSON.stringify(receipt, null, 2)}
 `, { mode: 384 });
-    await chmod5(path5, 384);
+    await chmod6(path5, 384);
   }
   async delete(profile) {
-    await rm6(this.path(profile), { force: true });
+    await rm7(this.path(profile), { force: true });
   }
   path(profile) {
     if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(profile)) {
       throw new Error("Invalid Moodle MCP profile name");
     }
-    return join12(this.baseDirectory, `${profile}.json`);
+    return join13(this.baseDirectory, `${profile}.json`);
   }
 };
 function createDefaultManagedDeployment(options) {
-  const homeDirectory = options.homeDirectory ?? homedir13();
-  const platform = options.platform ?? process.platform;
+  const homeDirectory = options.homeDirectory ?? homedir14();
+  const platform2 = options.platform ?? process.platform;
   const runtime = runtimeCommand(options.executable, options.executableArgs);
   const defaults = {
     wrangler: new NodeWranglerDeploymentAdapter({ wranglerBinPath: options.wranglerBinPath }),
@@ -9277,12 +10000,12 @@ function createDefaultManagedDeployment(options) {
       workerBundlePath: options.workerBundlePath,
       compatibilityDate: options.compatibilityDate
     }),
-    credentials: createDefaultCredentialStore({ platform, homeDirectory }),
+    credentials: createDefaultCredentialStore({ platform: platform2, homeDirectory }),
     sessions: createInteractiveMoodleSessionSource(options.auth),
     worker: new FetchManagedWorkerClient(options.fetch),
     renewal: new DefaultRenewalIntegration({
       ...options.renewal,
-      platform,
+      platform: platform2,
       homeDirectory,
       executable: runtime.command,
       executableArgs: runtime.args,
@@ -9290,12 +10013,12 @@ function createDefaultManagedDeployment(options) {
     }),
     clients: new DefaultClientIntegration({
       ...options.connector,
-      platform,
+      platform: platform2,
       homeDirectory,
       command: runtime.command,
       commandArgs: runtime.args
     }),
-    receipts: new PrivateDeploymentReceiptStore(join12(homeDirectory, ".config", "moodle-cli", "mcp", "deployments")),
+    receipts: new PrivateDeploymentReceiptStore(join13(homeDirectory, ".config", "moodle-cli", "mcp", "deployments")),
     createToken: () => randomBytes2(32).toString("base64url")
   };
   return new ManagedMcpDeployment({ ...defaults, ...options.dependencies });
@@ -9312,7 +10035,7 @@ function endpointUrl(endpoint, path5) {
 async function pinExpectedHosts(configPath, workerName, productionEndpoint) {
   let config;
   try {
-    config = JSON.parse(await readFile8(configPath, "utf8"));
+    config = JSON.parse(await readFile9(configPath, "utf8"));
   } catch {
     throw new DeploymentApplyError("RELEASE_CONFIG_INVALID", "The generated Wrangler configuration is invalid");
   }
@@ -9324,7 +10047,7 @@ async function pinExpectedHosts(configPath, workerName, productionEndpoint) {
     throw new DeploymentApplyError("MISSING_ENDPOINT", "The Worker production endpoint is invalid");
   }
   config.vars.EXPECTED_HOSTS = hosts.join(",");
-  await writeFile8(configPath, `${JSON.stringify(config, null, 2)}
+  await writeFile9(configPath, `${JSON.stringify(config, null, 2)}
 `, { mode: 384 });
 }
 function endpointHosts(workerName, endpoint) {
@@ -9373,9 +10096,9 @@ function readableToolResult(result) {
   }
   throw new DeploymentApplyError("MCP_CONTENT_INCOMPLETE", "MCP text content is missing the complete structured result");
 }
-function mcpUserFullname(result) {
-  const user = readableToolResult(result).user;
-  return isRecord9(user) && typeof user.fullname === "string" && user.fullname.trim() ? user.fullname.trim() : null;
+function smokeMoodleUser(result) {
+  const home = readableToolResult(result).home;
+  return isRecord9(home) && typeof home.name === "string" && home.name.trim() ? home.name.trim() : null;
 }
 function parseJsonOutput(output) {
   const candidates = [output.indexOf("{"), output.indexOf("[")].filter((index) => index >= 0).sort((a, b) => a - b);
@@ -9589,7 +10312,10 @@ function createMoodleMcpServer(gateway, options = {}) {
             protocolVersion: protocolVersion2,
             capabilities: { tools: { listChanged: false } },
             serverInfo,
-            instructions: gateway.submitAssignment ? "Access to the authenticated user's Moodle data. Only submit writes; it defaults to a dry run." : "Read-only access to the authenticated user's Moodle data."
+            instructions: [
+              gateway.submitAssignment ? "Access to the authenticated user's Moodle data. Only submit writes; it defaults to a dry run." : "Read-only access to the authenticated user's Moodle data.",
+              ...options.instructions ?? []
+            ].join(" ")
           });
         }
         if (request.method === "ping") {
@@ -9710,6 +10436,9 @@ async function callTool(gateway, params) {
 function toolContent(name, payload, structuredContent) {
   const text2 = { type: "text", text: JSON.stringify(structuredContent) };
   if (name !== "get_file" || !isMoodleFile(payload)) return [text2];
+  if (payload.mimeType.startsWith("image/")) {
+    return [text2, { type: "image", data: payload.blob, mimeType: payload.mimeType }];
+  }
   return [
     text2,
     {
@@ -9834,9 +10563,9 @@ function deriveMcpWorkerName(moodleOrigin) {
 var DefaultMcpCommandService = class {
   constructor(options) {
     this.options = options;
-    this.homeDirectory = options.homeDir ?? homedir14();
+    this.homeDirectory = options.homeDir ?? homedir15();
     this.wranglerInstance = options.wrangler;
-    this.receipts = options.receipts ?? new PrivateDeploymentReceiptStore(join13(this.homeDirectory, ".config", "moodle-cli", "mcp", "deployments"));
+    this.receipts = options.receipts ?? new PrivateDeploymentReceiptStore(join14(this.homeDirectory, ".config", "moodle-cli", "mcp", "deployments"));
     this.credentials = options.credentials ?? createDefaultCredentialStore({ platform: process.platform, homeDirectory: this.homeDirectory });
     this.worker = options.worker ?? new FetchManagedWorkerClient(options.fetchImpl);
     this.renewal = options.renewal ?? new DefaultRenewalIntegration({
@@ -9862,6 +10591,7 @@ var DefaultMcpCommandService = class {
   progressReporter;
   async deploy(input2) {
     await this.prepareToolchain(input2.yes);
+    const theme = this.theme();
     const progress = this.progress();
     try {
       progress.begin("Reading Cloudflare account and deployment state");
@@ -9872,7 +10602,8 @@ var DefaultMcpCommandService = class {
         const recovery = await deployment.rollback(identity.profile);
         return {
           data: recovery,
-          text: `Moodle MCP restored release ${recovery.versionId}.`
+          text: `${theme.tone("success", "Moodle MCP restored release")} ${theme.key(recovery.versionId)}.`,
+          next: ["moodle mcp status"]
         };
       }
       progress.begin("Planning the deployment");
@@ -9894,18 +10625,19 @@ var DefaultMcpCommandService = class {
             uploadCandidate: plan.uploadCandidate
           },
           text: [
-            "Moodle MCP deployment plan",
-            `Operation: ${plan.operation}`,
-            `Worker: ${plan.intent.workerName}`,
-            `Candidate upload: ${plan.uploadCandidate ? "yes" : "no"}`
-          ].join("\n")
+            theme.subject("Moodle MCP deployment plan"),
+            `  ${theme.dim("Operation:")} ${plan.operation}`,
+            `  ${theme.dim("Worker:")} ${theme.key(plan.intent.workerName)}`,
+            `  ${theme.dim("Candidate upload:")} ${plan.uploadCandidate ? "yes" : "no"}`
+          ].join("\n"),
+          next: ["moodle mcp deploy"]
         };
       }
       const events = [];
       for await (const event2 of deployment.apply(plan)) {
         events.push(event2);
-        if (event2.status === "started") progress.begin(formatOnboardingStage(event2.stageId, "pending"));
-        else if (event2.status === "completed") progress.end(formatOnboardingStage(event2.stageId, "completed"));
+        if (event2.status === "started") progress.begin(formatOnboardingStage(event2.stageId, "pending", theme));
+        else if (event2.status === "completed") progress.end(formatOnboardingStage(event2.stageId, "completed", theme));
         else progress.clear();
       }
       progress.begin("Reading deployment status");
@@ -9927,8 +10659,10 @@ var DefaultMcpCommandService = class {
         endpoint: `${endpoint.replace(/\/$/u, "")}/mcp`,
         moodleSite: identity.moodleOrigin,
         moodleUser: events.find((event2) => event2.moodleUser)?.moodleUser ?? "Unknown Moodle user",
-        clients: await this.connectedClientNames(identity.profile)
-      })
+        clients: await this.connectedClientNames(identity.profile),
+        renewal: this.renewalJob(identity.profile)
+      }, this.theme()),
+      next: ["moodle mcp status", "moodle mcp pair"]
     };
   }
   async planDeployment(deployment, initialIntent) {
@@ -9991,26 +10725,54 @@ var DefaultMcpCommandService = class {
       localAuthentication = { status: "unknown" };
     }
     const updateAvailable = await this.remoteWorkerBehindLocal(profile);
+    const [receipt, credentials] = await Promise.all([
+      this.receipts.read(profile),
+      readCredentialsForReport(() => this.credentials.read(profile))
+    ]);
+    const job = this.renewalJob(profile);
+    const hosted = receipt && credentials.value ? await this.worker.manageClients({ endpoint: receipt.productionEndpoint, sessionSyncToken: credentials.value.sessionSyncToken }).then((data2) => isClientList(data2) ? data2.clients.filter((client) => client.approved).length : null).catch(() => null) : null;
+    const credentialsState = !credentials.available || !managed.credentialsAvailable ? "unavailable" : managed.credentialsStored ? "stored" : "missing";
+    const renewal = {
+      installed: managed.renewalInstalled,
+      ...job ? { scheduler: job.scheduler, label: job.label, schedule: job.schedule, log: job.log } : {},
+      lastRun: receipt?.lastRenewal ?? null
+    };
     const data = {
       profile,
       localAuthentication,
       managed,
+      credentials: { state: credentialsState },
+      renewal,
+      hostedClients: hosted,
       protocols: [...SUPPORTED_PROTOCOL_VERSIONS],
       updateAvailable,
       ...input2.verbose ? { serviceVersion: VERSION } : {},
       ...input2.logs ? { logs: { available: false, reason: "live_tail_required" } } : {}
     };
+    const theme = this.theme();
+    const row = (label, value) => `${theme.dim(`${label}:`)} ${theme.status(value, { pass: "success", warn: "warning", fail: "danger", unknown: "muted", "not deployed": "warning", missing: "warning", "not connected": "warning", unavailable: "warning", stored: "success", installed: "success", connected: "success" })}`;
     return {
       data,
       text: [
-        `Moodle MCP: ${managed.readiness}`,
-        `Worker: ${managed.worker?.workerName ?? "not deployed"}`,
-        `Credentials: ${managed.credentialsStored ? "stored" : "missing"}`,
-        `Renewal: ${managed.renewalInstalled ? "installed" : "missing"}`,
-        `Clients: ${managed.clientsConnected ? "connected" : "not connected"}`,
-        ...updateAvailable ? ["Update: remote Worker is behind this CLI. Run `moodle mcp deploy` to update it."] : [],
-        ...input2.logs ? ["Logs: use a live sanitized tail from an interactive terminal"] : []
-      ].join("\n")
+        row("Moodle MCP", managed.readiness),
+        row("Worker", managed.worker?.workerName ?? "not deployed"),
+        row("Credentials", credentialsState),
+        row("Renewal", managed.renewalInstalled ? "installed" : "missing"),
+        ...managed.renewalInstalled && job ? [`  ${theme.dim(`${job.schedule}; you only hear from it when Moodle signs you out`)}`] : [],
+        `  ${theme.dim("Last run:")} ${renewalRunText(renewal.lastRun, theme)}`,
+        ...managed.renewalInstalled && job && input2.verbose ? [`  ${theme.dim("Log:")} ${theme.dim(job.log)}`] : [],
+        row("Local clients", managed.clientsConnected ? "connected" : "not connected"),
+        `${theme.dim("Hosted clients:")} ${hosted === null ? theme.dim("unknown") : hosted ? `${hosted} approved` : theme.dim("none")}`,
+        ...managed.recoveryActive ? [`${theme.dim("Release:")} ${theme.tone("warning", "the recovery Worker is live; OAuth sign-in is disabled until")} ${theme.key("moodle mcp deploy")} ${theme.tone("warning", "succeeds.")}`] : [],
+        ...updateAvailable ? [`${theme.dim("Update:")} remote Worker is behind this CLI. Run ${theme.key("moodle update")} to update it.`] : [],
+        ...input2.logs ? [`${theme.dim("Logs:")} use a live sanitized tail from an interactive terminal`] : []
+      ].join("\n"),
+      next: [
+        ...updateAvailable ? ["moodle update"] : [],
+        ...managed.readiness === "fail" ? ["moodle mcp login"] : [],
+        ...!managed.clientsConnected ? ["moodle mcp connect"] : [],
+        ...hosted ? [] : ["moodle mcp pair"]
+      ]
     };
   }
   async login() {
@@ -10020,9 +10782,12 @@ var DefaultMcpCommandService = class {
     try {
       progress.begin("Reading your Moodle session (a browser sign-in may be required)");
       const recovery = await this.deployment(false).recover(profile);
+      const theme = this.theme();
+      const done = (line) => `${theme.tone("success", "\u2713")} ${line}`;
       return {
         data: recovery,
-        text: "\u2713 New Moodle session acquired.\n\u2713 Remote session updated.\n\u2713 MCP readiness restored."
+        text: [done("New Moodle session acquired."), done("Remote session updated."), done("MCP readiness restored.")].join("\n"),
+        next: ["moodle mcp status"]
       };
     } finally {
       progress.clear();
@@ -10051,13 +10816,15 @@ var DefaultMcpCommandService = class {
     }
     const connected = [];
     for (const connector of selected) connected.push(await connectClient(connector));
+    const theme = this.theme();
     const text2 = [
-      ...connected.map((item) => `\u2713 ${item.client}`),
-      ...input2.showToken ? ["", "MCP access token", credentials.mcpAccessToken] : []
+      ...connected.map((item) => `${theme.tone("success", "\u2713")} ${item.client} ${theme.dim(item.changed ? `\xB7 ${item.configPath}` : "\xB7 already connected")}`),
+      ...input2.showToken ? ["", theme.subject("MCP access token"), `  ${credentials.mcpAccessToken}`] : []
     ].join("\n");
     return {
       data: { profile, mode: input2.mode, connected: connected.map(({ client, configPath, changed }) => ({ client, configPath, changed })) },
-      text: text2
+      text: text2,
+      next: ["moodle mcp status"]
     };
   }
   async manageClients(input2) {
@@ -10067,7 +10834,19 @@ var DefaultMcpCommandService = class {
     const credentials = await this.credentials.read(profile);
     if (!receipt || !credentials) throw new UsageError(`No managed Moodle MCP deployment exists for profile ${profile}.`);
     const data = await this.worker.manageClients({ endpoint: receipt.productionEndpoint, sessionSyncToken: credentials.sessionSyncToken, ...input2 });
-    return { data, text: input2.revoke ? "OAuth authorization revoked." : JSON.stringify(data, null, 2) };
+    const theme = this.theme();
+    if (input2.revoke) {
+      return { data, text: theme.tone("success", input2.clientId ? "OAuth client revoked." : "All OAuth access revoked."), next: ["moodle mcp pair"] };
+    }
+    const clients = isClientList(data) ? data.clients : [];
+    return {
+      data,
+      text: clients.length ? [
+        theme.subject("OAuth clients"),
+        ...clients.map((client) => `  ${theme.status(client.approved ? "approved" : "pending", { approved: "success", pending: "warning" }).padEnd(theme.enabled ? 18 : 9)} ${client.clientName}  ${theme.dim(client.clientId)}`)
+      ].join("\n") : theme.dim("No OAuth clients."),
+      next: clients.length ? [`moodle mcp revoke ${clients[0].clientId}`, "moodle mcp pair"] : ["moodle mcp pair"]
+    };
   }
   async pair() {
     const profile = deriveMcpProfile((await this.config()).baseUrl);
@@ -10089,17 +10868,8 @@ var DefaultMcpCommandService = class {
         expiresAt: pairing.expiresAt,
         authorizationServer: pairing.authorizationServer
       },
-      text: [
-        "Add this custom connector in Claude, then approve it with the pairing code.",
-        "",
-        "Connector URL",
-        `  ${endpoint}`,
-        "",
-        "Pairing code",
-        `  ${formatPairingCode(pairing.code)}`,
-        "",
-        `The code expires at ${pairing.expiresAt} and works for one approval.`
-      ].join("\n")
+      text: pairingCopy({ endpoint, code: pairing.code, expiresAt: pairing.expiresAt }, this.theme()),
+      next: ["moodle mcp clients"]
     };
   }
   async remove(input2) {
@@ -10115,11 +10885,12 @@ var DefaultMcpCommandService = class {
     return {
       data: result,
       text: [
-        "Moodle MCP has been removed.",
-        `Worker: ${result.workerRemoved ? "deleted" : "not present"}`,
-        "Local renewal, client registrations, and deployment credentials: deleted",
-        "Local Moodle configuration: kept; matching authentication cache: removed"
-      ].join("\n")
+        this.theme().tone("success", "Moodle MCP has been removed."),
+        `  ${this.theme().dim("Worker:")} ${result.workerRemoved ? "deleted" : "not present"}`,
+        `  ${this.theme().dim("Renewal job, client registrations, deployment credentials:")} deleted`,
+        `  ${this.theme().dim("Local Moodle configuration:")} kept ${this.theme().dim("(its authentication cache was removed)")}`
+      ].join("\n"),
+      next: ["moodle mcp deploy"]
     };
   }
   async serveStdio() {
@@ -10229,16 +11000,22 @@ var DefaultMcpCommandService = class {
       notifySignIn: this.notifyRenewalSignIn
     };
     const decision = await executeRenewalWithRecovery(decideRenewal(snapshot), snapshot, executor);
+    const outcome = uploaded ? { state: "healthy", reasonCode: "SESSION_VALID" } : { state: decision.state, reasonCode: decision.reasonCode };
+    receipt = { ...receipt, lastRenewal: { at: (/* @__PURE__ */ new Date()).toISOString(), ...outcome } };
+    await this.receipts.write(receipt);
+    const theme = this.theme();
     if (uploaded) {
       return {
-        data: { profile, state: "healthy", reasonCode: "SESSION_VALID", revision: receipt.sessionRevision },
-        text: "Moodle MCP session renewed."
+        data: { profile, ...outcome, revision: receipt.sessionRevision },
+        text: theme.tone("success", "Moodle MCP session renewed."),
+        next: ["moodle mcp status"]
       };
     }
     const detail = decision.state === "needs_sign_in" && signInDetail ? { detail: signInDetail } : {};
     return {
-      data: { profile, state: decision.state, reasonCode: decision.reasonCode, revision: receipt.sessionRevision, ...detail },
-      text: [renewalResultText(decision), signInDetail].filter(Boolean).join("\n")
+      data: { profile, ...outcome, revision: receipt.sessionRevision, ...detail },
+      text: [renewalResultText(decision, theme), signInDetail].filter(Boolean).join("\n"),
+      next: [decision.state === "needs_sign_in" ? "moodle mcp login" : "moodle mcp status"]
     };
   }
   async writeRenewalRevision(receipt, revision) {
@@ -10280,7 +11057,7 @@ var DefaultMcpCommandService = class {
       }
     });
     await this.receipts.write({ ...receipt, sessionRevision: uploaded.revision });
-    return { data: { profile, revision: uploaded.revision }, text: "Moodle MCP session updated." };
+    return { data: { profile, revision: uploaded.revision }, text: this.theme().tone("success", "Moodle MCP session updated."), next: ["moodle mcp status"] };
   }
   deployment(background) {
     if (this.options.createDeployment) return this.options.createDeployment(background);
@@ -10389,13 +11166,13 @@ Selection: `)).trim());
       fetch: this.options.fetchImpl
     });
   }
-  prompt(question) {
+  prompt(question2) {
     this.progress().clear();
-    if (this.options.prompt) return this.options.prompt(question);
+    if (this.options.prompt) return this.options.prompt(question2);
     const input2 = this.options.stdin ?? process.stdin;
     const output = this.options.stderr ?? process.stderr;
     const readline = createInterface({ input: input2, output });
-    return readline.question(question).finally(() => readline.close());
+    return readline.question(question2).finally(() => readline.close());
   }
   workerBundlePath() {
     return this.options.workerBundlePath ?? process.env.MOODLE_BUNDLED_WORKER ?? fileURLToPath(new URL("./worker/worker.js", import.meta.url));
@@ -10404,6 +11181,21 @@ Selection: `)).trim());
     this.wranglerInstance ??= new NodeWranglerDeploymentAdapter();
     return this.wranglerInstance;
   }
+  async workerState() {
+    try {
+      const profile = deriveMcpProfile((await this.config()).baseUrl);
+      const [receipt, credentials] = await Promise.all([
+        this.receipts.read(profile),
+        readCredentialsForReport(() => this.credentials.read(profile))
+      ]);
+      if (!receipt || !credentials.value) return null;
+      const behind = await this.remoteWorkerBehindLocal(profile);
+      const readiness = await this.worker.getReadiness({ endpoint: receipt.productionEndpoint, sessionSyncToken: credentials.value.sessionSyncToken }).catch(() => null);
+      return { behind, ready: readiness?.status === "pass" };
+    } catch {
+      return null;
+    }
+  }
   // The first-use Wrangler download asks a question, so it runs before a spinner
   // owns the terminal rather than drawing its prompt underneath one.
   async prepareToolchain(yes = false) {
@@ -10411,7 +11203,7 @@ Selection: `)).trim());
     await this.wrangler().prepare({ yes });
   }
   releaseDigest() {
-    return readFile9(this.workerBundlePath()).then((content) => sha256(content));
+    return readFile10(this.workerBundlePath()).then((content) => sha256(content));
   }
   // True when a deployment receipt exists but its recorded release digest no
   // longer matches the Worker bundle shipped with this CLI, i.e. the remote
@@ -10431,6 +11223,13 @@ Selection: `)).trim());
   }
   // Progress belongs on stderr so that --json and --yaml keep stdout to themselves.
   // One shared reporter, so anything else that writes can stop the animation first.
+  theme() {
+    return createTheme4(this.options.color?.() ?? false);
+  }
+  renewalJob(profile) {
+    const platform2 = process.platform;
+    return platform2 === "darwin" || platform2 === "linux" || platform2 === "win32" ? describeRenewalJob(platform2, this.homeDirectory, profile) : void 0;
+  }
   progress() {
     this.progressReporter ??= createProgressReporter({ stream: this.options.stderr ?? process.stderr });
     return this.progressReporter;
@@ -10495,12 +11294,36 @@ function isWranglerAuthRequired(error) {
   return error instanceof WranglerCommandError && /not authenticated|not logged in|wrangler login/iu.test(`${error.stdout}
 ${error.stderr}`);
 }
-function renewalResultText(decision) {
-  if (decision.state === "offline") return "Moodle is unreachable. The remote session was preserved.";
-  if (decision.state === "needs_sign_in") return "Moodle MCP needs sign-in. Run `moodle mcp login`.";
+function renewalResultText(decision, theme) {
+  if (decision.state === "offline") return `${theme.tone("warning", "Moodle is unreachable.")} The remote session was preserved.`;
+  if (decision.state === "needs_sign_in") return `${theme.tone("warning", "Moodle MCP needs sign-in.")} Run ${theme.key("moodle mcp login")}.`;
   if (decision.state === "conflict") return "Moodle MCP refreshed the remote session revision without overwriting it.";
-  if (decision.reasonCode === "RENEWAL_AGENT_MISSING") return "Moodle MCP renewal agent installed.";
-  return "Moodle MCP session is ready.";
+  if (decision.reasonCode === "RENEWAL_AGENT_MISSING") return theme.tone("success", "Moodle MCP renewal agent installed.");
+  return theme.tone("success", "Moodle MCP session is ready.");
+}
+function isClientList(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.clients);
+}
+function renewalRunText(lastRun, theme) {
+  if (!lastRun) return theme.dim("never (the job has not reported yet)");
+  const ago = Math.max(0, Math.round((Date.now() - Date.parse(lastRun.at)) / 6e4));
+  const when = ago < 1 ? "just now" : ago < 120 ? `${ago} min ago` : ago < 48 * 60 ? `${Math.round(ago / 60)} h ago` : `${Math.round(ago / 1440)} days ago`;
+  return `${when} ${theme.status(lastRun.state.replaceAll("_", " "), { healthy: "success", "needs sign in": "warning", offline: "warning", conflict: "warning" })}`;
+}
+function pairingCopy(input2, theme) {
+  const expires = new Date(input2.expiresAt);
+  const minutes = Math.max(0, Math.round((expires.getTime() - Date.now()) / 6e4));
+  return [
+    "Add this custom connector in Claude, then approve it with the pairing code.",
+    "",
+    theme.subject("Connector URL"),
+    `  ${theme.key(input2.endpoint)}`,
+    "",
+    theme.subject("Pairing code"),
+    `  ${theme.key(formatPairingCode(input2.code))}`,
+    "",
+    theme.dim(`One approval, valid for ${minutes} minutes (until ${expires.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}).`)
+  ].join("\n");
 }
 async function selectConnectors(connectors, requested) {
   const normalized = normalizeClientName(requested);
@@ -10584,7 +11407,7 @@ function buildProgram(io = {}) {
   program.option("--pretty", "Indent JSON output.");
   program.option("--limit <number>", "Maximum returned rows.", parsePositiveInt);
   program.option("--days <number>", "Deadline window in days.", parsePositiveInt);
-  const verbose = program.options.find((option) => option.long === "--verbose");
+  const verbose = program.options.find((option2) => option2.long === "--verbose");
   if (verbose) {
     verbose.short = "-v";
     verbose.flags = "-v, --verbose";
@@ -10674,7 +11497,9 @@ ${tryLines(["moodle due", "moodle units", "moodle --help"])}`}
       stdin: io.stdin,
       stdout,
       stderr,
-      fetchImpl: io.fetchImpl
+      fetchImpl: io.fetchImpl,
+      // Progress goes to stderr and the summary to stdout, so both streams must want colour.
+      color: () => colorEnabled2(stdout, io.env) && colorEnabled2(stderr, io.env) && program.opts().color !== false
     });
     return mcpService;
   };
@@ -10689,7 +11514,7 @@ ${tryLines(["moodle due", "moodle units", "moodle --help"])}`}
     env: io.env ?? process.env,
     format: outputFormat(program.opts(), stdout)
   }) === "human";
-  const theme = () => createTheme3(colorEnabled2(stderr, io.env) && program.opts().color !== false);
+  const theme = () => createTheme5(colorEnabled2(stderr, io.env) && program.opts().color !== false);
   const signIn = async (baseUrl) => {
     const ui = createUi3({ input: io.stdin ?? process.stdin, output: stderr, interactive: true });
     const auth2 = { env: io.env, fetch: io.fetchImpl, homeDir: io.homeDir, captureMobileToken: true };
@@ -10785,6 +11610,46 @@ ${tryLines(["moodle due", "moodle units", "moodle --help"])}`}
     command.option("--limit <number>", "Maximum returned rows.", parsePositiveInt).action(async (unit, options) => execute(name, { unit, limit: count("limit", options.limit), ...name === "due" ? { days: count("days", options.days) } : {} }, options));
   }
   addOutputOptions(program.command("find").description(humanDescription("find")).argument("<query>", "Words to look for").argument("[unit]", "Unit code, name, id or URL")).option("--limit <number>", "Maximum returned rows.", parsePositiveInt).option("--types <types>", "Comma-separated activity types.").action(async (query, unit, options) => execute("find", { query, unit, limit: count("limit", options.limit), types: options.types?.split(",") }, options));
+  addOutputOptions(program.command("attempt").description(humanDescription("attempt")).argument("<ref>", "Quiz attempt id or review URL")).action(async (ref2, options) => execute("attempt", { attempt: ref2 }, options));
+  const dev = program.command("dev", { hidden: true }).description("Maintainer utilities.");
+  dev.command("fetch").description("Print a same-site page as HTML with the session; sesskey values are redacted.").argument("<url>").action(async (url) => {
+    const client = await runtime.getClient();
+    if (new URL(url).origin !== new URL(client.baseUrl).origin) throw new UsageError("The URL must belong to the configured Moodle site.");
+    const html = await (await client.requestAbsolute(url)).text();
+    stdout.write(`${redactSesskey(html)}
+`);
+  });
+  addOutputOptions(mutating(program.command("update").description("Update the package and redeploy the managed MCP Worker when either is behind."))).option("--check", "Report versions without installing or deploying.").option("--quiet", "Print nothing; refresh the cached version only.").action(async (options) => {
+    const updateOptions = { homeDir: io.homeDir, env: io.env, fetchImpl: io.fetchImpl };
+    if (options.quiet) {
+      await refreshLatestVersion(updateOptions);
+      return;
+    }
+    const worker = await getMcpService().workerState();
+    const palette = theme();
+    const workerLine = worker === null ? [] : [`${palette.dim("Worker:")} ${palette.status(worker.behind ? "behind this package" : worker.ready ? "current" : "not ready", { current: "success", "behind this package": "warning", "not ready": "danger" })}`];
+    if (options.check) {
+      const latest = await refreshLatestVersion(updateOptions);
+      const available = isNewerVersion(latest ?? void 0, VERSION);
+      const report2 = { current: VERSION, latest, update_available: available, ...worker ? { worker_behind: worker.behind, worker_ready: worker.ready } : {} };
+      await runtime.output(report2, () => [
+        `${palette.dim("moodle-cli:")} ${palette.key(VERSION)} ${available ? palette.tone("warning", `\u2192 ${latest} available`) : latest ? palette.dim("(latest)") : palette.tone("warning", "(npm unreachable)")}`,
+        ...workerLine,
+        ...available || worker?.behind ? ["", tryLines(["moodle update"])] : []
+      ].join("\n"), options);
+      return;
+    }
+    if (program.opts().dryRun) {
+      const latest = await refreshLatestVersion(updateOptions);
+      const steps = [...isNewerVersion(latest ?? void 0, VERSION) ? [`install moodle-cli ${latest}`] : [], ...worker?.behind ? ["redeploy the Worker"] : []];
+      await runtime.output({ planned: steps, current: VERSION, latest }, () => steps.length ? `Would ${steps.join(", then ")}.` : "Nothing to do; everything is current.", options);
+      return;
+    }
+    const report = await runUpdate({ ...updateOptions, workerBehind: worker?.behind });
+    const stale = worker && !worker.ready && !report.deployed ? [`${palette.tone("warning", "The Worker is deployed but not answering.")} ${tryLines(["moodle mcp status"])}`] : [];
+    await runtime.output({ ...report, ...worker ? { worker_ready: worker.ready } : {} }, () => [palette.tone(report.ok ? report.updated || report.deployed ? "success" : "muted" : "danger", report.note), ...stale].join("\n"), options);
+    if (!report.ok) throw new CliError2("upstream", report.note);
+  });
   addOutputOptions(program.command("get").description("Download a resource by id, URL, or UNIT TASK phrase.").argument("<ref>", "Resource id, URL, or UNIT TASK phrase")).option("--to <directory>", "Destination directory.").option("--force", "Replace an existing file atomically.").action(async (ref2, options) => {
     const client = await runtime.getClient();
     const service = createIntentService(createMoodleGateway(client));
@@ -10819,6 +11684,75 @@ ${tryLines(["moodle due", "moodle units", "moodle --help"])}`}
     }
     await runtime.output(result, () => formatSubmissionReceipt(result.submission), options);
   });
+  const quiz = program.command("quiz").description("Take a quiz: start an attempt, answer questions, finish it. Beta.").summary("Take a quiz (beta)");
+  quiz.addHelpText("after", `
+${QUIZ_NOTICE.join("\n")}
+`);
+  const quizConsent = async (summary) => {
+    const palette = theme();
+    if (!program.opts().yes && !human()) throw new UsageError("Quiz actions need --yes when stdin is not interactive.", QUIZ_NOTICE.join(" "));
+    const notice = [palette.tone("warning", "BETA"), ...QUIZ_NOTICE.map((line) => palette.dim(line))].join("\n");
+    return confirm({ summary: `${notice}
+
+${summary}` }, { yes: Boolean(program.opts().yes), dryRun: false, interactive: human() });
+  };
+  const attemptNext = (page) => {
+    const open = page.navigation.find((entry) => entry.number !== "i" && /not yet|not answered/iu.test(entry.state));
+    if (!open) return [`moodle quiz finish ${page.attempt} ${page.quiz_id}`];
+    return [
+      `moodle quiz answer ${page.attempt} ${page.quiz_id} ${open.number} <answer>`,
+      ...open.page === page.page ? [] : [`moodle quiz show ${page.attempt} ${page.quiz_id} --page ${open.page + 1}`]
+    ];
+  };
+  const showPage = (page, palette) => `${palette.tone("warning", "BETA")} ${formatAttemptPage(page)}
+
+${tryLines(attemptNext(page))}`;
+  addOutputOptions(mutating(quiz.command("start").description("Start a new attempt, or continue the one in progress, and show its first page.").argument("<ref>", "Quiz id, URL, or UNIT TASK phrase"))).option("--password <password>", "Quiz access password for scripts; at a terminal you are asked for it instead.").action(async (ref2, options) => {
+    const client = await runtime.getClient();
+    const service = createIntentService(createMoodleGateway(client));
+    const id2 = await choose(() => service.resolveItem(ref2), (id3) => Promise.resolve(id3));
+    if (!program.opts().dryRun && !await quizConsent(`Start or continue an attempt on quiz ${theme().target(String(id2))}. Moodle records the attempt and its start time.`)) return;
+    if (program.opts().dryRun) return runtime.output({ planned: "start", quiz_id: id2 }, () => `Would start an attempt on quiz ${id2}.`, options);
+    const password = async () => {
+      if (options.password) return options.password;
+      const input2 = io.stdin ?? process.stdin;
+      if (!human() || !input2.isTTY) return null;
+      return readSecretLine(input2, stderr, "Quiz password (not echoed): ");
+    };
+    const page = await client.startQuizAttempt(id2, { password });
+    await runtime.output({ attempt: page }, () => showPage(page, theme()), options);
+  });
+  addOutputOptions(quiz.command("show").description("Show one page of an attempt in progress: questions, options and saved answers.").argument("<attempt>", "Attempt id").argument("<quiz>", "Quiz id")).option("--page <n>", "Page number, starting at 1.", parsePositiveInt).action(async (attempt, quizId, options) => {
+    const client = await runtime.getClient();
+    const page = await client.getQuizAttemptPage(parsePositiveInt(attempt), parsePositiveInt(quizId), (options.page ?? 1) - 1);
+    await runtime.output({ attempt: page }, () => showPage(page, theme()), options);
+  });
+  addOutputOptions(mutating(quiz.command("answer").description("Save one answer: option letters for a choice question (b, or a,c), the text otherwise.").argument("<attempt>", "Attempt id").argument("<quiz>", "Quiz id").argument("<question>", "Question number as shown").argument("[answer]", "Option letters or answer text"))).option("--from <file>", "Read the answer text from a file.").action(async (attempt, quizId, question2, answer, options) => {
+    const value = options.from ? await readFile11(path4.resolve(io.cwd ?? process.cwd(), options.from), "utf8") : answer;
+    if (!value?.trim()) throw new UsageError("Give the answer as an argument or with --from <file>.");
+    const request = { attemptId: parsePositiveInt(attempt), quizId: parsePositiveInt(quizId), question: question2, value };
+    const palette = theme();
+    const preview2 = value.trim().length > 80 ? `${value.trim().slice(0, 77)}...` : value.trim();
+    if (program.opts().dryRun) return runtime.output({ planned: "answer", ...request }, () => `Would answer question ${question2} of attempt ${attempt} with: ${preview2}`, options);
+    if (!await quizConsent(`Save ${palette.subject(preview2)} as the answer to question ${palette.target(question2)} of attempt ${attempt}.`)) return;
+    const client = await runtime.getClient();
+    const page = await client.answerQuizQuestion(request);
+    await runtime.output({ attempt: page }, () => showPage(page, palette), options);
+  });
+  addOutputOptions(mutating(quiz.command("finish").description("Submit the attempt for grading. Moodle does not allow undoing this.").argument("<attempt>", "Attempt id").argument("<quiz>", "Quiz id"))).action(async (attempt, quizId, options) => {
+    const client = await runtime.getClient();
+    const ids = [parsePositiveInt(attempt), parsePositiveInt(quizId)];
+    const summary = await client.getQuizAttemptSummary(...ids);
+    if (program.opts().dryRun) return runtime.output({ planned: "finish", summary }, () => formatAttemptSummary(summary), options);
+    const palette = theme();
+    const open = summary.rows.filter((row) => /not yet answered/iu.test(row.state));
+    const warning = open.length ? `
+${palette.tone("danger", `${open.length} question${open.length === 1 ? "" : "s"} not yet answered: ${open.map((row) => row.number).join(", ")}`)}` : "";
+    if (!await quizConsent(`${formatAttemptSummary(summary)}${warning}
+${palette.tone("warning", "Submit all and finish. Moodle does not allow undoing this.")}`)) return;
+    const receipt = await client.finishQuizAttempt(...ids);
+    await runtime.output({ finished: receipt }, () => formatAttemptFinish(receipt), options);
+  });
   addOutputOptions(program.command("open").description("Open a unit or activity reference in the browser.").argument("<ref>", "Unit or activity id, URL, or UNIT TASK phrase")).action(async (ref2, options) => {
     const client = await runtime.getClient();
     let url;
@@ -10945,7 +11879,7 @@ _arguments '1:command:(${names.join(" ")})' '*:reference:'
     else throw new UsageError("Choose zsh, bash or fish.");
   });
   addOutputOptions(mutating(program.command("uninstall").description("Remove local background jobs; optionally remove the selected Worker and configuration.").summary("Remove background jobs, Worker and config"))).option("--remote", "Also remove the configured managed MCP deployment.").option("--purge", "Also delete local Moodle CLI configuration, receipts and cache.").action(async (options) => {
-    const home = io.homeDir ?? homedir15();
+    const home = io.homeDir ?? homedir16();
     const jobs = await ownedJobs(home);
     const receipts = await readdir4(path4.join(home, ".config", "moodle-cli", "mcp", "deployments")).catch(() => []);
     const result = { jobs: jobs.map((j) => j.path), remote: Boolean(options.remote), purge: Boolean(options.purge), config: path4.join(home, CONFIG_DIR_NAME), cache: path4.join(home, CACHE_DIR_NAME), package_command: "npm rm -g moodle-cli (or bun remove -g moodle-cli); for the standalone install: rm ~/.local/bin/moodle", remaining: options.remote ? "Only the configured Worker is removed. Other profiles remain remote." : "Remote Workers and credentials remain unless removed with moodle mcp remove." };
@@ -10959,11 +11893,11 @@ _arguments '1:command:(${names.join(" ")})' '*:reference:'
     const profiles = new Set([...jobs.map((j) => j.profile), ...receipts.map((n2) => n2.replace(/\.json$/u, ""))].filter((p) => Boolean(p) && /^[a-z0-9_-]+$/u.test(p)));
     for (const profile of profiles) {
       await renewal2.remove(profile);
-      if (options.purge) await rm7(path4.join(home, "Library", "Logs", `com.moodle-cli.mcp-renewal.${profile}.log`), { force: true });
+      if (options.purge) await rm8(path4.join(home, "Library", "Logs", `com.moodle-cli.mcp-renewal.${profile}.log`), { force: true });
     }
     if (options.purge) {
-      await rm7(result.config, { recursive: true, force: true });
-      await rm7(result.cache, { recursive: true, force: true });
+      await rm8(result.config, { recursive: true, force: true });
+      await rm8(result.cache, { recursive: true, force: true });
     }
     await runtime.output(result, () => `Moodle background jobs removed.
 ${result.remaining}
@@ -11157,7 +12091,7 @@ Log: ${result.log_path}`, options);
   return program;
 }
 var HELP_SECTIONS = {
-  "Core commands": ["due", "news", "find", "get", "open", "submit", "units", "activities", "grades", "threads", "forums"],
+  "Core commands": ["due", "news", "find", "get", "open", "submit", "quiz", "units", "activities", "grades", "threads", "forums"],
   "Additional commands": ["user", "todo", "alerts", "overview", "download", "auth", "doctor", "completion", "uninstall"],
   "Agent commands": ["mcp", "commands", "skills"]
 };
@@ -11176,6 +12110,7 @@ async function runCli(argv = process.argv, io = {}) {
     }) === "human"
   });
   try {
+    await startupUpdateNotice(args, stderr, { homeDir: io.homeDir, env: io.env });
     await parseWithPrompts(() => buildProgram({ ...io, rootArgs: args }), args, { ui, fillers: { unit: pickUnit(io, ui) } });
     return 0;
   } catch (error) {
@@ -11204,7 +12139,7 @@ ${hint}
 }
 function openInBrowser(url) {
   return new Promise((resolve, reject) => {
-    const child = spawn4(process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer.exe" : "xdg-open", [url], { stdio: "ignore" });
+    const child = spawn5(process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer.exe" : "xdg-open", [url], { stdio: "ignore" });
     child.once("error", reject);
     child.once("exit", (code) => code === 0 ? resolve() : reject(new Error("Could not open the browser.")));
   });
@@ -11288,6 +12223,14 @@ function addOutputOptions(command) {
 function outputFormat(options, stdout) {
   return resolveFormat(options, Boolean(stdout && "isTTY" in stdout && stdout.isTTY));
 }
+var QUIZ_NOTICE = [
+  "moodle quiz is beta: it replays the browser's quiz forms, and a Moodle update can break it without warning.",
+  "Academic integrity: answers you send are your own submission under your institution's rules. Only use this",
+  "where the quiz allows it, and check the attempt in a browser before you finish."
+];
+function redactSesskey(html) {
+  return html.replace(/<input\b[^>]*>/giu, (tag) => /\bname\s*=\s*["']?sesskey["']?/iu.test(tag) ? tag.replace(/(\bvalue\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s>]+)/iu, '$1"REDACTED"') : tag).replace(/(["']?sesskey["']?\s*[:=]\s*["']?)[A-Za-z0-9]{8,}/gu, "$1REDACTED");
+}
 function submissionSummary(plan, final, theme) {
   const destination = `${theme.target(plan.name)}${plan.unit_id ? theme.dim(`  unit ${plan.unit_id}`) : ""}`;
   const lines = plan.uploads.length ? [`${theme.dim("Upload")}  ${theme.subject(plan.uploads.map((file2) => file2.name).join(", "))}`, `${theme.dim("    to")}  ${destination}`] : [`${theme.dim("Submit")}  ${destination}`, `${theme.dim("      ")}  ${theme.subject("the files already there")} for grading`];
@@ -11308,7 +12251,9 @@ function parseMcpConnectionMode(value) {
   throw new UsageError("MCP connection mode must be 'bridge' or 'remote'.");
 }
 async function outputMcpResult(runtime, result, options) {
-  await runtime.output(result.data, () => result.text, options);
+  await runtime.output(result.data, () => result.next?.length ? `${result.text}
+
+${tryLines(result.next)}` : result.text, options);
 }
 function errorOutputFormat(args, stdout) {
   try {
@@ -11378,7 +12323,7 @@ function queryMatches(text2, query) {
 function pathsReferToSameFile(moduleUrl, executable) {
   if (!executable) return false;
   try {
-    return realpathSync3(fileURLToPath2(moduleUrl)) === realpathSync3(executable);
+    return realpathSync4(fileURLToPath2(moduleUrl)) === realpathSync4(executable);
   } catch {
     return false;
   }
@@ -11391,5 +12336,6 @@ if (isMain) {
 }
 export {
   buildProgram,
+  redactSesskey,
   runCli
 };