Read a workflow document, e.g. GRADING.md or Access/Canvas.md.

path is relative to CourseGlobalWorkflow/.

Set this install up, one step per call. Relay the answer to the instructor.

Call with no arguments to see where things stand. Pass canvas_url to register a SCHOOL — that writes the config with an empty token and reports the file to paste one into; pass token as well only if the instructor prefers that, since the token then stays in this conversation's record. Pass course_url to register a COURSE, optionally overriding the proposed slug and course_dir.

Every course slug registered in the course root.

A course's coordinates: Canvas id, base url, school, GitHub org, output paths.

Never returns a secret — canvas_token_env names the variable, it is not the token.

Active students: id, name, email.

Every link in a block of Canvas HTML, classified by kind.

Every page in the course: title, url slug, published state.

One page, body included. slug is the page's url segment.

Create a page, unpublished.

Update a page's title and/or body. Publish state is left alone.

Every module: id, name, position, published state.

One module.

Create a module, unpublished.

What is inside a module, in order.

Add an item to a module, unpublished.

item_type is Canvas's own: Page, Assignment, Quiz, File, Discussion, ExternalUrl, SubHeader. A Page item needs page_url; Assignment/Quiz/File need content_id.

Every assignment: id, name, points, due date, published state.

One assignment, description included.

Create an assignment, unpublished. due_at is ISO-8601 UTC.

Update an assignment. Publish state is left alone.

Set one due date on several assignments. due_at is ISO-8601 UTC.

Assignments with submissions waiting to be graded.

Assignment groups and their weights.

One quiz: title, description, question count, points.

Every question on a quiz: id, name, type, points.

Create an empty quiz, unpublished. due_at is ISO-8601 UTC, time_limit is minutes.

Add or update questions. A question already carrying the same name is updated in place.

Each question is {"name", "type", "text", "points", ...} where type is one of: multiple_choice choices: list[str] correct: index multiple_answers choices: list[str] correct: list[index] true_false correct: true | false essay (no extra fields) text is HTML.

Rewrite the description summary and refresh the quiz's stale counts.

Canvas leaves question_count and points_possible stale after any question change, so this runs after the questions are in.

Render what would be sent, and say how to send it. Sends nothing.

Post an announcement. Requires confirm='SEND', which the preview explains.

Who submitted what: user id, submitted_at, current score, attempt count.

One submission in full, body and attachments included.

Split the submissions into graded / resubmitted / new / not submitted.

The assignment's Canvas rubric object, when it has one.

The rubric a student was shown outranks this — an assignment page carries its own table.

Build the Canvas page for a programming assignment whose starter repo is on GitHub.

assignment carries the content: code, title, gist, spec, restrictions, elaboration, test_items, and either prototype + params + returns (a function to write) or input + output + expected (a program reading stdin). Read the git-asmt-page skill before filling it — the field list and the section order are its subject.

Returns the rendered HTML; with publish_to_canvas it also creates the Canvas assignment.

Build the Canvas page for a Colab/Jupyter notebook assignment.

lab describes the notebook. The rubric TEXT is derived from the notebook itself; only the weight split is a default. Read the nb-homework-create skill first.

Build a formatted Google Doc — banners, section boxes, callouts, coloured code blocks.

blocks is the document's content in the generator's block form; read the gws-richdoc skill for the shapes. folder_id is a Drive folder; omitted, the doc lands in the default location and the answer says where.

Needs the gws CLI on this machine; without it the call fails with that message rather than producing a broken document.

The assignment as the STUDENT saw it — description, rubric, due date, attachments.

Grading is against what the student read, so this comes before any scoring.

The rubric the engine reads for this assignment, for the instructor to approve.

Priority is the instruction sheet first, then the Canvas rubric object, then the default — a proposal, never an applied decision.

Run Stage A: collect every submission, score what a machine can, and save the artifacts.

Returns the engine's result — per-student scores and the evidence it surfaced. It posts nothing and it writes no comment; the wording is Stage B's, done in conversation, and the post is a separate authorised step.

Write the rendered grades and comments to Canvas. Its own step, asked for on its own.

grades_json is the POST-READY file the report render produced — a Stage-A file is refused. The default is a dry run that reports what would be written; pass dry_run=false to write. fix is for correcting an earlier mis-grade: it is the only mode that deletes a comment, and only the one this poster recorded for the current attempt.

A post aborts when any evidence the engine surfaced was never read.

GLOBAL — generate the weekly Agenda (week start) and Wrap-up (week end) Canvas pages for a module, from the same module data. Config-driven per course (course_slug -> course_config). Triggers: 'week N agenda', 'wrap-up for week N', 'update the agenda', 'make the week 3 agenda/wrapup'.

GLOBAL methodology for building a Canvas ASSIGNMENT/LAB page from the universal skeleton canvas_core/assignment_page_builder.py. The skeleton is the CODE (machinery); this skill is the HOW (authoring method + finalize order). Per-course skills (e.g. customize-assignment-page = git plugin, jshell-lab = jshell plugin) supply the course config + content and reuse this. Policy (grading %, published, dates) lives in CourseGlobalWorkflow and is only REFERENCED here. Use when building/updating any Canvas assignment or lab page.

GLOBAL, config-driven — generate a weekly Canvas announcement from a module's contents for ANY course. Use when the user says make/write the weekly announcement, week N announcement, or announce this week. Reads the module, summarizes what to read/watch/do/submit, lists graded items with due dates, and closes warmly. Course coordinates come from course_config.load() (course_id, school, token) — nothing hardcoded. PREVIEW-first; sends emails only on the instructor's explicit go. Invoke with the course_slug + week or module id.

GLOBAL L1 ENTRY POINT (dispatcher) for creating a GitHub coding assignment end-to-end. Routes to two children: git-asmt-repo (build the solution/tests + prove 100/100 + ship the Starter + register in the org-hub) and git-asmt-page (build the Canvas assignment page via git_page). Language-agnostic; the language mechanics are L2 (git-asmt-repo/languages/*) and the course coordinates are the L3 course wrapper (config). Use when the user says 'make/build/create assignment ' — this decides repo-first then page.

GLOBAL L1 child of git-asmt — build the Canvas ASSIGNMENT PAGE for a git coding assignment via the global git_page (assignment-page-builder). Your job = fill the asmt dict well (gist, spec, I/O = function contract, examples call→output, restrictions, elaboration, test-items table, per-item points/rubric, per-item guide, function prototype+params) → git_page(course_slug, asmt). Language-agnostic; which fields to use (stdin-program vs function) comes from the L3 course wrapper's curriculum. Use to make/renew any git-assignment Canvas page. Canvas side ONLY — the repo is git-asmt-repo.

GLOBAL, language-agnostic L1 abstract for building + testing a GitHub coding-assignment repo through the org-hub autograder. Owns the WHAT (audit → instruction-fidelity harness → prove 100/100 → ship the Starter → gates) with NO language mechanics. The HOW-to-compile/run/assert is delegated to an L2 language skill (git-asmt-repo/languages/*), and the course coordinates come from an L3 course wrapper (config). Use as the shared core every course's git build/test wrapper points to. NEVER re-implement this per course.

GLOBAL step-by-step grading skill. The ONE ordered procedure for grading ANY course's Canvas assignment OR quiz/exam through the shared grade engine — Stage A (engine, no post) → Stage B (AI review in chat) → report → pre-post self-challenge → POST (instructor go + post-gate). Bundles the canonical policy (GRADING.md — Part D is the quiz/exam half), the flow (skills/grade/SKILL.md), the layer map (CourseGlobalWorkflow/README.md), and the engine contracts (GradingEngine/*) into one sequential runbook, and ships the runnable Stage-A driver grade_skill.py. Invoke BEFORE any grading work — never grade ad-hoc.

Grading SUB-SKILL for git-program assignments AND git-program quiz questions (the M-series coding items) — the type-specific plug-in of the global grade skill, analogous to grade-nb. ONE skill for both: internally a quiz question is graded STRICTER (quiz-exam-policy) and a homework LOOSER. Runs THROUGH THE ENGINE (core.grade → graders/gh) + GRADING Part B; reads the build-time grading info left by git-homework / quiz-builder. STATUS: STUB — full setup at first grading.

NB (Colab / Jupyter notebook) grading SUB-SKILL — the type-specific plug-in for the global grade skill. When an assignment's submission is a Colab/Drive notebook, grade dispatches HERE for the notebook + revision-history inspection, then returns to the general flow (report → self-challenge → POST). Consolidates GRADING.md Part C + GradingEngine/NbInspect.md into concrete steps. The NB grading RUNS THROUGH THE ENGINE (core.grade → graders/nb.py + nb_inspect) — this skill is the METHOD, not a standalone driver. Master is skills/grade/SKILL.md.

The gslides-format skill document.

Read and format Google Docs using gws CLI. Use when reading a Google Doc's content, or creating/reformatting a Google Doc with proper heading styles, bold text, or structured content.

Create a rich-format Google Doc (banner, color section boxes, navy step badges, tip/info/warning callouts, dark syntax-colored code blocks, bullets) DETERMINISTICALLY via the fixed generator build.py. Use when the user asks for a "gws-richdoc / rich-gdoc" doc or a polished, visually-structured Google Doc. ALWAYS run build.py — never hand-author the HTML (that is what made every session look different).

GLOBAL, config-driven — build a module OVERVIEW page (the representative page at the top of a Canvas module): 📌 Overview (the plan) + an optional slide embed + FLEXIBLE SECTION BLOCKS grouping that module's items (readings/videos/quizzes/assignments) as a roadmap. Categories are DATA — add/remove freely per course, no fixed columns, no wrappers needed. Renderer = module_overview.py (coords from course_config.load()). For per-slide breakdowns it uses the slide-plan skill. Triggers: 'module overview page', 'make the overview/representative page for module N', '대표 페이지'.

Create/prepare an NB (Colab / Jupyter) homework TEMPLATE so it can be graded cleanly by the grade-nb sub-skill. Embeds a hidden per-cell ANCHOR in every instruction + provides a matching pre-filled ANSWER cell, structures the notebook into sections with a per-section pin + an essay reflection, and bakes the student "do not delete the cells" guidance. The creation and grading sides are mirror images — the grader anchors on exactly what this skill stamps. Global; pairs with skills/grade-nb.

GLOBAL — turn a publisher's plain-text question bank (Liang/Pearson test bank, one chapter per file) into a Canvas CLASSIC quiz. Parses the bank into quiz_builder's question JSON, renders a preview HTML for review, then delegates the Canvas write to quiz-builder. Multiple-choice and multiple-answer items; per-question points are an input. Use when the user has a chapter test-bank .txt (or .docx text) and wants it as a Canvas quiz. Triggers: 'publisher bank', 'test bank', 'chapter N quiz from the bank', '뱅크로 퀴즈'.

GLOBAL methodology for building/updating a Canvas CLASSIC quiz — its question items + the description summary. Create a quiz from nothing OR modify an existing one. Dispatches question items by type (native MCQ/T-F/essay/fill-in via the Quizzes API; a git-program question defers to the course-local git-homework). All Canvas quiz API calls go through the co-located quiz_builder.py — never hand-rolled. Use when making/updating any Canvas quiz's questions or details.

Generic session orientation. Loads account + course global rules and detects the active course from the current working directory. For project-specific orientation, run from inside a project dir — the per-course readytogo.md takes precedence over this one.

GLOBAL sub-skill of module-overview-page — turn a multi-slide module into one SECTION per slide: 'this slide covers X → do these assignments/labs based on it', with the slide deck embedded in that section. Returns section tuples that module-overview-page's make_page consumes. Use when a module has SEVERAL slide decks and you want each slide's content summarized next to the tasks derived from it. Triggers: 'slide plan', 'per-slide breakdown', 'slide N covers … do …'.