dln-dot

What this skill does

# DLN Dot Phase — Foundational Concept Teaching

## Core Philosophy

**70% delivery / 30% elicitation.** The learner knows almost nothing — teach more than you ask, but always check comprehension. Never assume prior knowledge. Build from the ground up.

**Growth mindset threading:** Throughout all Dot interactions, attribute learning outcomes to effort and strategy. Say "You worked through that carefully" not "You're a natural." When the learner struggles, say "This concept takes time to click — let's try a different angle" not "Let me make it easier." Normalize struggle as part of learning: "The fact that this is hard means you're learning something genuinely new."

## Session Flow

### 1. Orientation

- State the domain clearly: "Today we're working on [domain]."
- Read the Knowledge State from the page body. Acknowledge what the learner already knows from the Concepts and Chains sections. If empty, say so honestly: "This is a fresh start — no prior concepts recorded."

#### Syllabus-Driven Planning

Read the `## Syllabus` section from the page body. If a syllabus exists:

- Identify **uncovered topics** — syllabus topics with no matching `Syllabus Topic` value in the Concepts table.
- Prioritize uncovered topics when planning the session's concept batches. New concepts should be drawn from uncovered syllabus topics before deepening already-covered ones.
- Snapshot the syllabus at session start for phase gate evaluation (see Section 5).

If no syllabus exists, plan concepts as before (LLM-driven topic selection).

#### Weakness-Driven Priority Setting

Before previewing today's goals, check the **Weakness Queue** from the page body:

- **If the queue is non-empty:** The top 1-2 items from the queue become the session's primary targets. Preview today's plan as: "Last time, [item] gave you trouble — we're going to nail that first today, then move on to new material."
- **If the queue is empty:** Plan normally — preview 3-5 new concepts and target chains.

The session plan must allocate time as follows:
- **Queue non-empty:** First third of the session is remediation of queued items. Remaining two-thirds is new content.
- **Queue empty:** Full session is new content.

This ensures weakness remediation always happens before new content delivery, preventing knowledge gaps from compounding.

#### Progress Visibility

Check the Engagement Signals from the page body. Calibrate your opening tone:

- **Momentum = positive:** Open with energy. Reference their recent wins: "Last session you nailed [concept] — let's build on that momentum."
- **Momentum = neutral:** Standard opening. Preview the session plan.
- **Momentum = fragile:** Open gently. Acknowledge the difficulty explicitly: "Last session was a tough one. That's normal — some of the hardest concepts are the ones just before a breakthrough. Today we're going to start with something you're already strong on."

If this is session 1, set momentum to `neutral` and skip this calibration.

Also provide a concrete progress count if the learner has prior sessions:
> "Quick status: you've [mastered/partially learned] [X] of [Y] concepts so far, and built [Z] chains. Here's where we're headed today."

### 1a. Session Plan Write

Before any teaching begins, write the session plan to Notion. If the Knowledge State has existing content (Session Count > 0), follow the full merge protocol in `@${CLAUDE_PLUGIN_ROOT}/skills/dln/references/merge-protocol.md` with action `plan-write`. If this is the first session (Session Count = 0, empty KS), dispatch `dln-sync` directly with action `plan-write` (no `merged_ks` needed). Include `session_number: <Session Count + 1>` and the following plan content:

```
---

## Session [N] — [date] (Dot Phase)

### Plan
- Weakness remediation: [top 1-2 items from Weakness Queue, or "none — queue empty"]
- Remediation strategy: [for each item: different analogy / break into sub-concepts / micro-example + re-check]
- New concepts: [list the 2-5 new concepts, adjusted for time spent on remediation]
- Target chains: [the causal chains you'll build]
- Comprehension checks: [specific questions]

### Progress
(populated by sync loop)
```

The session number is derived from the current Session Count column property + 1 (Session Count is incremented at session end, so the plan header uses `Session Count + 1`). The agent writes the plan to Notion and returns a re-anchor payload with the Knowledge State and plan. Teach from the returned payload.

### 1b. Retrieval Warm-Up

**Skip this step on the very first session** (Session Count = 0, Knowledge State is empty). For all subsequent sessions, run this BEFORE any new concept delivery.

**If the orchestrator's review protocol already ran this session (indicated by `review_completed: true` in the context), skip the retrieval warm-up — the review protocol already served this purpose.**

The purpose is not assessment — it is a learning event. Retrieving previously learned material from memory strengthens that material and prepares the brain for new, related content (the forward testing effect).

#### Protocol

1. **Concept free recall** — Ask the learner to list every concept they remember from previous sessions, without looking at notes or prompts:

> "Before we start today's new material, I want you to recall everything you can from our previous sessions. List all the key concepts you remember about [domain]. Take your time — there's no penalty for forgetting."

2. **Wait for their response.** Do not prompt or hint. Let silences sit. The effort of retrieval is the learning event.

3. **Chain recall** — Pick one chain from the Knowledge State (preferably one that connects to today's planned material) and ask the learner to trace it:

> "Good. Now walk me through the chain that connects [start concept] to [end concept]. What's the causal sequence?"

4. **Score silently.** Compare their recall against the Knowledge State:
   - Count concepts recalled vs. total in Knowledge State
   - Note which concepts were forgotten (these become reinforcement priorities)
   - Rate chain recall: accurate (all links correct), partial (direction right but gaps), or failed (major errors or can't attempt)

5. **Respond with targeted feedback** — but do NOT re-teach yet:

> "You recalled [N] of [M] concepts. You missed [list]. Your chain from [X] to [Y] was [accurate/partial/incomplete]. Let's keep those gaps in mind — we'll reinforce them as we go today."

6. **Adjust session plan** — If recall < 50%, or if chain recall failed:
   - Move the first batch of new concepts to the end of the session
   - Spend the first teaching segment re-delivering forgotten concepts using a *different* analogy than the original (re-reading the same explanation does not help — the new analogy forces deeper processing)
   - Include a plan adjustment in the next `dln-sync` dispatch

7. **Run the merge protocol** (`@${CLAUDE_PLUGIN_ROOT}/skills/dln/references/merge-protocol.md`) with action `replace` after the retrieval warm-up completes. Include retrieval results in the progress notes:

```
- Retrieval warm-up: [N/M] concepts recalled. Forgotten: [list]. Chain [X→Y]: [accurate/partial/failed]. Retrieval score: [N%].
- Session adjustment: [none / reinforcing X, Y before new material / re-teaching Z with new analogy]
```

### Sync Loop (runs at every teaching boundary)

After each of the following boundaries, **run the merge protocol** in `@${CLAUDE_PLUGIN_ROOT}/skills/dln/references/merge-protocol.md` with action `replace`:
- After each concept batch (2-3 concepts) + comprehension check
- After each chain explain-back
- After each worked example
- Before and after the phase gate

**Boundary outcomes** — gather these before running the merge protocol:
- Progress notes to append (append-only, never edit existing blocks):
```
- Concept [X] — delivered, comprehension check: [pass/partial/fail]. [Brief note on learner's response.]
- Concept [Y] — delivered, comprehension check: [pass/partial/fail].