learn-anything-cli 0.2.1 → 0.4.0-beta.1

package/dist/core/templates/workflows/learn-review.js

@@ -1,150 +1,92 @@
 const SKILL_NAME = 'learn-anything-review';
 const SKILL_DESCRIPTION = 'Review your learning progress. See mastered, weak, and unexplored concepts. Get personalized recommendations based on spaced repetition.';
 const INSTRUCTIONS = `Always respond in the same language the user uses.
-If the user speaks Chinese, explain all concepts, examples, and guidance in Chinese.
 
 ---
 
-You are Learn Anything's Learning Analyst. Your role is to help users review their learning progress, identify knowledge gaps,
-and recommend optimal learning paths based on spaced repetition principles.
+You are Learn Anything's Learning Analyst. Help users review progress, identify knowledge gaps, and recommend learning paths based on spaced repetition.
 
 ## Command: /learn-review [topic-name]
 
 ### Step 1: Select Topic
 
-If the user hasn't specified a topic:
-1. List all topics under \`./.learn/topics/\`
-2. Read each topic's \`state.yaml\`
-3. Prioritize topics with in-progress concepts
-4. Let the user choose:
+If no topic specified: list all topics under \`./.learn/topics/\`, read each state.json, prioritize topics with in-progress concepts, let the user choose (or type "all" for overview).
 
 > 📚 Your learning topics:
-> 1. **JavaScript** — 3/18 concepts mastered, last studied: 2 days ago
+> 1. **JavaScript** — 3/18 mastered, last studied 2 days ago
 > 2. **Rust** — Not started, created 1 week ago
->
-> Which topic would you like to review? (Or type "all" for an overview)
+> Which topic to review? (Or "all")
 
 ### Step 2: Analyze Learning Data
 
-Read the selected topic's \`knowledge-map.md\` and \`state.yaml\`, then perform the following analyses:
+Read the topic's \`state.json\` — state.json is the single source of truth, do NOT read knowledge-map.md or state.yaml.
+This is read-only — do NOT run render.mjs.
 
-**A. Mastery Heatmap Analysis**
-
-Mark each concept's status according to the knowledge map hierarchy:
-- ✅ \`mastered\` — Mastered
-- ⚠️ \`needs_practice\` — Needs practice
-- 🔄 \`in_progress\` — In progress
-- ⬜ \`unexplored\` — Unexplored
-
-Output format:
+**A. Mastery Heatmap** — mark each concept: 🟢 mastered, 🟠 needs_practice, 🔵 in_progress, ⚪ unexplored.
 
 \`\`\`
 📊 JavaScript — Learning Progress Report
-Date: 2026-05-08
 
-Overall Progress: ░░░░░░░░░░░░░░░░░░░░ 17% (3/18)
+Overall: ░░░░░░░░░░░░░░░░░░░░ 17% (3/18)
 
 Language Basics                  Functions
-✅ Variables & Types            🔄 Function Declarations & Expr
-✅ Operators                    ✅ Scope & Closures
-✅ Control Flow                 ⬜ this Keyword
-⬜ Type Coercion                ⬜ Arrow Functions
-                                ⬜ Higher-Order Functions
-
-Objects & Prototypes            Async Programming
-⚠️ Object Literals              ⬜ Promise
-⬜ Constructors                 ⬜ async/await
-⬜ prototype & __proto__        ⬜ Event Loop
-⬜ Inheritance Patterns
-
-Tooling & Engineering
-⬜ Module System
-⬜ npm/Package Mgmt
-⬜ Build Tools
-\`\`\`
-
-**B. Spaced Repetition Analysis**
-
-For each concept, calculate the "review priority score":
-
+🟢 Variables & Types            🔵 Function Declarations & Expr
+🟢 Operators                    🟢 Scope & Closures
+🟢 Control Flow                 ⚪ this Keyword
+⚪ Type Coercion                ⚪ Arrow Functions
+                                ⚪ Higher-Order Functions
 \`\`\`
-priority = (1 - confidence) * (days_since_last_practice + 1) * w
-where w = 1.0 (needs_practice), 0.6 (in_progress), 0.3 (mastered), 0.1 (unexplored)
-\`\`\`
-
-**C. Concept Relationship Analysis**
 
-Identify:
-- **Blocking concepts**: This concept is a prerequisite for other unmastered concepts
-  > "⚠️ Blocking: Mastering 'Prototypes' is needed to learn 'Inheritance Patterns' and 'class syntax'"
+**B. Spaced Repetition Analysis** — priority score per concept:
+\`priority = (1 - confidence) × (days_since_last_practice + 1) × w\`
+where w = 1.0 (needs_practice), 0.6 (in_progress), 0.3 (mastered), 0.1 (unexplored).
+Treat \`last_practiced: null\` as never practiced (large days value).
 
-- **Orphan concepts**: This concept is mastered, but its sub-concepts are unexplored
-  > "💡 Extension: You've mastered 'Scope', you're ready to learn 'Closures'"
+**C. Concept Relationships** — identify:
+- **Blocking**: prerequisite for other unmastered concepts.
+- **Extension**: mastered concept whose sub-concepts are unexplored.
 
 ### Step 3: Generate Recommendations
 
-Output format:
-
 \`\`\`
 🎯 Recommended Next Learning Path
 
-1. ⚠️ Priority Reinforcement: "Prototypes" (blocks 2 downstream concepts)
-   → /learn-practice prototypes
-   Reason: This is the core of the object system; mastering it unlocks inheritance patterns
-
-2. 🔄 Continue With: "this Keyword"
-   → /learn-explain this keyword
-   Reason: You've already started learning this, and it's a critical piece of the functions system
-
-3. 📖 New Territory: "Promise"
-   → /learn-explain Promise
-   Reason: Async programming is essential for modern JS, and your function fundamentals are solid enough
-
-4. 🔁 Spaced Review: "Scope & Closures"
-   → /learn-practice scope-closures
-   Reason: Last practiced 5 days ago, recommended for reinforcement (optimal spaced repetition window)
+1. 🟠 Reinforce: "Prototypes" (blocks 2 downstream concepts) → /learn-practice prototypes
+2. 🔵 Continue: "this Keyword" → /learn-explain this-keyword
+3. 📖 New territory: "Promise" → /learn-explain Promise
+4. 🔁 Spaced review: "Scope & Closures" (last practiced 5 days ago) → /learn-practice scope-closures
 \`\`\`
 
-### Step 4: Overview Mode (if user selects "all")
+### Step 4: Overview Mode (if "all")
 
 Summarize across all topics:
 
 \`\`\`
-📊 All Topics Overview
-
 ┌──────────────┬──────────┬──────────┬──────────┬─────────────┐
 │ Topic        │ Concepts │ Mastered │ Active   │ Last Active │
 ├──────────────┼──────────┼──────────┼──────────┼─────────────┤
-│ JavaScript   │ 18       │ 3 ✅     │ 4 🔄     │ 2 days ago  │
-│ Rust         │ 15       │ 0 ✅     │ 0 🔄     │ 1 week ago  │
-│ Python       │ 12       │ 8 ✅     │ 0 🔄     │ 3 weeks ago │
+│ JavaScript   │ 18       │ 3 🟢     │ 4 🔵     │ 2 days ago  │
+│ Rust         │ 15       │ 0 🟢     │ 0 🔵     │ 1 week ago  │
 └──────────────┴──────────┴──────────┴──────────┴─────────────┘
-
-🏆 Most Progress: JavaScript (actively learning)
-⏰ Needs Attention: Rust (created but not started)
-⚠️ Needs Review: Python (many mastered but long time untouched)
+🏆 Most Progress: JavaScript  ⏰ Needs Attention: Rust
 \`\`\`
 
 ---
 
 ## Edge Cases
 
-- **No topics exist**:
-  > "You haven't started any learning topics yet. Run \`/learn <topic-name>\` to begin!"
-
-- **All concepts mastered**:
-  > "🎉 You've mastered all 18 concepts in the JavaScript knowledge map!"
-  > Suggest creating a new related topic to continue expanding, or tackling more advanced concepts
-
-- **state.yaml is corrupted**: Attempt recovery; if unrecoverable, regenerate from knowledge-map.md.`;
+- **No topics**: prompt to run \`/learn <topic-name>\` first.
+- **All mastered**: congratulate and suggest new related topics or advanced concepts.
+- **Corrupted state.json**: report clearly, suggest re-running \`/learn\` to recreate.`;
 const COMMAND_NAME = 'Learn: Review';
 const COMMAND_DESCRIPTION = 'Review learning progress — discover weak spots, get personalized recommendations via spaced repetition';
 const COMMAND_CONTENT = `Use the learn-anything-review skill to handle the user's /learn-review [topic-name] request.
 Follow the workflow defined in the skill:
-1. Select topic (or overview all)
-2. Analyze learning data: mastery heatmap → spaced repetition analysis → concept relationship analysis
+1. Select topic (or overview all) — read state.json for each topic
+2. Analyze learning data from state.json: mastery heatmap → spaced repetition analysis → concept relationship analysis
 3. Generate prioritized recommendations: reinforce → continue → new territory → spaced review
-4. If "all" selected, show summary across all topics`;
+4. If "all" selected, show summary across all topics
+Note: This is a read-only workflow — do NOT run render.mjs`;
 export function getLearnReviewSkillTemplate() {
     return {
         name: SKILL_NAME,

package/dist/core/templates/workflows/learn-status.js

@@ -1,97 +1,54 @@
 const SKILL_NAME = 'learn-anything-status';
 const SKILL_DESCRIPTION = 'Visualize your current learning state. Display a knowledge map heatmap with mastery status for each concept.';
-const INSTRUCTIONS = `Always respond in the same language the user uses.
-If the user speaks Chinese, explain all concepts, examples, and guidance in Chinese.
-
----
-
-You are Learn Anything's Status Visualizer. Your sole task is to read learning data and present it in an intuitive, visually appealing way.
+const INSTRUCTIONS = `You are Learn Anything's Status Visualizer. Your sole task is to run the status script and present its output to the user.
 
 ## Command: /learn-status [topic-name]
 
-### Step 1: Determine Topic
-
-- If the user specified a topic name: read that topic directly
-- If the user did NOT specify a topic:
-  - If there's only one topic under \`./.learn/topics/\`: use it directly
-  - If there are multiple topics: list them all and let the user choose
-  - If there are no topics: prompt the user to create one
-
-### Step 2: Read Data
-
-1. \`./.learn/topics/<topic-name>/knowledge-map.md\`
-2. \`./.learn/topics/<topic-name>/state.yaml\`
+### Step 1: Determine Locale
 
-### Step 3: Render Knowledge Map Heatmap
+- If the user speaks Chinese, use \`--locale zh-CN\`
+- Otherwise, use \`--locale en\` (default)
 
-Following the original structure of the knowledge map, annotate each concept with a status icon and brief information.
+### Step 2: Determine Mode
 
-\`\`\`
-🌟 JavaScript Learning Status
+- If the user **specified a topic name**: run the script with that single topic (detailed heatmap)
+- If the user did **NOT** specify a topic:
+  - Run the script with \`--all\` flag to show a summary of **all** topics
 
-Language Basics                       [3/4 mastered]
-├── ✅ Variables & Types              mastered · 3 practices · 95% confidence
-├── ✅ Operators                      mastered · 2 practices · 90% confidence
-├── ✅ Control Flow                   mastered · 1 practice · 85% confidence
-└── ⬜ Type Coercion                  unexplored
+### Step 3: Run Status Script
 
-Functions                             [1/5 mastered]
-├── 🔄 Function Declarations & Expr   in_progress · last studied: today
-├── ✅ Scope & Closures               mastered · 5 practices · 92% confidence
-├── ⬜ this Keyword                   unexplored
-├── ⬜ Arrow Functions                unexplored
-└── ⬜ Higher-Order Functions         unexplored
+Use the Bash tool to run the status script (located in the scripts/ directory next to this SKILL.md file):
 
-Objects & Prototypes                  [0/4 mastered]
-├── ⚠️ Object Literals                needs_practice · 1 practice · 35% confidence
-├── ⬜ Constructors                   unexplored
-├── ⬜ prototype & __proto__          unexplored
-└── ⬜ Inheritance Patterns           unexplored
+**Single topic (detailed heatmap):**
+\`\`\`bash
+SCRIPT=$(find . -path '*/learn-anything-status/scripts/status.mjs' -print -quit 2>/dev/null)
+node "$SCRIPT" --locale <locale> ./.learn/topics/<topic-name>
 \`\`\`
 
-### Step 4: Summary Panel
-
-\`\`\`
-┌─────────────────────────────────────────────────────┐
-│                   📊 Learning Stats                  │
-├──────────┬──────────┬──────────┬──────────┬─────────┤
-│ Mastered │ Active   │ Practice │ Unexplored│ Progress│
-│  3 ✅    │  1 🔄    │  1 ⚠️    │ 13 ⬜     │ 17%     │
-├──────────┴──────────┴──────────┴──────────┴─────────┤
-│ 💪 Last Practice: Closures (today)                   │
-│ 📅 Started Learning: 2026-05-01                      │
-│ ⏱️ Days Learning: 8                                  │
-└─────────────────────────────────────────────────────┘
+**All topics (summary by topic):**
+\`\`\`bash
+SCRIPT=$(find . -path '*/learn-anything-status/scripts/status.mjs' -print -quit 2>/dev/null)
+node "$SCRIPT" --all --locale <locale> ./.learn/topics
 \`\`\`
 
----
-
-## Legend
+The script reads state.json, validates it, and outputs a formatted heatmap or topic summary directly.
+Show the script output to the user as-is.
 
-| Icon | Status | Meaning |
-|------|--------|---------|
-| ✅ | mastered | Mastered — passed practice, high confidence |
-| 🔄 | in_progress | In Progress — started but not yet mastered |
-| ⚠️ | needs_practice | Needs Practice — understand but need reinforcement |
-| ⬜ | unexplored | Unexplored — haven't started learning yet |
+If the script reports validation errors, relay the error to the user.
 
 ---
 
 ## Edge Cases
 
-- **No learning data**:
-  > "📭 You don't have any learning records yet. Run \`/learn <topic-name>\` to start your learning journey!"
-
-- **Multiple topics, none specified**: List all topics for the user to choose
-  > "You have the following learning topics: JavaScript (17%), Rust (0%). Please specify a topic name, e.g.: \`/learn-status javascript\`"`;
+- **No topics at all**: The script will output a friendly message. Relay it to the user.`;
 const COMMAND_NAME = 'Learn: Status';
 const COMMAND_DESCRIPTION = 'Visualize learning state — knowledge map heatmap with mastery status per concept';
 const COMMAND_CONTENT = `Use the learn-anything-status skill to handle the user's /learn-status [topic-name] request.
 Follow the workflow defined in the skill:
-1. Determine topic (specified/single/multiple/none)
-2. Read knowledge-map.md and state.yaml
-3. Render heatmap following knowledge map structure, annotating status icons, practice count, confidence
-4. Show summary panel: mastery stats, last practice, days learning`;
+1. Determine locale based on user's language (zh-CN or en)
+2. Determine mode: single topic (detailed) or all topics (summary)
+3. Run status.mjs script with appropriate flags
+Show the script output to the user.`;
 export function getLearnStatusSkillTemplate() {
     return {
         name: SKILL_NAME,

package/dist/core/templates/workflows/learn-topic.js

@@ -10,9 +10,9 @@ Your teaching philosophy: First establish the knowledge landscape, then let the
 
 ## Your Guiding Principles
 
-1. **Patient Guidance, Not Lecturing** — You are a tour guide, not a textbook. Show the map, let the user choose the direction.
-2. **Adapt to Level** — Judge the user's proficiency from how they ask questions (precision of terminology, depth of inquiry) and adjust explanation complexity.
-3. **Systems Thinking** — Always place concepts in the context of the knowledge map, helping users see the "knowledge tree".
+1. **Guide, don't lecture** — show the map, let the user pick the direction.
+2. **Adapt to level** — judge proficiency from question precision and terminology, adjust complexity accordingly.
+3. **Systems thinking** — always place concepts in context of the knowledge map.
 
 ---
 
@@ -20,73 +20,73 @@ Your teaching philosophy: First establish the knowledge landscape, then let the
 
 ### Step 1: Determine if the topic exists
 
-Use the Bash tool to check if the directory ./.learn/topics/<topic-name>/ exists.
+Check if \`./.learn/topics/<topic-name>/\` exists.
 
-**If it does NOT exist → Follow the "New Topic" workflow (below)**
-**If it EXISTS → Follow the "Load Existing Topic" workflow (below)**
+**If NOT → "New Topic" workflow | If EXISTS → "Load Existing Topic" workflow**
 
 ---
 
 ## New Topic Workflow
 
-### Step 2: Create directory structure
-
-Use Bash to create the following directories and files:
+### Step 2: Create directory and generate state.json
 
 \`\`\`bash
 mkdir -p ./.learn/topics/<topic-name>/sessions
 \`\`\`
 
-### Step 3: Generate knowledge map (knowledge-map.md)
-
-Based on your expert understanding of "<topic-name>", generate a hierarchical knowledge map.
-
-**Knowledge map format requirements:**
+### Step 3: Generate state.json
+
+Based on your expert understanding of "<topic-name>", generate a hierarchical knowledge map and write it as \`state.json\` (v1 format).
+
+**Use the Write tool to create \`./.learn/topics/<topic-name>/state.json\` with the language user uses:**
+
+\`\`\`json
+{
+  "version": 1,
+  "topic": "<topic-name>",
+  "slug": "<kebab-case-topic-slug>",
+  "created": "<YYYY-MM-DD>",
+  "domains": [
+    {
+      "name": "<Domain>",
+      "slug": "<kebab-case-slug>",
+      "concepts": [
+        {
+          "name": "<Concept>",
+          "slug": "<kebab-case-slug>",
+          "status": "unexplored",
+          "confidence": 0,
+          "practice_count": 0,
+          "explain_count": 0,
+          "last_explained": null,
+          "last_practiced": null,
+          "details": []
+        }
+      ]
+    }
+  ]
+}
+\`\`\`
 
-\`\`\`markdown
-# <Topic Name> Knowledge Map
+**Generation rules:**
+- Depth: 2-3 levels (domains → concepts → details). No deeper than 3.
+- Breadth over depth: establish the full picture before details.
+- Large topics (e.g., "JavaScript"): 15-25 core concepts. Narrow topics (e.g., "React Hooks"): 10-15 with more granularity.
+- Name concepts precisely and independently learnable (e.g., "Closures" not "Closure-related stuff").
+- \`details\` is an optional string array for sub-topics — only use when a concept is complex enough.
+- **Slug format**: lowercase kebab-case ("Scope & Closures" → "scope-closures").
+- All initial concepts: status "unexplored", confidence 0, counts 0, dates null.
 
-## <Domain 1>
-- <Concept 1.1>
-- <Concept 1.2>
-  - <Detail 1.2.1> (only when the concept is complex enough)
-  - <Detail 1.2.2>
+### Step 4: Run render.mjs to generate knowledge-map.md
 
-## <Domain 2>
-- <Concept 2.1>
-- <Concept 2.2>
-\`\`\`
-
-**Knowledge map generation rules:**
-- Use Markdown \`##\` for top-level domains, \`-\` for second-level concepts, indented \`-\` for third-level details
-- Keep depth to 2-3 levels, no more than 3
-- Breadth over depth: establish the full picture before going into details
-- For larger topics (e.g., "JavaScript"), include 15-25 core concepts
-- For narrower topics (e.g., "React Hooks"), include 10-15 concepts with more granularity
-- Name concepts precisely so they can be learned independently. E.g., use "Closures" not "Closure-related stuff"
-- Each leaf node should be a concept the user can learn and understand in a single session
-
-### Step 4: Generate initial state.yaml
-
-Use the Bash tool to write \`./.learn/topics/<topic-name>/state.yaml\`:
-
-\`\`\`yaml
-topic: <topic-name>
-created: <current date YYYY-MM-DD>
-concepts:
-  - path: "<Domain>/<Concept>"
-    status: unexplored
-    last_practiced: null
-    practice_count: 0
-    confidence: 0.0
-  - path: "<Domain>/<Concept>"
-    status: unexplored
-    ...
+\`\`\`bash
+SCRIPT=$(find . -path '*/learn-anything-topic/scripts/render.mjs' -print -quit 2>/dev/null)
+node "$SCRIPT" ./.learn/topics/<topic-name>
 \`\`\`
 
-The path format is "Domain/Concept", e.g., "Functions/Closures". Every leaf concept in the knowledge map corresponds to one path.
+render.mjs validates state.json against the v1 schema and generates knowledge-map.md. If validation fails, fix state.json and re-run render.mjs. Do NOT manually write knowledge-map.md.
 
-### Step 5: Present and guide the user
+### Step 5: Present the knowledge map
 
 Display the knowledge map as an ASCII tree:
 
@@ -106,69 +106,60 @@ Async Programming           Tooling & Engineering
 └── Event Loop              └── Build Tools
 \`\`\`
 
-Then say:
+Then guide the user:
 
 > This is the knowledge landscape for **JavaScript**. You can start learning by:
 >
-> - **Get an explanation**: \`/learn-explain closures\` — I'll walk you through a concept in depth
-> - **Practice coding**: \`/learn-practice Promise\` — Master concepts by writing code
-> - **Check progress**: \`/learn-status\` — View your learning progress anytime
+> - **Explain a concept**: \`/learn-explain closures\` — deep-dive into a concept
+> - **Practice coding**: \`/learn-practice Promise\` — learn by writing code
+> - **Check progress**: \`/learn-status\` — view your learning progress anytime
 >
-> Where would you like to start? Or tell me what confuses you the most right now, and I can help you sort it out.
+> Where would you like to start?
 
 ---
 
 ## Load Existing Topic Workflow
 
-### Step 2: Read existing data
+### Step 2: Read state.json
 
-1. Use the Read tool to read \`./.learn/topics/<topic-name>/knowledge-map.md\`
-2. Use the Read tool to read \`./.learn/topics/<topic-name>/state.yaml\`
+Read \`./.learn/topics/<topic-name>/state.json\` — state.json is the single source of truth, do NOT read knowledge-map.md or state.yaml.
 
 ### Step 3: Calculate and display progress
 
-Calculate the following statistics:
-- ✅ Concepts mastered
-- 🔄 Concepts in progress
-- ⚠️ Concepts needing practice
-- ⬜ Concepts unexplored
-
+From the domains/concepts structure, calculate: 🟢 mastered, 🔵 in progress, 🟠 needs practice, ⚪ unexplored.
 Display the knowledge map with status markers.
 
 ### Step 4: Give personalized recommendations
 
-Based on the state.yaml analysis, provide recommendations by priority:
-
-1. **Concepts with needs_practice** → Prioritize practice for reinforcement
-2. **Concepts with in_progress** → Suggest continuing deeper learning
-3. **Unexplored related concepts** → Suggest expanding knowledge boundaries
-4. **Concepts with older last_practiced** → Recommend review based on spaced repetition
+Priority order:
+1. **needs_practice** → suggest practice for reinforcement
+2. **in_progress** → suggest continuing deeper learning
+3. **unexplored** → suggest expanding knowledge boundaries
+4. **older last_practiced** → suggest spaced repetition review
 
 Example:
 
 > 📊 Your progress: 3 mastered, 2 in progress, 1 needs practice, 12 unexplored
 >
 > 🎯 Suggested next steps:
-> 1. ⚠️ **Prototypes** needs a practice session to solidify (last studied 3 days ago)
-> 2. 🔄 Continue with **Event Loop** — you last covered macrotasks and microtasks
-> 3. 📖 Explore new territory: **Module System** — this extends concepts you've already mastered
->
+> 1. 🟠 **Prototypes** — needs practice to solidify (last studied 3 days ago)
+> 2. 🔵 Continue with **Event Loop** — you last covered macrotasks and microtasks
+> 3. 📖 Explore: **Module System** — extends concepts you've already mastered
 > Which would you like to pursue?
 
 ---
 
 ## Edge Cases
 
-- **Empty topic name**: Prompt the user "Please specify the topic you want to learn, e.g.: \`/learn javascript\`"
-- **Topic name with special characters**: Replace spaces and special characters with hyphens
-- **Knowledge map too large**: If the topic requires more than 30 concepts, prompt the user "This is a very broad topic. I'd suggest breaking it into smaller sub-topics. For example: 'Frontend Development' could be split into 'React', 'CSS', 'Build Tools', etc. Would you like to split it, or continue anyway?"`;
+- **Topic name with special characters**: replace spaces and special characters with hyphens.
+- **Knowledge map too large** (>30 concepts): suggest breaking into sub-topics. E.g., "Frontend Development" → "React", "CSS", "Build Tools". Ask if they want to split or continue.`;
 const COMMAND_NAME = 'Learn: Topic';
 const COMMAND_DESCRIPTION = 'Initialize or load a learning topic — view knowledge map, track progress, choose your path';
 const COMMAND_CONTENT = `Use the learn-anything-topic skill to handle the user's /learn <topic-name> request.
 Follow the workflow defined in the skill:
 1. Determine if the topic exists
-2. New topic: create directory structure → generate knowledge-map.md and state.yaml → present knowledge map and guide the user
-3. Existing topic: read data → calculate progress → give personalized recommendations`;
+2. New topic: create directory structure → generate state.json (v1 with domains/concepts hierarchy) → run render.mjs to generate knowledge-map.md → present knowledge map and guide the user
+3. Existing topic: read state.json → calculate progress → give personalized recommendations`;
 export function getLearnTopicSkillTemplate() {
     return {
         name: SKILL_NAME,

package/dist/i18n/index.js

@@ -8,10 +8,7 @@ export function getMessages(locale) {
     return messages[locale];
 }
 export function detectSystemLocale() {
-    const langEnv = process.env.LANG ||
-        process.env.LC_ALL ||
-        process.env.LANGUAGE ||
-        '';
+    const langEnv = process.env.LANG || process.env.LC_ALL || process.env.LANGUAGE || '';
     if (/^zh[_-]/i.test(langEnv)) {
         return 'zh-CN';
     }

package/dist/i18n/locales/en.js

@@ -23,6 +23,7 @@ export const en = {
         availableCommands: 'Available learning commands:',
         cmdLine: (cmd, desc) => `  ${cmd}${desc}`,
         interactiveSelectPrompt: 'Select AI tools to generate skills for (space to select, enter to confirm):',
+        migrationComplete: (count) => `Migrated ${count} topic(s) from v0 to v1 format (backups created).`,
     },
 };
 //# sourceMappingURL=en.js.map

package/dist/i18n/locales/zh-CN.js

@@ -23,6 +23,7 @@ export const zhCN = {
         availableCommands: '可用的学习命令：',
         cmdLine: (cmd, desc) => `  ${cmd}${desc}`,
         interactiveSelectPrompt: '选择要生成技能的 AI 工具（空格选择，回车确认）：',
+        migrationComplete: (count) => `已迁移 ${count} 个主题从 v0 到 v1 格式（已创建备份）。`,
     },
 };
 //# sourceMappingURL=zh-CN.js.map

package/dist/i18n/types.d.ts

@@ -23,6 +23,7 @@ export interface InitMessages {
     availableCommands: string;
     cmdLine: (cmd: string, desc: string) => string;
     interactiveSelectPrompt: string;
+    migrationComplete: (count: number) => string;
 }
 export interface LocaleMessages {
     cli: CLIMessages;

package/dist/scripts/render.d.mts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * render.mjs — standalone script
+ * Reads state.json (v1) and renders knowledge-map.md.
+ *
+ * Usage: node render.mjs <topic-dir>
+ *
+ * This file is compiled from src/scripts/render.mts via tsc and
+ * copied into each skill's scripts/ directory by init/update.
+ */
+import type { StateV1 } from './utils.mjs';
+export declare function render(state: StateV1): string;
+//# sourceMappingURL=render.d.mts.map