dsh-diagnostic-tutor 0.1.0 → 0.1.1

package/README.md

@@ -11,9 +11,14 @@ learn interactively, and move to the next best step.
 
 ## Status
 
-`v0.1.0` — the first stable release, and the first one meant to be **installed
-rather than built**: `dsh plugin --profile web add dsh-diagnostic-tutor`, with
-prebuilt output and no clone, no `pnpm install`, no build step.
+`v0.1.1` — the current stable release. Conversation-scoped projects, focus,
+next steps and handoffs keep each learning session separate, while maps and
+lessons remain shared. The Learning UI now offers one next action and reports
+its actual state, with working scroll containers in docked and expanded views.
+
+Install the prebuilt package with
+`dsh plugin --profile web add dsh-diagnostic-tutor@0.1.1` — no clone, no
+`pnpm install`, no build step.
 
 The learning loop works end to end: a real goal in your own words, a diagnosis
 map grown one node at a time, a tutor-written lesson, a check answered in the
@@ -126,13 +131,11 @@ library plus fonts and CSS, and the client bundle is a single JavaScript file
 with nowhere to serve those from. This is the most visible rough edge in any
 STEM lesson.
 
-**Skill presence cannot always be detected.** The runtime reports whether the
-Universal Diagnostic Tutor skill is available, but the skill registry reads the
-*global* layer unless it is given a viewing scope, and the standard web profile
-mounts skills per agent. From a plugin at the profile root the catalog is
-therefore empty whether the skill is installed or not. The runtime says
-`cannot tell` rather than guessing, and the panel stays quiet. If lessons never
-appear, check the skill first.
+**Skill presence requires a live Agent.** The runtime checks the open
+conversation's Agent scope on each overview, including its workspace. Before an
+Agent exists, or while discovery is empty or incomplete, it reports `cannot tell`
+and the panel stays quiet. Polling picks up later registration and Agent changes.
+If lessons never appear, check the skill first.
 
 **Storage is one document.** Every record lives in
 `<dsh-home>/storages/udt.json`. It is readable, copyable and easy to export, and
@@ -154,6 +157,7 @@ matrix as load-bearing, not decoration.
 
 | This plugin | Verified against DSH | Node |
 | --- | --- | --- |
+| `0.1.1` | `0.2.1-rc.2`, `0.2.0-rc.2` (test suite also on `0.1.7-alpha.2`) | `^22.19.0 \|\| >=24.0.0` |
 | `0.1.0` | `0.1.7-alpha.2` (also composed under `0.1.5-rc.1`) | `^22.19.0 \|\| >=24.0.0` |
 
 Rules this repository enforces mechanically:
@@ -165,7 +169,10 @@ Rules this repository enforces mechanically:
   second runtime copy can be resolved. Enforced by `verbatimModuleSyntax`, and
   verified on the built artifact (it contains zero imports).
 - **No `instanceof` across package boundaries.** Take runtime objects from `ctx`.
-- Peer ranges are wide (`<0.2.0`); dev dependencies pin one exact cohort.
+- Peer ranges name the release lines this plugin was verified on. DSH ships
+  prereleases, and npm's semver only admits a prerelease when its line is named
+  in the range — so the compatibility matrix above, not the range floor, is the
+  contract. Dev dependencies pin one exact cohort for the type baseline.
 
 ---
 
@@ -175,7 +182,7 @@ Rules this repository enforces mechanically:
 
 | | |
 | --- | --- |
-| [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) | verified against `0.1.7-alpha.2` |
+| [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) | verified against `0.2.1-rc.2` |
 | the [Universal Diagnostic Tutor](https://github.com/SenmuuuuW/universal-diagnostic-tutor-skill) skill | the teaching brain. Without it the runtime loads, records and displays state, but **no lesson is ever written** |
 | Node | `^22.19.0 \|\| >=24.0.0` |
 
@@ -227,7 +234,7 @@ learn?*.
 
 ```sh
 npm pack
-dsh plugin --profile web add "$PWD/dsh-diagnostic-tutor-0.1.0-rc.1.tgz"
+dsh plugin --profile web add "$PWD/dsh-diagnostic-tutor-0.1.1.tgz"
 ```
 
 **What gets installed is prebuilt.** The package ships `lib/` — the host half
@@ -258,10 +265,30 @@ With the json backend you get exactly one document, `<storage root>/udt.json`
 
 | Slot | Holds |
 | --- | --- |
-| `global` | the learner singleton — preferences, active goal, `initializedAt` |
+| `global` | the learner singleton — preferences, `initializedAt`, and the legacy shared `activeCourseId` marker |
 | `tables.courses` | one record per learning goal, in the learner's own words |
 | `tables.nodes` | the diagnosis map: `id`, `courseId`, `title`, `parentId?`, `relation`, `state`, `evidence[]` |
 
+Courses, maps, lessons and evidence are shared by the learner's conversations.
+Project selection, focus, next step and handoff belong to one conversation,
+identified by its session ID. The legacy `activeCourseId` remains in storage for
+compatibility; it does not select a project for a conversation. A fresh
+conversation starts with the library, even when historical projects exist.
+
+| Conversation selection | Project binding |
+| --- | --- |
+| `none` | A new goal, or a validated write explicitly naming a course or node in this conversation, may select its project. Reading shared data does not select it. |
+| `new` | The learner pressed **Start something new**. Only a new goal created here may bind; historical map or lesson writes leave this choice intact. |
+| `project` | The selected course is the default for tools. Creating another goal does not replace it; writes to another course require selecting that course first. |
+
+`udt_status` reports this conversation's `selection` and, only for `project`,
+its `courseId`. Goal, map and lesson writes return `projectAdopted` and
+`projectBinding`: `adopted`, `already-selected`, `not-selected`, or
+`missing-session-id`. A choice made while a write is pending takes precedence
+over that write's adoption. Without a reliable session ID, status reports
+`sessionAvailable: false`; explicit shared writes can still be stored, but their
+result is `missing-session-id` and they claim no conversation binding.
+
 Two deliberate rules:
 
 - **zod is the contract.** Every record is validated at the durable boundary, so
@@ -294,13 +321,13 @@ route around them:
 
 ### Tools
 
-Five, and none of them decides anything about teaching.
+Six, and none of them decides anything about teaching.
 
 | Tool | Does |
 | --- | --- |
-| `udt_status` | reports the runtime: domain, version, goals, map, **and the current focus** |
-| `udt_goal_create` | records a goal and plants the map root — and nothing else |
-| `udt_map_get` | reads the map with each node's relation, state and evidence |
+| `udt_status` | reports shared goals and counts, plus this conversation's selection, focus and pending next step |
+| `udt_goal_create` | records a goal and plants only the map root; may also select it for this conversation |
+| `udt_map_get` | reads the selected project's map, or an explicitly named shared course, with each node's relation, state and evidence |
 | `udt_map_update` | `add-nodes` · `set-state` · `add-evidence` |
 | `udt_lesson_update` | writes teaching into the learning surface as blocks |
 | `udt_decide_next` | records where the learner should go next, and why |
@@ -394,19 +421,20 @@ conversation rather than at load.
 
 ### Teaching-brain detection
 
-At load the plugin asks the platform's own skill registry whether the
-Universal Diagnostic Tutor skill is installed — no path is hardcoded, no skill
-root is assumed, and nothing is copied. A missing catalog, a missing skill and
-an unreadable body each degrade to a reported status rather than an error.
+Each overview asks the platform's own Agent and Skill registries whether the
+Universal Diagnostic Tutor skill is available in the requesting session's live
+Agent scope and cwd. No path is hardcoded, no skill root is assumed, and nothing
+is copied. Missing services and incomplete discovery return an inconclusive
+status; complete scoped discovery can establish presence or absence.
 
 Compatibility is probed by **capability**, not by a version string: the skill's
 maintenance contract permits only `name` and `description` in frontmatter, so
 it cannot declare a version. The result carries a short content digest as a
 version hint.
 
-Detection results stay **internal** — logged at `debug`, absent from every tool
-output. The skill forbids naming its files, versions or repository in
-learner-facing text, and this runtime will not be what leaks them.
+Paths, fingerprints and compatibility details stay **internal**, absent from
+every tool output and overview. The overview exposes only availability. The skill
+forbids naming its files, versions or repository in learner-facing text.
 
 ### How the two halves agree
 
@@ -492,18 +520,61 @@ Machine Learning            [goal, unconfirmed]
 └─ Python                   [prerequisite, unconfirmed]
 ```
 
+Two query parameters reach the states that are otherwise awkward to produce on
+demand — `?scenario=` (`first-use`, `map`, `handoff`, `next`, `stay`, `noskill`,
+`long`, `scroll`, `library`, `new`) and `?surface=tab` for the docked right-sidebar
+tab. The scenario switch is in the page's toolbar, and the theme toggle sets the same
+`body[data-ds-dark-theme]` attribute DSH does. The page carries the real DSH
+design tokens for the same reason: with hardcoded fallbacks in their place, a
+token that resolves to near-white in dark mode looks perfectly fine locally.
+
 To capture the panel from a *live* profile instead:
 
 ```sh
 pnpm screenshot "<dsh-url-with-token>" preview/dsh-ui.png
 ```
 
+### Auditing the presentation
+
+```sh
+pnpm preview                                                     # in one shell
+pnpm audit:ui http://127.0.0.1:8391/?scenario=next                # in another
+pnpm audit:ui "<dsh-url-with-token>" /tmp/audit --surface=tab
+pnpm check:scroll http://127.0.0.1:8391/ /tmp/udt-scroll-check
+```
+
+The scroll regression requires local Chrome and runs against the built bundle.
+The preview uses a clipped, fixed-height slot like DSH, so the whole document
+cannot scroll to mask an unscrollable plugin. The check sends real wheel events
+and verifies bottom content remains visible in the tab, expanded tab, stacked
+panel, all three wide-panel panes, and long library/welcome views, in both themes.
+Only fixture data is used; no live learner state is changed. The ordinary visual
+audit alone does **not** verify scrolling.
+
+The visual audit measures, at each width this project targets and in both themes: the contrast
+of every control's own text against its own fill, class names in the DOM that no
+rule matches, how many controls carry primary weight in one view, tap targets
+under 28px, type under 10.5px, and anything spilling or clipped. It prints a
+table, writes `findings.json`, and saves screenshots — it does not fail the run,
+so a human can disagree with it.
+
+That is not a substitute for looking. It is what makes looking affordable: the
+docked tab's invisible primary button and the dark-mode 1.05:1 controls were
+both found by it, in a live profile, in seconds.
+
+What the surfaces look like now, captured from a live profile:
+
+| | light | dark |
+| --- | --- | --- |
+| full panel | ![panel, light](preview/ui-polish/panel-light-1440.png) | ![panel, dark](preview/ui-polish/panel-dark-1440.png) |
+| docked tab | ![tab, light](preview/ui-polish/tab-light-400.png) | ![tab, dark](preview/ui-polish/tab-dark-400.png) |
+
 ## Development
 
 ```sh
 pnpm install
 pnpm typecheck   # tsc --noEmit  (host and client)
-pnpm test        # 253 tests: unit, guard, DOM, render, real composition
+pnpm test        # 455 tests: unit, guard, DOM, render, real composition
 pnpm build       # tsc -> lib/ (host) + tsdown -> lib/client.js
 ```
 
@@ -571,18 +642,19 @@ panel opens, the map and the lesson surface render, and `GET /export` and
 `POST /reset` work. What does not happen is teaching — nothing writes a lesson,
 because nothing is making teaching decisions.
 
-**The plugin cannot always tell you that.** The skill registry reads the
-*global* layer unless it is given a viewing scope, and the standard web profile
-mounts the filesystem skill provider **inside a per-agent layer**. So a plugin
-at the profile root sees an empty skill catalog whether the skill is missing or
-merely mounted where it cannot look. The runtime therefore reports three states,
-not two:
+**Availability is checked for the conversation you have open.** On every
+`GET /overview?sessionId=…`, the plugin resolves that session's live Agent from
+DSH's Agent registry and asks the Skill registry for a complete snapshot using
+`{ scope: agent, cwd: agent.session.header.cwd }`. A root catalog containing
+Office skills cannot establish whether that Agent has a tutor. Services are
+resolved for each request, so delayed registration, removal and preset changes
+are picked up by the panel's existing polling. The runtime reports three states:
 
 | `teachingBrain` | meaning | what the panel does |
 | --- | --- | --- |
-| `true` | found | nothing |
-| `false` | not found, **in a catalog that has entries** | says a tutor is needed |
-| `null` | cannot tell from this scope | says nothing |
+| `true` | found and model-invocable in the live Agent scope | nothing |
+| `false` | unavailable after complete scoped discovery with entries | says a tutor is needed |
+| `null` | no live Agent, empty/incomplete discovery, or unsupported/unavailable service | says nothing |
 
 An earlier revision treated "not in my catalog" as "not installed" and showed a
 notice on that basis. In a web profile that was a confident, wrong answer — the

package/lib/api.js

@@ -102,24 +102,104 @@ function stringField(body, key) {
 /* Handler                                                                    */
 /* -------------------------------------------------------------------------- */
 /**
- * Which course the panel should show: the learner's active goal, else the most
- * recently updated one. Read-only — the panel never changes focus implicitly.
+ * The focus this conversation is working on, or nothing.
+ *
+ * Learning state belongs to a conversation, not to a course. The course and its
+ * map and its lessons are shared knowledge and stay visible to everyone; where
+ * *this* conversation has got to is not. A focus carrying a different
+ * conversation's id — or none at all, which means it predates the field — is
+ * not this panel's to show, so it reports nothing rather than someone else's
+ * lesson under the learner's chat.
+ *
+ * @param state - the runtime.
+ * @param courseId - the course being viewed.
+ * @param sessionId - the conversation asking, when it said.
+ * @returns the focus record, or undefined.
  */
-function currentCourse(state) {
-    const activeId = state.readLearner().activeCourseId;
-    if (activeId !== undefined) {
-        const active = state.readCourse(activeId);
-        if (active !== undefined)
-            return active;
-    }
+function focusBelongingTo(state, courseId, sessionId) {
+    // No conversation named means no conversation's state: guessing is what let
+    // one conversation's lesson appear under another's chat.
+    if (sessionId === undefined || sessionId.length === 0)
+        return undefined;
+    return state.readFocus(sessionId, courseId);
+}
+/** The project a conversation has open, if any. */
+function projectFor(state, sessionId) {
+    return state.resolveProject(sessionId).course;
+}
+/**
+ * Every Learning Project, with the numbers the library shows on a card.
+ *
+ * Learner-level, like the maps and lessons themselves: this is what the
+ * learner has, not what this conversation is doing with it.
+ */
+function libraryOf(state) {
     return state
         .listCourses()
-        .slice()
-        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0];
+        .map((course) => {
+        const nodes = state.listNodes(course.id);
+        return {
+            id: course.id,
+            title: course.title,
+            goal: course.goal,
+            confirmed: nodes.filter((node) => node.state === 'confirmed').length,
+            total: nodes.length,
+            updatedAt: course.updatedAt,
+        };
+    })
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+async function handleOverview(state, deps, sessionId, res) {
+    // Availability belongs to the requesting conversation and can change while
+    // the plugin stays loaded. A failed observation is inconclusive.
+    let teachingBrain = null;
+    try {
+        teachingBrain = typeof deps.teachingBrain === 'function'
+            ? await deps.teachingBrain(sessionId)
+            : deps.teachingBrain ?? null;
+    }
+    catch {
+        // The runtime remains readable if discovery is temporarily unavailable.
+    }
+    const { selection, course } = state.resolveProject(sessionId);
+    const library = libraryOf(state);
+    if (course === undefined) {
+        // No project open in this conversation. That is the library, not an error,
+        // and not an empty runtime: the projects it lists are real and shared.
+        sendJson(res, 200, {
+            ok: true,
+            selection,
+            course: null,
+            nodes: [],
+            focus: null,
+            nextStep: null,
+            handoff: null,
+            teachingBrain,
+            lessonCount: state.lessonCount(),
+            library,
+        });
+        return;
+    }
+    const mine = focusBelongingTo(state, course.id, sessionId);
+    sendJson(res, 200, {
+        ok: true,
+        selection,
+        course: courseView(course),
+        nodes: state.listNodes(course.id).map(nodeView),
+        focus: mine === undefined ? null : focusOf(state, sessionId ?? '', course.id),
+        // A decision is attached to a focus, so it follows the same rule.
+        nextStep: mine === undefined ? null : nextStepOf(state, sessionId ?? '', course.id),
+        teachingBrain,
+        // The handoff for whichever node is focused, so a reload or a restart
+        // rebuilds the progress line instead of showing a blank wait.
+        handoff: mine === undefined ? null : handoffFor(state, sessionId ?? '', mine.nodeId, Date.now()),
+        lessonCount: state.lessonCount(),
+        library,
+    });
 }
 /** The active focus for one course, joined with its node, as a view. */
-function focusOf(state, courseId) {
-    const focus = state.readFocus(courseId);
+function focusOf(state, sessionId, courseId) {
+    const focus = state.readFocus(sessionId, courseId);
     if (focus === undefined || focus.status !== 'active')
         return null;
     const node = state.readNode(focus.nodeId);
@@ -135,11 +215,11 @@ function focusOf(state, courseId) {
  * fresh record without `nextStepId`, so acting on a recommendation clears it
  * without anything having to remember that it did.
  */
-function nextStepOf(state, courseId) {
-    const focus = state.readFocus(courseId);
+function nextStepOf(state, sessionId, courseId) {
+    const focus = state.readFocus(sessionId, courseId);
     if (focus?.nextStepId === undefined)
         return null;
-    const step = state.readNextStep(focus.nextStepId);
+    const step = state.readNextStep(sessionId, focus.nextStepId);
     if (step === undefined)
         return null;
     const from = state.readNode(step.fromNodeId);
@@ -154,55 +234,63 @@ function nextStepOf(state, courseId) {
         createdAt: step.createdAt,
     };
 }
-function handleOverview(state, deps, res) {
-    const course = currentCourse(state);
-    if (course === undefined) {
-        // An empty state is a normal state, not an error: the panel says so. The
-        // shape must still be complete — an omitted field reads as `undefined`,
-        // and a surface that checks `teachingBrain === false` would never fire in
-        // the one state it exists for.
-        sendJson(res, 200, {
-            ok: true,
-            course: null,
-            nodes: [],
-            focus: null,
-            nextStep: null,
-            handoff: null,
-            teachingBrain: deps.teachingBrain ?? null,
-            lessonCount: 0,
-        });
-        return;
+/**
+ * The focus this conversation is working on, or nothing.
+ *
+ * Learning state belongs to a conversation, not to a course. The course and its
+ * map and its lessons are shared knowledge and stay visible to everyone; where
+ * *this* conversation has got to is not. A focus carrying a different
+ * conversation's id — or none at all, which means it predates the field — is
+ * not this panel's to show, so it reports nothing rather than someone else's
+ * lesson under the learner's chat.
+ *
+ * @param state - the runtime.
+ * @param courseId - the course being viewed.
+ * @param sessionId - the conversation asking, when it said.
+ * @returns the focus record, or undefined.
+ */
+/**
+ * `POST /project { sessionId, courseId? }` — choose what this conversation learns.
+ *
+ * The choice is the conversation's, and that is the whole point of the route:
+ * the projects are shared, but opening one is a decision a conversation makes
+ * and keeps. Sending no `courseId` selects "start something new", which is a
+ * deliberate state — it stops the library being shown and stops any project
+ * being opened, until the tutor creates one here.
+ *
+ * Selecting never fabricates execution state. There is no focus until the
+ * learner starts a node, so switching projects shows "no learning focus yet"
+ * rather than pretending the previous project's position carried over.
+ */
+async function handleSelectProject(state, req, res) {
+    const body = await readJsonBody(req);
+    if (body === undefined)
+        return fail(res, 400, 'bad-body');
+    const sessionId = stringField(body, 'sessionId');
+    if (sessionId === undefined)
+        return fail(res, 400, 'missing-session-id');
+    const courseId = stringField(body, 'courseId');
+    if (courseId !== undefined && state.readCourse(courseId) === undefined) {
+        return fail(res, 404, 'no-such-course');
     }
-    sendJson(res, 200, {
-        ok: true,
-        course: courseView(course),
-        nodes: state.listNodes(course.id).map(nodeView),
-        focus: focusOf(state, course.id),
-        nextStep: nextStepOf(state, course.id),
-        teachingBrain: deps.teachingBrain ?? null,
-        // The handoff for whichever node is focused, so a reload or a restart
-        // rebuilds the progress line instead of showing a blank wait.
-        handoff: (() => {
-            const focus = state.readFocus(course.id);
-            return focus === undefined ? null : handoffFor(state, focus.nodeId, Date.now());
-        })(),
-        lessonCount: state.lessonCount(),
-    });
+    const record = await state.selectProject(sessionId, courseId, new Date().toISOString());
+    sendJson(res, 200, { ok: true, project: record });
 }
 /** `GET /lesson?nodeId=` — the lesson the tutor has written for a node, if any. */
-function handleLesson(state, course, nodeId, res) {
-    if (course === undefined)
-        return fail(res, 404, 'no-course');
+function handleLesson(state, nodeId, res) {
+    // Resolved from the node, not from the caller's project: a lesson belongs to
+    // the learner, and asking for one should not depend on what this conversation
+    // happens to have open.
     const node = state.readNode(nodeId);
-    if (node === undefined || node.courseId !== course.id)
+    if (node === undefined || state.readCourse(node.courseId) === undefined) {
         return fail(res, 404, 'no-such-node');
+    }
     sendJson(res, 200, { ok: true, lesson: state.lessonForNode(nodeId) ?? null });
 }
-function handleNode(state, course, nodeId, res) {
-    if (course === undefined)
-        return fail(res, 404, 'no-course');
+function handleNode(state, nodeId, res) {
     const node = state.readNode(nodeId);
-    if (node === undefined || node.courseId !== course.id)
+    const course = node === undefined ? undefined : state.readCourse(node.courseId);
+    if (node === undefined || course === undefined)
         return fail(res, 404, 'no-such-node');
     const parent = node.parentId === undefined ? undefined : state.readNode(node.parentId);
     const children = state
@@ -229,8 +317,8 @@ function handleNode(state, course, nodeId, res) {
 /** How long a handoff is left alone before another request is treated as a retry. */
 const HANDOFF_DEDUPE_MS = 3000;
 /** Build the handoff view, which is what a surface renders. */
-function handoffFor(state, nodeId, nowMs) {
-    const record = state.readHandoff(nodeId);
+function handoffFor(state, sessionId, nodeId, nowMs) {
+    const record = state.readHandoff(sessionId, nodeId);
     if (record === undefined)
         return null;
     return handoffView(record, nowMs, state.lessonForNode(nodeId) !== undefined);
@@ -251,9 +339,7 @@ function handoffFor(state, nodeId, nowMs) {
  * returns it untouched, which is what makes a double click harmless; a request
  * after it has gone quiet is a retry and bumps the attempt count.
  */
-async function handleStartFocus(state, deps, course, req, res) {
-    if (course === undefined)
-        return fail(res, 404, 'no-course');
+async function handleStartFocus(state, deps, req, res) {
     const body = await readJsonBody(req);
     if (body === undefined)
         return fail(res, 400, 'bad-body');
@@ -261,38 +347,51 @@ async function handleStartFocus(state, deps, course, req, res) {
     if (nodeId === undefined)
         return fail(res, 400, 'missing-node-id');
     const sessionId = stringField(body, 'sessionId');
+    // Required: a focus that cannot say whose it is cannot be shown to anyone,
+    // so accepting one would create state nobody could ever see.
+    if (sessionId === undefined)
+        return fail(res, 400, 'missing-session-id');
+    // The course comes from the NODE, not from what this conversation had open.
+    // Starting a node in a project is choosing that project — the other
+    // direction is the one that must not happen, and does not: selecting a
+    // project never invents a focus.
     const node = state.readNode(nodeId);
-    if (node === undefined || node.courseId !== course.id)
+    const course = node === undefined ? undefined : state.readCourse(node.courseId);
+    if (node === undefined || course === undefined)
         return fail(res, 404, 'no-such-node');
+    const chosen = state.readProject(sessionId);
+    if (chosen?.courseId !== course.id) {
+        await state.selectProject(sessionId, course.id, new Date().toISOString());
+    }
     const now = new Date();
-    const previous = state.readHandoff(nodeId);
+    const previous = state.readHandoff(sessionId, nodeId);
     // Double-click protection: the same target, still in flight and recent, is
     // the same handoff. Not an error — just nothing new to do.
     if (previous !== undefined &&
         previous.status !== 'failed' &&
         now.getTime() - Date.parse(previous.requestedAt) < HANDOFF_DEDUPE_MS) {
-        const focus = state.readFocus(course.id);
+        const focus = state.readFocus(sessionId, course.id);
         sendJson(res, 200, {
             ok: true,
             focus: focus === undefined ? null : focusView(focus, node),
             prompted: previous.promptedAt !== undefined,
-            handoff: handoffFor(state, nodeId, now.getTime()),
+            handoff: handoffFor(state, sessionId, nodeId, now.getTime()),
             deduped: true,
         });
         return;
     }
     let handoff = beginHandoff({
         courseId: course.id,
-        fromNodeId: previous?.fromNodeId ?? state.readFocus(course.id)?.nodeId ?? nodeId,
+        fromNodeId: previous?.fromNodeId ?? state.readFocus(sessionId, course.id)?.nodeId ?? nodeId,
         targetNodeId: nodeId,
         now: now.toISOString(),
-        ...(sessionId === undefined ? {} : { sessionId }),
+        sessionId,
         ...(previous === undefined ? {} : { previous }),
     });
     await state.writeHandoff(handoff);
     let focus;
     try {
-        focus = await state.startFocus(course.id, nodeId, now.toISOString());
+        focus = await state.startFocus(course.id, nodeId, now.toISOString(), sessionId);
     }
     catch (error) {
         // Covers an unknown node and a node from another course alike.
@@ -310,7 +409,7 @@ async function handleStartFocus(state, deps, course, req, res) {
         focus: focusView(focus, node),
         prompted: outcome.prompted,
         ...(outcome.reason === undefined ? {} : { promptReason: outcome.reason }),
-        handoff: handoffFor(state, nodeId, Date.now()),
+        handoff: handoffFor(state, sessionId, nodeId, Date.now()),
     });
 }
 /**
@@ -350,11 +449,14 @@ async function handleObserved(state, req, res) {
     const nodeId = stringField(body, 'nodeId');
     if (nodeId === undefined)
         return fail(res, 400, 'missing-node-id');
-    const record = state.readHandoff(nodeId);
+    const sessionId = stringField(body, 'sessionId');
+    if (sessionId === undefined)
+        return fail(res, 400, 'missing-session-id');
+    const record = state.readHandoff(sessionId, nodeId);
     if (record === undefined)
         return fail(res, 404, 'no-handoff');
     await state.writeHandoff(withObserved(record, new Date().toISOString()));
-    sendJson(res, 200, { ok: true, handoff: handoffFor(state, nodeId, Date.now()) });
+    sendJson(res, 200, { ok: true, handoff: handoffFor(state, sessionId, nodeId, Date.now()) });
 }
 /**
  * Build the request handler.
@@ -368,9 +470,15 @@ export function createApiHandler(deps) {
         const method = req.method ?? 'GET';
         const url = new URL(req.url ?? '/', 'http://localhost');
         const route = url.pathname.slice(API_PREFIX.length) || '/';
-        const course = currentCourse(state);
-        if (method === 'GET' && route === '/overview')
-            return handleOverview(state, deps, res);
+        // Read per request, not once: a conversation's project is its own, and the
+        // route that changes it must not be answered from a value captured before.
+        const asker = url.searchParams.get('sessionId') ?? undefined;
+        const course = projectFor(state, asker);
+        if (method === 'GET' && route === '/overview') {
+            return handleOverview(state, deps, url.searchParams.get('sessionId') ?? undefined, res);
+        }
+        if (method === 'POST' && route === '/project')
+            return await handleSelectProject(state, req, res);
         if (method === 'GET' && route === '/export')
             return handleExport(state, res);
         if (method === 'POST' && route === '/reset')
@@ -379,16 +487,16 @@ export function createApiHandler(deps) {
             const nodeId = url.searchParams.get('id');
             if (nodeId === null || nodeId.length === 0)
                 return fail(res, 400, 'missing-id');
-            return handleNode(state, course, nodeId, res);
+            return handleNode(state, nodeId, res);
         }
         if (method === 'GET' && route === '/lesson') {
             const nodeId = url.searchParams.get('nodeId');
             if (nodeId === null || nodeId.length === 0)
                 return fail(res, 400, 'missing-node-id');
-            return handleLesson(state, course, nodeId, res);
+            return handleLesson(state, nodeId, res);
         }
         if (method === 'POST' && route === '/focus') {
-            return handleStartFocus(state, deps, course, req, res);
+            return handleStartFocus(state, deps, req, res);
         }
         if (method === 'POST' && route === '/handoff/observed') {
             return handleObserved(state, req, res);