dsh-diagnostic-tutor 0.1.0

package/lib/types/handoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff.d.ts","sourceRoot":"","sources":["../../src/handoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,kEAAmE,CAAA;AAChG,eAAO,MAAM,mBAAmB;;;;;;EAA2B,CAAA;AAC3D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;iBA+BxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACzD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAA;AAM/B,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;CACrC,GAAG,aAAa,CAWhB;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAEnF;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAE9E;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,CAEnG;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAG9E;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAQ5E;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAG9E;AAMD,8BAA8B;AAC9B,MAAM,MAAM,YAAY,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,eAAe,GAAG,cAAc,GAAG,QAAQ,GAAG,SAAS,CAAA;AAEzH;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,SAAU,CAAA;AAErC,MAAM,WAAW,WAAW;IAC1B,6DAA6D;IAC7D,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,YAAY,CAAA;IACnB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,uDAAuD;IACvD,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAQD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,WAAW,CA0CjG"}

package/lib/types/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * dsh-diagnostic-tutor — DeepSeek Harness plugin entry point.
+ *
+ * A DSH plugin is a module exporting `apply(ctx, config)`. Cordis calls it at
+ * load time and everything registered through `ctx` is disposed automatically
+ * on unload.
+ *
+ * ---------------------------------------------------------------------------
+ * v0.0.3 scope (see docs/planning/PLAN.md §7)
+ * ---------------------------------------------------------------------------
+ * Goal → detection → diagnosis map. The runtime now carries real product
+ * semantics: it records a learning goal in the learner's words, plants a map
+ * root, and lets a map grow one diagnosis at a time under rules that make
+ * unverified mastery impossible to store.
+ *
+ * Still deliberately absent:
+ *   - no lesson generation, no quiz system -> v0.0.4+
+ *   - no client half / UI                  -> v0.0.4
+ *   - no resource ingestion, no RAG        -> out of scope for v0.1
+ *
+ * ---------------------------------------------------------------------------
+ * Cross-version discipline (see PLAN.md 2.12 #9 / #16)
+ * ---------------------------------------------------------------------------
+ * Three harness cohorts can be resolvable at once (the running host, the
+ * shared profile fallback, and this package's own store). Therefore:
+ *
+ *   1. never `export default` — Cordis' `unwrapExports` prefers `.default` and
+ *      would silently DROP `inject`, so only named exports appear here.
+ *   2. every *type* coming from `@deepseek-ai/*` is imported with `import type`
+ *      (enforced by `verbatimModuleSyntax`), so no second runtime copy is
+ *      resolved for anything that merely describes a shape.
+ *   3. services and instances — `tools`, `storageDomain`, `skills`,
+ *      `systemPrompt`, the opened `Domain` — are always taken from `ctx` via
+ *      `ctx.get(...)`, never constructed and never `instanceof`-checked. A
+ *      cross-cohort copy would make such a check silently false.
+ *
+ * Pure *builder* helpers (`defineTool`, `defineDomain`, `domainTable`) are the
+ * one documented exception: they take plain data and return plain data, so
+ * they are imported as values. See the header of `state.ts`.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Plugin module name. Stable kebab-case, equal to the loader row `id` in
+ * cordis.patch.yml and distinct from the npm package name.
+ */
+export declare const name = "diagnostic-tutor";
+/**
+ * Services this plugin requires before it may load.
+ *
+ * Only services the standard profiles guarantee are declared here — both come
+ * from `@deepseek-ai/dsh-base`. Everything optional (the skill catalog, the
+ * system prompt) is resolved lazily with `ctx.get(...)`, so a profile without
+ * them loses the corresponding enhancement instead of leaving the whole plugin
+ * tree pending. A pending plugin prints nothing at all, which is hard to
+ * diagnose.
+ */
+export declare const inject: string[];
+/**
+ * Load the plugin.
+ *
+ * `apply` is async, and Cordis keeps the fiber in `LOADING` until the returned
+ * promise settles — so `await ctx.plugin(...)` genuinely waits for the storage
+ * domain to be open, for first-run initialization to be durable, and for the
+ * tools to be registered. A nested `ctx.inject(...)` would return its own
+ * fiber, letting the outer fiber report ACTIVE while the domain was still
+ * opening.
+ *
+ * @param ctx - the Cordis context the loader hands to this plugin.
+ */
+export declare function apply(ctx: Context): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAUlD;;;GAGG;AACH,eAAO,MAAM,IAAI,qBAAqB,CAAA;AAEtC;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,UAA6B,CAAA;AAEhD;;;;;;;;;;;GAWG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CA0HvD"}

package/lib/types/lesson.d.ts

@@ -0,0 +1,295 @@
+/**
+ * Learning Block and Lesson schemas.
+ *
+ * The data schema lives here (host side, zod-validated at the durable
+ * boundary). The **renderers live in the client half** and are keyed by
+ * `block.type`, so adding Formula, Code, Comparison, Practice or Resource later
+ * means adding one renderer entry — never rewriting the lesson renderer.
+ *
+ * A block is `{ id, type, content, metadata? }`: the envelope is uniform and
+ * `content` is shaped per type. The envelope is what the renderer registry
+ * dispatches on; `content` is what a renderer understands. An unrecognised
+ * `type` is not an error — the client falls back to a readable placeholder, so
+ * a lesson authored by a newer host still renders in an older browser half.
+ *
+ * ---------------------------------------------------------------------------
+ * What v0.0.4 deliberately does NOT do
+ * ---------------------------------------------------------------------------
+ * There is no model-generated lesson here. `buildPrototypeLesson` is a
+ * **deterministic projection of state the runtime already holds** — the node's
+ * own title, relation, state and evidence — assembled into the four block
+ * types. It exists to prove the schema and the renderer end to end.
+ *
+ * That is why every lesson carries `origin`. A prototype lesson can never be
+ * mistaken for teaching content, and when real generation arrives it will be
+ * distinguishable in the stored record rather than by convention.
+ */
+import { z } from 'zod';
+import type { CourseRecord, NodeRecord } from './state.js';
+/**
+ * A teaching unit is a few blocks, not a chapter.
+ *
+ * The cap is what makes "never generate a whole course in one call" structural
+ * rather than advisory — the same reasoning as the diagnosis map's node caps.
+ * Six leaves room for a real unit (orient, example, diagram, check) plus a
+ * correction.
+ */
+export declare const MAX_BLOCKS_PER_UPDATE = 6;
+/**
+ * A lesson accumulates across a session, so its ceiling is higher than one
+ * call's — but it is still a ceiling. Past this the lesson has stopped being a
+ * learning surface and become a document.
+ */
+export declare const MAX_BLOCKS_PER_LESSON = 24;
+/**
+ * Per-field length caps, enforced by zod at the durable boundary.
+ *
+ * Structural validation alone would accept a single 5 MB text block; these make
+ * "oversized payload" a rejection rather than a rendering problem.
+ */
+export declare const MAX_TEXT_CHARS = 6000;
+export declare const MAX_DIAGRAM_CHARS = 4000;
+export declare const MAX_PROMPT_CHARS = 1000;
+export declare const MAX_TITLE_CHARS = 200;
+export declare const MAX_STEP_CHARS = 400;
+export declare const MAX_STEPS = 12;
+export declare const TextBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    content: z.ZodObject<{
+        md: z.ZodString;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const ExampleBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"example">;
+    content: z.ZodObject<{
+        title: z.ZodString;
+        steps: z.ZodArray<z.ZodString>;
+        takeaway: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const DiagramBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"diagram">;
+    content: z.ZodObject<{
+        format: z.ZodEnum<{
+            ascii: "ascii";
+            mermaid: "mermaid";
+        }>;
+        spec: z.ZodString;
+        caption: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const CheckBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"check">;
+    content: z.ZodObject<{
+        prompt: z.ZodString;
+        expect: z.ZodOptional<z.ZodEnum<{
+            reasoning: "reasoning";
+            answer: "answer";
+        }>>;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/** Every block type this version understands. */
+export declare const BLOCK_SCHEMAS: readonly [z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    content: z.ZodObject<{
+        md: z.ZodString;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"example">;
+    content: z.ZodObject<{
+        title: z.ZodString;
+        steps: z.ZodArray<z.ZodString>;
+        takeaway: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"diagram">;
+    content: z.ZodObject<{
+        format: z.ZodEnum<{
+            ascii: "ascii";
+            mermaid: "mermaid";
+        }>;
+        spec: z.ZodString;
+        caption: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"check">;
+    content: z.ZodObject<{
+        prompt: z.ZodString;
+        expect: z.ZodOptional<z.ZodEnum<{
+            reasoning: "reasoning";
+            answer: "answer";
+        }>>;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>];
+export declare const BlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    content: z.ZodObject<{
+        md: z.ZodString;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"example">;
+    content: z.ZodObject<{
+        title: z.ZodString;
+        steps: z.ZodArray<z.ZodString>;
+        takeaway: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"diagram">;
+    content: z.ZodObject<{
+        format: z.ZodEnum<{
+            ascii: "ascii";
+            mermaid: "mermaid";
+        }>;
+        spec: z.ZodString;
+        caption: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"check">;
+    content: z.ZodObject<{
+        prompt: z.ZodString;
+        expect: z.ZodOptional<z.ZodEnum<{
+            reasoning: "reasoning";
+            answer: "answer";
+        }>>;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>], "type">;
+export type TextBlock = z.infer<typeof TextBlockSchema>;
+export type ExampleBlock = z.infer<typeof ExampleBlockSchema>;
+export type DiagramBlock = z.infer<typeof DiagramBlockSchema>;
+export type CheckBlock = z.infer<typeof CheckBlockSchema>;
+export type Block = z.infer<typeof BlockSchema>;
+export type BlockType = Block['type'];
+/** The block types this build can render, for diagnostics and tests. */
+export declare const SUPPORTED_BLOCK_TYPES: readonly BlockType[];
+/**
+ * `tutor` is what the runtime writes now: blocks the teaching brain submitted
+ * through `udt_lesson_update`.
+ *
+ * `prototype` is retained rather than removed because v0.0.4 wrote records with
+ * it, and the domain version cannot be bumped to invalidate them (the `single`
+ * layout rejects a version mismatch outright — see `state.ts`). It is no longer
+ * produced by the runtime.
+ */
+export declare const LESSON_ORIGINS: readonly ["prototype", "tutor"];
+export declare const LessonOriginSchema: z.ZodEnum<{
+    prototype: "prototype";
+    tutor: "tutor";
+}>;
+export type LessonOrigin = z.infer<typeof LessonOriginSchema>;
+export declare const LessonSchema: z.ZodObject<{
+    id: z.ZodString;
+    courseId: z.ZodString;
+    nodeId: z.ZodString;
+    title: z.ZodString;
+    blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        content: z.ZodObject<{
+            md: z.ZodString;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"example">;
+        content: z.ZodObject<{
+            title: z.ZodString;
+            steps: z.ZodArray<z.ZodString>;
+            takeaway: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"diagram">;
+        content: z.ZodObject<{
+            format: z.ZodEnum<{
+                ascii: "ascii";
+                mermaid: "mermaid";
+            }>;
+            spec: z.ZodString;
+            caption: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"check">;
+        content: z.ZodObject<{
+            prompt: z.ZodString;
+            expect: z.ZodOptional<z.ZodEnum<{
+                reasoning: "reasoning";
+                answer: "answer";
+            }>>;
+            hint: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>], "type">>;
+    origin: z.ZodEnum<{
+        prototype: "prototype";
+        tutor: "tutor";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type LessonRecord = z.infer<typeof LessonSchema>;
+export type LessonKey = string;
+/**
+ * Build a prototype lesson for one node.
+ *
+ * **Not on the runtime path any more.** v0.0.5 teaches through the tutor, and
+ * `udt_lesson_update` is how blocks arrive. This builder is kept for two
+ * honest reasons: v0.0.4 wrote `origin: 'prototype'` records that must still
+ * parse, and it is a convenient deterministic fixture for the preview and the
+ * block-renderer tests.
+ *
+ * It projects stored state into the four block types — it does not invent
+ * teaching content.
+ *
+ * @param input.course - the course the node belongs to.
+ * @param input.node - the node to build for.
+ * @param input.nodes - every node of the course, for the map diagram.
+ * @param input.now - ISO timestamp.
+ * @returns a validated lesson record.
+ */
+export declare function buildPrototypeLesson(input: {
+    course: CourseRecord;
+    node: NodeRecord;
+    nodes: readonly NodeRecord[];
+    now: string;
+}): LessonRecord;
+/**
+ * Read a block's type without trusting the value.
+ *
+ * Used by the client's renderer registry so an unknown type degrades instead of
+ * throwing.
+ *
+ * @param value - any parsed block-shaped value.
+ * @returns the declared type, or `undefined`.
+ */
+export declare function blockTypeOf(value: unknown): string | undefined;
+//# sourceMappingURL=lesson.d.ts.map

package/lib/types/lesson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lesson.d.ts","sourceRoot":"","sources":["../../src/lesson.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAM1D;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAEtC;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,OAAO,CAAA;AAClC,eAAO,MAAM,iBAAiB,OAAO,CAAA;AACrC,eAAO,MAAM,gBAAgB,OAAO,CAAA;AACpC,eAAO,MAAM,eAAe,MAAM,CAAA;AAClC,eAAO,MAAM,cAAc,MAAM,CAAA;AACjC,eAAO,MAAM,SAAS,KAAK,CAAA;AAa3B,eAAO,MAAM,eAAe;;;;;;;iBAO1B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;iBAQ7B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAc7B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;iBAS3B,CAAA;AAEF,iDAAiD;AACjD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKhB,CAAA;AAEV,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAKtB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAC/C,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,CAAA;AAErC,wEAAwE;AACxE,eAAO,MAAM,qBAAqB,EAAE,SAAS,SAAS,EAErD,CAAA;AAMD;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,iCAAkC,CAAA;AAC7D,eAAO,MAAM,kBAAkB;;;EAAyB,CAAA;AACxD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUvB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACvD,MAAM,MAAM,SAAS,GAAG,MAAM,CAAA;AAsD9B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,EAAE,SAAS,UAAU,EAAE,CAAA;IAC5B,GAAG,EAAE,MAAM,CAAA;CACZ,GAAG,YAAY,CA2Df;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAI9D"}

package/lib/types/prompt.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Waking the teaching brain.
+ *
+ * "Start learning" is a UI act, but teaching happens in the chat — so the panel
+ * needs a way to tell the tutor that a node is now in focus. This module is
+ * that hand-off: it composes one ordinary user-role turn from the plugin and
+ * delivers it to the agent that owns the learner's session.
+ *
+ * Why a user-role message rather than injected context: `agent.inject()` adds
+ * model-visible context but **does not wake an idle agent**, so nothing would
+ * happen until the learner typed something. `followup()` opens a turn, which is
+ * exactly the intent of pressing the button. `@deepseek-ai/dsh-command-goal`
+ * and `dsh-headless` do the same thing for the same reason.
+ *
+ * The source is `{ kind: 'diagnostic-tutor' }` — the plugin declares its own
+ * kind. Harness 0.1.7 removed the shared catch-all `plugin` kind: a producer now
+ * merges its own entry into `MessageSourceMap`, and the augmentation below is
+ * that declaration. It is also what makes the value type-check at all, so a
+ * future rename cannot drift out of sync silently.
+ *
+ * Note what this module does **not** do: it does not decide what to teach. It
+ * reports which node the learner selected and asks the tutor to begin. Every
+ * teaching decision stays with the teaching brain.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { CourseRecord, NodeRecord } from './state.js';
+/**
+ * Attribution for every turn this plugin opens.
+ *
+ * Must equal the declared kind below; TypeScript enforces it, because the value
+ * is passed where the augmented union is expected.
+ */
+export declare const PLUGIN_SOURCE = "diagnostic-tutor";
+/**
+ * Declare this plugin's message-source kind.
+ *
+ * Harness 0.1.7 has no shared catch-all `plugin` kind (see `MessageSourceMap`
+ * in `@deepseek-ai/dsh-llm`): `kind` is merge-extensible and each producer names
+ * itself in its own module. `dsh-schedule`, `dsh-webhook` and `agent-team` all
+ * do exactly this.
+ *
+ * The literal is repeated rather than referenced through `PLUGIN_SOURCE`,
+ * because a module augmentation needs a literal type. The two cannot drift: the
+ * assignment below fails to compile if they disagree.
+ */
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'diagnostic-tutor': {
+            readonly kind: 'diagnostic-tutor';
+        };
+    }
+}
+export interface FocusPromptResult {
+    /** Whether a turn was actually opened. */
+    readonly prompted: boolean;
+    /** Why not, when `prompted` is false. Surfaced to the panel, not to the learner as an error. */
+    readonly reason?: string;
+}
+/**
+ * Compose the turn text.
+ *
+ * Written in the learner's voice, because it lands in the transcript they are
+ * reading: it should look like the button they just pressed, not like a system
+ * directive. It states the node and the expected shape of the reply, and stops
+ * — the tool descriptions carry the detail about blocks and caps.
+ *
+ * @param course - the course being learned.
+ * @param node - the node put in focus.
+ * @returns the message text.
+ */
+export declare function focusPromptText(course: CourseRecord, node: NodeRecord): string;
+/**
+ * Deliver one turn to the agent that owns a session.
+ *
+ * Never throws for a missing agent: the focus has already been recorded by the
+ * time this runs, and the tutor can pick it up on the next turn regardless. A
+ * graceful "not prompted" keeps the button useful in every configuration.
+ *
+ * @param ctx - the plugin's context.
+ * @param sessionId - the session the panel is showing, when it knows one.
+ * @param text - the turn text.
+ * @returns whether a turn was opened, and why not when it was not.
+ */
+export declare function promptSession(ctx: Context, sessionId: string | undefined, text: string): FocusPromptResult;
+//# sourceMappingURL=prompt.d.ts.map

package/lib/types/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,aAAa,qBAAqB,CAAA;AAE/C;;;;;;;;;;;GAWG;AACH,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,gBAAgB;QACxB,kBAAkB,EAAE;YAAE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;SAAE,CAAA;KAC1D;CACF;AAED,MAAM,WAAW,iBAAiB;IAChC,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,gGAAgG;IAChG,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAM9E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAsC1G"}