@xiaotianxt/skills 0.1.0

package/skills/gws-gmail-watch/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: gws-gmail-watch
+version: 1.0.0
+description: "Gmail: Watch for new emails and stream them as NDJSON."
+metadata:
+  openclaw:
+    category: "productivity"
+    requires:
+      bins: ["gws"]
+    cliHelp: "gws gmail +watch --help"
+---
+
+# gmail +watch
+
+> **PREREQUISITE:** Read `../gws-shared/SKILL.md` for auth, global flags, and security rules. If missing, run `gws generate-skills` to create it.
+
+Watch for new emails and stream them as NDJSON
+
+## Usage
+
+```bash
+gws gmail +watch
+```
+
+## Flags
+
+| Flag | Required | Default | Description |
+|------|----------|---------|-------------|
+| `--project` | — | — | GCP project ID for Pub/Sub resources |
+| `--subscription` | — | — | Existing Pub/Sub subscription name (skip setup) |
+| `--topic` | — | — | Existing Pub/Sub topic with Gmail push permission already granted |
+| `--label-ids` | — | — | Comma-separated Gmail label IDs to filter (e.g., INBOX,UNREAD) |
+| `--max-messages` | — | 10 | Max messages per pull batch |
+| `--poll-interval` | — | 5 | Seconds between pulls |
+| `--msg-format` | — | full | Gmail message format: full, metadata, minimal, raw |
+| `--once` | — | — | Pull once and exit |
+| `--cleanup` | — | — | Delete created Pub/Sub resources on exit |
+| `--output-dir` | — | — | Write each message to a separate JSON file in this directory |
+
+## Examples
+
+```bash
+gws gmail +watch --project my-gcp-project
+gws gmail +watch --project my-project --label-ids INBOX --once
+gws gmail +watch --subscription projects/p/subscriptions/my-sub
+gws gmail +watch --project my-project --cleanup --output-dir ./emails
+```
+
+## Tips
+
+- Gmail watch expires after 7 days — re-run to renew.
+- Without --cleanup, Pub/Sub resources persist for reconnection.
+- Press Ctrl-C to stop gracefully.
+
+## See Also
+
+- [gws-shared](../gws-shared/SKILL.md) — Global flags and auth
+- [gws-gmail](../gws-gmail/SKILL.md) — All send, read, and manage email commands

package/skills/gws-shared/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: gws-shared
+description: Shared authentication, security, and command conventions for locally generated Google Workspace gws skills.
+---
+
+# gws-shared
+
+Use this reference before running any `gws-*` skill.
+
+## Auth
+
+- Use the local `gws` CLI auth state. Do not print tokens, refresh tokens, cookies, or raw credential files.
+- If authentication is missing, run the narrowest relevant login flow, for example `gws auth login --services gmail`.
+- Prefer read-only scopes unless the user explicitly asks to send, create, update, delete, or watch resources.
+
+## Command Safety
+
+- Inspect command shape with `gws <service> --help` and method schemas with `gws schema <service>.<resource>.<method>`.
+- Prefer `--json` output for agent workflows and summarize only the fields needed for the task.
+- For email and document content, avoid dumping full bodies unless the user asked for exact content.
+- For write operations, state the target account, recipient, calendar, document, or Drive path before executing.
+
+## Data Handling
+
+- Treat Gmail messages, Calendar events, Docs content, Drive files, and contact-like metadata as private.
+- Keep exports local by default.
+- Do not include user data, OAuth files, cache directories, or raw API responses in commits.

package/skills/helium-browser-mcp/SKILL.md

@@ -0,0 +1,137 @@
+---
+name: helium-browser-mcp
+description: Use when Codex needs to control or inspect the user's logged-in Helium browser through the locally installed OpenBrowserMCP extension. Trigger for requests about OpenBrowserMCP, Helium tabs, reading current browser tabs, browser MCP, openbrowsermcp, webpage interaction, or testing this local browser stack.
+---
+
+# Helium Browser MCP
+
+Use this skill for the local OpenBrowserMCP + Helium setup.
+
+## Local Services
+
+- OpenBrowserMCP project: `/Users/yupeit/dev/openbrowsermcp`
+- OpenBrowserMCP server: `http://127.0.0.1:3500`
+- OpenBrowserMCP MCP endpoint: `http://127.0.0.1:3500/mcp`
+- OpenBrowserMCP WebSocket bridge: `ws://127.0.0.1:3500/ws`
+- Helium extension id: `ocjmfbmadhimfjoonaljbmpcfnbgiolc`
+- OpenBrowserMCP token: `~/openbrowsermcp/settings.json`
+Important: use `127.0.0.1`, not `localhost`, for OpenBrowserMCP. `localhost`
+can resolve to IPv6 `::1`, while the server listens on IPv4.
+
+## Privacy And Safety
+
+Helium is the user's real browser profile. Treat tab URLs, page text, screenshots,
+cookies, account state, and extension state as sensitive.
+
+- Do not print the OpenBrowserMCP bearer token.
+- Prefer read-only inspection first: `browsers_context`, `tabs_context`,
+  `get_page_text`, `read_page`.
+- Before submitting forms, sending messages, uploading files, making purchases,
+  changing account settings, or reading highly sensitive pages, ask for explicit
+  confirmation.
+- For demos, create a new tab on `https://example.com` and operate only there.
+
+## Quick Checks
+
+```bash
+curl -sS http://127.0.0.1:3500/status
+```
+
+If OpenBrowserMCP shows no connected extension, open the options page:
+
+```bash
+/usr/bin/open -b net.imput.helium chrome-extension://ocjmfbmadhimfjoonaljbmpcfnbgiolc/options.html
+```
+
+Then set:
+
+- Server URL: `ws://127.0.0.1:3500/ws`
+- Token: value from `~/openbrowsermcp/settings.json`
+
+## Calling OpenBrowserMCP
+
+Use the bundled helper so the token is read locally and not printed:
+
+```bash
+/Users/yupeit/dev/skills/skills/helium-browser-mcp/scripts/obmcp.mjs browsers_context
+/Users/yupeit/dev/skills/skills/helium-browser-mcp/scripts/obmcp.mjs tabs_context '{"all":true}'
+/Users/yupeit/dev/skills/skills/helium-browser-mcp/scripts/obmcp.mjs get_page_text '{"tabId":123,"browserId":"..."}'
+```
+
+## OpenCode Integration
+
+OpenCode is configured globally in `/Users/yupeit/.config/opencode/opencode.json`
+with an `openbrowsermcp` local MCP entry. It runs this stdio proxy:
+
+```bash
+/Users/yupeit/dev/skills/skills/helium-browser-mcp/scripts/openbrowsermcp-stdio-proxy.mjs
+```
+
+The proxy reads `~/openbrowsermcp/settings.json` locally and forwards to
+`http://127.0.0.1:3500/mcp`, so the bearer token is not stored in OpenCode's
+config file.
+
+Verify OpenCode sees it:
+
+```bash
+opencode mcp list
+```
+
+Common tools:
+
+- `browsers_context` lists connected Helium browser instances.
+- `tabs_context` lists tabs. Pass `{"all":true,"browserId":"..."}`.
+  After an agent has chosen a tab, pass `tabId` too so context is anchored to
+  that tab's window/group instead of the user's foreground tab.
+- `tabs_create` creates a new background tab by default. Pass
+  `{"url":"https://example.com","browserId":"..."}` and keep the returned
+  numeric tab ID for all later calls. Use `active:true` only when the user
+  explicitly wants the tab brought to the foreground.
+- `navigate` changes an existing tab. Pass
+  `{"url":"https://example.com","tabId":123,"browserId":"..."}` when the
+  current target tab can be overwritten instead of creating another tab.
+- `tabs_close` closes a tab by ID. Use it for task-owned temporary tabs once
+  they are no longer needed.
+- `read_page` reads the accessibility tree. Requires `tabId`.
+- `get_page_text` extracts `document.body.innerText`. Requires `tabId`.
+- `find` searches accessible elements by description. Requires `tabId`.
+- `click_element` clicks a ref from `find`/`read_page`. Requires `tabId`.
+- `javascript_tool` evaluates page JavaScript. Requires `tabId`.
+
+## Stable Tab Targeting
+
+Do not operate by "whatever tab is active" after the first discovery step.
+Helium is the user's real browser and they may continue using it while Codex is
+working.
+
+- Create or identify a target tab first, record both `browserId` and `tabId`,
+  and pass them explicitly to every tab-targeted tool.
+- For monitoring, call `read_network_requests`, `read_console_messages`, and
+  `get_response_body` with the pinned `tabId`.
+- When refreshing tab context during a task, use
+  `tabs_context {"all":true,"tabId":123,"browserId":"..."}` so the listing is
+  resolved relative to the pinned tab, not the user's current foreground tab.
+- Avoid `tabs_activate` unless foreground focus is part of the user's request.
+  CDP-backed tools such as `javascript_tool`, `read_page`, and monitoring work
+  on background tabs.
+
+## Tab Lifecycle
+
+Keep the user's browser tidy.
+
+- Track every tab created for the task. Before finishing, close task-owned tabs
+  with `tabs_close` unless the user asked to keep them open or the tab now
+  contains useful state the user expects to inspect.
+- Prefer reusing the current target tab with `navigate` when moving to the next
+  website and the current page can be safely overwritten. Do this for agent-
+  created scratch tabs and for user-approved disposable pages.
+- Do not overwrite or close tabs that existed before the task unless the user
+  explicitly says the current page can be reused or closed.
+
+For a safe smoke test:
+
+```bash
+scripts/obmcp.mjs browsers_context
+scripts/obmcp.mjs tabs_context '{"all":true}'
+scripts/obmcp.mjs tabs_create '{"url":"https://example.com"}'
+```

package/skills/helium-browser-mcp/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Helium Browser MCP"
+  short_description: "Control Helium through the local OpenBrowserMCP extension."
+  default_prompt: "Show my current Helium tabs using OpenBrowserMCP."

package/skills/helium-browser-mcp/scripts/obmcp.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+
+const endpoint = 'http://127.0.0.1:3500/mcp';
+const tokenPath = `${process.env.HOME}/openbrowsermcp/settings.json`;
+
+function usage() {
+  console.error('usage: obmcp.mjs <tool-name> [json-arguments]');
+  console.error('example: obmcp.mjs tabs_context \'{"all":true}\'');
+  process.exit(2);
+}
+
+const toolName = process.argv[2];
+if (!toolName) usage();
+
+let args = {};
+if (process.argv[3]) {
+  try {
+    args = JSON.parse(process.argv[3]);
+  } catch (err) {
+    console.error(`invalid JSON arguments: ${err.message}`);
+    process.exit(2);
+  }
+}
+
+const token = JSON.parse(fs.readFileSync(tokenPath, 'utf8')).token;
+if (!token) {
+  console.error(`missing token in ${tokenPath}`);
+  process.exit(1);
+}
+
+const baseHeaders = {
+  'content-type': 'application/json',
+  accept: 'application/json, text/event-stream',
+  authorization: `Bearer ${token}`,
+};
+
+function parseSseOrJson(text) {
+  for (const line of text.split('\n')) {
+    if (!line.startsWith('data: ')) continue;
+    const payload = line.slice(6).trim();
+    if (!payload) continue;
+    return JSON.parse(payload);
+  }
+  return JSON.parse(text);
+}
+
+async function rpc(sessionId, id, method, params) {
+  const headers = sessionId
+    ? { ...baseHeaders, 'mcp-session-id': sessionId }
+    : baseHeaders;
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ jsonrpc: '2.0', id, method, params }),
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${text}`);
+  }
+  return {
+    sessionId: response.headers.get('mcp-session-id'),
+    body: parseSseOrJson(text),
+  };
+}
+
+const init = await rpc(null, 1, 'initialize', {
+  protocolVersion: '2024-11-05',
+  capabilities: {},
+  clientInfo: { name: 'codex-obmcp-helper', version: '0' },
+});
+
+const sessionId = init.sessionId;
+if (!sessionId) {
+  throw new Error('OpenBrowserMCP did not return an MCP session id');
+}
+
+const result = await rpc(sessionId, 2, 'tools/call', {
+  name: toolName,
+  arguments: args,
+});
+
+const body = result.body;
+const content = body.result?.content;
+if (Array.isArray(content)) {
+  for (const item of content) {
+    if (item?.type === 'text') console.log(item.text);
+    else console.log(JSON.stringify(item));
+  }
+} else {
+  console.log(JSON.stringify(body, null, 2));
+}

package/skills/helium-browser-mcp/scripts/openbrowsermcp-stdio-proxy.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+
+const endpoint = process.env.OPENBROWSERMCP_MCP_URL || 'http://127.0.0.1:3500/mcp';
+const tokenPath = process.env.OPENBROWSERMCP_SETTINGS || `${process.env.HOME}/openbrowsermcp/settings.json`;
+const logPath = process.env.OPENBROWSERMCP_PROXY_LOG || '';
+
+let sessionId = null;
+let input = Buffer.alloc(0);
+let chain = Promise.resolve();
+let framing = null;
+
+function log(message) {
+  if (!logPath) return;
+  fs.appendFileSync(logPath, `${new Date().toISOString()} ${message}\n`);
+}
+
+function readToken() {
+  const settings = JSON.parse(fs.readFileSync(tokenPath, 'utf8'));
+  if (typeof settings.token !== 'string' || settings.token.length === 0) {
+    throw new Error(`missing token in ${tokenPath}`);
+  }
+  return settings.token;
+}
+
+function writeMessage(message) {
+  const body = JSON.stringify(message);
+  if (framing === 'ndjson') {
+    process.stdout.write(`${body}\n`);
+    return;
+  }
+  process.stdout.write(`Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);
+}
+
+function parseSseOrJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+
+  const dataLines = [];
+  for (const line of trimmed.split(/\r?\n/)) {
+    if (line.startsWith('data:')) dataLines.push(line.slice(5).trimStart());
+  }
+  if (dataLines.length > 0) {
+    return JSON.parse(dataLines.join('\n'));
+  }
+  return JSON.parse(trimmed);
+}
+
+async function forward(message) {
+  log(`forward ${message.method || '<response>'} id=${Object.prototype.hasOwnProperty.call(message, 'id') ? message.id : '<none>'}`);
+  const token = readToken();
+  const headers = {
+    'content-type': 'application/json',
+    accept: 'application/json, text/event-stream',
+    authorization: `Bearer ${token}`,
+  };
+  if (sessionId) headers['mcp-session-id'] = sessionId;
+
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(message),
+  });
+
+  const nextSessionId = response.headers.get('mcp-session-id');
+  if (nextSessionId) sessionId = nextSessionId;
+
+  const text = await response.text();
+  log(`response status=${response.status} bytes=${Buffer.byteLength(text)} session=${sessionId ? 'yes' : 'no'}`);
+  if (!response.ok) {
+    throw new Error(`OpenBrowserMCP HTTP ${response.status}: ${text}`);
+  }
+
+  const body = parseSseOrJson(text);
+  if (body) writeMessage(body);
+}
+
+function jsonRpcError(id, error) {
+  writeMessage({
+    jsonrpc: '2.0',
+    id,
+    error: {
+      code: -32000,
+      message: error instanceof Error ? error.message : String(error),
+    },
+  });
+}
+
+function handle(message) {
+  chain = chain.then(async () => {
+    try {
+      await forward(message);
+    } catch (error) {
+      if (Object.prototype.hasOwnProperty.call(message, 'id')) {
+        jsonRpcError(message.id, error);
+      } else {
+        console.error(error instanceof Error ? error.message : String(error));
+      }
+    }
+  });
+}
+
+function drain() {
+  if (framing === null && input.length > 0) {
+    const first = input.subarray(0, 1).toString('utf8');
+    framing = first === '{' ? 'ndjson' : 'headers';
+    log(`framing=${framing}`);
+  }
+
+  if (framing === 'ndjson') {
+    while (true) {
+      const lineEnd = input.indexOf('\n');
+      if (lineEnd === -1) return;
+
+      const line = input.subarray(0, lineEnd).toString('utf8').trim();
+      input = input.subarray(lineEnd + 1);
+      if (!line) continue;
+
+      try {
+        handle(JSON.parse(line));
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+      }
+    }
+  }
+
+  while (true) {
+    let headerEnd = input.indexOf('\r\n\r\n');
+    let separatorLength = 4;
+    if (headerEnd === -1) {
+      headerEnd = input.indexOf('\n\n');
+      separatorLength = 2;
+    }
+    if (headerEnd === -1) return;
+
+    const header = input.subarray(0, headerEnd).toString('latin1');
+    const match = header.match(/content-length:\s*(\d+)/i);
+    if (!match) {
+      console.error('missing Content-Length header');
+      process.exit(1);
+    }
+
+    const length = Number(match[1]);
+    const bodyStart = headerEnd + separatorLength;
+    const bodyEnd = bodyStart + length;
+    if (input.length < bodyEnd) return;
+
+    const body = input.subarray(bodyStart, bodyEnd).toString('utf8');
+    input = input.subarray(bodyEnd);
+
+    try {
+      handle(JSON.parse(body));
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+
+process.stdin.on('data', (chunk) => {
+  log(`stdin bytes=${chunk.length}`);
+  if (process.env.OPENBROWSERMCP_PROXY_PREVIEW === '1') {
+    log(`stdin preview=${JSON.stringify(chunk.subarray(0, 200).toString('utf8'))}`);
+  }
+  input = Buffer.concat([input, chunk]);
+  drain();
+});
+
+process.stdin.on('end', () => {
+  chain.finally(() => process.exit(0));
+});

package/skills/learn/SKILL.md

@@ -0,0 +1,122 @@
+---
+name: learn
+description: Build and run evidence-based learning workflows. Use when Codex needs to create or continue a study workspace, collect and convert learning materials, design goals, teach from sources, quiz the user, score answers, track progress, maintain an error log, or run spaced review for subjects such as courses, books, technical topics, exams, or career prep.
+---
+
+# Learn
+
+Use this skill to turn a topic into a source-grounded, interactive learning system.
+
+## Core Principles
+
+- Start from a learning goal, but allow it to change as evidence of the learner's needs emerges.
+- Prefer source-grounded teaching over generic explanation. Identify the exact source chunk before teaching.
+- Teach in small units, then ask retrieval questions before marking progress.
+- Treat mistakes as the main signal. Log wrong, vague, overconfident, or ungrounded answers.
+- Use spaced review, but usually only when the user asks to review or when resuming after a noticeable gap.
+- Avoid material hoarding. Collect enough sources to cover the goal; do not delay learning indefinitely.
+
+Read `references/learning-science.md` when designing a new workflow, defending the method, or revising the learning loop.
+
+## New Learning Workspace
+
+When creating a new study workspace, use:
+
+```bash
+python3 /path/to/learn/scripts/init_learning_workspace.py TOPIC --path /target/parent --goal "..."
+```
+
+The script creates:
+
+- `materials/` for source files and web caches
+- `notes/` for lesson plans and ordinary notes
+- `cases/` for worked examples or problem traces
+- `outputs/` for compiled PDFs or exports
+- `AGENTS.md` for local study rules
+- `tasklog.typ` for progress, scores, and next steps
+- `errorlog.typ` for misconceptions and review actions
+- `workbook.typ` for worked examples, section notes, verification questions, and corrections
+- `materials/source-index.md` for collected sources
+- `notes/reading-sequence.md` for the first pass route
+
+If the workspace already exists, inspect `AGENTS.md`, then `tasklog.typ`, then `errorlog.typ` before teaching.
+
+## Source Collection
+
+For each topic, build a source index before deep teaching:
+
+1. Gather likely authoritative materials: books, official docs, papers, syllabi, lectures, slides, assignments, transcripts, examples, and prior notes.
+2. Prefer primary sources: official docs, textbook chapters, course pages, papers, source code, specs.
+3. Convert materials into AI-readable form:
+   - PDFs/books: text extraction or OCR as needed.
+   - Videos/audio: transcripts with timestamps when possible.
+   - Slides/images: OCR plus image references.
+   - Web pages: URL plus local cache or concise source notes.
+4. Record every source in `materials/source-index.md` with purpose, priority, and local path.
+5. Do not copy large copyrighted texts into notes. Store local references and write original summaries.
+
+Use specialized skills when appropriate, for example OCR/document skills for PDFs or screenshots.
+
+## Tracking Files
+
+Use `tasklog.typ` for:
+
+- learning goal and current assumptions
+- scoring rubric
+- lesson/chapter table
+- session log
+- next action
+
+Use `errorlog.typ` for:
+
+- misconception category
+- original question
+- learner answer, preserving the error
+- correction
+- domain-specific consequence or rule
+- review action and status
+
+Use `workbook.typ` for:
+
+- section-level notes
+- worked examples
+- verification questions
+- corrected explanations
+- drills or transfer exercises
+
+## Teaching Loop
+
+For each section, chapter, lecture, or case:
+
+1. Select a small unit from the reading sequence.
+2. Read the relevant source material first.
+3. Explain in the learner's language with all essential knowledge points for that unit.
+4. Include at least one concrete example or system mapping.
+5. Name common wrong interpretations before the quiz.
+6. Ask verification questions that require retrieval and transfer, not just recognition.
+7. Stop and wait for the learner's answer.
+8. Score answers using the local rubric.
+9. Update `tasklog.typ`.
+10. Add or update `errorlog.typ` for every weak answer.
+11. Only mark a unit `done` when the learner can explain, apply, and avoid the key trap.
+
+## Review Loop
+
+When the user asks to review, or resumes after a meaningful gap:
+
+1. Read open/review items in `errorlog.typ`.
+2. Ask questions that test the old misconception without showing the correction first.
+3. If answered correctly twice across separate reviews, mark the item `closed`.
+4. If still weak, keep it `review` and add a sharper review action.
+
+Avoid unsolicited heavy review sessions; offer a brief review option when stale errors are visible.
+
+## Failure Modes To Avoid
+
+- Turning learning into passive summaries.
+- Collecting too many materials before starting.
+- Rigid goals that ignore what the learner discovers.
+- Overly broad lessons with no retrieval.
+- Marking progress without questions.
+- Logging every tiny imperfection until the workflow becomes maintenance-heavy.
+- Letting AI answer from memory when source grounding is available.

package/skills/learn/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Learn"
+  short_description: "Evidence-based study workflows"
+  default_prompt: "Use $learn to create a source-grounded study workspace with progress tracking, retrieval questions, and an error log."
+
+policy:
+  allow_implicit_invocation: true

package/skills/learn/assets/AGENTS.template.md

@@ -0,0 +1,33 @@
+# {TOPIC} Learning Instructions
+
+Use this file whenever the user asks to study, review, explain, quiz, or continue `{TOPIC}` in this workspace.
+
+## Local Context
+
+- Current learning goal: {GOAL}
+- Goals may evolve as weak points are discovered.
+- Prefer source-grounded teaching over generic explanation.
+- Use retrieval questions and error logging before marking progress.
+
+## Primary Files
+
+- `materials/source-index.md`: collected sources and local paths.
+- `notes/reading-sequence.md`: lesson order.
+- `tasklog.typ`: progress, scores, and next actions.
+- `errorlog.typ`: misconceptions, corrections, and review status.
+- `workbook.typ`: worked examples, section notes, verification questions, and corrections.
+
+## Default Study Method
+
+1. Inspect `tasklog.typ`, then `errorlog.typ`, before teaching.
+2. Select the next `doing`, `review`, or `todo` item.
+3. Read relevant source material.
+4. Explain the unit with all essential knowledge points.
+5. Ask verification questions.
+6. Wait for the learner answer.
+7. Score answers using `tasklog.typ`.
+8. Update `tasklog.typ`.
+9. Add or update `errorlog.typ` for wrong, vague, or ungrounded answers.
+10. Update `workbook.typ` for worked examples, lesson notes, or corrected explanations.
+
+Do not mark a unit `done` until the learner can explain, apply, and avoid the key misconception.