moodle-cli 0.8.0 → 0.9.0

package/dist/moodle.js

@@ -20,6 +20,8 @@ var counts = z.object(Object.fromEntries(["notification_count", "unread_notifica
 var postSchema = z.object({ id, parent_id: n, name: s, author: z.object({ id, name: s }), time_created: id, created: s, message_text: s, links: z.array(z.object({ text: s, url: s })).optional() });
 var gradeSchema = z.object({ unit_id: id, code: s, graded: id, total: id, total_grade: s, total_range: s, total_percentage: s, items: z.array(z.object({ name: s, type: s, grade: s, range: s, percentage: s, weight: s, contribution: s, feedback: s, status: s, due: s, due_at: n })).optional() });
 var searchSchema = z.object({ unit_id: id, forum_id: id, discussion_id: id, name: s, post_id: id, snippet: s, time_created: n, created: s, url: s });
+var submissionFile = z.object({ name: z.string(), bytes: n, url: s });
+var receiptSchema = z.object({ id, name: s, unit_id: n, url: s, action: z.enum(["planned", "saved", "submitted"]), submission_status: s, grading_status: s, due: s, time_remaining: s, last_modified: s, statement: s, statement_accepted: z.boolean().optional(), files: z.array(submissionFile).optional(), uploads: z.array(z.object({ name: z.string(), bytes: id, path: s })).optional(), removed: z.array(z.string()).optional(), limits: z.object({ max_bytes: n, max_files: n, area_max_bytes: n, accepted_types: z.array(z.string()).optional() }).optional(), checked_at: z.string() });
 var input = (shape) => z.object(shape).strict();
 var list = (key, value) => z.object({ [key]: z.array(value).optional(), total: id });
 var intentContracts = {
@@ -33,6 +35,7 @@ var intentContracts = {
   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() }) }) }
 };
 function humanDescription(name) {
@@ -723,9 +726,9 @@ var PrivateFileCredentialBackend = class {
   baseDirectory;
   name = "private credential file";
   async read(profile) {
-    const path4 = this.path(profile);
+    const path5 = this.path(profile);
     try {
-      return parseCredentials(await readFile(path4, "utf8"));
+      return parseCredentials(await readFile(path5, "utf8"));
     } catch (error) {
       if (isMissing(error)) {
         return null;
@@ -734,15 +737,15 @@ var PrivateFileCredentialBackend = class {
     }
   }
   async write(profile, credentials) {
-    const path4 = this.path(profile);
-    const temporary = `${path4}.${process.pid}.tmp`;
-    await mkdir(dirname(path4), { recursive: true, mode: 448 });
-    await chmod(dirname(path4), 448);
+    const path5 = this.path(profile);
+    const temporary = `${path5}.${process.pid}.tmp`;
+    await mkdir(dirname(path5), { recursive: true, mode: 448 });
+    await chmod(dirname(path5), 448);
     await writeFile(temporary, `${JSON.stringify(credentials)}
 `, { encoding: "utf8", mode: 384 });
     await chmod(temporary, 384);
-    await rename(temporary, path4);
-    await chmod(path4, 384);
+    await rename(temporary, path5);
+    await chmod(path5, 384);
   }
   async delete(profile) {
     await rm(this.path(profile), { force: true });
@@ -798,9 +801,9 @@ function windowsCredentialInput(profile, credentials) {
     ...credentials ? { credentials: JSON.stringify(credentials) } : {}
   });
 }
-function windowsDpapiInput(path4, credentials) {
+function windowsDpapiInput(path5, credentials) {
   return JSON.stringify({
-    path: path4,
+    path: path5,
     ...credentials ? { credentials: JSON.stringify(credentials) } : {}
   });
 }
@@ -910,10 +913,10 @@ async function readCachedSession(baseUrl, options = {}) {
     return null;
   }
   const fs = options.fs ?? nodeFs;
-  const path4 = sessionCachePath(options.homeDir);
+  const path5 = sessionCachePath(options.homeDir);
   let raw;
   try {
-    raw = await fs.readFile(path4, "utf8");
+    raw = await fs.readFile(path5, "utf8");
   } catch (error) {
     if (isMissingFileError(error)) {
       return null;
@@ -931,7 +934,7 @@ async function readCachedSession(baseUrl, options = {}) {
       if (session) await writeCachedSession(session, { ...options, noCache: false });
     }
   } catch {
-    if (parseCachedSession(raw)) await fs.rm(path4, { force: true });
+    if (parseCachedSession(raw)) await fs.rm(path5, { force: true });
     return null;
   }
   if (!session || !sameBaseUrl(session.baseUrl, baseUrl)) {
@@ -943,13 +946,13 @@ async function readCachedSession(baseUrl, options = {}) {
 async function writeCachedSession(session, options = {}) {
   if (options.noCache) return;
   const fs = options.fs ?? nodeFs;
-  const path4 = sessionCachePath(options.homeDir);
+  const path5 = sessionCachePath(options.homeDir);
   const keyring = await createEncryptionKeyring(await cacheEncryptionKey(options));
   const encrypted = { version: 2, encrypted_session: await encryptValue(JSON.stringify(session), keyring) };
-  await fs.mkdir(dirname2(path4), { recursive: true, mode: 448 });
-  await fs.writeFile(path4, `${JSON.stringify(encrypted)}
+  await fs.mkdir(dirname2(path5), { recursive: true, mode: 448 });
+  await fs.writeFile(path5, `${JSON.stringify(encrypted)}
 `, { encoding: "utf8", mode: 384 });
-  await fs.chmod(path4, 384);
+  await fs.chmod(path5, 384);
 }
 async function deleteCachedSession(baseUrl, options = {}) {
   const current2 = await readCachedSession(baseUrl, { ...options, noCache: false, ttlMs: Number.MAX_SAFE_INTEGER });
@@ -1347,8 +1350,8 @@ function isLoginRedirect(responseUrl, baseUrl) {
   if (!responseUrl) {
     return false;
   }
-  const path4 = new URL(responseUrl, baseUrl).pathname;
-  return path4 === LOGIN_PATH || path4.startsWith("/login/");
+  const path5 = new URL(responseUrl, baseUrl).pathname;
+  return path5 === LOGIN_PATH || path5.startsWith("/login/");
 }
 function looksLikeLoginPage(html) {
   return /name=["']username["']/i.test(html) && /name=["']password["']/i.test(html);
@@ -1391,7 +1394,24 @@ var defaultExecFile = (file2, args) => new Promise((resolve) => {
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import { dirname as dirname3, join as join4 } from "path";
-import { createInterface } from "readline/promises";
+import { createUi, isAgentEnvironment } from "@bunizao/cli-kit";
+
+// src/wordmark.ts
+var MOODLE_TAGLINE = "Read Moodle and submit work from the command line.";
+var MOODLE_WORDMARK = [
+  "                     _ _",
+  "  _ __  ___  ___  __| | |___",
+  " | '  \\/ _ \\/ _ \\/ _` | / -_)",
+  " |_|_|_\\___/\\___/\\__,_|_\\___|"
+].join("\n");
+var shown = false;
+function showWordmark(ui) {
+  if (shown) return;
+  shown = true;
+  ui.banner(MOODLE_WORDMARK, MOODLE_TAGLINE);
+}
+
+// src/config.ts
 import YAML from "yaml";
 var nodeFs2 = { readFile: readFile3, writeFile: writeFile3, mkdir: mkdir3 };
 function cwdConfigPath(cwd = process.cwd()) {
@@ -1453,29 +1473,32 @@ async function loadConfig(options = {}) {
   return toMoodleConfig(loaded.config, baseUrl);
 }
 async function promptForBaseUrl(options = {}) {
-  const prompt = options.prompt ?? defaultPrompt(options);
-  const output = options.stderr ?? process.stderr;
-  output.write("Configuration required\n");
-  output.write("Moodle base URL is not configured yet.\n");
-  output.write(`Runtime: ${process.versions.bun ? `bun ${process.versions.bun}` : `node ${process.versions.node}`}. Browser SQLite needs Bun or Node 22.13+. Run moodle doctor for diagnostics.
-`);
-  output.write("Required format: https://school.example.edu\n");
-  output.write("Use the site root only. Do not include paths like /login/index.php or /my/.\n");
+  const ui = createUi({ input: process.stdin, output: options.stderr ?? process.stderr, ...options.prompt ? { interactive: false } : {} });
+  const prompt = options.prompt ?? defaultPrompt(ui);
+  showWordmark(ui);
+  ui.intro("Moodle setup");
+  ui.note([
+    "Moodle base URL is not configured yet.",
+    `Runtime: ${process.versions.bun ? `bun ${process.versions.bun}` : `node ${process.versions.node}`}. Browser SQLite needs Bun or Node 22.13+. Run moodle doctor for diagnostics.`,
+    "Use the site root only, for example https://school.example.edu.",
+    "Do not include paths like /login/index.php or /my/."
+  ].join("\n"), "Configuration required");
   while (true) {
     let baseUrl;
     try {
       baseUrl = normalizeBaseUrl(await prompt("Moodle base URL"));
     } catch (error) {
-      output.write(`Invalid URL: ${error instanceof Error ? error.message : String(error)}
-`);
+      ui.warn(`Invalid URL: ${error instanceof Error ? error.message : String(error)}`);
       continue;
     }
+    const spin = ui.spinner();
+    spin.start(`Checking ${baseUrl}`);
     const probe = await probeBaseUrl(baseUrl, options);
     if (probe.ok) {
+      spin.stop(`${baseUrl} looks like Moodle`);
       return baseUrl;
     }
-    output.write(`Validation failed: ${probe.message ?? "site did not look like Moodle"}
-`);
+    spin.error(`Validation failed: ${probe.message ?? "site did not look like Moodle"}`);
   }
 }
 async function probeBaseUrl(baseUrl, options = {}) {
@@ -1523,19 +1546,19 @@ async function loadExistingConfig(options) {
   const paths = [explicitPath, cwdConfigPath(options.cwd), userConfigPath(options.homeDir)].filter(
     (value) => Boolean(value)
   );
-  for (const path4 of paths) {
-    const config = await readConfigFile(path4, options);
+  for (const path5 of paths) {
+    const config = await readConfigFile(path5, options);
     if (config) {
-      return { config, path: path4 };
+      return { config, path: path5 };
     }
   }
   return { config: {}, path: explicitPath ?? null };
 }
-async function readConfigFile(path4, options) {
+async function readConfigFile(path5, options) {
   const fs = options.fs ?? nodeFs2;
   let raw;
   try {
-    raw = await fs.readFile(path4, "utf8");
+    raw = await fs.readFile(path5, "utf8");
   } catch (error) {
     if (isMissingFileError2(error)) {
       return null;
@@ -1544,34 +1567,24 @@ async function readConfigFile(path4, options) {
   }
   const parsed = YAML.parse(raw) ?? {};
   if (!isRecord3(parsed)) {
-    throw new ConfigError(`${path4} must contain a YAML object.`);
+    throw new ConfigError(`${path5} must contain a YAML object.`);
   }
   return parsed;
 }
-async function saveConfigFile(path4, config, options) {
+async function saveConfigFile(path5, config, options) {
   const fs = options.fs ?? nodeFs2;
-  await fs.mkdir(dirname3(path4), { recursive: true });
-  await fs.writeFile(path4, YAML.stringify(config, { sortMapEntries: true }), "utf8");
+  await fs.mkdir(dirname3(path5), { recursive: true });
+  await fs.writeFile(path5, YAML.stringify(config, { sortMapEntries: true }), "utf8");
 }
 function toMoodleConfig(config, baseUrl) {
   const { base_url: _baseUrl, ...rest } = config;
   return { ...rest, baseUrl };
 }
-function defaultPrompt(options) {
-  return async (label) => {
-    const rl = createInterface({
-      input: process.stdin,
-      output: options.stdout ?? process.stdout
-    });
-    try {
-      return await rl.question(`${label} > `);
-    } finally {
-      rl.close();
-    }
-  };
+function defaultPrompt(ui) {
+  return (label) => ui.text(label, { placeholder: "https://school.example.edu" });
 }
 function isInteractive(options) {
-  return Boolean((options.stdin ?? process.stdin).isTTY);
+  return Boolean((options.stdin ?? process.stdin).isTTY) && !isAgentEnvironment(options.env ?? process.env);
 }
 function isRecord3(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -1834,9 +1847,9 @@ async function ownedJobs(homeDir = homedir6()) {
   const files = await readdir2(root).catch(() => []);
   const jobs = [];
   for (const name of files.filter((n2) => n2 === "com.moodle-cli.keepalive.plist" || /^com\.moodle-cli\.mcp-renewal\.[a-z0-9_-]+\.plist$/u.test(n2))) {
-    const path4 = join7(root, name);
-    const content = await readFile4(path4, "utf8");
-    jobs.push({ path: path4, profile: name.match(/mcp-renewal\.(.+)\.plist$/u)?.[1], interpreter: content.match(/<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]+)<\/string>/u)?.[1] });
+    const path5 = join7(root, name);
+    const content = await readFile4(path5, "utf8");
+    jobs.push({ path: path5, profile: name.match(/mcp-renewal\.(.+)\.plist$/u)?.[1], interpreter: content.match(/<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]+)<\/string>/u)?.[1] });
   }
   return jobs;
 }
@@ -1910,7 +1923,7 @@ async function doctor(options = {}) {
 
 // src/cli.ts
 import { rm as rm7, readdir as readdir3 } from "fs/promises";
-import { homedir as homedir12 } from "os";
+import { homedir as homedir13 } from "os";
 
 // src/mcp/renewal/decision.ts
 function decideRenewal(snapshot) {
@@ -2047,7 +2060,7 @@ function macOSPlan(options, intervalMinutes) {
     throw new Error("macOS renewal installation requires the current user ID");
   }
   const label = `com.moodle-cli.mcp-renewal.${options.profile}`;
-  const path4 = `${trimEnd(options.homeDirectory, "/")}/Library/LaunchAgents/${label}.plist`;
+  const path5 = `${trimEnd(options.homeDirectory, "/")}/Library/LaunchAgents/${label}.plist`;
   const target = `gui/${options.uid}`;
   const logPath = `${trimEnd(options.homeDirectory, "/")}/Library/Logs/${label}.log`;
   const plist = [
@@ -2069,12 +2082,12 @@ function macOSPlan(options, intervalMinutes) {
     platform: "darwin",
     profile: options.profile,
     label,
-    files: [{ path: path4, content: plist, mode: 384 }],
+    files: [{ path: path5, content: plist, mode: 384 }],
     installCommands: [
-      { command: "launchctl", args: ["bootout", target, path4], ignoreFailure: true },
-      { command: "launchctl", args: ["bootstrap", target, path4] }
+      { command: "launchctl", args: ["bootout", target, path5], ignoreFailure: true },
+      { command: "launchctl", args: ["bootstrap", target, path5] }
     ],
-    removeCommands: [{ command: "launchctl", args: ["bootout", target, path4], ignoreFailure: true }]
+    removeCommands: [{ command: "launchctl", args: ["bootout", target, path5], ignoreFailure: true }]
   };
 }
 function linuxPlan(options, intervalMinutes) {
@@ -2125,7 +2138,7 @@ function linuxPlan(options, intervalMinutes) {
 }
 function windowsPlan(options, intervalMinutes) {
   const label = `Moodle CLI MCP Renewal (${options.profile})`;
-  const path4 = `${trimEnd(options.homeDirectory, "\\/")}\\AppData\\Local\\moodle-cli\\renewal\\${options.profile}.xml`;
+  const path5 = `${trimEnd(options.homeDirectory, "\\/")}\\AppData\\Local\\moodle-cli\\renewal\\${options.profile}.xml`;
   const argumentsText = [...options.executableArgs ?? [], ...renewalArgs(options.profile)].map(windowsArgument).join(" ");
   const task = [
     '<?xml version="1.0" encoding="UTF-8"?>',
@@ -2145,8 +2158,8 @@ function windowsPlan(options, intervalMinutes) {
     platform: "win32",
     profile: options.profile,
     label,
-    files: [{ path: path4, content: task, mode: 384 }],
-    installCommands: [{ command: "schtasks.exe", args: ["/Create", "/TN", label, "/XML", path4, "/F"] }],
+    files: [{ path: path5, content: task, mode: 384 }],
+    installCommands: [{ command: "schtasks.exe", args: ["/Create", "/TN", label, "/XML", path5, "/F"] }],
     removeCommands: [{ command: "schtasks.exe", args: ["/Delete", "/TN", label, "/F"], ignoreFailure: true }]
   };
 }
@@ -2206,17 +2219,17 @@ import { dirname as dirname5 } from "path";
 import { promisify } from "util";
 var execFile = promisify(execFileCallback2);
 var NodeRenewalInstallerIO = class {
-  async writePrivate(path4, content, mode) {
-    await mkdir5(dirname5(path4), { recursive: true, mode: 448 });
-    await writeFile5(path4, content, { encoding: "utf8", mode });
-    await chmod3(path4, mode);
+  async writePrivate(path5, content, mode) {
+    await mkdir5(dirname5(path5), { recursive: true, mode: 448 });
+    await writeFile5(path5, content, { encoding: "utf8", mode });
+    await chmod3(path5, mode);
   }
-  async removeFile(path4) {
-    await rm4(path4, { force: true });
+  async removeFile(path5) {
+    await rm4(path5, { force: true });
   }
-  async exists(path4) {
+  async exists(path5) {
     try {
-      await readFile5(path4);
+      await readFile5(path5);
       return true;
     } catch (error) {
       if (isMissing2(error)) {
@@ -2334,13 +2347,14 @@ var MoodleGatewayError = class extends Error {
     this.code = code;
   }
 };
-function createMoodleGateway(client) {
+function createMoodleGateway(client, hooks = {}) {
   return {
     getUser: () => client.getSiteInfo(),
     listThreads: (id2) => client.getForumDiscussionRefs ? client.getForumDiscussionRefs(id2) : Promise.resolve([]),
     listNewsForums: (id2) => client.getNewsForums ? client.getNewsForums(id2) : Promise.resolve([]),
     getOverview: (input2) => client.getOverview(input2.todoLimit, input2.todoDays, input2.alertsLimit),
     ...client.getTodo ? { getDue: (days, courseId) => client.getTodo(Number.MAX_SAFE_INTEGER, days, courseId) } : {},
+    ...client.submitAssignmentFiles ? { submitAssignment: (input2) => client.submitAssignmentFiles({ ...input2, ...hooks.onSubmitProgress ? { onProgress: hooks.onSubmitProgress } : {} }) } : {},
     listCourses: () => client.getCourses(),
     async getCourse({ courseId }) {
       const [courses, sections] = await Promise.all([
@@ -2658,9 +2672,9 @@ function splitUnitPhrase(phrase, courses) {
 }
 
 // src/intents.ts
-async function inParallel(items, size, run) {
+async function inParallel(items, size2, run) {
   const results = [];
-  for (let index = 0; index < items.length; index += size) results.push(...await Promise.all(items.slice(index, index + size).map(run)));
+  for (let index = 0; index < items.length; index += size2) results.push(...await Promise.all(items.slice(index, index + size2).map(run)));
   return results;
 }
 function createIntentService(gateway, now = () => Date.now()) {
@@ -2851,6 +2865,12 @@ function createIntentService(gateway, now = () => Date.now()) {
         result = { file: { name: file2.name, mime_type: file2.mimeType, bytes: file2.bytes, uri: file2.uri } };
         break;
       }
+      case "submit": {
+        if (!gateway.submitAssignment) throw new MoodleGatewayError("MOODLE_TOOL_UNAVAILABLE", "Submitting needs local files; run moodle submit or the local MCP server on the machine that holds them.");
+        const activityId = await resolveItem(input2.ref);
+        result = { submission: await gateway.submitAssignment({ activityId, files: input2.files, final: Boolean(input2.final), replace: Boolean(input2.replace), acceptStatement: Boolean(input2.accept_statement), dryRun: Boolean(input2.dry_run) }) };
+        break;
+      }
     }
     return intentContracts[name].output.parse(stripEmpty(result));
   }
@@ -2861,16 +2881,26 @@ function createIntentService(gateway, now = () => Date.now()) {
   return { run, resolveItem, fileSource, find, sections };
 }
 
+// src/screens.ts
+import { createTheme as createTheme2 } from "@bunizao/cli-kit";
+
 // src/terminal-table.ts
+import { createTheme } from "@bunizao/cli-kit";
 var DEFAULT_WIDTH = 120;
+var TONED_LABEL = /status|state|type|grade|due|ok|action|grading/iu;
+var colorEnabled = () => false;
+function configureTerminalTables(options) {
+  colorEnabled = options.color;
+}
 function renderTerminalTable(columns, rows, options = {}) {
+  const theme = createTheme(colorEnabled());
   const width = Math.max(20, options.width ?? process.stdout.columns ?? DEFAULT_WIDTH);
   const clean = rows.map((row) => columns.map((_, i) => sanitizeTerminalText(row[i] ?? "").replace(/\s+/gu, " ")));
   const lengths = columns.map((c, i) => Math.max(c.label.length, ...clean.map((r) => Array.from(r[i]).length)));
   const flexible = columns.map((c, i) => c.flex || /name|title|subject|feedback|description|value|course|unit/iu.test(c.label) ? i : -1).filter((i) => i >= 0);
   const widths = columns.map((c, i) => c.width ?? (flexible.includes(i) ? Math.min(lengths[i], 36) : lengths[i]));
   const minimum = widths.reduce((n2, w, i) => n2 + (flexible.includes(i) ? 8 : w), 0) + columns.length * 3 + 1;
-  const title = options.title ? [sanitizeTerminalText(options.title)] : [];
+  const title = options.title ? [theme.subject(sanitizeTerminalText(options.title))] : [];
   if (width < 60 || minimum > width) {
     const wrap = (line2) => Array.from(line2).reduce((lines, char) => {
       if (!lines.length || Array.from(lines.at(-1)).length >= width) lines.push("");
@@ -2889,9 +2919,21 @@ function renderTerminalTable(columns, rows, options = {}) {
     const trimmed = chars.length > w ? `${chars.slice(0, w - 1).join("")}\u2026` : v;
     return trimmed + " ".repeat(Math.max(0, w - Array.from(trimmed).length));
   };
-  const border = (l, m, r) => l + widths.map((w) => "\u2500".repeat(w + 2)).join(m) + r;
-  const line = (row) => "\u2502" + widths.map((w, i) => ` ${fit(row[i] ?? "", w)} `).join("\u2502") + "\u2502";
-  return [...title, border("\u250C", "\u252C", "\u2510"), line(columns.map((c) => c.label)), border("\u251C", "\u253C", "\u2524"), ...clean.map(line), border("\u2514", "\u2534", "\u2518")].join("\n");
+  const paint = (cell, i, row) => {
+    if (options.keyValue) return i === 0 ? theme.dim(cell) : /status|grading|action/iu.test(row[0] ?? "") ? theme.status(cell) : cell;
+    return i === 0 ? theme.key(cell) : TONED_LABEL.test(columns[i]?.label ?? "") ? theme.status(cell) : cell;
+  };
+  const border = (l, m, r) => theme.dim(l + widths.map((w) => "\u2500".repeat(w + 2)).join(m) + r);
+  const bar = theme.dim("\u2502");
+  const line = (row, paintCell) => bar + widths.map((w, i) => ` ${paintCell(fit(row[i] ?? "", w), i)} `).join(bar) + bar;
+  return [
+    ...title,
+    border("\u250C", "\u252C", "\u2510"),
+    line(columns.map((c) => c.label), (cell) => theme.dim(cell)),
+    border("\u251C", "\u253C", "\u2524"),
+    ...clean.map((row) => line(row, (cell, i) => paint(cell, i, row))),
+    border("\u2514", "\u2534", "\u2518")
+  ].join("\n");
 }
 function renderKeyValueTable(rows, options = {}) {
   const present = rows.filter(([, value]) => value !== "");
@@ -2903,10 +2945,10 @@ No details` : "No details";
     { label: "Field" },
     { label: "Value" }
   ];
-  return renderTerminalTable(columns, present, options);
+  return renderTerminalTable(columns, present, { ...options, keyValue: true });
 }
 function sanitizeTerminalText(value) {
-  return value.replace(/\r\n?/gu, "\n").replace(/\t/gu, " ").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu, "");
+  return value.replace(/\r\n?/gu, "\n").replace(/\t/gu, " ").replace(/[---Ÿ]/gu, "");
 }
 
 // src/screens.ts
@@ -2927,16 +2969,17 @@ function moment(value, now) {
 function renderScreen(data, options = {}) {
   const lines = [];
   const now = options.now ?? Date.now();
+  const theme = createTheme2(Boolean(options.color));
   const dueText = (row) => {
-    if (!row.due_at) return text(row.status || row.submission_status);
+    if (!row.due_at) return theme.status(text(row.status || row.submission_status));
     const days = Math.ceil((Number(row.due_at) * 1e3 - now) / 864e5);
     const value = `${days < 0 ? `${-days} days overdue` : days === 0 ? "today" : days === 1 ? "tomorrow" : `in ${days} days`} \xB7 ${moment(row.due, now)}`;
-    return options.color && days <= 2 ? `\x1B[${days < 0 ? 31 : 33}m${value}\x1B[0m` : value;
+    return days < 0 ? theme.tone("danger", value) : days <= 2 ? theme.tone("warning", value) : theme.dim(value);
   };
   const rows = (items, title) => {
-    lines.push(title);
-    if (!items.length) lines.push("  None");
-    for (const r of items) lines.push(`  ${text(r.unit_code || r.type)}  ${text(r.name)}${r.due_at ? `  ${dueText(r)}` : ""}${r.id ? `  #${r.id}` : ""}`);
+    lines.push(theme.subject(title));
+    if (!items.length) lines.push(theme.dim("  None"));
+    for (const r of items) lines.push(`  ${theme.key(text(r.unit_code || r.type))}  ${text(r.name)}${r.due_at ? `  ${dueText(r)}` : ""}${r.id ? `  ${theme.dim(`#${r.id}`)}` : ""}`);
   };
   let next = "moodle due --days 30 \xB7 moodle grades";
   if (data.home) {
@@ -3001,7 +3044,7 @@ function renderScreen(data, options = {}) {
     rows(array(key ? data[key] : []), key === "due" ? "Due" : "Matches");
     if (data.total !== void 0) lines.push(`${data.total} total`);
   }
-  lines.push("", `Try  ${next}`);
+  lines.push("", theme.dim(`Try  ${next}`));
   const width = Math.max(40, options.width || 80);
   return lines.flatMap((line) => {
     if (line.includes("\x1B[") || line.startsWith("\u2502") || /^[┌└├]/u.test(line)) return [line];
@@ -3022,12 +3065,20 @@ function renderScreen(data, options = {}) {
 }
 
 // src/cli.ts
-import { createInterface as createInterface4 } from "readline/promises";
 import { spawn as spawn3 } from "child_process";
 import {
+  banner,
+  colorEnabled as colorEnabled2,
   confirm,
   createProgram,
+  createTheme as createTheme3,
+  createUi as createUi3,
+  detectAudience,
+  examples,
+  helpSection,
   insertDefaultVerb,
+  isInformationalExit,
+  parseWithPrompts,
   render,
   reportError,
   normalizeError,
@@ -3036,12 +3087,15 @@ import {
   writeOutput
 } from "@bunizao/cli-kit";
 import { realpathSync as realpathSync3 } from "fs";
-import path3 from "path";
+import path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/moodle-client-core.ts
 import { z as z2 } from "zod";
 
+// src/moodle-assign-core.ts
+import { parse as parse4 } from "node-html-parser";
+
 // src/html-utils.ts
 import { parse as parse2 } from "node-html-parser";
 function htmlToStructuredContent(html, baseUrl) {
@@ -3111,262 +3165,6 @@ function decodeHtml2(value) {
   return value.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
 }
 
-// src/parsers.ts
-function schema(parser) {
-  return { parse: parser };
-}
-var UserInfoSchema = schema(parseUserInfo);
-var CourseSchema = schema(parseCourse);
-var CoursesSchema = schema(parseCourses);
-var ActivitySchema = schema(parseActivity);
-var SectionSchema = schema(parseSection);
-var CourseContentsSchema = schema(parseCourseContents);
-var TodoItemSchema = schema(parseTodoItem);
-function parseUserInfo(value) {
-  const data = asRecord(value);
-  return {
-    userid: numberValue(data.userid),
-    username: stringValue(data.username),
-    fullname: stringValue(data.fullname),
-    sitename: stringValue(data.sitename),
-    siteurl: stringValue(data.siteurl),
-    lang: stringValue(data.lang),
-    ...data.timezone ? { timezone: String(data.timezone) } : {}
-  };
-}
-function parseCourse(value, nowSeconds = Math.floor(Date.now() / 1e3)) {
-  const data = asRecord(value);
-  const course = {
-    id: numberValue(data.id),
-    shortname: stringValue(data.shortname),
-    fullname: stringValue(data.fullname),
-    category: numberValue(data.category),
-    visible: booleanValue(data.visible, true),
-    startdate: numberValue(data.startdate)
-  };
-  const enddate = numberValue(data.enddate);
-  if (enddate > 0) {
-    course.enddate = enddate;
-  }
-  return course;
-}
-function parseCourses(value) {
-  return asArray(value).map((item) => parseCourse(item));
-}
-function parseActivity(value) {
-  const data = asRecord(value);
-  return {
-    id: numberValue(data.id),
-    name: stringValue(data.name),
-    modname: stringValue(data.modname),
-    url: stringValue(data.url),
-    visible: booleanValue(data.visible, true),
-    description: stringValue(data.description),
-    ...data.completiondata && typeof data.completiondata === "object" ? { completion: numberValue(asRecord(data.completiondata).state) } : {},
-    ...Array.isArray(data.contents) ? { file_entries: data.contents.filter((f) => asRecord(f).fileurl).map((f) => ({ name: stringValue(asRecord(f).filename), url: stringValue(asRecord(f).fileurl), requires_authentication: true })) } : {}
-  };
-}
-function parseSection(value) {
-  const data = asRecord(value);
-  return {
-    id: numberValue(data.id),
-    name: stringValue(data.name),
-    section: numberValue(data.section),
-    visible: booleanValue(data.visible, true),
-    summary: stringValue(data.summary),
-    ...data.current !== void 0 ? { current: booleanValue(data.current) } : {},
-    activities: asArray(data.modules).map((item) => parseActivity(item))
-  };
-}
-function parseCourseContents(value) {
-  return asArray(value).map((item) => parseSection(item));
-}
-function parseCourseFormatState(value, baseUrl) {
-  const state = asRecord(parseJsonValue(value));
-  const activities = /* @__PURE__ */ new Map();
-  const activitiesBySection = /* @__PURE__ */ new Map();
-  for (const item of asArray(state.cm)) {
-    const data = asRecord(item);
-    const id2 = numberValue(data.id);
-    const sectionId = stringValue(data.sectionid);
-    const module = stringValue(data.module) || stringValue(data.plugin).replace(/^mod_/u, "") || stringValue(data.modname).toLowerCase();
-    const activity = {
-      id: id2,
-      name: htmlText(data.name, baseUrl),
-      modname: module.toLowerCase(),
-      url: stringValue(data.url) ? resolveUrl(baseUrl, stringValue(data.url)) : "",
-      visible: booleanValue(data.visible, true) && booleanValue(data.uservisible, true) && !booleanValue(data.stealth),
-      description: htmlText(data.content ?? data.description, baseUrl),
-      ...data.completionstate !== void 0 && data.completionstate !== null ? { completion: numberValue(data.completionstate) } : {}
-    };
-    activities.set(String(id2), activity);
-    const sectionActivities = activitiesBySection.get(sectionId) ?? [];
-    sectionActivities.push(activity);
-    activitiesBySection.set(sectionId, sectionActivities);
-  }
-  return asArray(state.section).map((item) => {
-    const data = asRecord(item);
-    const id2 = numberValue(data.id);
-    const hasActivityList = Array.isArray(data.cmlist);
-    const listedActivities = asArray(data.cmlist).map((activityId) => activities.get(stringValue(activityId))).filter((activity) => activity !== void 0);
-    return {
-      id: id2,
-      name: htmlText(data.title || data.rawtitle, baseUrl),
-      section: numberValue(data.section ?? data.number),
-      visible: booleanValue(data.visible, true),
-      summary: htmlText(data.summary, baseUrl),
-      ...data.current !== void 0 ? { current: booleanValue(data.current) } : {},
-      activities: hasActivityList ? listedActivities : activitiesBySection.get(String(id2)) ?? []
-    };
-  });
-}
-function parseTodoItem(value) {
-  const data = asRecord(value);
-  const course = asRecord(data.course);
-  const action = asRecord(data.action);
-  const progress = course.progress;
-  return {
-    id: numberValue(data.id),
-    name: stringValue(data.name),
-    activity_name: stringValue(data.activityname),
-    modname: stringValue(data.modulename),
-    course_id: numberValue(course.id),
-    course_name: stringValue(course.fullname),
-    due_at: numberValue(data.timesort) || numberValue(data.timestart),
-    overdue: booleanValue(data.overdue),
-    actionable: booleanValue(action.actionable),
-    action_name: stringValue(action.name),
-    action_url: stringValue(action.url),
-    url: stringValue(data.url),
-    event_type: stringValue(data.eventtype),
-    course_progress: typeof progress === "number" ? progress : void 0
-  };
-}
-function parseTodoItems(value) {
-  return asArray(value).map((item) => parseTodoItem(item));
-}
-function parseAlertNotification(value) {
-  const data = asRecord(value);
-  return {
-    id: numberValue(data.id),
-    subject: stringValue(data.subject),
-    short_subject: stringValue(data.shortenedsubject),
-    event_type: stringValue(data.eventtype),
-    component: stringValue(data.component),
-    created_at: numberValue(data.timecreated),
-    created_pretty: stringValue(data.timecreatedpretty),
-    read: booleanValue(data.read),
-    context_url: stringValue(data.contexturl),
-    context_name: stringValue(data.contexturlname)
-  };
-}
-function parseAlertSummary(notificationsData, countsData, unreadCountsData) {
-  const notificationsRecord = asRecord(notificationsData);
-  const counts2 = asRecord(countsData);
-  const unreadCounts = asRecord(unreadCountsData);
-  const types = asRecord(counts2.types);
-  const unreadTypes = asRecord(unreadCounts.types);
-  const notifications = asArray(notificationsRecord.notifications).map((item) => parseAlertNotification(item));
-  return {
-    notifications,
-    notification_count: notifications.length,
-    unread_notification_count: notifications.filter((notification) => !notification.read).length,
-    starred_message_count: numberValue(counts2.favourites),
-    direct_message_count: numberValue(types["1"]),
-    group_message_count: numberValue(types["2"]),
-    self_message_count: numberValue(types["3"]),
-    unread_starred_message_count: numberValue(unreadCounts.favourites),
-    unread_direct_message_count: numberValue(unreadTypes["1"]),
-    unread_group_message_count: numberValue(unreadTypes["2"]),
-    unread_self_message_count: numberValue(unreadTypes["3"])
-  };
-}
-function parseForumPostAuthor(value) {
-  const data = asRecord(value);
-  const urls = asRecord(data.urls);
-  return {
-    id: numberValue(data.id),
-    fullname: stringValue(data.fullname),
-    profile_url: stringValue(urls.profile),
-    profile_image_url: stringValue(urls.profileimage)
-  };
-}
-function parseForumPost(value, baseUrl = "") {
-  const data = asRecord(value);
-  const urls = asRecord(data.urls);
-  const messageHtml = stringValue(data.message);
-  const structured = htmlToStructuredContent(messageHtml, stringValue(urls.view || urls.discuss) || baseUrl);
-  return {
-    id: numberValue(data.id),
-    discussion_id: numberValue(data.discussionid),
-    subject: stringValue(data.subject),
-    message_html: messageHtml,
-    message_text: structured.text,
-    image_urls: structured.image_urls,
-    links: structured.links,
-    tables: structured.tables,
-    author: parseForumPostAuthor(data.author),
-    parent_id: numberValue(data.parentid),
-    time_created: numberValue(data.timecreated),
-    time_modified: numberValue(data.timemodified),
-    created_pretty: "",
-    unread: booleanValue(data.unread),
-    is_deleted: booleanValue(data.isdeleted),
-    is_private_reply: booleanValue(data.isprivatereply),
-    url: stringValue(urls.view || urls.viewisolated),
-    reply_url: stringValue(urls.reply)
-  };
-}
-function parseForumDiscussion(value, discussionId, baseUrl = "") {
-  const data = asRecord(value);
-  const posts = asArray(data.posts).map((item) => parseForumPost(item, baseUrl));
-  return {
-    id: discussionId,
-    subject: posts[0]?.subject ?? "",
-    course_id: numberValue(data.courseid),
-    forum_id: numberValue(data.forumid),
-    group_id: numberValue(data.groupid),
-    group_name: stringValue(data.groupname),
-    url: posts[0]?.url ? posts[0].url.split("#", 1)[0] : "",
-    posts
-  };
-}
-function asRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function asArray(value) {
-  return Array.isArray(value) ? value : [];
-}
-function stringValue(value) {
-  return typeof value === "string" ? value : value == null ? "" : String(value);
-}
-function numberValue(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))) {
-    return Number(value);
-  }
-  return 0;
-}
-function booleanValue(value, defaultValue = false) {
-  if (value === void 0 || value === null) {
-    return defaultValue;
-  }
-  return Boolean(value);
-}
-function parseJsonValue(value) {
-  if (typeof value !== "string") return value;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return {};
-  }
-}
-function htmlText(value, baseUrl) {
-  return htmlToStructuredContent(stringValue(value), baseUrl).text;
-}
-
 // src/scraper.ts
 import { parse as parse3 } from "node-html-parser";
 function parseMoodleErrorHtml(html) {
@@ -3398,8 +3196,8 @@ function parseMoodleErrorHtml(html) {
 function parsePageContext(html, baseUrl) {
   const root = parse3(html);
   const config = parseMoodleConfig(html);
-  const sesskey = stringValue2(config.sesskey).trim();
-  const userid = numberValue2(config.userId) || numberValue2(root.querySelector("[data-user-id]")?.getAttribute("data-user-id"));
+  const sesskey = stringValue(config.sesskey).trim();
+  const userid = numberValue(config.userId) || numberValue(root.querySelector("[data-user-id]")?.getAttribute("data-user-id"));
   if (!sesskey || !userid) {
     throw new Error("Session appears invalid: could not load authenticated Moodle context");
   }
@@ -3411,8 +3209,8 @@ function parsePageContext(html, baseUrl) {
       fullname: cleanNodeText(root.querySelector(".userfullname")),
       sitename: extractSitename(root),
       siteurl: baseUrl,
-      ...config.timezone ? { timezone: stringValue2(config.timezone) } : {},
-      lang: stringValue2(config.language) || root.querySelector("html")?.getAttribute("lang") || ""
+      ...config.timezone ? { timezone: stringValue(config.timezone) } : {},
+      lang: stringValue(config.language) || root.querySelector("html")?.getAttribute("lang") || ""
     }
   };
 }
@@ -3861,96 +3659,705 @@ function safeInt(value) {
   if (typeof value === "string" && /^\d+$/.test(value.trim())) {
     return Number(value.trim());
   }
-  return 0;
+  return 0;
+}
+function parseMaybeUrl(href, baseUrl) {
+  try {
+    return new URL(href, baseUrl);
+  } catch {
+    return null;
+  }
+}
+function numericQueryValue(url, key) {
+  const value = url.searchParams.get(key);
+  if (!value || !/^\d+$/.test(value)) {
+    return null;
+  }
+  return Number(value);
+}
+function parseMoodleConfig(html) {
+  const match = html.match(/M\.cfg\s*=\s*({[\s\S]*?});/);
+  if (!match) {
+    return {};
+  }
+  try {
+    return JSON.parse(match[1]);
+  } catch {
+    return {};
+  }
+}
+function extractSitename(root) {
+  const title = cleanNodeText(root.querySelector("title"));
+  return title.includes("|") ? title.split("|").at(-1)?.trim() ?? title : title;
+}
+function pageTitle(html) {
+  return cleanNodeText(parse3(html).querySelector("h1"));
+}
+function activityContext(html) {
+  const root = parse3(html);
+  const context = { course_id: parseCourseIdFromPageHtml(html) ?? 0, course_name: "", section_name: "" };
+  const breadcrumbs = root.querySelectorAll('nav[aria-label="Breadcrumb"] a[href], #page-navbar .breadcrumb a[href]');
+  const links = breadcrumbs.length ? breadcrumbs : root.querySelectorAll('a[href*="/course/view.php?id="]');
+  for (const link2 of links) {
+    const href = link2.getAttribute("href") ?? "";
+    const courseId = numberQueryValue(href, "id");
+    if (courseId !== null) {
+      context.course_id = courseId;
+    }
+    if (numberQueryValue(href, "section") === null) {
+      context.course_name ||= cleanNodeText(link2);
+    } else {
+      context.section_name = cleanNodeText(link2);
+    }
+  }
+  return context;
+}
+function extractLabeledText(html, label) {
+  const root = parse3(html);
+  for (const node of root.querySelectorAll("strong, b")) {
+    if (cleanNodeText(node) !== label) {
+      continue;
+    }
+    const parent = node.parentNode;
+    return cleanText(parent?.textContent.replace(label, "") ?? "");
+  }
+  return "";
+}
+function findTableValue(html, label) {
+  const root = parse3(html);
+  for (const row of root.querySelectorAll("tr")) {
+    const cells = row.querySelectorAll("th, td");
+    if (cleanNodeText(cells[0]) === label) {
+      return cleanTableCell(cells[1]);
+    }
+  }
+  return "";
+}
+function cleanTableCell(node) {
+  if (!node) {
+    return "";
+  }
+  const clone = parse3(node.toString());
+  for (const unwanted of clone.querySelectorAll(".action-menu, .dropdown, script, style")) {
+    unwanted.remove();
+  }
+  return cleanText(clone.textContent.replace("( Empty )", "(Empty)"));
+}
+function numberQueryValue(href, key) {
+  try {
+    return numericQueryValue(new URL(href, "https://moodle.invalid"), key);
+  } catch {
+    return null;
+  }
+}
+function numberValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))) {
+    return Number(value);
+  }
+  return 0;
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : value == null ? "" : String(value);
+}
+function fileEntry(name, url, baseUrl) {
+  return {
+    name,
+    url,
+    requires_authentication: new URL(url).origin === new URL(baseUrl).origin
+  };
+}
+function unique(items) {
+  return [...new Set(items)];
+}
+
+// src/moodle-assign-core.ts
+async function submitAssignmentFiles(deps, request) {
+  const id2 = request.activityId;
+  if (!Number.isSafeInteger(id2) || id2 <= 0) throw deps.usage("The assignment id must be a positive integer.");
+  if (!request.files.length && !request.final) throw deps.usage("Give at least one file to upload, or use --final to submit the existing draft.");
+  const seen = /* @__PURE__ */ new Set();
+  for (const file2 of request.files) {
+    if (!file2.name || /[\\/]/u.test(file2.name)) throw deps.usage(`'${file2.name}' is not a plain file name.`);
+    if (seen.has(file2.name.toLowerCase())) throw deps.usage(`'${file2.name}' is given twice; Moodle keeps one file per name.`);
+    seen.add(file2.name.toLowerCase());
+  }
+  const viewUrl = `${deps.baseUrl}${ASSIGN_VIEW_PATH}?id=${id2}`;
+  request.onProgress?.("Reading the assignment");
+  const before = parseReceiptPage(await pageText(deps, viewUrl), id2, deps.baseUrl);
+  const form = parseSubmissionForm(await pageText(deps, `${viewUrl}&action=editsubmission`), deps);
+  const draft = await listDraftFiles(deps, form);
+  const removed = request.replace ? draft.map((file2) => file2.name) : [];
+  const kept = request.replace ? [] : draft.filter((file2) => !seen.has(file2.name.toLowerCase()));
+  checkLimits(deps, form, kept, request.files);
+  let statement = form.statement;
+  let confirm2;
+  if (request.final && !statement) {
+    confirm2 = parseConfirmForm(await pageText(deps, `${viewUrl}&action=submit`), deps);
+    statement = confirm2.statement;
+  }
+  if (statement && !request.acceptStatement) {
+    throw deps.usage(`Moodle requires you to accept this statement: "${statement}"`, "Re-run with --accept-statement once you agree.");
+  }
+  const limits = describeLimits(form);
+  const uploads = request.files.map((file2) => ({ name: file2.name, bytes: file2.bytes.byteLength, ...file2.path ? { path: file2.path } : {} }));
+  if (request.dryRun) {
+    return {
+      ...before,
+      action: "planned",
+      files: draft.map((file2) => ({ name: file2.name, bytes: file2.bytes })),
+      uploads,
+      removed,
+      limits,
+      ...statement ? { statement, statement_accepted: true } : {},
+      checked_at: timestamp(deps)
+    };
+  }
+  if (removed.length) {
+    request.onProgress?.(`Removing ${removed.join(", ")}`);
+    await deleteDraftFiles(deps, form, draft);
+  }
+  const storedNames = [];
+  for (const [index, file2] of request.files.entries()) {
+    request.onProgress?.(`Uploading ${file2.name} (${index + 1}/${request.files.length})`);
+    storedNames.push(await uploadDraftFile(deps, form, file2));
+  }
+  if (storedNames.length || removed.length) {
+    request.onProgress?.("Saving the submission");
+    const savedHtml = await postForm(deps, form.action, [...form.fields, ...form.statement ? [["submissionstatement", "1"]] : [], ["submitbutton", "Save changes"]]);
+    if (savedHtml !== null) throw deps.fail(`Moodle did not save the submission: ${noticesOf(savedHtml) || "it returned the edit form again without a reason"}`);
+  }
+  request.onProgress?.("Reading the receipt");
+  let receipt = parseReceiptPage(await pageText(deps, viewUrl), id2, deps.baseUrl);
+  const listed = new Set(receipt.files.map((file2) => file2.name.toLowerCase()));
+  const missing = storedNames.filter((name) => !listed.has(name.toLowerCase()));
+  if (missing.length) throw deps.fail(`Moodle saved the submission but its page does not list ${missing.join(", ")}; check the assignment in a browser before submitting.`);
+  let action = "saved";
+  if (isSubmitted(receipt.submission_status)) action = "submitted";
+  else if (request.final) {
+    request.onProgress?.("Submitting for grading");
+    confirm2 ??= parseConfirmForm(await pageText(deps, `${viewUrl}&action=submit`), deps);
+    const errorHtml = await postForm(deps, confirm2.action, [...confirm2.fields, ...confirm2.statement ? [["submissionstatement", "1"]] : [], ["submitbutton", "Continue"]]);
+    if (errorHtml !== null) throw deps.fail(`Moodle did not submit the assignment for grading: ${noticesOf(errorHtml) || "it returned the confirmation page again without a reason"}`);
+    receipt = parseReceiptPage(await pageText(deps, viewUrl), id2, deps.baseUrl);
+    if (!isSubmitted(receipt.submission_status)) throw deps.fail(`Moodle accepted the confirmation but still reports "${receipt.submission_status || "no status"}"; check the assignment in a browser.`);
+    action = "submitted";
+  }
+  return {
+    ...receipt,
+    action,
+    uploads,
+    removed,
+    limits,
+    ...statement ? { statement, statement_accepted: true } : {},
+    checked_at: timestamp(deps)
+  };
+}
+function parseSubmissionForm(html, deps) {
+  const root = parse4(html);
+  const form = formWithAction(root, "savesubmission");
+  if (!form) {
+    const notice = noticesOf(html);
+    if (root.querySelectorAll("input[type=submit], button").some((button) => /begin assignment/iu.test(cleanText(button.getAttribute("value") ?? button.textContent)))) {
+      throw deps.fail("This is a timed assignment; start it in a browser before uploading files.");
+    }
+    throw deps.fail(notice ? `Moodle is not accepting a submission: ${notice}` : "Moodle did not show a submission form for this assignment.");
+  }
+  const itemid = form.querySelector("input[name=files_filemanager]")?.getAttribute("value")?.trim() ?? "";
+  if (!itemid) throw deps.fail("This assignment does not accept file uploads.");
+  const options = filemanagerOptions(html, itemid);
+  if (!options) throw deps.fail("Moodle did not describe the file upload area for this assignment.");
+  const fields2 = formFields(form);
+  const sesskey = fields2.find(([name]) => name === "sesskey")?.[1] ?? "";
+  if (!sesskey) throw deps.fail("The submission form has no session key.");
+  const picker = record2(options.filepicker);
+  const repositories = (Array.isArray(picker.repositories) ? picker.repositories : Object.values(record2(picker.repositories))).map(record2);
+  const upload = repositories.find((repo) => repo.type === "upload");
+  if (!upload || upload.id === void 0) throw deps.fail("The site does not allow direct file uploads for this assignment.");
+  const accepted = options.accepted_types;
+  const acceptedTypes = Array.isArray(accepted) ? accepted.map(String).filter(Boolean) : accepted === void 0 || accepted === "*" ? "*" : [String(accepted)];
+  return {
+    action: resolveUrl(deps.baseUrl, form.getAttribute("action") || `${deps.baseUrl}${ASSIGN_VIEW_PATH}`),
+    fields: fields2,
+    sesskey,
+    itemid,
+    clientId: String(options.client_id ?? ""),
+    contextId: String(record2(options.context).id ?? ""),
+    repoId: String(upload.id),
+    author: String(picker.author ?? ""),
+    license: String(picker.defaultlicense ?? ""),
+    maxBytes: integer(options.maxbytes),
+    areaMaxBytes: integer(options.areamaxbytes),
+    maxFiles: integer(options.maxfiles),
+    acceptedTypes: acceptedTypes.length === 1 && acceptedTypes[0] === "*" ? "*" : acceptedTypes,
+    ...statementOf(form)
+  };
+}
+function parseConfirmForm(html, deps) {
+  const root = parse4(html);
+  const form = formWithAction(root, "confirmsubmit");
+  if (!form) {
+    const notice = noticesOf(html);
+    throw deps.fail(notice ? `Moodle is not accepting a submission for grading: ${notice}` : "Moodle did not show the submit-for-grading confirmation.");
+  }
+  return { action: resolveUrl(deps.baseUrl, form.getAttribute("action") || `${deps.baseUrl}${ASSIGN_VIEW_PATH}`), fields: formFields(form), ...statementOf(form) };
+}
+function parseReceiptPage(html, activityId, baseUrl) {
+  const page = parseAssignmentHtml(html, activityId, baseUrl);
+  const root = parse4(html);
+  const files = /* @__PURE__ */ new Map();
+  const add = (link2) => {
+    const name = cleanText(link2.textContent);
+    const href = link2.getAttribute("href") ?? "";
+    if (name && !files.has(name.toLowerCase())) files.set(name.toLowerCase(), { name, ...href ? { url: resolveUrl(baseUrl, href) } : {} });
+  };
+  for (const link2 of root.querySelectorAll(".fileuploadsubmission a[href]")) add(link2);
+  for (const link2 of tableCell(root, "File submissions")?.querySelectorAll("a[href]") ?? []) add(link2);
+  return {
+    id: activityId,
+    name: page.name,
+    ...page.course_id ? { unit_id: page.course_id } : {},
+    url: page.url,
+    submission_status: page.submission_status,
+    grading_status: page.grading_status,
+    due: page.due_pretty || cleanText(tableCell(root, "Due date")?.textContent),
+    time_remaining: page.time_remaining,
+    last_modified: cleanText(tableCell(root, "Last modified")?.textContent),
+    files: [...files.values()]
+  };
+}
+function noticesOf(html) {
+  const root = parse4(html);
+  const texts = [];
+  for (const node of root.querySelectorAll(".alert, .invalid-feedback, .form-control-feedback, .error, [data-fieldtype] .text-danger")) {
+    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 formWithAction(root, action) {
+  for (const form of root.querySelectorAll("form")) {
+    if (form.querySelectorAll("input[name=action]").some((input2) => input2.getAttribute("value") === action)) return form;
+  }
+  return null;
+}
+function formFields(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((option) => option.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 statementOf(form) {
+  const box = form.querySelector("input[name=submissionstatement]");
+  if (!box) return {};
+  const id2 = box.getAttribute("id");
+  const label = (id2 ? form.querySelector(`label[for="${id2}"]`) : null) ?? box.closest("label") ?? box.parentNode?.querySelector("label") ?? null;
+  const text2 = cleanText(label?.textContent).replace(/\s*Required\s*$/u, "").trim();
+  return { statement: text2 || "Submission statement" };
+}
+function filemanagerOptions(html, itemid) {
+  const pattern = /M\.form_filemanager\.init\(\s*Y\s*,\s*/gu;
+  let match;
+  while (match = pattern.exec(html)) {
+    const json = balancedObject(html, match.index + match[0].length);
+    if (!json) continue;
+    try {
+      const options = JSON.parse(json);
+      if (isRecord4(options) && String(options.itemid) === itemid) return options;
+    } catch {
+    }
+  }
+  return null;
+}
+function balancedObject(text2, start) {
+  if (text2[start] !== "{") return null;
+  let depth = 0;
+  let quoted = false;
+  for (let index = start; index < text2.length; index += 1) {
+    const char = text2[index];
+    if (quoted) {
+      if (char === "\\") index += 1;
+      else if (char === '"') quoted = false;
+    } else if (char === '"') quoted = true;
+    else if (char === "{") depth += 1;
+    else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return text2.slice(start, index + 1);
+    }
+  }
+  return null;
+}
+function tableCell(root, label) {
+  for (const row of root.querySelectorAll("tr")) {
+    const cells = row.querySelectorAll("th, td");
+    if (cells.length > 1 && cleanText(cells[0].textContent) === label) return cells[1];
+  }
+  return null;
+}
+async function pageText(deps, url) {
+  return (await deps.request(url)).text();
+}
+async function postForm(deps, action, fields2) {
+  const response = await deps.request(action, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(fields2).toString()
+  });
+  const html = await response.text();
+  return landedOnView(response.url) ? null : html;
+}
+function landedOnView(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.pathname.endsWith(ASSIGN_VIEW_PATH) && (parsed.searchParams.get("action") ?? "view") === "view";
+  } catch {
+    return false;
+  }
+}
+async function draftAjax(deps, form, action, params) {
+  const body = new URLSearchParams({ sesskey: form.sesskey, client_id: form.clientId, itemid: form.itemid, ...params });
+  const response = await deps.request(`${deps.baseUrl}/repository/draftfiles_ajax.php?action=${action}`, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  }, { allowErrorStatus: true });
+  return jsonOf(deps, response, `draft file ${action}`);
+}
+async function listDraftFiles(deps, form) {
+  const data = record2(await draftAjax(deps, form, "list", { filepath: "/" }));
+  const list2 = Array.isArray(data.list) ? data.list.map(record2) : [];
+  return list2.filter((item) => item.type !== "folder").map((item) => ({ name: String(item.filename ?? item.fullname ?? ""), path: String(item.filepath ?? "/"), bytes: integer(item.size) })).filter((item) => item.name);
+}
+async function deleteDraftFiles(deps, form, files) {
+  const selected = JSON.stringify(files.map((file2) => ({ filename: file2.name, filepath: file2.path })));
+  const result = await draftAjax(deps, form, "deleteselected", { selected });
+  if (result === false) throw deps.fail("Moodle did not remove the existing submission files.");
+}
+async function uploadDraftFile(deps, form, file2) {
+  const body = new FormData();
+  body.set("sesskey", form.sesskey);
+  body.set("client_id", form.clientId);
+  body.set("repo_id", form.repoId);
+  body.set("itemid", form.itemid);
+  body.set("env", "filemanager");
+  body.set("ctx_id", form.contextId);
+  body.set("title", file2.name);
+  body.set("author", form.author);
+  body.set("license", form.license);
+  body.set("savepath", "/");
+  body.set("maxbytes", String(form.maxBytes));
+  body.set("areamaxbytes", String(form.areaMaxBytes));
+  for (const type of form.acceptedTypes === "*" ? ["*"] : form.acceptedTypes) body.append("accepted_types[]", type);
+  body.set("overwrite", "1");
+  body.set("repo_upload_file", new Blob([Uint8Array.from(file2.bytes)]), file2.name);
+  const response = await deps.request(`${deps.baseUrl}/repository/repository_ajax.php?action=upload`, { method: "POST", body }, { allowErrorStatus: true });
+  const data = record2(await jsonOf(deps, response, `upload of ${file2.name}`));
+  if (typeof data.error === "string" && data.error) throw deps.fail(`Moodle refused ${file2.name}: ${data.error}`, typeof data.errorcode === "string" ? data.errorcode : void 0);
+  if (data.event === "fileexists") throw deps.fail(`Moodle reports ${file2.name} already exists and did not overwrite it.`);
+  const stored = typeof data.file === "string" && data.file ? data.file : file2.name;
+  if (!data.url && !data.id && !data.file) throw deps.fail(`Moodle did not confirm the upload of ${file2.name}.`);
+  return stored;
+}
+async function jsonOf(deps, response, step) {
+  const text2 = await response.text();
+  try {
+    return JSON.parse(text2);
+  } catch {
+    const notice = noticesOf(text2);
+    throw deps.fail(`Moodle did not answer the ${step} with JSON (HTTP ${response.status})${notice ? `: ${notice}` : ""}`);
+  }
+}
+function checkLimits(deps, form, kept, files) {
+  if (form.maxFiles > 0 && kept.length + files.length > form.maxFiles) {
+    throw deps.usage(`This assignment allows ${form.maxFiles} file${form.maxFiles === 1 ? "" : "s"}; the submission would hold ${kept.length + files.length}.`, kept.length ? "Use --replace to drop the existing files first." : void 0);
+  }
+  for (const file2 of files) {
+    if (form.maxBytes > 0 && file2.bytes.byteLength > form.maxBytes) throw deps.usage(`${file2.name} is ${size(file2.bytes.byteLength)}; the limit is ${size(form.maxBytes)}.`);
+    if (form.acceptedTypes !== "*" && form.acceptedTypes.every((type) => type.startsWith(".")) && !form.acceptedTypes.some((type) => file2.name.toLowerCase().endsWith(type.toLowerCase()))) {
+      throw deps.usage(`${file2.name} is not an accepted type; allowed: ${form.acceptedTypes.join(", ")}.`);
+    }
+  }
+  const total = kept.reduce((sum, file2) => sum + file2.bytes, 0) + files.reduce((sum, file2) => sum + file2.bytes.byteLength, 0);
+  if (form.areaMaxBytes > 0 && total > form.areaMaxBytes) throw deps.usage(`The submission would total ${size(total)}; the limit is ${size(form.areaMaxBytes)}.`, kept.length ? "Use --replace to drop the existing files first." : void 0);
+}
+function describeLimits(form) {
+  return {
+    ...form.maxBytes > 0 ? { max_bytes: form.maxBytes } : {},
+    ...form.maxFiles > 0 ? { max_files: form.maxFiles } : {},
+    ...form.areaMaxBytes > 0 ? { area_max_bytes: form.areaMaxBytes } : {},
+    ...form.acceptedTypes !== "*" ? { accepted_types: form.acceptedTypes } : {}
+  };
+}
+function isSubmitted(status) {
+  return /\bsubmitted\b/iu.test(status) && !/\bnot submitted\b/iu.test(status);
+}
+function size(bytes) {
+  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KiB`;
+  return `${bytes} B`;
+}
+function timestamp(deps) {
+  return (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+}
+function integer(value) {
+  const number = Number(value);
+  return Number.isSafeInteger(number) ? number : 0;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record2(value) {
+  return isRecord4(value) ? value : {};
+}
+
+// src/parsers.ts
+function schema(parser) {
+  return { parse: parser };
+}
+var UserInfoSchema = schema(parseUserInfo);
+var CourseSchema = schema(parseCourse);
+var CoursesSchema = schema(parseCourses);
+var ActivitySchema = schema(parseActivity);
+var SectionSchema = schema(parseSection);
+var CourseContentsSchema = schema(parseCourseContents);
+var TodoItemSchema = schema(parseTodoItem);
+function parseUserInfo(value) {
+  const data = asRecord(value);
+  return {
+    userid: numberValue2(data.userid),
+    username: stringValue2(data.username),
+    fullname: stringValue2(data.fullname),
+    sitename: stringValue2(data.sitename),
+    siteurl: stringValue2(data.siteurl),
+    lang: stringValue2(data.lang),
+    ...data.timezone ? { timezone: String(data.timezone) } : {}
+  };
+}
+function parseCourse(value, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  const data = asRecord(value);
+  const course = {
+    id: numberValue2(data.id),
+    shortname: stringValue2(data.shortname),
+    fullname: stringValue2(data.fullname),
+    category: numberValue2(data.category),
+    visible: booleanValue(data.visible, true),
+    startdate: numberValue2(data.startdate)
+  };
+  const enddate = numberValue2(data.enddate);
+  if (enddate > 0) {
+    course.enddate = enddate;
+  }
+  return course;
+}
+function parseCourses(value) {
+  return asArray(value).map((item) => parseCourse(item));
+}
+function parseActivity(value) {
+  const data = asRecord(value);
+  return {
+    id: numberValue2(data.id),
+    name: stringValue2(data.name),
+    modname: stringValue2(data.modname),
+    url: stringValue2(data.url),
+    visible: booleanValue(data.visible, true),
+    description: stringValue2(data.description),
+    ...data.completiondata && typeof data.completiondata === "object" ? { completion: numberValue2(asRecord(data.completiondata).state) } : {},
+    ...Array.isArray(data.contents) ? { file_entries: data.contents.filter((f) => asRecord(f).fileurl).map((f) => ({ name: stringValue2(asRecord(f).filename), url: stringValue2(asRecord(f).fileurl), requires_authentication: true })) } : {}
+  };
+}
+function parseSection(value) {
+  const data = asRecord(value);
+  return {
+    id: numberValue2(data.id),
+    name: stringValue2(data.name),
+    section: numberValue2(data.section),
+    visible: booleanValue(data.visible, true),
+    summary: stringValue2(data.summary),
+    ...data.current !== void 0 ? { current: booleanValue(data.current) } : {},
+    activities: asArray(data.modules).map((item) => parseActivity(item))
+  };
+}
+function parseCourseContents(value) {
+  return asArray(value).map((item) => parseSection(item));
+}
+function parseCourseFormatState(value, baseUrl) {
+  const state = asRecord(parseJsonValue(value));
+  const activities = /* @__PURE__ */ new Map();
+  const activitiesBySection = /* @__PURE__ */ new Map();
+  for (const item of asArray(state.cm)) {
+    const data = asRecord(item);
+    const id2 = numberValue2(data.id);
+    const sectionId = stringValue2(data.sectionid);
+    const module = stringValue2(data.module) || stringValue2(data.plugin).replace(/^mod_/u, "") || stringValue2(data.modname).toLowerCase();
+    const activity = {
+      id: id2,
+      name: htmlText(data.name, baseUrl),
+      modname: module.toLowerCase(),
+      url: stringValue2(data.url) ? resolveUrl(baseUrl, stringValue2(data.url)) : "",
+      visible: booleanValue(data.visible, true) && booleanValue(data.uservisible, true) && !booleanValue(data.stealth),
+      description: htmlText(data.content ?? data.description, baseUrl),
+      ...data.completionstate !== void 0 && data.completionstate !== null ? { completion: numberValue2(data.completionstate) } : {}
+    };
+    activities.set(String(id2), activity);
+    const sectionActivities = activitiesBySection.get(sectionId) ?? [];
+    sectionActivities.push(activity);
+    activitiesBySection.set(sectionId, sectionActivities);
+  }
+  return asArray(state.section).map((item) => {
+    const data = asRecord(item);
+    const id2 = numberValue2(data.id);
+    const hasActivityList = Array.isArray(data.cmlist);
+    const listedActivities = asArray(data.cmlist).map((activityId) => activities.get(stringValue2(activityId))).filter((activity) => activity !== void 0);
+    return {
+      id: id2,
+      name: htmlText(data.title || data.rawtitle, baseUrl),
+      section: numberValue2(data.section ?? data.number),
+      visible: booleanValue(data.visible, true),
+      summary: htmlText(data.summary, baseUrl),
+      ...data.current !== void 0 ? { current: booleanValue(data.current) } : {},
+      activities: hasActivityList ? listedActivities : activitiesBySection.get(String(id2)) ?? []
+    };
+  });
 }
-function parseMaybeUrl(href, baseUrl) {
-  try {
-    return new URL(href, baseUrl);
-  } catch {
-    return null;
-  }
+function parseTodoItem(value) {
+  const data = asRecord(value);
+  const course = asRecord(data.course);
+  const action = asRecord(data.action);
+  const progress = course.progress;
+  return {
+    id: numberValue2(data.id),
+    name: stringValue2(data.name),
+    activity_name: stringValue2(data.activityname),
+    modname: stringValue2(data.modulename),
+    course_id: numberValue2(course.id),
+    course_name: stringValue2(course.fullname),
+    due_at: numberValue2(data.timesort) || numberValue2(data.timestart),
+    overdue: booleanValue(data.overdue),
+    actionable: booleanValue(action.actionable),
+    action_name: stringValue2(action.name),
+    action_url: stringValue2(action.url),
+    url: stringValue2(data.url),
+    event_type: stringValue2(data.eventtype),
+    course_progress: typeof progress === "number" ? progress : void 0
+  };
 }
-function numericQueryValue(url, key) {
-  const value = url.searchParams.get(key);
-  if (!value || !/^\d+$/.test(value)) {
-    return null;
-  }
-  return Number(value);
+function parseTodoItems(value) {
+  return asArray(value).map((item) => parseTodoItem(item));
 }
-function parseMoodleConfig(html) {
-  const match = html.match(/M\.cfg\s*=\s*({[\s\S]*?});/);
-  if (!match) {
-    return {};
-  }
-  try {
-    return JSON.parse(match[1]);
-  } catch {
-    return {};
-  }
+function parseAlertNotification(value) {
+  const data = asRecord(value);
+  return {
+    id: numberValue2(data.id),
+    subject: stringValue2(data.subject),
+    short_subject: stringValue2(data.shortenedsubject),
+    event_type: stringValue2(data.eventtype),
+    component: stringValue2(data.component),
+    created_at: numberValue2(data.timecreated),
+    created_pretty: stringValue2(data.timecreatedpretty),
+    read: booleanValue(data.read),
+    context_url: stringValue2(data.contexturl),
+    context_name: stringValue2(data.contexturlname)
+  };
 }
-function extractSitename(root) {
-  const title = cleanNodeText(root.querySelector("title"));
-  return title.includes("|") ? title.split("|").at(-1)?.trim() ?? title : title;
+function parseAlertSummary(notificationsData, countsData, unreadCountsData) {
+  const notificationsRecord = asRecord(notificationsData);
+  const counts2 = asRecord(countsData);
+  const unreadCounts = asRecord(unreadCountsData);
+  const types = asRecord(counts2.types);
+  const unreadTypes = asRecord(unreadCounts.types);
+  const notifications = asArray(notificationsRecord.notifications).map((item) => parseAlertNotification(item));
+  return {
+    notifications,
+    notification_count: notifications.length,
+    unread_notification_count: notifications.filter((notification) => !notification.read).length,
+    starred_message_count: numberValue2(counts2.favourites),
+    direct_message_count: numberValue2(types["1"]),
+    group_message_count: numberValue2(types["2"]),
+    self_message_count: numberValue2(types["3"]),
+    unread_starred_message_count: numberValue2(unreadCounts.favourites),
+    unread_direct_message_count: numberValue2(unreadTypes["1"]),
+    unread_group_message_count: numberValue2(unreadTypes["2"]),
+    unread_self_message_count: numberValue2(unreadTypes["3"])
+  };
 }
-function pageTitle(html) {
-  return cleanNodeText(parse3(html).querySelector("h1"));
+function parseForumPostAuthor(value) {
+  const data = asRecord(value);
+  const urls = asRecord(data.urls);
+  return {
+    id: numberValue2(data.id),
+    fullname: stringValue2(data.fullname),
+    profile_url: stringValue2(urls.profile),
+    profile_image_url: stringValue2(urls.profileimage)
+  };
 }
-function activityContext(html) {
-  const root = parse3(html);
-  const context = { course_id: parseCourseIdFromPageHtml(html) ?? 0, course_name: "", section_name: "" };
-  const breadcrumbs = root.querySelectorAll('nav[aria-label="Breadcrumb"] a[href], #page-navbar .breadcrumb a[href]');
-  const links = breadcrumbs.length ? breadcrumbs : root.querySelectorAll('a[href*="/course/view.php?id="]');
-  for (const link2 of links) {
-    const href = link2.getAttribute("href") ?? "";
-    const courseId = numberQueryValue(href, "id");
-    if (courseId !== null) {
-      context.course_id = courseId;
-    }
-    if (numberQueryValue(href, "section") === null) {
-      context.course_name ||= cleanNodeText(link2);
-    } else {
-      context.section_name = cleanNodeText(link2);
-    }
-  }
-  return context;
+function parseForumPost(value, baseUrl = "") {
+  const data = asRecord(value);
+  const urls = asRecord(data.urls);
+  const messageHtml = stringValue2(data.message);
+  const structured = htmlToStructuredContent(messageHtml, stringValue2(urls.view || urls.discuss) || baseUrl);
+  return {
+    id: numberValue2(data.id),
+    discussion_id: numberValue2(data.discussionid),
+    subject: stringValue2(data.subject),
+    message_html: messageHtml,
+    message_text: structured.text,
+    image_urls: structured.image_urls,
+    links: structured.links,
+    tables: structured.tables,
+    author: parseForumPostAuthor(data.author),
+    parent_id: numberValue2(data.parentid),
+    time_created: numberValue2(data.timecreated),
+    time_modified: numberValue2(data.timemodified),
+    created_pretty: "",
+    unread: booleanValue(data.unread),
+    is_deleted: booleanValue(data.isdeleted),
+    is_private_reply: booleanValue(data.isprivatereply),
+    url: stringValue2(urls.view || urls.viewisolated),
+    reply_url: stringValue2(urls.reply)
+  };
 }
-function extractLabeledText(html, label) {
-  const root = parse3(html);
-  for (const node of root.querySelectorAll("strong, b")) {
-    if (cleanNodeText(node) !== label) {
-      continue;
-    }
-    const parent = node.parentNode;
-    return cleanText(parent?.textContent.replace(label, "") ?? "");
-  }
-  return "";
+function parseForumDiscussion(value, discussionId, baseUrl = "") {
+  const data = asRecord(value);
+  const posts = asArray(data.posts).map((item) => parseForumPost(item, baseUrl));
+  return {
+    id: discussionId,
+    subject: posts[0]?.subject ?? "",
+    course_id: numberValue2(data.courseid),
+    forum_id: numberValue2(data.forumid),
+    group_id: numberValue2(data.groupid),
+    group_name: stringValue2(data.groupname),
+    url: posts[0]?.url ? posts[0].url.split("#", 1)[0] : "",
+    posts
+  };
 }
-function findTableValue(html, label) {
-  const root = parse3(html);
-  for (const row of root.querySelectorAll("tr")) {
-    const cells = row.querySelectorAll("th, td");
-    if (cleanNodeText(cells[0]) === label) {
-      return cleanTableCell(cells[1]);
-    }
-  }
-  return "";
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function cleanTableCell(node) {
-  if (!node) {
-    return "";
-  }
-  const clone = parse3(node.toString());
-  for (const unwanted of clone.querySelectorAll(".action-menu, .dropdown, script, style")) {
-    unwanted.remove();
-  }
-  return cleanText(clone.textContent.replace("( Empty )", "(Empty)"));
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
 }
-function numberQueryValue(href, key) {
-  try {
-    return numericQueryValue(new URL(href, "https://moodle.invalid"), key);
-  } catch {
-    return null;
-  }
+function stringValue2(value) {
+  return typeof value === "string" ? value : value == null ? "" : String(value);
 }
 function numberValue2(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
@@ -3961,18 +4368,22 @@ function numberValue2(value) {
   }
   return 0;
 }
-function stringValue2(value) {
-  return typeof value === "string" ? value : value == null ? "" : String(value);
+function booleanValue(value, defaultValue = false) {
+  if (value === void 0 || value === null) {
+    return defaultValue;
+  }
+  return Boolean(value);
 }
-function fileEntry(name, url, baseUrl) {
-  return {
-    name,
-    url,
-    requires_authentication: new URL(url).origin === new URL(baseUrl).origin
-  };
+function parseJsonValue(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
 }
-function unique(items) {
-  return [...new Set(items)];
+function htmlText(value, baseUrl) {
+  return htmlToStructuredContent(stringValue2(value), baseUrl).text;
 }
 
 // src/moodle-forum-core.ts
@@ -4109,13 +4520,13 @@ var ForumModule = class {
   }
 };
 function shouldFallbackForumAjax(error) {
-  if (!isRecord4(error)) {
+  if (!isRecord5(error)) {
     return false;
   }
   const code = typeof error.moodleErrorCode === "string" ? error.moodleErrorCode : "";
   return code === "servicenotavailable" || code === "accessexception" || error instanceof Error && error.message.includes("Web service is not available");
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -4247,9 +4658,9 @@ async function searchForumContent(source, query, options = {}) {
   hits.sort(sortBy === "recent" ? sortRecent : sortRelevant);
   return hits.slice(0, options.limit ?? 20).map(([, hit]) => includePostText ? hit : { ...hit, snippet: "" });
 }
-async function inParallel2(items, size, run) {
+async function inParallel2(items, size2, run) {
   const results = [];
-  for (let index = 0; index < items.length; index += size) results.push(...await Promise.all(items.slice(index, index + size).map(run)));
+  for (let index = 0; index < items.length; index += size2) results.push(...await Promise.all(items.slice(index, index + size2).map(run)));
   return results;
 }
 function normalizeQuery(value) {
@@ -4425,7 +4836,7 @@ var MoodleClientCore = class {
         await this.ensureSession();
         return this.call(functionName, args);
       },
-      getPage: (path4, params) => this.get(path4, params),
+      getPage: (path5, params) => this.get(path5, params),
       getCourses: () => this.getCourses(),
       getCourseContents: (courseId) => this.getCourseContents(courseId)
     });
@@ -4435,7 +4846,7 @@ var MoodleClientCore = class {
     try {
       if (this.unavailable.has(FUNC_GET_SITE_INFO) && this.userInfo?.fullname) return this.userInfo;
       const data = await this.call(FUNC_GET_SITE_INFO);
-      if (isRecord5(data) && "userid" in data) {
+      if (isRecord6(data) && "userid" in data) {
         const info = parseUserInfo(data);
         this.sesskey = typeof data.sesskey === "string" ? data.sesskey : this.sesskey;
         this.userid = info.userid;
@@ -4534,9 +4945,9 @@ var MoodleClientCore = class {
     let type = "";
     try {
       const data = await this.call(FUNC_GET_COURSE_MODULE, { cmid: id2 });
-      const module = isRecord5(data) && isRecord5(data.cm) ? data.cm : data;
-      type = isRecord5(module) && typeof module.modname === "string" ? module.modname : "";
-      courseId = isRecord5(module) && typeof module.course === "number" ? module.course : void 0;
+      const module = isRecord6(data) && isRecord6(data.cm) ? data.cm : data;
+      type = isRecord6(module) && typeof module.modname === "string" ? module.modname : "";
+      courseId = isRecord6(module) && typeof module.course === "number" ? module.course : void 0;
     } catch (error) {
       if (!this.errors.isApi(error) || error.moodleErrorCode !== "servicenotavailable") {
         throw error;
@@ -4580,14 +4991,14 @@ var MoodleClientCore = class {
       } else {
         data = await this.call(FUNC_GET_ACTION_EVENTS, { ...window, limittononsuspendedevents: true });
       }
-      const events = isRecord5(data) && Array.isArray(data.events) ? data.events : [];
+      const events = isRecord6(data) && Array.isArray(data.events) ? data.events : [];
       for (const item of parseTodoItems(events)) if (!seen.has(item.id)) {
         seen.add(item.id);
         items.push(item);
       }
       if (events.length < batchSize) break;
       const last = events.at(-1);
-      const next = isRecord5(last) && typeof last.id === "number" ? last.id : void 0;
+      const next = isRecord6(last) && typeof last.id === "number" ? last.id : void 0;
       if (!next || next === aftereventid) throw this.errors.api("Moodle repeated a calendar page; refine the date window.");
       aftereventid = next;
     }
@@ -4754,8 +5165,18 @@ var MoodleClientCore = class {
   async getFolder(id2) {
     return parseFolderHtml(await this.get(FOLDER_VIEW_PATH, { id: id2 }), id2, this.baseUrl);
   }
-  async requestAbsolute(url, init = {}) {
-    return this.requestAbsoluteInternal(url, init, true);
+  async requestAbsolute(url, init = {}, options = {}) {
+    return this.requestAbsoluteInternal(url, init, true, Boolean(options.allowErrorStatus));
+  }
+  /** Uploads files into an assignment and reads the receipt back from the site. */
+  async submitAssignment(request) {
+    await this.ensureSession();
+    return submitAssignmentFiles({
+      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)
+    }, request);
   }
   async getNewsForums(courseId) {
     const units = courseId === void 0 ? await this.getCourses() : (await this.getCourses()).filter((c) => c.id === courseId);
@@ -4765,7 +5186,7 @@ var MoodleClientCore = class {
       await this.ensureSession();
       const data = await this.call("mod_forum_get_forums_by_courses", { courseids: units.map((c) => c.id) });
       for (const f of Array.isArray(data) ? data : []) {
-        if (!isRecord5(f) || f.type !== "news" || typeof f.cmid !== "number") continue;
+        if (!isRecord6(f) || f.type !== "news" || typeof f.cmid !== "number") continue;
         const c = units.find((c2) => c2.id === f.course);
         forums.push({ id: f.cmid, name: String(f.name || ""), course_id: Number(f.course), course_name: c?.fullname || "", url: `${this.baseUrl}/mod/forum/view.php?id=${f.cmid}` });
       }
@@ -4893,16 +5314,16 @@ var MoodleClientCore = class {
   async getAbsolute(url) {
     return (await this.requestAbsolute(url)).text();
   }
-  async requestAbsoluteInternal(url, init, allowRetry) {
+  async requestAbsoluteInternal(url, init, allowRetry, allowErrorStatus = false) {
     const response = await fetchWithSession(url, init, this.baseUrl, this.cookie, this.fetchImpl);
     if (response.url.includes("/login/")) {
       if (this.onLoginRequired && allowRetry && !this.retryingLogin) {
         await this.reauthenticate();
-        return this.requestAbsoluteInternal(url, init, false);
+        return this.requestAbsoluteInternal(url, init, false, allowErrorStatus);
       }
       throw this.errors.api("Session expired", "servicerequireslogin");
     }
-    if (!response.ok) {
+    if (!response.ok && !allowErrorStatus) {
       const context = `HTTP ${response.status} loading ${safeUrl(url)}`;
       const contentType3 = response.headers.get("content-type")?.toLowerCase() ?? "";
       if (contentType3.includes("text/html") || contentType3.includes("application/xhtml+xml")) {
@@ -4920,7 +5341,7 @@ var MoodleClientCore = class {
     let offset = 0;
     while (true) {
       const data = await this.call(FUNC_GET_COURSES_BY_TIMELINE, { classification: "all", limit: 100, offset });
-      if (!isRecord5(data) || !Array.isArray(data.courses) || !data.courses.length) {
+      if (!isRecord6(data) || !Array.isArray(data.courses) || !data.courses.length) {
         break;
       }
       courses.push(...data.courses);
@@ -5080,19 +5501,19 @@ function placeholderUserInfo(baseUrl, userid) {
   };
 }
 function parseTodoPayload(value) {
-  return parseTodoItems(isRecord5(value) && Array.isArray(value.events) ? value.events : []);
+  return parseTodoItems(isRecord6(value) && Array.isArray(value.events) ? value.events : []);
 }
 function errorMessage(value) {
   return value instanceof Error ? value.message : "Unknown Moodle error";
 }
-function chunks(values, size) {
+function chunks(values, size2) {
   const result = [];
-  for (let index = 0; index < values.length; index += size) {
-    result.push(values.slice(index, index + size));
+  for (let index = 0; index < values.length; index += size2) {
+    result.push(values.slice(index, index + size2));
   }
   return result;
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isLoginErrorCode2(code) {
@@ -5114,10 +5535,30 @@ function safeUrl(value) {
   }
 }
 
+// src/submit.ts
+import { readFile as readFile6, stat as stat2 } from "fs/promises";
+import { homedir as homedir8 } from "os";
+import path from "path";
+function resolveSubmissionPath(given, cwd = process.cwd()) {
+  return path.resolve(cwd, given.startsWith("~/") ? path.join(homedir8(), given.slice(2)) : given);
+}
+async function readSubmissionFiles(paths, cwd = process.cwd()) {
+  const files = [];
+  for (const given of paths) {
+    const resolved = resolveSubmissionPath(given, cwd);
+    const info = await stat2(resolved).catch(() => null);
+    if (!info) throw new UsageError(`File not found: ${given}`);
+    if (!info.isFile()) throw new UsageError(`Not a file: ${given}`, "Zip a folder before uploading it.");
+    files.push({ name: path.basename(resolved), bytes: await readFile6(resolved), path: resolved });
+  }
+  return files;
+}
+
 // src/client.ts
 var NODE_ERROR_ADAPTER = {
   api: (message, moodleErrorCode) => new MoodleAPIError(message, moodleErrorCode),
   notFound: (message) => new NotFoundError(message),
+  usage: (message, hint) => new UsageError(message, hint),
   isApi: (error) => error instanceof MoodleAPIError,
   isLoginRequired: isLoginRequiredError
 };
@@ -5126,6 +5567,11 @@ var MoodleClient = class extends MoodleClientCore {
     const resolvedOptions = typeof options === "string" ? { cookie: { name: "MoodleSession", value: options } } : options;
     super(baseUrl, { ...resolvedOptions, errorAdapter: NODE_ERROR_ADAPTER });
   }
+  /** Reads local files, then uploads them into the assignment. Only the Node client has a filesystem. */
+  async submitAssignmentFiles(request) {
+    const { files, cwd, ...rest } = request;
+    return this.submitAssignment({ ...rest, files: await readSubmissionFiles(files, cwd) });
+  }
 };
 async function createMoodleClient(baseUrl, options = {}) {
   const cacheOptions2 = {
@@ -5234,6 +5680,35 @@ function formatDownloadReceipt(receipt) {
     ["Final URL", receipt.final_url]
   ], { title: "Download" });
 }
+function formatSubmissionReceipt(receipt) {
+  const size2 = (bytes) => bytes >= 1024 * 1024 ? `${(bytes / (1024 * 1024)).toFixed(1)} MiB` : bytes >= 1024 ? `${(bytes / 1024).toFixed(1)} KiB` : `${bytes} B`;
+  const limits = [
+    receipt.limits.max_files ? `${receipt.limits.max_files} files` : "",
+    receipt.limits.max_bytes ? `${size2(receipt.limits.max_bytes)} each` : "",
+    receipt.limits.area_max_bytes ? `${size2(receipt.limits.area_max_bytes)} total` : "",
+    receipt.limits.accepted_types?.length ? receipt.limits.accepted_types.join(" ") : ""
+  ].filter(Boolean).join(", ");
+  const table = renderKeyValueTable([
+    ["Assignment", receipt.name],
+    ["Unit id", receipt.unit_id ? String(receipt.unit_id) : ""],
+    ["URL", receipt.url],
+    ["Action", receipt.action],
+    ["Status", receipt.submission_status],
+    ["Grading", receipt.grading_status],
+    ["Due", receipt.due],
+    ["Time remaining", receipt.time_remaining],
+    ["Last modified", receipt.last_modified],
+    [receipt.action === "planned" ? "Files now" : "Files", receipt.files.map((file2) => file2.bytes ? `${file2.name} (${size2(file2.bytes)})` : file2.name).join(", ")],
+    ["Uploads", receipt.uploads.map((file2) => `${file2.name} (${size2(file2.bytes)})`).join(", ")],
+    ["Removed", receipt.removed.join(", ")],
+    ["Statement", receipt.statement ? `${receipt.statement_accepted ? "accepted" : "not accepted"}: ${receipt.statement}` : ""],
+    ["Limits", limits],
+    ["Checked", receipt.checked_at]
+  ], { title: receipt.action === "planned" ? "Submission plan" : "Submission" });
+  const note = receipt.action === "planned" ? "Plan only; nothing was uploaded. Re-run without --dry-run to upload." : receipt.action === "saved" && /draft|not submitted/iu.test(receipt.submission_status) ? "Saved as a draft. Re-run with --final to submit it for grading." : "";
+  return note ? `${table}
+${note}` : table;
+}
 function formatForumDiscussion(discussion, options = {}) {
   const lines = [`Discussion: ${discussion.id}`];
   if (discussion.subject) {
@@ -5351,10 +5826,10 @@ function formatTimestamp(value) {
 import { createWriteStream } from "fs";
 import { link, lstat, rename as rename2, unlink } from "fs/promises";
 import { randomUUID } from "crypto";
-import path from "path";
+import path2 from "path";
 import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
-import { parse as parse4 } from "node-html-parser";
+import { parse as parse5 } 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",
@@ -5374,14 +5849,14 @@ var FILE_SYSTEM_ERROR_CODES = /* @__PURE__ */ new Set([
 ]);
 async function downloadMoodleFile(client, request, signal) {
   throwIfCancelled(signal);
-  const explicitDestination = request.destination ? path.resolve(request.destination) : void 0;
+  const explicitDestination = request.destination ? path2.resolve(request.destination) : void 0;
   if (explicitDestination && !request.force) {
     await ensureDestinationAvailable(explicitDestination);
   }
   const resolved = await resolveDownload(client, request.source, signal);
   throwIfCancelled(signal);
-  const filename = explicitDestination ? path.basename(explicitDestination) : chooseUpstreamFilename(resolved);
-  const destination = explicitDestination ?? path.resolve(request.directory ?? process.cwd(), filename);
+  const filename = explicitDestination ? path2.basename(explicitDestination) : chooseUpstreamFilename(resolved);
+  const destination = explicitDestination ?? path2.resolve(request.directory ?? process.cwd(), filename);
   if (!explicitDestination && !request.force) {
     await ensureDestinationAvailable(destination);
   }
@@ -5476,7 +5951,7 @@ async function responseOrWrapper(client, requestUrl, sourceUrl, targetName, sign
   };
 }
 function resourceLinks2(html, baseUrl) {
-  const root = parse4(html);
+  const root = parse5(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()
@@ -5492,7 +5967,7 @@ function isHtmlWrapper(response) {
   return type.includes("text/html") || type.includes("application/xhtml+xml");
 }
 function looksLikeLoginPage3(html) {
-  const root = parse4(html);
+  const root = parse5(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) {
@@ -5553,7 +6028,7 @@ async function ensureDestinationAvailable(destination) {
   throw new UsageError(`Destination already exists: ${destination}`, "Choose another --dest path or pass --force to replace this exact file.");
 }
 async function writeResponse(response, destination, force, signal) {
-  const temporaryPath = path.join(path.dirname(destination), `.${path.basename(destination)}.moodle-${randomUUID()}.tmp`);
+  const temporaryPath = path2.join(path2.dirname(destination), `.${path2.basename(destination)}.moodle-${randomUUID()}.tmp`);
   let bytesWritten = 0;
   const counter = new Transform({
     transform(chunk, _encoding, callback) {
@@ -5625,7 +6100,7 @@ function isFileSystemError(error) {
 // src/skills.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import { mkdirSync, readFileSync, writeFileSync, rmSync } from "fs";
-import path2 from "path";
+import path3 from "path";
 
 // src/command-contract.ts
 import { VERBS } from "@bunizao/cli-kit";
@@ -5682,7 +6157,7 @@ function isMutating(command) {
 var SKILL_NAME = "moodle-cli";
 var SKILL_SOURCE = "https://github.com/bunizao/moodle-cli";
 var SKILLS_SPEC_URL = "https://github.com/vercel-labs/skills";
-var SKILL_DESCRIPTION = "Read Moodle units, deadlines, grades, announcements and files; diagnose sign-in and manage a private MCP server.";
+var SKILL_DESCRIPTION = "Read Moodle units, deadlines, grades, announcements and files; submit assignment files; diagnose sign-in and manage a private MCP server.";
 var SKILL_BUNDLE_TEMPLATES = [
   ["SKILL.md", "skill.template.md"],
   ["references/setup-and-auth.md", "skill-references/setup-and-auth.md"],
@@ -5729,10 +6204,10 @@ function extractCommanderCommands(program) {
   return describeProgram(program).commands.flatMap((command) => commandDescriptionRows(command));
 }
 function commandDescriptionRows(command, parentPath = []) {
-  const path4 = [...parentPath, command.name];
+  const path5 = [...parentPath, command.name];
   const row = {
     name: command.name,
-    path: path4,
+    path: path5,
     description: command.description,
     arguments: command.positionals.map((argument) => ({
       name: argument.name,
@@ -5746,15 +6221,15 @@ function commandDescriptionRows(command, parentPath = []) {
       return { name, alias, description: option.description, required: option.required };
     })
   };
-  return [row, ...command.commands.flatMap((child) => commandDescriptionRows(child, path4))];
+  return [row, ...command.commands.flatMap((child) => commandDescriptionRows(child, path5))];
 }
 function writeGeneratedSkill(program, target = "SKILL.md") {
   const commands = extractCommanderCommands(program);
-  const targetDir = path2.dirname(target);
-  for (const obsolete of ["profile-and-courses", "deadlines-and-alerts", "coursework-and-grades", "downloads", "forums", "output-and-errors", "maintenance"]) rmSync(path2.join(targetDir, "references", `${obsolete}.md`), { force: true });
+  const targetDir = path3.dirname(target);
+  for (const obsolete of ["profile-and-courses", "deadlines-and-alerts", "coursework-and-grades", "downloads", "forums", "output-and-errors", "maintenance"]) rmSync(path3.join(targetDir, "references", `${obsolete}.md`), { force: true });
   for (const [relativeTarget, relativeTemplate] of SKILL_BUNDLE_TEMPLATES) {
-    const outputPath = relativeTarget === "SKILL.md" ? target : path2.join(targetDir, relativeTarget);
-    mkdirSync(path2.dirname(outputPath), { recursive: true });
+    const outputPath = relativeTarget === "SKILL.md" ? target : path3.join(targetDir, relativeTarget);
+    mkdirSync(path3.dirname(outputPath), { recursive: true });
     const template = readSkillTemplate(relativeTemplate);
     writeFileSync(outputPath, renderSkillMarkdown(commands, template), "utf8");
   }
@@ -5862,11 +6337,11 @@ function isCommandAvailable(name, runCommand) {
   return !result.error && result.status === 0;
 }
 function readSkillTemplate(relativePath = "skill.template.md") {
-  return readFileSync(path2.join(process.cwd(), "src", relativePath), "utf8");
+  return readFileSync(path3.join(process.cwd(), "src", relativePath), "utf8");
 }
 
 // src/version.ts
-var VERSION = "0.8.0";
+var VERSION = "0.9.0";
 
 // src/forum.ts
 function parseDiscussionReference(value) {
@@ -5957,7 +6432,7 @@ function resolveTopLevelUrl(baseUrlOrOptions, targetValue, resolveCourseIdForUrl
   if (parsed.host.toLowerCase() !== configuredHost) {
     throw new UsageError(`URL host '${parsed.host.toLowerCase()}' does not match configured Moodle site '${configuredHost}'.`);
   }
-  const path4 = parsed.pathname.replace(/\/$/, "");
+  const path5 = parsed.pathname.replace(/\/$/, "");
   const intParam = (key, label) => {
     const value = parsed.searchParams.get(key);
     if (!value || !/^\d+$/.test(value)) {
@@ -5965,45 +6440,45 @@ function resolveTopLevelUrl(baseUrlOrOptions, targetValue, resolveCourseIdForUrl
     }
     return value;
   };
-  if (path4.endsWith("/mod/forum/discuss.php")) {
+  if (path5.endsWith("/mod/forum/discuss.php")) {
     return objectMode ? { commandName: "forum_discussion", kwargs: { discussion: intParam("d", "discussion ID"), postId: parsed.hash, asJson: false, asYaml: false } } : { commandName: "forum:discussion", args: [intParam("d", "discussion ID"), parsed.hash] };
   }
-  if (path4.endsWith("/mod/forum/view.php")) {
+  if (path5.endsWith("/mod/forum/view.php")) {
     return objectMode ? { commandName: "forum_discussions", kwargs: { forum: intParam("id", "forum module ID"), asJson: false, asYaml: false } } : { commandName: "forum:discussions", args: [intParam("id", "forum module ID")] };
   }
-  if (path4.endsWith("/mod/assign/view.php")) {
+  if (path5.endsWith("/mod/assign/view.php")) {
     const id2 = intParam("id", "assignment module ID");
     return objectMode ? { commandName: "assign", kwargs: { assign: id2, asJson: false, asYaml: false } } : { commandName: "assign", args: [id2] };
   }
-  if (path4.endsWith("/mod/quiz/view.php")) {
+  if (path5.endsWith("/mod/quiz/view.php")) {
     const id2 = intParam("id", "quiz module ID");
     return objectMode ? { commandName: "quiz", kwargs: { quiz: id2, asJson: false, asYaml: false } } : { commandName: "quiz", args: [id2] };
   }
-  if (path4.endsWith("/mod/resource/view.php")) {
+  if (path5.endsWith("/mod/resource/view.php")) {
     const id2 = intParam("id", "resource module ID");
     return objectMode ? { commandName: "resource", kwargs: { resource: id2, asJson: false, asYaml: false } } : { commandName: "resource", args: [id2] };
   }
-  if (path4.endsWith("/mod/url/view.php")) {
+  if (path5.endsWith("/mod/url/view.php")) {
     const id2 = intParam("id", "link module ID");
     return objectMode ? { commandName: "link", kwargs: { link: id2, asJson: false, asYaml: false } } : { commandName: "link", args: [id2] };
   }
-  if (path4.endsWith("/mod/page/view.php")) {
+  if (path5.endsWith("/mod/page/view.php")) {
     const id2 = intParam("id", "page module ID");
     return objectMode ? { commandName: "page", kwargs: { page: id2, asJson: false, asYaml: false } } : { commandName: "page", args: [id2] };
   }
-  if (path4.endsWith("/mod/folder/view.php")) {
+  if (path5.endsWith("/mod/folder/view.php")) {
     const id2 = intParam("id", "folder module ID");
     return objectMode ? { commandName: "folder", kwargs: { folder: id2, asJson: false, asYaml: false } } : { commandName: "folder", args: [id2] };
   }
-  if (path4.endsWith("/course/view.php")) {
+  if (path5.endsWith("/course/view.php")) {
     const id2 = intParam("id", "course ID");
     return objectMode ? { commandName: "course", kwargs: { course: id2, asJson: false, asYaml: false } } : { commandName: "course", args: [id2] };
   }
-  if (path4.endsWith("/course/user.php") && parsed.searchParams.get("mode") === "grade" || path4.includes("/grade/report/")) {
+  if (path5.endsWith("/course/user.php") && parsed.searchParams.get("mode") === "grade" || path5.includes("/grade/report/")) {
     const id2 = intParam("id", "course ID");
     return objectMode ? { commandName: "grades", kwargs: { course: id2, asJson: false, asYaml: false } } : { commandName: "grades", args: [id2] };
   }
-  if (path4.includes("/mod/") && path4.endsWith("/view.php")) {
+  if (path5.includes("/mod/") && path5.endsWith("/view.php")) {
     if (!resolveCourseIdForUrl) {
       throw new UsageError("Could not resolve course ID from the activity page.");
     }
@@ -6021,10 +6496,10 @@ function resolveTopLevelUrl(baseUrlOrOptions, targetValue, resolveCourseIdForUrl
 
 // src/mcp/cli.ts
 import { createHash as createHash3 } from "crypto";
-import { readFile as readFile8 } from "fs/promises";
-import { homedir as homedir11 } from "os";
+import { readFile as readFile9 } from "fs/promises";
+import { homedir as homedir12 } from "os";
 import { join as join11 } from "path";
-import { createInterface as createInterface3 } from "readline/promises";
+import { createInterface } from "readline/promises";
 import { fileURLToPath } from "url";
 
 // src/mcp/protocol.ts
@@ -6076,7 +6551,7 @@ function parseJsonRpcRequest(input2) {
   return JsonRpcRequestSchema.parse(input2);
 }
 function resolveProtocolVersion(request, context = {}) {
-  const meta = isRecord6(request.params?._meta) ? request.params._meta : void 0;
+  const meta = isRecord7(request.params?._meta) ? request.params._meta : void 0;
   const initializeVersion = request.method === "initialize" && typeof request.params?.protocolVersion === "string" ? request.params.protocolVersion : void 0;
   const requested = context.protocolVersion ?? stringValue3(meta?.["io.modelcontextprotocol/protocolVersion"]) ?? initializeVersion ?? MODERN_PROTOCOL_VERSION;
   if (!isSupportedProtocolVersion(requested)) {
@@ -6085,7 +6560,7 @@ function resolveProtocolVersion(request, context = {}) {
   return requested;
 }
 function assertRequestMetadata(request, protocolVersion2, context = {}) {
-  const meta = isRecord6(request.params?._meta) ? request.params._meta : void 0;
+  const meta = isRecord7(request.params?._meta) ? request.params._meta : void 0;
   const metaVersion = stringValue3(meta?.["io.modelcontextprotocol/protocolVersion"]);
   if (protocolVersion2 === MODERN_PROTOCOL_VERSION) {
     const parsed = ModernClientMetadataSchema.safeParse(meta);
@@ -6116,7 +6591,7 @@ function jsonRpcSuccess(id2, result) {
 function jsonRpcFailure(id2, error) {
   return { jsonrpc: "2.0", id: id2, error };
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringValue3(value) {
@@ -6191,7 +6666,7 @@ async function bridgeRemoteMcp(options) {
       await writeRemoteError(options.output, request.id, response.status);
       return;
     }
-    if (request.method === "initialize" && isRecord7(payload) && "result" in payload) {
+    if (request.method === "initialize" && isRecord8(payload) && "result" in payload) {
       negotiatedProtocolVersion = responseProtocolVersion(payload) ?? initializedProtocolVersion(request) ?? negotiatedProtocolVersion;
     }
     await writeJson(options.output, payload);
@@ -6216,7 +6691,7 @@ function normalizeMcpEndpoint(value) {
   return url.toString();
 }
 function protocolVersion(request, negotiatedVersion) {
-  const meta = isRecord7(request.params?._meta) ? request.params?._meta : void 0;
+  const meta = isRecord8(request.params?._meta) ? request.params?._meta : void 0;
   const metadataVersion = meta?.["io.modelcontextprotocol/protocolVersion"];
   if (typeof metadataVersion === "string") return metadataVersion;
   return initializedProtocolVersion(request) ?? negotiatedVersion;
@@ -6226,7 +6701,7 @@ function initializedProtocolVersion(request) {
   return typeof initialized === "string" ? initialized : void 0;
 }
 function responseProtocolVersion(payload) {
-  const result = isRecord7(payload.result) ? payload.result : void 0;
+  const result = isRecord8(payload.result) ? payload.result : void 0;
   return typeof result?.protocolVersion === "string" ? result.protocolVersion : void 0;
 }
 async function writeSseMessages(output, body, id2) {
@@ -6260,10 +6735,10 @@ async function forwardProtocolNegotiationError(output, response, id2) {
   }
   try {
     const payload = await response.json();
-    if (!isRecord7(payload) || payload.jsonrpc !== "2.0" || payload.id !== id2 || !isRecord7(payload.error)) {
+    if (!isRecord8(payload) || payload.jsonrpc !== "2.0" || payload.id !== id2 || !isRecord8(payload.error)) {
       return false;
     }
-    const data = isRecord7(payload.error.data) ? payload.error.data : void 0;
+    const data = isRecord8(payload.error.data) ? payload.error.data : void 0;
     const supported = Array.isArray(data?.supported) ? data.supported.filter((version) => typeof version === "string") : [];
     if (payload.error.code !== -32022 || typeof data?.requested !== "string" || supported.length === 0) {
       return false;
@@ -6283,9 +6758,9 @@ async function writeJson(output, value) {
 `);
 }
 function isBridgeRequest(value) {
-  return isRecord7(value) && value.jsonrpc === "2.0" && typeof value.method === "string";
+  return isRecord8(value) && value.jsonrpc === "2.0" && typeof value.method === "string";
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -6557,13 +7032,13 @@ function resolveConnection(options) {
 }
 
 // src/mcp/connectors/node-connectors.ts
-import { chmod as chmod4, mkdir as mkdir6, readFile as readFile6, rm as rm5, stat as stat2, writeFile as writeFile6 } from "fs/promises";
-import { homedir as homedir8 } from "os";
+import { chmod as chmod4, mkdir as mkdir6, readFile as readFile7, rm as rm5, stat as stat3, writeFile as writeFile6 } from "fs/promises";
+import { homedir as homedir9 } from "os";
 import { dirname as dirname6, join as join8 } from "path";
 var NodeConnectorFileSystem = class {
-  async exists(path4) {
+  async exists(path5) {
     try {
-      await stat2(path4);
+      await stat3(path5);
       return true;
     } catch (error) {
       if (isMissing3(error)) {
@@ -6572,20 +7047,20 @@ var NodeConnectorFileSystem = class {
       throw error;
     }
   }
-  async readText(path4) {
-    return readFile6(path4, "utf8");
+  async readText(path5) {
+    return readFile7(path5, "utf8");
   }
-  async writePrivate(path4, content) {
-    await mkdir6(dirname6(path4), { recursive: true, mode: 448 });
-    await writeFile6(path4, content, { encoding: "utf8", mode: 384 });
-    await chmod4(path4, 384);
+  async writePrivate(path5, content) {
+    await mkdir6(dirname6(path5), { recursive: true, mode: 448 });
+    await writeFile6(path5, content, { encoding: "utf8", mode: 384 });
+    await chmod4(path5, 384);
   }
-  async remove(path4) {
-    await rm5(path4, { force: true });
+  async remove(path5) {
+    await rm5(path5, { force: true });
   }
 };
 function createDefaultClientConnectors(profile, options = {}) {
-  const home = options.homeDirectory ?? homedir8();
+  const home = options.homeDirectory ?? homedir9();
   const platform = options.platform ?? process.platform;
   const fileSystem = options.fileSystem ?? new NodeConnectorFileSystem();
   const runtime = runtimeCommand(options.command, options.commandArgs);
@@ -7370,10 +7845,10 @@ function asDeploymentError(error) {
 }
 
 // src/mcp/wrangler.ts
-import { createInterface as createInterface2 } from "readline/promises";
+import { createUi as createUi2 } from "@bunizao/cli-kit";
 import { mkdir as mkdir7 } from "fs/promises";
 import { existsSync } from "fs";
-import { homedir as homedir9 } from "os";
+import { homedir as homedir10 } from "os";
 import { join as join9 } from "path";
 async function resolveWrangler(runner, options = {}) {
   const env = options.env ?? process.env;
@@ -7385,7 +7860,7 @@ 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 = join9(options.homeDir ?? homedir9(), ".config", "moodle-cli", "tools", `wrangler@${WRANGLER_VERSION}`);
+  const root = join9(options.homeDir ?? homedir10(), ".config", "moodle-cli", "tools", `wrangler@${WRANGLER_VERSION}`);
   const script = join9(root, "node_modules", "wrangler", "bin", "wrangler.js");
   const bun = findExecutable("bun", env);
   const node = findExecutable("node", env);
@@ -7395,13 +7870,10 @@ async function resolveWrangler(runner, options = {}) {
     if (!bun && !npm) throw new Error("Install Bun or npm to download the pinned Cloudflare toolchain.");
     const yes = options.yes ?? (process.argv.includes("--yes") || process.argv.includes("-y"));
     if (!yes) {
-      if (!process.stdin.isTTY) throw new UsageError("Cloudflare management needs a first-use Wrangler download.", "Rerun with --yes to download and cache the pinned toolchain.");
-      const reader = createInterface2({ input: process.stdin, output: process.stderr });
-      try {
-        const answer = await reader.question(`Download Cloudflare Wrangler ${WRANGLER_VERSION} (cached for next time)? [Y/n] `);
-        if (answer.trim() && !/^y(?:es)?$/iu.test(answer.trim())) throw new UsageError("Wrangler download cancelled.", "Retry when ready to install Cloudflare's toolchain.");
-      } finally {
-        reader.close();
+      const ui = createUi2({ input: process.stdin, output: process.stderr });
+      if (!ui.interactive) throw new UsageError("Cloudflare management needs a first-use Wrangler download.", "Rerun with --yes to download and cache the pinned toolchain.");
+      if (!await ui.confirm(`Download Cloudflare Wrangler ${WRANGLER_VERSION} (cached for next time)?`, { initial: true })) {
+        throw new UsageError("Wrangler download cancelled.", "Retry when ready to install Cloudflare's toolchain.");
       }
     }
     notice(`Cloudflare management needs Wrangler ${WRANGLER_VERSION}; downloading once to ${root}.`);
@@ -7421,8 +7893,8 @@ function sameMajorAtLeast(actual, pinned) {
 import { isDeepStrictEqual } from "util";
 import { spawn as spawn2 } from "child_process";
 import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
-import { chmod as chmod5, mkdir as mkdir8, mkdtemp, readFile as readFile7, rm as rm6, writeFile as writeFile7 } from "fs/promises";
-import { homedir as homedir10, tmpdir } from "os";
+import { chmod as chmod5, mkdir as mkdir8, mkdtemp, readFile as readFile8, rm as rm6, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir11, tmpdir } from "os";
 import { basename, dirname as dirname7, join as join10 } from "path";
 var MODERN_MCP_VERSION = "2026-07-28";
 var WORKER_PROPAGATION_ATTEMPTS = 10;
@@ -7614,7 +8086,7 @@ ${error.stderr}`)) {
       const binding = (value, name) => {
         let result2 = null;
         visit(value, (_key, item) => {
-          if (isRecord8(item) && item.name === name && typeof item.text === "string") result2 = item.text;
+          if (isRecord9(item) && item.name === name && typeof item.text === "string") result2 = item.text;
         });
         return result2;
       };
@@ -7660,7 +8132,7 @@ ${error.stderr}`)) {
   }
 };
 async function copyReleaseBundle(source, destination) {
-  await writeFile7(destination, await readFile7(source));
+  await writeFile7(destination, await readFile8(source));
 }
 var NodeReleaseMaterializer = class {
   constructor(options) {
@@ -7782,10 +8254,10 @@ var FetchManagedWorkerClient = class {
       })
     }, isRetryableSessionUpload);
     const body = await safeJson(response);
-    if (response.ok && isRecord8(body) && typeof body.revision === "number") {
+    if (response.ok && isRecord9(body) && typeof body.revision === "number") {
       return { revision: body.revision };
     }
-    const code = isRecord8(body) && typeof body.code === "string" ? body.code : "SESSION_UPLOAD_FAILED";
+    const code = isRecord9(body) && typeof body.code === "string" ? body.code : "SESSION_UPLOAD_FAILED";
     throw new DeploymentApplyError(code, `The Worker rejected the Moodle session update (${code})`);
   }
   async getReadiness(input2) {
@@ -7793,7 +8265,7 @@ var FetchManagedWorkerClient = class {
       headers: { authorization: `Bearer ${input2.sessionSyncToken}` }
     }, isRetryableSessionUpload);
     const body = await safeJson(response);
-    if (isRecord8(body) && (body.status === "pass" || body.status === "warn" || body.status === "fail")) {
+    if (isRecord9(body) && (body.status === "pass" || body.status === "warn" || body.status === "fail")) {
       const session = firstHealthCheck(body, "moodle:session");
       const upstream = firstHealthCheck(body, "moodle:upstream");
       return {
@@ -7820,7 +8292,7 @@ var FetchManagedWorkerClient = class {
       isRetryableWorkerPropagation
     );
     const healthBody = await safeJson(health);
-    if (!health.ok || !isRecord8(healthBody) || healthBody.status !== "pass") {
+    if (!health.ok || !isRecord9(healthBody) || healthBody.status !== "pass") {
       throw new DeploymentApplyError("HEALTH_CHECK_FAILED", "Worker liveness check failed");
     }
     let readiness = await this.getReadiness(input2);
@@ -7851,11 +8323,11 @@ var FetchManagedWorkerClient = class {
     if (!Array.isArray(courses)) throw new DeploymentApplyError("MCP_SMOKE_FAILED", "MCP list_courses returned no course list");
     if (courses.length) {
       const first2 = courses[0];
-      if (!isRecord8(first2) || !Number.isSafeInteger(first2.id) || Number(first2.id) <= 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");
       }
       const detail = readableToolResult(await this.mcpCall(input2.endpoint, input2.mcpAccessToken, "tools/call", { name: "get_course", arguments: { courseId: first2.id } }, 5));
-      if (!isRecord8(detail.course) || !isRecord8(detail.course.course) || detail.course.course.id !== first2.id || !Array.isArray(detail.course.sections)) {
+      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");
       }
     }
@@ -7879,7 +8351,7 @@ var FetchManagedWorkerClient = class {
       headers: { authorization: `Bearer ${input2.sessionSyncToken}` }
     });
     const body = await safeJson(response);
-    if (!response.ok || !isRecord8(body) || typeof body.code !== "string" || typeof body.expiresAt !== "string") {
+    if (!response.ok || !isRecord9(body) || typeof body.code !== "string" || typeof body.expiresAt !== "string") {
       throw new DeploymentApplyError("PAIRING_UNAVAILABLE", "The Worker could not open a pairing window");
     }
     return {
@@ -7916,7 +8388,7 @@ var FetchManagedWorkerClient = class {
       })
     }, isRetryableSessionUpload);
     const body = await safeJson(response);
-    if (!response.ok || !isRecord8(body) || body.jsonrpc !== "2.0" || body.id !== id2 || "error" in body || !("result" in body)) {
+    if (!response.ok || !isRecord9(body) || body.jsonrpc !== "2.0" || body.id !== id2 || "error" in body || !("result" in body)) {
       throw new DeploymentApplyError("MCP_SMOKE_FAILED", `MCP ${method} check failed`);
     }
     if (method === "tools/call") readableToolResult(body.result);
@@ -7934,13 +8406,13 @@ var FetchManagedWorkerClient = class {
   }
 };
 var PrivateDeploymentReceiptStore = class {
-  constructor(baseDirectory = join10(homedir10(), ".config", "moodle-cli", "mcp", "deployments")) {
+  constructor(baseDirectory = join10(homedir11(), ".config", "moodle-cli", "mcp", "deployments")) {
     this.baseDirectory = baseDirectory;
   }
   baseDirectory;
   async read(profile) {
     try {
-      const parsed = JSON.parse(await readFile7(this.path(profile), "utf8"));
+      const parsed = JSON.parse(await readFile8(this.path(profile), "utf8"));
       return isReceipt(parsed) ? parsed : null;
     } catch (error) {
       if (isMissing4(error)) {
@@ -7950,11 +8422,11 @@ var PrivateDeploymentReceiptStore = class {
     }
   }
   async write(receipt) {
-    const path4 = this.path(receipt.profile);
-    await mkdir8(dirname7(path4), { recursive: true, mode: 448 });
-    await writeFile7(path4, `${JSON.stringify(receipt, null, 2)}
+    const path5 = this.path(receipt.profile);
+    await mkdir8(dirname7(path5), { recursive: true, mode: 448 });
+    await writeFile7(path5, `${JSON.stringify(receipt, null, 2)}
 `, { mode: 384 });
-    await chmod5(path4, 384);
+    await chmod5(path5, 384);
   }
   async delete(profile) {
     await rm6(this.path(profile), { force: true });
@@ -7967,7 +8439,7 @@ var PrivateDeploymentReceiptStore = class {
   }
 };
 function createDefaultManagedDeployment(options) {
-  const homeDirectory = options.homeDirectory ?? homedir10();
+  const homeDirectory = options.homeDirectory ?? homedir11();
   const platform = options.platform ?? process.platform;
   const runtime = runtimeCommand(options.executable, options.executableArgs);
   const defaults = {
@@ -8005,17 +8477,17 @@ function digest(value) {
 function ownershipId(accountId, workerName) {
   return `moodle-cli:${accountId}:${workerName}`;
 }
-function endpointUrl(endpoint, path4) {
-  return `${endpoint.replace(/\/$/u, "")}${path4}`;
+function endpointUrl(endpoint, path5) {
+  return `${endpoint.replace(/\/$/u, "")}${path5}`;
 }
 async function pinExpectedHosts(configPath, workerName, productionEndpoint) {
   let config;
   try {
-    config = JSON.parse(await readFile7(configPath, "utf8"));
+    config = JSON.parse(await readFile8(configPath, "utf8"));
   } catch {
     throw new DeploymentApplyError("RELEASE_CONFIG_INVALID", "The generated Wrangler configuration is invalid");
   }
-  if (!isRecord8(config) || !isRecord8(config.vars)) {
+  if (!isRecord9(config) || !isRecord9(config.vars)) {
     throw new DeploymentApplyError("RELEASE_CONFIG_INVALID", "The generated Wrangler configuration is invalid");
   }
   const hosts = endpointHosts(workerName, productionEndpoint);
@@ -8055,18 +8527,18 @@ async function safeJson(response) {
 }
 function firstHealthCheck(body, name) {
   const checks = body.checks;
-  if (!isRecord8(checks) || !Array.isArray(checks[name])) {
+  if (!isRecord9(checks) || !Array.isArray(checks[name])) {
     return null;
   }
   const check = checks[name][0];
-  return isRecord8(check) ? check : null;
+  return isRecord9(check) ? check : null;
 }
 function readableToolResult(result) {
-  if (isRecord8(result) && result.isError !== true && Array.isArray(result.content)) {
+  if (isRecord9(result) && result.isError !== true && Array.isArray(result.content)) {
     try {
-      const text2 = result.content.filter((block) => isRecord8(block) && block.type === "text").map((block) => block.text).join("\n");
+      const text2 = result.content.filter((block) => isRecord9(block) && block.type === "text").map((block) => block.text).join("\n");
       const parsed = JSON.parse(text2);
-      if (isRecord8(parsed) && isDeepStrictEqual(parsed, result.structuredContent)) return parsed;
+      if (isRecord9(parsed) && isDeepStrictEqual(parsed, result.structuredContent)) return parsed;
     } catch {
     }
   }
@@ -8074,7 +8546,7 @@ function readableToolResult(result) {
 }
 function mcpUserFullname(result) {
   const user = readableToolResult(result).user;
-  return isRecord8(user) && typeof user.fullname === "string" && user.fullname.trim() ? user.fullname.trim() : null;
+  return isRecord9(user) && typeof user.fullname === "string" && user.fullname.trim() ? user.fullname.trim() : null;
 }
 function parseJsonOutput(output) {
   const candidates = [output.indexOf("{"), output.indexOf("[")].filter((index) => index >= 0).sort((a, b) => a - b);
@@ -8090,7 +8562,7 @@ function parseJsonOutput(output) {
 function deploymentHistory(value) {
   const entries = [];
   visit(value, (_key, item) => {
-    if (!isRecord8(item) || !Array.isArray(item.versions)) {
+    if (!isRecord9(item) || !Array.isArray(item.versions)) {
       return;
     }
     const versionId = activeVersionId(item.versions);
@@ -8098,7 +8570,7 @@ function deploymentHistory(value) {
       return;
     }
     const createdOn = typeof item.created_on === "string" ? Date.parse(item.created_on) : Number.NaN;
-    const message = isRecord8(item.annotations) ? item.annotations["workers/message"] : void 0;
+    const message = isRecord9(item.annotations) ? item.annotations["workers/message"] : void 0;
     entries.push({
       versionId,
       message: typeof message === "string" ? message : null,
@@ -8109,7 +8581,7 @@ function deploymentHistory(value) {
   return entries.sort((a, b) => b.createdOn - a.createdOn || b.index - a.index).map(({ versionId, message }) => ({ versionId, message }));
 }
 function activeVersionId(versions) {
-  const records = versions.filter(isRecord8);
+  const records = versions.filter(isRecord9);
   const active = records.find((version) => version.percentage === 100) ?? records[0];
   const id2 = active?.version_id ?? active?.versionId;
   return typeof id2 === "string" ? id2 : null;
@@ -8120,7 +8592,7 @@ function releaseDigestFromMessage(message) {
 function collectAccountObjects(value) {
   const accounts = [];
   visit(value, (_key, item) => {
-    if (!isRecord8(item)) {
+    if (!isRecord9(item)) {
       return;
     }
     const id2 = typeof item.id === "string" ? item.id : typeof item.account_id === "string" ? item.account_id : null;
@@ -8149,14 +8621,14 @@ function visit(value, visitor, key = "") {
     for (const item of value) {
       visit(item, visitor);
     }
-  } else if (isRecord8(value)) {
+  } else if (isRecord9(value)) {
     for (const [childKey, item] of Object.entries(value)) {
       visit(item, visitor, childKey);
     }
   }
 }
 function isReceipt(value) {
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     return false;
   }
   return [
@@ -8170,7 +8642,7 @@ function isReceipt(value) {
     "releaseDigest"
   ].every((key) => typeof value[key] === "string") && typeof value.sessionRevision === "number";
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isMissing4(error) {
@@ -8234,13 +8706,23 @@ var READ_ONLY_ANNOTATIONS = {
   idempotentHint: true,
   openWorldHint: true
 };
+var WRITE_ANNOTATIONS = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: false,
+  openWorldHint: true
+};
+var WRITE_TOOLS = /* @__PURE__ */ new Set(["submit"]);
 var aliases = { get_overview: "home", list_courses: "units", get_course: "unit", get_activity: "item", get_grades: "grades", get_thread: "thread", get_file: "file" };
 var TOOL_CATALOG = Object.entries(intentContracts).map(([name, contract]) => ({
   name,
   description: intentDescription(name),
   inputSchema: compactSchema(z4.toJSONSchema(contract.input, { io: "input" })),
-  annotations: READ_ONLY_ANNOTATIONS
+  annotations: WRITE_TOOLS.has(name) ? WRITE_ANNOTATIONS : READ_ONLY_ANNOTATIONS
 }));
+function toolsFor(gateway) {
+  return gateway.submitAssignment ? TOOL_CATALOG : TOOL_CATALOG.filter((tool) => !WRITE_TOOLS.has(tool.name));
+}
 var TOOL_OUTPUT_SCHEMAS = Object.fromEntries(Object.entries(intentContracts).map(([name, contract]) => [name, compactSchema(z4.toJSONSchema(contract.output))]));
 function compactSchema(value) {
   if (Array.isArray(value)) return value.map(compactSchema);
@@ -8278,7 +8760,7 @@ function createMoodleMcpServer(gateway, options = {}) {
             protocolVersion: protocolVersion2,
             capabilities: { tools: { listChanged: false } },
             serverInfo,
-            instructions: "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."
           });
         }
         if (request.method === "ping") {
@@ -8286,7 +8768,7 @@ function createMoodleMcpServer(gateway, options = {}) {
         }
         if (request.method === "tools/list") {
           return jsonRpcSuccess(id2, {
-            tools: TOOL_CATALOG,
+            tools: toolsFor(gateway),
             resultType: "complete",
             _meta: RESULT_META
           });
@@ -8342,8 +8824,9 @@ async function callTool(gateway, params) {
   const requested = typeof params?.name === "string" ? params.name : "";
   const name = Object.hasOwn(aliases, requested) ? aliases[requested] : requested;
   if (!Object.hasOwn(intentContracts, name) && !["get_user", "list_activities", "list_forums"].includes(name)) throw new McpCallError("TOOL_NOT_FOUND", `Unknown Moodle tool: ${requested || "<missing>"}`);
+  if (WRITE_TOOLS.has(name) && !gateway.submitAssignment) throw new McpCallError("TOOL_NOT_FOUND", `${requested} is only available on a local MCP server with access to the files.`);
   const raw = params?.arguments ?? {};
-  if (!isRecord9(raw)) throw new McpCallError("INVALID_TOOL_ARGUMENTS", "Tool arguments must be an object.");
+  if (!isRecord10(raw)) throw new McpCallError("INVALID_TOOL_ARGUMENTS", "Tool arguments must be an object.");
   const args = { ...raw };
   if (Object.hasOwn(aliases, requested)) {
     const renames = { courseId: "unit", activityId: "ref", discussionId: "discussion_id", source: "ref", todoDays: "days", gradedOnly: "graded_only" };
@@ -8391,7 +8874,7 @@ async function callTool(gateway, params) {
       const mapped2 = { type: "MOODLE_RESULT_INVALID", message: `Moodle returned ${name} data in an unexpected shape.`, hint: "Retry once; if it persists, run the same command locally with --verbose and report the tool name.", issues: error.issues.slice(0, 5).map((issue) => ({ path: issue.path.join("."), message: issue.message })) };
       return { content: [{ type: "text", text: JSON.stringify({ error: mapped2 }) }], structuredContent: { error: mapped2 }, isError: true, resultType: "complete", _meta: RESULT_META };
     }
-    const mapped = error instanceof ReferenceError ? { type: error.code, code: error.code, message: error.message, hint: error.hint, candidates: error.candidates } : mapMoodleError(error);
+    const mapped = error instanceof ReferenceError ? { type: error.code, code: error.code, message: error.message, hint: error.hint, candidates: error.candidates } : mapMoodleError(error, WRITE_TOOLS.has(name));
     return { content: [{ type: "text", text: JSON.stringify({ error: mapped }) }], structuredContent: { error: mapped }, isError: true, resultType: "complete", _meta: RESULT_META };
   }
 }
@@ -8410,9 +8893,11 @@ function toolContent(name, payload, structuredContent) {
     }
   ];
 }
-function mapMoodleError(error) {
-  const record2 = isRecord9(error) ? error : {};
-  const code = typeof record2.code === "string" ? record2.code : "";
+function mapMoodleError(error, verbatim = false) {
+  const record3 = isRecord10(error) ? error : {};
+  const code = typeof record3.code === "string" ? record3.code : "";
+  const own = verbatim && typeof record3.message === "string" && record3.message.trim() && code !== "auth" ? record3.message : void 0;
+  const ownHint = verbatim && typeof record3.hint === "string" && record3.hint.trim() ? record3.hint : void 0;
   const typeByCode = {
     auth: "MOODLE_AUTH_REQUIRED",
     not_found: "MOODLE_NOT_FOUND",
@@ -8421,8 +8906,8 @@ function mapMoodleError(error) {
   };
   const type = code.startsWith("MOODLE_") ? code : typeByCode[code] ?? "MOODLE_UPSTREAM_ERROR";
   const message = type === "MOODLE_AUTH_REQUIRED" ? "The Moodle session has expired. Sign in again." : type === "MOODLE_NOT_FOUND" || type === "MOODLE_COURSE_NOT_FOUND" ? "The requested Moodle item was not found." : type === "MOODLE_INVALID_REQUEST" ? "The Moodle request is invalid." : "Moodle could not complete the request.";
-  const moodleCode = typeof record2.moodleErrorCode === "string" && /^[a-z][a-z0-9_]{0,63}$/u.test(record2.moodleErrorCode) ? record2.moodleErrorCode : void 0;
-  return { type, message, hint: type === "MOODLE_AUTH_REQUIRED" ? "Run moodle mcp login for a remote server, or moodle auth login locally; then retry." : "Run moodle doctor, or refine the request using units and find.", ...type === "MOODLE_AUTH_REQUIRED" ? { recovery: { action: "moodle mcp login", where: "machine running moodle-cli", then: "retry this tool" } } : {}, ...moodleCode ? { moodleCode } : {} };
+  const moodleCode = typeof record3.moodleErrorCode === "string" && /^[a-z][a-z0-9_]{0,63}$/u.test(record3.moodleErrorCode) ? record3.moodleErrorCode : void 0;
+  return { type, message: own ?? message, hint: ownHint ?? (type === "MOODLE_AUTH_REQUIRED" ? "Run moodle mcp login for a remote server, or moodle auth login locally; then retry." : "Run moodle doctor, or refine the request using units and find."), ...type === "MOODLE_AUTH_REQUIRED" ? { recovery: { action: "moodle mcp login", where: "machine running moodle-cli", then: "retry this tool" } } : {}, ...moodleCode ? { moodleCode } : {} };
 }
 var McpCallError = class extends Error {
   type;
@@ -8434,11 +8919,11 @@ var McpCallError = class extends Error {
     this.details = details;
   }
 };
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isMoodleFile(value) {
-  return isRecord9(value) && typeof value.name === "string" && typeof value.mimeType === "string" && typeof value.bytes === "number" && typeof value.uri === "string" && typeof value.blob === "string";
+  return isRecord10(value) && typeof value.name === "string" && typeof value.mimeType === "string" && typeof value.bytes === "number" && typeof value.uri === "string" && typeof value.blob === "string";
 }
 
 // src/mcp/stdio.ts
@@ -8494,12 +8979,12 @@ async function writeResponse2(output, response) {
 `);
 }
 function initializeProtocolVersion(input2) {
-  if (!isRecord10(input2) || input2.method !== "initialize" || !isRecord10(input2.params)) {
+  if (!isRecord11(input2) || input2.method !== "initialize" || !isRecord11(input2.params)) {
     return void 0;
   }
   return typeof input2.params.protocolVersion === "string" ? input2.params.protocolVersion : void 0;
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -8520,7 +9005,7 @@ function deriveMcpWorkerName(moodleOrigin) {
 var DefaultMcpCommandService = class {
   constructor(options) {
     this.options = options;
-    this.homeDirectory = options.homeDir ?? homedir11();
+    this.homeDirectory = options.homeDir ?? homedir12();
     this.wranglerInstance = options.wrangler;
     this.receipts = options.receipts ?? new PrivateDeploymentReceiptStore(join11(this.homeDirectory, ".config", "moodle-cli", "mcp", "deployments"));
     this.credentials = options.credentials ?? createDefaultCredentialStore({ platform: process.platform, homeDirectory: this.homeDirectory });
@@ -9077,7 +9562,7 @@ Selection: `)).trim());
     if (this.options.prompt) return this.options.prompt(question);
     const input2 = this.options.stdin ?? process.stdin;
     const output = this.options.stderr ?? process.stderr;
-    const readline = createInterface3({ input: input2, output });
+    const readline = createInterface({ input: input2, output });
     return readline.question(question).finally(() => readline.close());
   }
   workerBundlePath() {
@@ -9088,7 +9573,7 @@ Selection: `)).trim());
     return this.wranglerInstance;
   }
   releaseDigest() {
-    return readFile8(this.workerBundlePath()).then((content) => sha256(content));
+    return readFile9(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
@@ -9233,12 +9718,12 @@ function sha256(value) {
 // src/cli.ts
 var NOUNS = [
   { name: "units", aliases: ["courses"], verbs: ["list", "show"], defaultByArity: { 0: "list", 1: "show" } },
-  { name: "activities", verbs: ["list", "show"], defaultByArity: { 1: "list" }, valueFlags: ["--limit", "--section"] },
+  { name: "activities", verbs: ["list", "show"], defaultByArity: { 0: "list", 1: "list" }, valueFlags: ["--limit", "--section"] },
   { name: "grades", verbs: ["list"], defaultByArity: { 0: "list", 1: "list" } },
   {
     name: "forums",
     verbs: ["list", "show", "search"],
-    defaultByArity: { 1: "list" },
+    defaultByArity: { 0: "list", 1: "list" },
     valueFlags: ["--limit", "--course", "--forum", "--limit-forums", "--limit-discussions", "--unit"]
   },
   { name: "threads", verbs: ["show"], defaultByArity: { 1: "show" }, valueFlags: ["--post", "--limit", "--offset"] }
@@ -9246,7 +9731,8 @@ var NOUNS = [
 function buildProgram(io = {}) {
   const stdout = io.stdout ?? process.stdout;
   const stderr = io.stderr ?? process.stderr;
-  const program = createProgram({ name: "moodle", version: VERSION, description: "Terminal-first CLI for Moodle LMS." });
+  const program = createProgram({ name: "moodle", version: VERSION, description: MOODLE_TAGLINE });
+  banner(program, MOODLE_WORDMARK);
   program.configureOutput({
     writeOut: (text2) => stdout.write(text2),
     writeErr: (text2) => stderr.write(text2),
@@ -9271,9 +9757,11 @@ function buildProgram(io = {}) {
     width: stdout.columns || void 0,
     color: !process.env.NO_COLOR && program.opts().color !== false && outputFormat({ ...program.opts(), ...options }, stdout) === "table"
   });
+  configureTerminalTables({ color: () => colorEnabled2(stdout, io.env) && program.opts().color !== false });
   const count = (key, local, fallback) => program.opts()[key] ?? local ?? fallback;
   const runtime = {
     client: null,
+    busy: false,
     screen,
     count,
     baseUrl: async () => (await loadConfig({ env: io.env, cwd: io.cwd, homeDir: io.homeDir, stdin: io.stdin, stderr, fetch: io.fetchImpl })).baseUrl,
@@ -9283,11 +9771,11 @@ function buildProgram(io = {}) {
         let inflight = 0;
         let displayed = false;
         let timer;
-        runtime.client = await createMoodleClient(baseUrl, {
+        const connect = () => createMoodleClient(baseUrl, {
           env: io.env,
           fetchImpl: async (input2, init) => {
             const started2 = Date.now();
-            const tty = Boolean("isTTY" in stderr && stderr.isTTY) && !program.opts().json && !io.rootArgs?.includes("--json");
+            const tty = Boolean("isTTY" in stderr && stderr.isTTY) && !program.opts().json && !io.rootArgs?.includes("--json") && !runtime.busy;
             if (tty && inflight++ === 0) timer = setTimeout(() => {
               displayed = true;
               stderr.write("Loading Moodle\u2026");
@@ -9313,14 +9801,21 @@ function buildProgram(io = {}) {
           homeDir: io.homeDir,
           noCache: Boolean(program.opts().cache === false)
         });
+        try {
+          runtime.client = await connect();
+        } catch (error) {
+          if (!(error instanceof AuthError) || !human()) throw error;
+          await signIn(baseUrl);
+          runtime.client = await connect();
+        }
       }
       return runtime.client;
     },
     output: async (data, formatter, options) => {
       const merged = { ...program.opts(), ...options };
       const format = outputFormat(merged, stdout);
-      const human = format === "table" ? formatter() : "";
-      const text2 = format === "table" ? `${human}${human.includes("Try  ") ? "" : "\n\nTry  moodle due \xB7 moodle units \xB7 moodle --help"}
+      const human2 = format === "table" ? formatter() : "";
+      const text2 = format === "table" ? `${human2}${human2.includes("Try  ") ? "" : "\n\nTry  moodle due \xB7 moodle units \xB7 moodle --help"}
 ` : format === "json" ? `${JSON.stringify(JSON.parse(render(data, { format, fields: parseFields(data, merged.fields) })), null, merged.pretty ? 2 : void 0)}
 ` : render(data, { format, fields: parseFields(data, merged.fields) });
       if (io.stdout && !merged.output) {
@@ -9348,23 +9843,40 @@ function buildProgram(io = {}) {
     const result = await runner.run(name, args);
     await runtime.output(result, () => screen(result, options), options);
   };
+  const human = () => detectAudience({
+    stdin: io.stdin ?? process.stdin,
+    stdout: { isTTY: Boolean(stdout && "isTTY" in stdout && stdout.isTTY) },
+    env: io.env ?? process.env,
+    format: outputFormat(program.opts(), stdout)
+  }) === "human";
+  const theme = () => createTheme3(colorEnabled2(stderr, io.env) && program.opts().color !== false);
+  const signIn = async (baseUrl) => {
+    const ui = createUi3({ input: io.stdin ?? process.stdin, output: stderr, interactive: true });
+    showWordmark(ui);
+    ui.note(`No Moodle session for ${baseUrl}.
+Sign in once in your browser; later commands reuse that session.`, "One-time setup");
+    if (!await ui.confirm("Open the browser to sign in?", { initial: true })) {
+      throw new AuthError(`No usable MoodleSession found for ${baseUrl}.`, "Run moodle auth login when you are ready.");
+    }
+    const spin = ui.spinner();
+    spin.start("Opening the browser");
+    try {
+      const session = await getAuthenticatedSessionWithBrowserFallback(baseUrl, { env: io.env, fetch: io.fetchImpl, homeDir: io.homeDir, onBrowserOpened: (url) => spin.message(`Finish signing in at ${url}`) });
+      spin.stop(`Signed in as userid ${session.userid}`);
+    } catch (error) {
+      spin.error("Sign-in did not complete");
+      throw error;
+    }
+  };
   const choose = async (action, retry) => {
     try {
       return await action();
     } catch (error) {
-      if (!(error instanceof ReferenceError) || error.code !== "ambiguous" || !(io.stdin?.isTTY ?? process.stdin.isTTY) || outputFormat(program.opts(), stdout) !== "table") throw error;
-      stderr.write(`${error.message}
-${error.candidates.map((c, i) => `  ${i + 1}  ${c.name}`).join("\n")}
-`);
-      const reader = createInterface4({ input: io.stdin ?? process.stdin, output: stderr });
-      try {
-        const answer = await reader.question(`Pick [1-${error.candidates.length}]: `);
-        const chosen = error.candidates[Number(answer) - 1];
-        if (!chosen) throw error;
-        return await retry(chosen.id);
-      } finally {
-        reader.close();
-      }
+      if (!(error instanceof ReferenceError) || error.code !== "ambiguous" || !human()) throw error;
+      const ui = createUi3({ input: io.stdin ?? process.stdin, output: stderr, interactive: true });
+      const hint = (c) => c.code ?? c.type;
+      const chosen = await ui.select(error.message, error.candidates.map((c) => ({ value: c.id, label: c.name, ...hint(c) ? { hint: hint(c) } : {} })));
+      return await retry(chosen);
     }
   };
   program.action(async (targets, options) => {
@@ -9429,15 +9941,42 @@ ${error.candidates.map((c, i) => `  ${i + 1}  ${c.name}`).join("\n")}
     if (name === "due") command.option("--days <number>", "Deadline window in days.", parsePositiveInt);
     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>").argument("[unit]")).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("get").description("Download a resource by id, URL, or UNIT TASK phrase.").argument("<ref>")).option("--to <directory>", "Destination directory.").option("--force", "Replace an existing file atomically.").action(async (ref2, 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("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));
     const source = await choose(() => service.fileSource(ref2), (id2) => Promise.resolve(id2));
-    const receipt = await downloadMoodleFile(client, { source: String(source), directory: options.to ? path3.resolve(io.cwd ?? process.cwd(), options.to) : void 0, force: options.force });
+    const receipt = await downloadMoodleFile(client, { source: String(source), directory: options.to ? path4.resolve(io.cwd ?? process.cwd(), options.to) : void 0, force: options.force });
     await runtime.output(receipt, () => formatDownloadReceipt(receipt), options);
   });
-  addOutputOptions(program.command("open").description("Open a unit or activity reference in the browser.").argument("<ref>")).action(async (ref2, options) => {
+  addOutputOptions(mutating(program.command("submit").description(humanDescription("submit")).summary("Upload files into an assignment").argument("<ref>", "Assignment id, URL, or UNIT TASK phrase").argument("[files...]", "Local files to upload"))).option("--final", "Also submit for grading. Moodle does not allow undoing this.").option("--replace", "Remove the files already in the submission first.").option("--accept-statement", "Agree to the site's submission statement when it requires one.").action(async (ref2, files, options) => {
+    const interactive = human();
+    if (!program.opts().dryRun && !program.opts().yes && !interactive) throw new UsageError("Mutation requires --yes when stdin is not interactive.", "Run with --dry-run to see the plan first.");
+    const client = await runtime.getClient();
+    const service = createIntentService(createMoodleGateway(client));
+    const args = { files: files.map((file2) => resolveSubmissionPath(file2, io.cwd ?? process.cwd())), final: Boolean(options.final), replace: Boolean(options.replace), accept_statement: Boolean(options.acceptStatement) };
+    const plan = await choose(() => service.run("submit", { ref: ref2, ...args, dry_run: true }), (id2) => service.run("submit", { ref: id2, ...args, dry_run: true }));
+    const planned = plan.submission;
+    if (program.opts().dryRun) return runtime.output(plan, () => formatSubmissionReceipt(planned), options);
+    if (!await confirm({ summary: submissionSummary(planned, args.final, theme()) }, { yes: Boolean(program.opts().yes), dryRun: false, interactive })) return;
+    const spin = interactive ? createUi3({ input: io.stdin ?? process.stdin, output: stderr, interactive: true }).spinner() : void 0;
+    runtime.busy = true;
+    spin?.start("Preparing the upload");
+    let result;
+    try {
+      const live = createIntentService(createMoodleGateway(client, { onSubmitProgress: (message) => spin?.message(message) }));
+      result = await live.run("submit", { ref: planned.id, ...args, dry_run: false });
+      const receipt = result.submission;
+      spin?.stop(receipt.uploads.length ? `Uploaded ${receipt.uploads.map((file2) => file2.name).join(", ")} to ${receipt.name}` : `Submitted ${receipt.name}`);
+    } catch (error) {
+      spin?.error("The upload did not complete");
+      throw error;
+    } finally {
+      runtime.busy = false;
+    }
+    await runtime.output(result, () => formatSubmissionReceipt(result.submission), 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;
     if (looksLikeUrl(ref2)) {
@@ -9495,7 +10034,7 @@ ${error.candidates.map((c, i) => `  ${i + 1}  ${c.name}`).join("\n")}
     const result = stripEmpty({ activities: rows.slice(0, count("limit", options.limit)), total: rows.length });
     await runtime.output(result, () => runtime.screen(result, options), options);
   });
-  addOutputOptions(activities.command("show").description("Show activity details; resource and folder files can be passed to moodle get or download.").argument("<id>", "Course-module ID")).action(
+  addOutputOptions(activities.command("show").description("Show activity details; resource and folder files can be passed to moodle get or download.").summary("Show activity details").argument("<id>", "Course-module ID")).action(
     async (id2, options) => {
       await execute("item", { ref: parsePositiveInt(id2) }, options);
     }
@@ -9503,7 +10042,7 @@ ${error.candidates.map((c, i) => `  ${i + 1}  ${c.name}`).join("\n")}
   addOutputOptions(
     program.command("download").alias("dl").description("Download one authenticated Moodle file.").argument("<source>", "Course-module ID or authenticated Moodle file URL").option("--dest <path>", "Exact downloaded file path").option("--force", "Atomically replace an existing destination")
   ).action(async (source, options) => {
-    const destination = options.dest ? path3.resolve(io.cwd ?? process.cwd(), options.dest) : void 0;
+    const destination = options.dest ? path4.resolve(io.cwd ?? process.cwd(), options.dest) : void 0;
     const receipt = await downloadMoodleFile(await runtime.getClient(), {
       source,
       destination,
@@ -9548,12 +10087,12 @@ ${error.candidates.map((c, i) => `  ${i + 1}  ${c.name}`).join("\n")}
     await runtime.output(stripEmpty({ forums: forums2.map((f) => ({ id: f.id, name: f.name, unit_id: f.course_id })), total }), () => formatForumActivities(forums2), options);
   });
   addForumSearchCommand(forums.command("search").description("Search forum discussion titles and post text."), runtime, 20);
-  addOutputOptions(program.command("doctor").description("Diagnose runtime, browser access, session, background jobs and MCP setup.")).action(async (options) => {
+  addOutputOptions(program.command("doctor").description("Diagnose runtime, browser access, session, background jobs and MCP setup.").summary("Diagnose runtime, session and MCP setup")).action(async (options) => {
     const result = await doctor(io);
     await runtime.output(result, () => result.checks.map((c) => `${c.status.toUpperCase()} ${c.name}: ${c.detail}${c.hint ? `
   ${c.hint}` : ""}`).join("\n") + "\n\nTry  moodle auth login \xB7 moodle mcp status", options);
   });
-  program.command("completion").description("Print shell completion for zsh, bash or fish.").argument("<shell>").action((shell) => {
+  program.command("completion").description("Print shell completion for zsh, bash or fish.").addArgument(program.createArgument("<shell>", "Shell to target").choices(["zsh", "bash", "fish"])).action((shell) => {
     const names = program.commands.filter((c) => c.name() !== "help").flatMap((c) => [c.name(), ...c.aliases()]);
     if (shell === "bash") stdout.write(`complete -W '${names.join(" ")}' moodle
 `);
@@ -9563,22 +10102,22 @@ _arguments '1:command:(${names.join(" ")})' '*:reference:'
     else if (shell === "fish") stdout.write(names.map((n2) => `complete -c moodle -f -a '${n2}'`).join("\n") + "\n");
     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."))).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 ?? homedir12();
+  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 ?? homedir13();
     const jobs = await ownedJobs(home);
-    const receipts = await readdir3(path3.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: path3.join(home, CONFIG_DIR_NAME), cache: path3.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." };
+    const receipts = await readdir3(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." };
     if (program.opts().dryRun) return runtime.output(result, () => JSON.stringify(result, null, 2), options);
     if (options.purge && receipts.length && !options.remote) throw new UsageError("Managed deployment receipts exist; remove the Worker before purging its recovery information.", "Run moodle mcp remove for each configured site, then moodle uninstall --purge.");
     if (options.purge && receipts.length > 1) throw new UsageError("Multiple managed deployment receipts exist; remove each Worker before purging configuration.");
-    if (!await confirm({ summary: `Remove Moodle background jobs${options.remote ? ", the configured Worker" : ""}${options.purge ? ", configuration and cache" : ""}.` }, { yes: Boolean(program.opts().yes), dryRun: false, interactive: Boolean(io.stdin?.isTTY ?? process.stdin.isTTY) })) return;
+    if (!await confirm({ summary: `Remove Moodle background jobs${options.remote ? ", the configured Worker" : ""}${options.purge ? ", configuration and cache" : ""}.` }, { yes: Boolean(program.opts().yes), dryRun: false, interactive: human() })) return;
     if (options.remote) await getMcpService().remove({ yes: true });
     if (process.platform === "darwin") await uninstallKeepalive({ homeDir: home });
     const renewal2 = new DefaultRenewalIntegration({ homeDirectory: home, executable: process.execPath });
     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(path3.join(home, "Library", "Logs", `com.moodle-cli.mcp-renewal.${profile}.log`), { force: true });
+      if (options.purge) await rm7(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 });
@@ -9617,7 +10156,7 @@ ${url}
     }
   );
   const keepalive = addOutputOptions(
-    auth.command("keepalive").description("Renew the Moodle session once; used by the background keepalive agent.").option("--no-renew", "Only touch the session; skip re-login when it is expired.")
+    auth.command("keepalive").description("Renew the Moodle session once; used by the background keepalive agent.").summary("Renew the session once").option("--no-renew", "Only touch the session; skip re-login when it is expired.")
   ).action(async (options) => {
     const baseUrl = await runtime.baseUrl();
     const result = await keepAliveOnce(baseUrl, { homeDir: io.homeDir, fetchImpl: io.fetchImpl, renewOnExpiry: options.renew });
@@ -9629,7 +10168,7 @@ ${url}
     const globals = program.opts();
     if (!await confirm(
       { summary: `Install the Moodle session keepalive agent${options.interval ? ` with a ${options.interval}-minute interval` : ""}.` },
-      { yes: Boolean(globals.yes), dryRun: Boolean(globals.dryRun), interactive: Boolean(io.stdin?.isTTY ?? process.stdin.isTTY) }
+      { yes: Boolean(globals.yes), dryRun: Boolean(globals.dryRun), interactive: human() }
     )) return;
     const baseUrl = await runtime.baseUrl();
     await getAuthenticatedSessionWithBrowserFallback(baseUrl, { env: io.env, homeDir: io.homeDir, fetch: io.fetchImpl, noCache: true, nonInteractive: true });
@@ -9643,7 +10182,7 @@ Log: ${result.log_path}`, options);
       const globals = program.opts();
       if (!await confirm(
         { summary: "Remove the Moodle session keepalive agent." },
-        { yes: Boolean(globals.yes), dryRun: Boolean(globals.dryRun), interactive: Boolean(io.stdin?.isTTY ?? process.stdin.isTTY) }
+        { yes: Boolean(globals.yes), dryRun: Boolean(globals.dryRun), interactive: human() }
       )) return;
       const result = await uninstallKeepalive({ homeDir: io.homeDir });
       await runtime.output(result, () => `Keepalive removed (${result.plist_path})`, options);
@@ -9655,7 +10194,7 @@ Log: ${result.log_path}`, options);
       await runtime.output(result, () => result.installed ? `Keepalive installed (${result.plist_path})` : "Keepalive not installed", options);
     }
   );
-  const mcp = program.command("mcp").description("Deploy a private MCP Worker on Cloudflare; encrypted session storage and local renewal. Free-tier limits apply.");
+  const mcp = program.command("mcp").description("Deploy a private MCP Worker on Cloudflare; encrypted session storage and local renewal. Free-tier limits apply.").summary("Private MCP server on Cloudflare");
   addOutputOptions(mutating(mcp.command("deploy").description("Deploy or update the managed Moodle MCP server."))).option("--dry-run", "Preview deployment changes without applying them.").option("--repair", "Repair authentication and managed deployment state.").option("--rotate-key", "Rotate the session encryption key and migrate the active session.").option("--rotate-token", "Rotate the MCP access token with an overlap window.").option("--rollback", "Restore the previous healthy Worker release.").action(async (options) => {
     const dryRun = Boolean(options.dryRun || program.opts().dryRun);
     if (!dryRun && !await confirm(
@@ -9663,7 +10202,7 @@ Log: ${result.log_path}`, options);
       {
         yes: Boolean(program.opts().yes),
         dryRun: false,
-        interactive: Boolean(io.stdin?.isTTY ?? process.stdin.isTTY)
+        interactive: human()
       }
     )) return;
     const result = await getMcpService().deploy({
@@ -9705,11 +10244,11 @@ Log: ${result.log_path}`, options);
   addOutputOptions(mcp.command("clients").description("List pending and approved OAuth clients.")).action(async (options) => {
     await outputMcpResult(runtime, await getMcpService().manageClients({}), options);
   });
-  addOutputOptions(mutating(mcp.command("revoke").description("Revoke an OAuth client or all OAuth access.").argument("[client-id]"))).option("--all", "Revoke every client, token, pending authorization, and pairing window.").action(async (clientId, options) => {
+  addOutputOptions(mutating(mcp.command("revoke").description("Revoke an OAuth client or all OAuth access.").argument("[client-id]", "OAuth client id; omit with --all"))).option("--all", "Revoke every client, token, pending authorization, and pairing window.").action(async (clientId, options) => {
     if (Boolean(clientId) === Boolean(options.all)) throw new UsageError("Provide a client ID or --all.");
     await outputMcpResult(runtime, await getMcpService().manageClients({ revoke: true, clientId }), options);
   });
-  addOutputOptions(mutating(mcp.command("pair").description("Open a pairing window so Claude can connect to the remote MCP server."))).action(
+  addOutputOptions(mutating(mcp.command("pair").description("Open a pairing window so Claude can connect to the remote MCP server.").summary("Open a pairing window for Claude"))).action(
     async (options) => {
       await outputMcpResult(runtime, await getMcpService().pair(), options);
     }
@@ -9742,7 +10281,7 @@ Log: ${result.log_path}`, options);
       await runtime.output(description, () => JSON.stringify(description, null, 2), options);
     }
   );
-  const skills = program.command("skills").description("Show skill metadata or delegate to the shared skills CLI.");
+  const skills = program.command("skills").description("Show skill metadata or delegate to the shared skills CLI.").summary("Agent skill metadata");
   skills.action(() => {
     stdout.write(`${formatSkillSummary()}
 `);
@@ -9752,18 +10291,40 @@ Log: ${result.log_path}`, options);
     stdout.write("Generated Moodle skill bundle\n");
   });
   skills.command("add").description("Install the published skill through npx skills add.").allowUnknownOption(true).action((_options, command) => installSkill(command.args));
+  for (const [title, names] of Object.entries(HELP_SECTIONS)) {
+    for (const name of names) for (const command of program.commands) if (command.name() === name) helpSection(command, title);
+  }
+  examples(program, [
+    "moodle  # today: due items, alerts and news",
+    "moodle UNIT grades",
+    'moodle submit UNIT "Assignment 2" report.pdf'
+  ]);
   return program;
 }
+var HELP_SECTIONS = {
+  "Core commands": ["due", "news", "find", "get", "open", "submit", "units", "activities", "grades", "threads", "forums"],
+  "Additional commands": ["user", "todo", "alerts", "overview", "download", "auth", "doctor", "completion", "uninstall"],
+  "Agent commands": ["mcp", "commands", "skills"]
+};
 async function runCli(argv = process.argv, io = {}) {
   const stderr = io.stderr ?? process.stderr;
   const stdout = io.stdout ?? process.stdout;
   const args = insertDefaultVerb(argv.slice(2), NOUNS);
-  const program = buildProgram({ ...io, rootArgs: args });
+  const ui = createUi3({
+    input: io.stdin ?? process.stdin,
+    output: stderr,
+    interactive: detectAudience({
+      stdin: io.stdin ?? process.stdin,
+      stdout: { isTTY: Boolean(stdout && "isTTY" in stdout && stdout.isTTY) },
+      env: io.env ?? process.env,
+      format: errorOutputFormat(args, stdout)
+    }) === "human"
+  });
   try {
-    await program.parseAsync(args, { from: "user" });
+    await parseWithPrompts(() => buildProgram({ ...io, rootArgs: args }), args, { ui, fillers: { unit: pickUnit(io, ui) } });
     return 0;
   } catch (error) {
-    if (isCommanderCompletion(error)) {
+    if (isInformationalExit(error)) {
       return 0;
     }
     const format = errorOutputFormat(args, stdout);
@@ -9843,11 +10404,26 @@ function addForumSearchCommand(command, runtime, defaultLimit) {
   });
 }
 function addOutputOptions(command) {
-  return command.option("--pretty", "Indent JSON output.").option("--json", "Output as JSON.").option("--yaml", "Output as YAML.").option("--table", "Force human output.").option("--fields <fields>", "Keep only listed top-level fields in structured output.");
+  for (const [flags, description] of [
+    ["--pretty", "Indent JSON output."],
+    ["--json", "Output as JSON."],
+    ["--yaml", "Output as YAML."],
+    ["--table", "Force human output."],
+    ["--fields <fields>", "Keep only listed top-level fields in structured output."]
+  ]) command.addOption(command.createOption(flags, description).hideHelp());
+  return command;
 }
 function outputFormat(options, stdout) {
   return resolveFormat(options, Boolean(stdout && "isTTY" in stdout && stdout.isTTY));
 }
+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`];
+  if (plan.removed.length) lines.push(`${theme.dim("Remove")}  ${theme.tone("danger", plan.removed.join(", "))} ${theme.dim("first")}`);
+  if (plan.statement) lines.push(`${theme.dim(" Agree")}  "${plan.statement}"`);
+  lines.push(final ? theme.tone("warning", "Then submit for grading. Moodle does not allow undoing this.") : theme.dim("Moodle keeps a draft where the assignment allows drafts; otherwise it submits at once."));
+  return lines.join("\n");
+}
 function parsePositiveInt(value) {
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 1) {
@@ -9888,11 +10464,24 @@ function parseFields(data, value) {
   }
   return fields2;
 }
-function isCommanderCompletion(error) {
-  if (!error || typeof error !== "object") return false;
-  if ("exitCode" in error && error.exitCode === 0) return true;
-  const code = "code" in error ? String(error.code) : "";
-  return code.startsWith("commander.help") || code === "commander.version";
+function pickUnit(io, ui) {
+  return async () => {
+    const spin = ui.spinner();
+    spin.start("Loading your units");
+    try {
+      return await selectUnit(spin);
+    } catch (error) {
+      spin.stop("Could not load your units");
+      throw error;
+    }
+  };
+  async function selectUnit(spin) {
+    const { baseUrl } = await loadConfig({ env: io.env, cwd: io.cwd, homeDir: io.homeDir, stdin: io.stdin, stderr: io.stderr ?? process.stderr, fetch: io.fetchImpl });
+    const client = await createMoodleClient(baseUrl, { env: io.env, fetchImpl: io.fetchImpl, homeDir: io.homeDir });
+    const courses = await client.getCourses();
+    spin.stop(`${courses.length} units`);
+    return ui.select("Which unit?", courses.map((course) => ({ value: String(course.id), label: course.fullname, ...course.shortname ? { hint: course.shortname } : {} })));
+  }
 }
 function parseRootOutputOptions(args) {
   const fieldsIndex = args.findIndex((arg) => arg === "--fields" || arg.startsWith("--fields="));