Preface

When learning with agents like DSH, a common practice is to throw the material at the model and ask it to summarize it. The problem is that this is a one-off delivery: the model doesn’t know which concepts you haven’t mastered, there are no progress thresholds, no review scheduling, and learning state is lost if you switch sessions.

dsh-plugin-lookatstudy turns the entire learning chain into a DSH plugin: imports material as courses, tracks mastery per concept, and schedules reviews using spaced repetition. DSH’s philosophy is “everything is a plugin,” and learning can be integrated into the host’s integration points—sidebar entry, slash commands, tool cards, each with its own place. Below, I introduce what this plugin does, how to install it, and how to use it.

What is it

dsh-plugin-lookatstudy is maintained by Kaiji-Z, under the MIT license, with the learning engine module vendored from LookatStudy (MIT). Its one-sentence positioning is: import arbitrary markdown documents, local folders, or GitHub learning repositories as guided courses within DeepSeek Harness, featuring skill-tree-style level progression, BKT mastery tracking, and SM-2 spaced repetition.

The plugin has two sides: the tutor in the chat, and a three-column panel that takes over the view. The host is defined as the session model plus the agent-turn engine; the panel has the UI, and the host has the loop.

Import: Building Courses from Four Sources

Below are the four entry points for creating a course, select the tool by source:

  1. study_import_markdown / study_import_folder: Import markdown documents or local folders, supports 12 document formats including EPUB, DOCX, PPTX, and PDF text.
  2. study_import_github: Import GitHub learning repositories via jsDelivr CDN; works even in environments where github.com is unreachable.
  3. study_import_url: Import single articles, arXiv papers, or video metadata.
  4. study_apply_design: A structural protocol designed by the tutor, responsible for organizing imported content into a course structure.

Core Mechanism: Mastery Based on the Weakest Concept

The plugin uses Knowledge Components (KC) to track learning state. The process is as follows:

  1. During the first lesson, the tutor derives 2–7 concepts (study_define_concepts).
  2. Each answer is attributed to a specific concept (study_record_answer, with concept).
  3. BKT runs per concept; course mastery is determined by the weakest concept.
  4. When a quiz appears, it prioritizes weak concepts.

Progression is driven by mastery: ≥50% unlocks the next lesson; ≥90% graduates and schedules the first SM-2 review; answering itself also drives the review plan.

Additionally, there is a proposal channel (propose → apply): if ≥85% and the learner provides a convincing Feynman-style explanation, the tutor can propose early graduation (study_propose_mastery), but waits for a clear yes/no from the learner (study_resolve_proposal) before applying. The learner’s decision is not skipped.

Friction Awareness & Learner Memory

Confusion, getting stuck, and frustration during learning are silently recorded (study_report_friction), presented in the course tree as ⚡😣 weak points, and the tutor adjusts strategy accordingly.

The learner’s memory has three slots: global style, per-course mode, and per-lesson gaps, updated via read-merge-write (study_remember). Each turn also injects a dynamic learner snapshot, including focus, strategy band, weak concepts, friction, memory, due count, and pending proposal. The tutor sees this context every round.

Learning Panel: Three-Column Structure

The dsh sidebar has a “Study” row (located below “New Chat,” parallel to other plugin entries). Clicking it opens a three-column panel that takes over the view. The styles use all of dsh’s --dsw-* tokens. When closing the panel or switching sessions, the middle column is returned directly to the host.

The left column is the course: course selection, progress, a due box with one-click review launch, the course tree (level thresholds, mastery bars, ⚡😣 weak point markers), and an empty state offering one-click demo import. Note on interaction design: clicking a course in the course column only does FOCUS, switches the blackboard content, and uses zero model traffic; the tutor only intervenes when you send a message.

The middle column is the tutor chat, with an independent composer. The panel never touches dsh’s host composer. The column header has soul pills: guide (引导), direct (精讲), practice (实战). Quiz questions from the tutor render A-D options as clickable answer buttons.

The right column is the blackboard, carrying the content of the current focus course:

  • Explanation: Server-side sanitized markdown rich rendering, KaTeX formulas loaded on demand, syntax highlighted code, mermaid diagrams (mermaid uses CDN loader, offline silent degradation).
  • 🕸 Concept Map View: Knowledge components of the same lesson drawn as a concept map, bundled with ELK layout, independent of external services.
  • Cornell Notes Three-Zone: Confirmation before deleting each note.
  • Read-aloud Bar: Sentences of the current lesson are synthesized sentence-by-sentence on the host via Microsoft Edge Neural Voice, cached to disk, with offline fallback to system voice; the current sentence is highlighted during playback.

All learning state comes from a shared 3-second polling request to /lookatstudy/api/state. The three columns read the same state.

DSH Native Integration Points

Beyond the panel, the plugin also integrates into several host integration points:

  • Bilingual Copy: The entire client half registers the lookatstudy locale namespace (zh/en, forced key parity). Switching the host language switches the learning panel accordingly.
  • Settings Page: settings.section entries, including teaching style, study mode toggle, read-only stats (courses/XP/streak), and state file path.
  • /study Slash Command: Bare /study activates hibernating installation and queues a kickoff prompt; /study <text> queues the request. Slash commands work wherever they are available.
  • Input Box Dock Pills (conversation.composer.dock): Shows ⚡due · 🔥streak · Lv when active; not rendered when hibernating.
  • Session Tab Tool Cards: tool.call.toolview keyed entries, overriding study_record_answer (✓/✗ + concept), study_lesson, study_due_reviews, study_exam_result.
  • Startup Layer Prefetch: dsh.client.immediately: true, the sidebar “Study” row renders on the first frame without waiting for bundle fetch.

The Tool Surface with 30 Tools

The tool surface has 30 tools, grouped by import / learn / progress / artifacts / memory / proposals / reviews / awareness / misc. Besides the import, concept and answer, proposal, friction and memory tools mentioned above, there are a few groups worth mentioning separately:

  • Interactive Practice (artifacts, since 0.15.0): study_generate_quiz (interactive practice card), study_pose_guess, study_compare_table, study_draw_diagram (mermaid), study_code_walkthrough. Each renders as a card within the panel and persists to notes.
  • Consolidation & Output (memory): study_consolidate, study_translate_lesson (bilingual course), study_export (export course package as markdown).
  • Review: study_due_reviews queries due items, study_record_record_review records review results; Exam mode study_exam_result includes star ratings.
  • Misc: study_set_mode, study_delete_course. Also study_courses supports progress viewing and full-text search, with XP and streak integrated.

Regarding profiles: the plugin works with any profile. The web profile additionally provides HTTP APIs for the learning tab and loads browser-side features; the headless profile only gets the pure tool surface.

Installation and Activation

Install from npm:

dsh plugin add dsh-plugin-lookatstudy        # from npm

Or install from a local tarball:

dsh plugin add ./dsh-plugin-lookatstudy-0.2.1.tgz

The first command goes through npm, the second installs from the local tarball file. Note that the version number in the repository’s package.json is 0.16.0, while the tarball filename in the README installation example is 0.2.1; these are inconsistent. Use the actual package you obtain when installing. After installation, it works with any profile, and you can see the “Study” entry in the sidebar without extra configuration.

Typical Usage

The most direct entry is to speak to the tutor:

import https://github.com/microsoft/AI-For-Beginners and teach me lesson 1

This will make the tutor import that GitHub learning repository as a course and start the first lesson. The subsequent learning loop is the mechanism described above: deriving concepts, attributing answers, BKT updates, unlocking and graduating based on mastery.

Query due reviews:

what reviews are due today?

Slash commands can also be used: bare /study activates hibernating installation and queues a kickoff prompt; /study <text> queues the request to the tutor. Sending a message or clicking a starter inside the panel is the entry point into the course thread—the panel activates the hibernated learning face, creates a course session on the host, and streams the reply through the session event window, using the plugin’s own markdown pipeline for rendering.

Applicability and Notes

Suitable scenarios: you already have systematic learning materials—markdown documents, local folders, GitHub learning repositories, or scattered articles—and want to progress through them as a course in DSH, tracked by concept mastery, and reviewed according to an SM-2 plan, instead of asking repeatedly.

A few things to note before installing and using:

  1. The plugin runs with the current dsh process permissions; check the source code and license before installing. This project is MIT, and the learning engine module is vendored from LookatStudy (MIT).
  2. The panel and learning tab HTTP APIs are only available under the web profile; the headless profile only has the pure tool surface and can still complete the full loop of import, teaching, and review.
  3. Network dependencies: mermaid rendering uses a CDN loader with offline silent degradation; Edge Neural Voice for reading is synthesized on the host with offline fallback to system voice; the ELK layout for concept maps is bundled locally and does not depend on external services.

Conclusion

The value of dsh-plugin-lookatstudy lies in turning “asking the model to learn things” into a stateful, thresholded, and review-scheduled process, and fully leveraging the host’s integration points rather than just piling up a bag of tools. If you are using DSH to learn a new domain, it is worth a try.

Project Homepage: https://github.com/Kaiji-Z/dsh-plugin-lookatstudy

Community Directory Page: https://www.skillhub.cn/plugins/Kaiji-Z/dsh-plugin-lookatstudy (skillhub.cn is a community-maintained plugin directory, with no official affiliation to DeepSeek or Hyperbolic)