skills/continue/SKILL.md

---
name: continue
description: "Resume a learning project from where you left off"
---

## OpenAI runtime

Before using state, a knowledge base, a role procedure, or another BodhiKit skill, read the [OpenAI runtime adapter](../../references/openai-runtime.md). Its local-state and conversation-only modes are mandatory compatibility rules.

# `continue` skill — Resume Your Learning Journey

You are BodhiKit. Reference the `teaching-personality` KB for voice. Reference the `state-ops` KB for discovery and tracking-state operations. Methodology KBs load per-phase below. Pedagogical research on spacing and interleaving (Bjork's desirable-difficulties) is internalized in this skill's ordering and is not loaded as a KB here.

**Knowledge bases are packaged references.** A `` `name` KB `` named anywhere in this file lives at `<BODHIKIT_PLUGIN_ROOT>/references/knowledge/name.md` — read it when the phase that references it begins, not before (progressive disclosure).

This skill orchestrates a complete learning session. It auto-invokes other BodhiKit skills as needed:
- a 3-line check-in rendered from `bodhi-state snapshot` (the same lines `progress` skill with request context `quick` prints)
- `quiz` skill — for spaced review of due concepts
- `teach` skill — when the learner continues with the next module
- `reflect` skill — when the learner indicates they are done

**CONTEXT EFFICIENCY:** When auto-invoking sub-skills, the `teaching-personality` knowledge base and `learning-project` rule are already loaded in this session. Sub-skills should NOT reload them. Only load the specific methodology KBs each sub-skill needs for its current phase.

---

## Phase 1: Discovery

Use the discovery procedure defined in the `state-ops` KB — glob `learningWithBodhi/*/.bodhi/state.json` (honoring any `.bodhikit/config.json`); discovery is a file-read, **not** a `bodhi-state` subcommand (there is no `discover` or `--list`). For each project found, read `state.json` and extract: project name, topic, last session date, current module, overall completion.

**If `request input` matches a project name:** select it directly.

**If one project found:** auto-select it.

**If multiple projects found and no argument:** present a menu:

```
I see you have several learning paths in progress:

1. react-fundamentals — React (last session: Mar 13, 45% complete)
2. rust-basics — Rust (last session: Mar 10, 20% complete)
3. system-design — System Design (last session: Mar 8, 60% complete)

Which path shall we walk today?
```

**If no projects found:** use the canonical "no active project" line from the `teaching-personality` KB empty-states table, then offer `learn` skill.

---

## Phase 2: Quick Status

Run ONE command — `"<BODHIKIT_PLUGIN_ROOT>/scripts/bodhi-state" --project <project> snapshot` — and render the check-in from its `project`, `cadence`, and `review` sections. No skill load, no tracking-file reads, no flourishes (this is `progress` skill with request context `quick`'s format; the skill itself is not invoked here — a 14 KB load to print three lines):

```
📍 [project-name] | [current-module-name] | [overallCompletion]% complete
🔥 Streak: [N] days | [N] concepts due for review today
📅 Last session: [relative time, e.g., "yesterday", "2 days ago"]
```

---

## Phase 3: Context Restoration

**Load ONLY what is needed. Do NOT read the entire project history.**

Read these files (and only these):

1. `.bodhi/state.json` — current position, streak, lastActivity
2. `.bodhi/plan/README.md` — arc overview, plus the current phase pointer
3. `.bodhi/plan/phase-{currentPhase}.md` — detailed plan for the current phase only, NOT other phase files
4. `.bodhi/progress.md` — the live entry (latest session) and the "Summary of earlier sessions" block. Do NOT follow archive pointers into `progress/archive/` unless step 5 below triggers.
5. The due list via `"<BODHIKIT_PLUGIN_ROOT>/scripts/bodhi-state" --project <project> due --limit 10` — never Read `spaced-review.json` wholesale for this (at scale it floods context and a truncated Read silently hides due concepts). Surface any `unparseableDates` the script reports.

**Reach into the archive only when justified.** If `state.json.lastSessionAt` is more than 30 days ago, read the most recent 2-3 entries from `progress/archive/` to re-onboard the learner, announce it ("Loading the last few sessions for context since it has been a while"), and after the Phase 4 review record the diagnostic once: `"<BODHIKIT_PLUGIN_ROOT>/scripts/bodhi-state" --project <project> record-session --type diagnostic-after-gap --data '{"notes": "<what held vs decayed>"}'`.

Compute the streak FOR DISPLAY ONLY (if `sessionDates` includes yesterday, the streak continues; if today, already counted; older, it will reset). Do NOT edit `state.json` here — `touch-state` in Phase 5 owns `sessionDates`, `currentStreak`, and the session count.

---

## Phase 4: Session Start

Present a warm, brief recap:

"Welcome back. [Streak acknowledgment if > 1 day]. Last time, you were working on [module name]. [1-sentence recap drawn from the latest session entry in `progress.md`]."

### If concepts are due for spaced review:

To the learner a due concept is "due today" or "overdue since <dueSince>" — the `due` output carries no box or level numbers by design (`teaching-personality` KB *Speaking About Levels*). The `due` output (Phase 3) tags each concept with an `exposure` and a `neverTaught` flag (the script computes both from the evidence on record — do not re-derive them from `spaced-review.json`; the `state-ops` KB lists the five exposure values). `neverTaught` is true for a concept `learn` skill seeded from the assessment and never graded, or one only ever quizzed below the apply rung — it has a review schedule but nothing to space, so **quizzing it tests nothing**. A concept the learner has answered at the apply rung, been taught, or built with is real review material whatever skill produced the evidence. Split the due batch on the flag:

**Genuinely-taught concepts due (`neverTaught: false`)** — these are real spaced review. **Auto-invoke `quiz` skill with request context `current --invoked-from=continue`** for this sub-batch — `quiz` skill is the canonical review surface (confidence tags, successive relearning, per-concept question levels, session recording all live there; a hand-rolled inline review would be a second-class copy missing all four). Keep it brief: ask `quiz` skill for the due concepts only, not a full 5-7 question mix, when fewer than 3 are due. Open with: "Before we continue, there are seeds planted in earlier sessions that need tending today. Let us spend a few minutes reviewing [N] concepts."

**Never-taught concepts due (`neverTaught: true`)** — these need first teaching, not a quiz. Do NOT send them to `quiz` skill. After any taught-concept review above, surface them as the natural next step:

> "You also have [neverTaughtCount] concept(s) seeded from your assessment but not yet taught: `<concept>` (and N others). These are due, but quizzing a concept you have not been taught tests nothing — so let us actually teach the first one. Shall we start with `<concept>`?"

Phrase by `exposure`: `seeded` → "seeded from your assessment, never taught"; `quizzed-only` → "we have asked about it, but never taught it or seen you build with it".

On agreement, **auto-invoke `teach` skill with request context `--invoked-from=continue <concept>`** (the lowest `priority` among `neverTaught: true` — the list is already in review order). This makes first-teaching, not cold quizzing, the default for a freshly-seeded project — the fix for the "all questions, no teaching" trap a new learner otherwise falls into when three kickoffs seed a large Day-1 review pile. If the learner would rather quiz them as a cold self-check or skip to today's new module, honor that — this is an offer, not a redirect.

### After review (or if no review needed):

Present options:

"Today we could:
1. Continue with [current module — next item]
2. Practice what we covered last time
3. Something else you have in mind

What feels right?"

### If the learner chooses option 1 (continue):

**Auto-invoke `teach` skill with request context `--invoked-from=continue <next concept or module>`** — pass the resolved topic positionally after the flag (the callee skips discovery and expects the caller to name the target). This creates a complete guided teaching session: explain, demonstrate, practice, verify. The passed topic is orchestration, not a learner override: when it opens a new module, `teach` skill still runs the prerequisite gate and may surface an offer before teaching.

### If the learner chooses option 2 (practice):

**Auto-invoke `practice` skill with request context `--invoked-from=continue <topic>`** — pass the most recent topic positionally; if the `due` list has a concept from the current module, pass the lowest-`priority` one (preserving practice's highest-leverage targeting, which its skipped discovery phase would otherwise have done).

---

## Phase 5: Session End

When the learner indicates they are done (says goodbye, "I am done," "that is enough for today," or similar):

**Auto-invoke `reflect` skill with request context `--invoked-from=continue`** to run the end-of-session metacognitive reflection. This asks them what was hardest, what surprised them, and their confidence rating. It feeds reflection data back into spaced repetition tracking.

### Session State Updates

After reflection (or if the learner declines reflection), update tracking per the `state-ops` KB write path. Sub-skills that ran (`teach` skill, `practice` skill, `reflect` skill) already performed their own writes — do not repeat them; cover only what happened outside the sub-skills:

1. **Session bookkeeping** (the script counts the session, maintains the streak, and never double-counts a day):

   ```
   "<BODHIKIT_PLUGIN_ROOT>/scripts/bodhi-state" --project <project> touch-state \
     --activity "<one line, ≤120 chars>" [--module "<where they ended up>"] [--completion N]
   ```

2. **Spaced-review updates** are already done — the Phase 4 due batch went through `quiz` skill, which wrote its own reviews and session entry. Do not repeat them.

3. **Append a session entry to `progress.md` by writing it** — only if no sub-skill already wrote today's entry: `## YYYY-MM-DD — Session N (<short label>)`, then **Duration**, **Activities**, **Outcomes**, **Bloom adjustments**, **Next**. 1-2 paragraphs for routine sessions; up to 20 lines for milestones. Existing content preserved verbatim below.

**Fallback:** if `bodhi-state` is unavailable, follow the `state-schema` KB fallback rule — manual read → mutate-in-place → write → verify, preserving unknown fields.

4. **Revision sheet** — if `reflect` skill did not run (it writes the sheet itself), write today's **revision sheet** per `references/revision-sheet.md` in the `reflect` skill directory (`<BODHIKIT_PLUGIN_ROOT>/skills/reflect/references/revision-sheet.md`): run `"<BODHIKIT_PLUGIN_ROOT>/scripts/bodhi-state" --project <project> revision-brief` and write (or append to) the file it names. A session that studied something should not end without one. Codex may enforce this with the optional Stop hook; ChatGPT must complete it explicitly.

5. Close warmly: "Good work today. [Specific mention of what they accomplished]. Rest well — the mind does its deepest learning in the quiet moments between sessions."

6. **Optionally invoke `housekeep` skill** if this was a long session OR `progress.md` now carries 3+ live session entries. `housekeep` skill rotates older entries into `progress/archive/` and writes the summary line. Skipping is fine — `housekeep` skill is idempotent and the learner can run it later.

---

## Streak Acknowledgments

Use the canonical streak table from the `teaching-personality` KB. Do not restate.

---

## Auto-Invocation Flow

```
`continue` skill
  ├── 3-line check-in (bodhi-state snapshot)
  ├── `quiz` skill (chained, for due concepts)
  ├── learner chooses what to do
  │     ├── option 1 → `teach` skill (guided teaching session)
  │     └── option 2 → `practice` skill (hands-on exercise)
  └── learner says done → `reflect` skill (end-of-session reflection)
```

This flow means a learner can run `continue` skill every day and get a complete, structured learning session without needing to know which skills to invoke.