dsh-diagnostic-tutor 0.1.0 → 0.2.0

package/lib/api.js

@@ -18,7 +18,13 @@
  */
 import { beginHandoff, handoffView, withFocusRecorded, withObserved, withPromptFailure, withPrompted, } from './handoff.js';
 import { focusPromptText } from './prompt.js';
+import { resolveLearningSession } from './project-session.js';
+import { buildDiagnostics } from './diagnostics.js';
 import { guarded } from './trust-fence.js';
+import { handlePathApi } from './path-api.js';
+import { buildIcs, sortTasks, taskView } from './plan.js';
+import { buildInsights } from './insights.js';
+import { REVIEW_RATINGS, dueCards, scheduleReview } from './review.js';
 /** Largest request body accepted, in bytes. */
 export const MAX_BODY_BYTES = 64 * 1024;
 /** Route prefix owned by this plugin. */
@@ -102,24 +108,122 @@ 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);
+        const learningPath = state.readPath(course.id);
+        const status = learningPath?.acceptedVersion != null
+            ? 'accepted'
+            : learningPath !== undefined && (learningPath.brief !== null || learningPath.assessment !== null || learningPath.curricula.length > 0)
+                ? 'active'
+                : 'legacy';
+        return {
+            id: course.id,
+            title: course.title,
+            goal: course.goal,
+            confirmed: nodes.filter((node) => node.state === 'confirmed').length,
+            total: nodes.length,
+            updatedAt: course.updatedAt,
+            status,
+            acceptedVersion: learningPath?.acceptedVersion ?? null,
+        };
+    })
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+function reviewView(card) {
+    return {
+        id: card.id, front: card.front, back: card.back, dueAt: card.dueAt,
+        ...(card.courseId === undefined ? {} : { courseId: card.courseId }),
+        ...(card.nodeId === undefined ? {} : { nodeId: card.nodeId }),
+        ...(card.sourceRefs === undefined ? {} : { sourceRefs: card.sourceRefs }),
+    };
+}
+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(),
+            tasks: sortTasks(state.listTasks()).map(taskView),
+            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(),
+        tasks: sortTasks(state.listTasks()).map(taskView),
+        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 +239,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 +258,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 +341,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 +363,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 +371,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 +433,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 +473,68 @@ 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()) });
+}
+/**
+ * `GET /preferences` — the learner's interface language, if one is saved.
+ *
+ * The value lives on the learner singleton rather than in the browser so it
+ * survives DSH restarts (the web port changes, and browser storage does not
+ * follow it) and applies to every conversation. It is a display preference
+ * only: nothing about the diagnosis, teaching or stored evidence changes.
+ */
+function handlePreferences(state, res) {
+    const language = state.readLearner().preferredLanguage;
+    sendJson(res, 200, {
+        ok: true,
+        language: language === 'en' || language === 'zh' ? language : null,
+    });
+}
+/** One of the two languages this build ships copy for. */
+const LANGUAGES = ['en', 'zh'];
+/**
+ * `POST /preferences/language { language }` — remember the interface language.
+ *
+ * Validated here rather than trusted from the body: an unknown value would
+ * leave the UI without copy after the next load, so it is rejected instead of
+ * stored.
+ */
+async function handleSetLanguage(state, req, res) {
+    const body = await readJsonBody(req);
+    if (body === undefined)
+        return fail(res, 400, 'bad-body');
+    const language = body.language;
+    if (typeof language !== 'string' || !LANGUAGES.includes(language)) {
+        return fail(res, 400, 'unsupported-language');
+    }
+    const now = new Date().toISOString();
+    await state.updateLearner({ preferredLanguage: language }, now);
+    sendJson(res, 200, { ok: true, language });
+}
+/**
+ * `GET /project/session?courseId=&sessionId=` — which conversation resumes a project.
+ *
+ * A project is shared, but where it was last studied is not. The browser asks
+ * this before "entering learning" so continuing a project opens the
+ * conversation that actually holds its focus/run instead of rebinding the
+ * project to whichever conversation happens to be on screen. Read-only: no
+ * selection is written by answering it.
+ */
+function handleProjectSession(state, url, res) {
+    const courseId = url.searchParams.get('courseId');
+    if (courseId === null || courseId.length === 0)
+        return fail(res, 400, 'missing-course-id');
+    const resolved = resolveLearningSession(state, courseId, url.searchParams.get('sessionId') ?? undefined);
+    if (resolved === null)
+        return fail(res, 404, 'no-such-course');
+    sendJson(res, 200, { ok: true, sessionId: resolved.sessionId, reason: resolved.reason });
 }
 /**
  * Build the request handler.
@@ -368,31 +548,137 @@ 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);
+        if (await handlePathApi(route, req, res, deps, url))
+            return;
+        // 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 === 'GET' && route === '/project/session')
+            return handleProjectSession(state, url, res);
+        if (method === 'GET' && route === '/diagnostics') {
+            if (deps.journal === undefined)
+                return fail(res, 503, 'diagnostics-disabled');
+            try {
+                sendJson(res, 200, await buildDiagnostics(state, deps.journal, { ...(deps.pluginVersion === undefined ? {} : { pluginVersion: deps.pluginVersion }) }));
+            }
+            catch (cause) {
+                deps.onEvent?.('diagnostics.error', { error: cause.message.slice(0, 240) });
+                return fail(res, 500, 'diagnostics-unavailable');
+            }
+            return;
+        }
+        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')
             return await handleReset(state, res);
+        if (method === 'POST' && route === '/plan/task') {
+            const input = await readJsonBody(req);
+            const taskId = input === undefined ? undefined : stringField(input, 'taskId');
+            if (taskId === undefined)
+                return fail(res, 400, 'missing-task-id');
+            const task = state.readTask(taskId);
+            if (task === undefined)
+                return fail(res, 404, 'no-such-task');
+            const status = input?.status === 'open' || input?.status === 'archived' ? input.status : 'done';
+            await state.writeTask({ ...task, status, updatedAt: new Date().toISOString() });
+            return sendJson(res, 200, { ok: true, tasks: sortTasks(state.listTasks()).map(taskView) });
+        }
+        if (method === 'GET' && route === '/insights') {
+            const courseId = url.searchParams.get('courseId') ?? course?.id;
+            if (courseId === undefined || courseId.length === 0)
+                return fail(res, 404, 'no-such-course');
+            const target = state.readCourse(courseId);
+            if (target === undefined)
+                return fail(res, 404, 'no-such-course');
+            return sendJson(res, 200, buildInsights(state, target, new Date().toISOString()));
+        }
+        if (method === 'POST' && route === '/review/undo') {
+            const input = await readJsonBody(req);
+            const cardId = input === undefined ? undefined : stringField(input, 'cardId');
+            if (cardId === undefined)
+                return fail(res, 400, 'missing-card-id');
+            const card = state.readReviewCard(cardId);
+            if (card === undefined)
+                return fail(res, 404, 'no-such-review-card');
+            const log = state.listReviewLog().filter((entry) => entry.cardId === cardId).sort((left, right) => left.at.localeCompare(right.at)).at(-1);
+            if (log === undefined || log.previousIntervalDays === undefined || log.previousEase === undefined || log.previousReps === undefined || log.previousLapses === undefined)
+                return fail(res, 409, 'cannot-undo');
+            const restored = {
+                ...card, dueAt: log.previousDue, intervalDays: log.previousIntervalDays, ease: log.previousEase,
+                reps: log.previousReps, lapses: log.previousLapses, updatedAt: new Date().toISOString(),
+            };
+            await state.writeReviewCard(restored);
+            await state.deleteReviewLog(log.id);
+            return sendJson(res, 200, { ok: true, card: reviewView(restored), remaining: dueCards(state.listReviewCards()).length });
+        }
+        if (method === 'GET' && route === '/review') {
+            const cards = dueCards(state.listReviewCards()).slice(0, 20).map(reviewView);
+            return sendJson(res, 200, { ok: true, cards, count: cards.length });
+        }
+        if (method === 'POST' && route === '/review/grade') {
+            const input = await readJsonBody(req);
+            const cardId = input === undefined ? undefined : stringField(input, 'cardId');
+            const rating = input === undefined ? undefined : stringField(input, 'rating');
+            if (cardId === undefined)
+                return fail(res, 400, 'missing-card-id');
+            if (rating === undefined || !REVIEW_RATINGS.includes(rating))
+                return fail(res, 400, 'invalid-rating');
+            const card = state.readReviewCard(cardId);
+            if (card === undefined)
+                return fail(res, 404, 'no-such-review-card');
+            const graded = scheduleReview(card, rating);
+            await state.writeReviewCard(graded.card);
+            await state.writeReviewLog(graded.log);
+            return sendJson(res, 200, { ok: true, card: reviewView(graded.card), remaining: dueCards(state.listReviewCards()).length });
+        }
+        if (method === 'GET' && route === '/plan/ics') {
+            const calendar = buildIcs(state.listTasks(), new Date());
+            res.statusCode = 200;
+            res.setHeader('content-type', 'text/calendar; charset=utf-8');
+            res.setHeader('content-disposition', 'attachment; filename="dsh-diagnostic-tutor-plan.ics"');
+            res.setHeader('cache-control', 'no-store');
+            res.end(calendar);
+            return;
+        }
+        if (method === 'GET' && route === '/source') {
+            const sourceId = url.searchParams.get('id');
+            if (sourceId === null || sourceId.length === 0)
+                return fail(res, 400, 'missing-id');
+            const source = state.readSource(sourceId);
+            if (source === undefined)
+                return fail(res, 404, 'no-such-source');
+            return sendJson(res, 200, { ok: true, source });
+        }
         if (method === 'GET' && route === '/node') {
             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);
         }
+        if (method === 'GET' && route === '/preferences') {
+            return handlePreferences(state, res);
+        }
+        if (method === 'POST' && route === '/preferences/language') {
+            return await handleSetLanguage(state, req, res);
+        }
         return fail(res, method === 'GET' || method === 'POST' ? 404 : 405, 'no-such-route');
     };
 }