People with ADHD don’t need more information — they need structured, step-by-step guidance that helps them consistently start and stick with the things they know they should do.

The ADHD Dojo teaches reliable regulation — practical skills and systems for follow-through, focus, and emotional control.

What The Dojo Teaches

What You’ll Learn

  • How to start tasks without overwhelm

  • How to stick with routines when motivation drops

  • How to regulate emotions and attention

  • How to reduce friction, chaos, and inconsistency

  • How to build systems that actually work with ADHD

Why The Dojo Works

Not Hacks. Not Motivation. Not More Information.

Structured Guidance
Step-by-step training that shows how to execute, not just what to do.

Reliable Regulation
Tools for consistency, emotional balance, and follow-through.

Real Support
A dojo — not a course. Accountability, community, and practical help.

Who This Is For

For People Who Struggle With:

  • Starting tasks

  • Sticking with routines

  • Feeling overwhelmed

  • Forgetting priorities

  • Feeling “behind” or “not normal”Knowing what to do but never doing it

Enter The Dojo

Structured support. Real guidance. A place to finally start and stick with the things you know you should do.

Inside the Dojo, You’ll Get:

  • A supportive community of people who “get it”

  • Practical guidance as the Dojo training is built

  • Early access to systems & tools for ADHD regulation

  • A place to ask questions and get answers

  • Accountability check-ins

  • Progress logs

  • Dojo announcements

  • First access to future lessons & beta training

Why Join Now (As a Founding Member):

  • You get early access to the system before it’s public

  • Your feedback shapes the dojo

  • You’ll help build the culture from day one

  • You’ll get first access to exercises and training trials

  • You’re part of the founding circle of the dojo

What’s Coming Soon:

  • The Reliable Regulation Framework

  • Step-by-step execution training

  • Dojo rituals and practice cards

  • ADHD follow-through tools

  • Troubleshooting system

  • Skill-paths and dojo ranks

  • Video lessons and worksheets

Start Your Training

Join the ADHD Dojo community and get early access to training, tools, and support.

The Core SkillThe skill is switching between thinking and doing.Most people struggle not because they can’t think or act—
but because they can’t switch between the two.

The LoopThought → Action → Visible ResultThis is the smallest unit of progress.Think just enough.
Act immediately.
Make something real.

THE TWO SWORDS

Short Sword = ThinkingLong Sword = DoingTrain both.But more importantly, train switching between them.Use each according to the situation.

THE WAY

Core Skill

The skill is switching between thinking and doing. Most people don’t struggle because they can’t think or act— but because they can’t switch between the two.

The Loop

Thought → Action → Visible Result

The Two Swords

Short Sword = Thinking
Long Sword = Doing

Train both. But more importantly—train switching between them.

THE FORGEThis is where ideas are turned into something real.The Forge is for building, testing, and refining.Nothing here needs to be perfect. It only needs to exist.Every block below is a rep. Every rep makes the system stronger.

FORGE RULEThink → Build → See it existDo not overthink.
Do not redesign.Build → Observe → Refine

EXPERIMENT 01 — THINK BEFORE REVEALPurpose: Train the pause before actionFocus: Thinking → Decision → Action

PromptWhat is the smallest action you can take right now?Build one small thing on your dojo site right now.

EXPERIMENT 02 — SPACING TESTPurpose: Compare line breaks and spacing behaviorsFocus: Readability vs controlTest each section below and observe how it renders.

Line Break CommandLine one
Line twoNon-breaking space test:Short Sword
Long Sword

EXPERIMENT 03 — DOJO PANELPurpose: Build a reusable dojo content panelFocus: Structure, spacing, readabilityThis block will be reused across The Way, Training, and future dashboards.

TRAINING

Daily Loop

Thought → Action → Visible Result

Instruction

Think just enough.
Act immediately.
Make something real.

Focus

Train the switch between thinking and doing.

EXPERIMENT 04 — TWO SWORDS LAYOUTPurpose: Visually represent the dual system (Thinking vs Doing)Focus: Separation, clarity, and balanceThinking ↔ DoingThis experiment tests a split layout that represents the two swords.Each side should feel:
- distinct
- equal
- complementaryThe goal is not just visual—it is conceptual.This layout should make it obvious:You are not choosing one.
You are learning to use both.TestDoes each side feel clear on its own?Does the layout make the relationship obvious?Would this help someone understand the system instantly?

Thinking

Planning, structuring, deciding.

Doing

Executing, building, producing.

EXPERIMENT 05 — DOJO WISDOM (CALLOUT)Purpose: Highlight key principles and insightsFocus: Emphasis, clarity, and attentionPrinciple → Emphasis → ReflectionThis component is used to isolate important ideas.It should feel:
- distinct from normal content
- easy to notice
- easy to rememberThe goal is to create moments of pause.TestDoes it draw your attention immediately?Does it feel like something worth remembering?Would you naturally stop and reflect on it?

Train the switch—not just the states.

EXPERIMENT 06 — STACKED TRAINING BLOCKPurpose: Break a process into clear, sequential stepsFocus: Structure, flow, and usabilityStep → Step → StepThis component represents a training sequence.Each step should feel:
- simple
- actionable
- connected to the nextThe goal is to guide action without confusion.TestCan you follow the steps without thinking too hard?Does each step feel clear and actionable?Does the sequence feel natural from start to finish?

Step 1

Think just enough

Step 2

Act immediately

Step 3

Create visible result

EXPERIMENT 07 — TRAINING FLOW (LOOP BLOCK)Purpose: Represent the thinking → doing loopFocus: Rhythm, clarity, and repetitionThought → Action → ResultThis component represents the core training loop.It should feel:
- continuous
- repeatable
- easy to executeThe goal is to reinforce rhythm.TestDoes the loop feel intuitive?Can you imagine repeating it immediately?Does it clearly represent the process of progress?

THOUGHT

Clarify the next move.
Think just enough.

→

ACTION

Build immediately.
Make it real.

→

RESULT

Something visible exists.
Progress is proven.

EXPERIMENT 08 — PROGRESS BARPurpose: Visualize progress and developmentFocus: clarity, motivation, and feedbackStart → Progress → CompletionThis component represents growth over time.It should feel:
- simple
- informative
- motivatingThe goal is to make progress visible.TestIs the progress easy to understand at a glance?Does it feel motivating or neutral?Would this help track real development?

Thinking → Doing Integration

EXPERIMENT 09 — FORGE GRIDPurpose: Organize multiple components or experiments visuallyFocus: structure, spacing, and layoutBlock + Block + BlockThis component represents a workspace.It should feel:
- organized
- modular
- expandableThe goal is to display multiple elements without clutter.TestDoes the layout feel clean or crowded?Can you easily distinguish each block?Does it feel like a system rather than a list?

Experiment A
Experiment B

Experiment A

First forge block content goes here.

Experiment B

Second forge block content goes here.

EXPERIMENT 10 — ACTION CARDPurpose: Convert thinking into immediate action
Focus: Clarity, simplicity, executionIdea → ActionThis component removes ambiguity.It should answer:“What do I do right now?”

Next Action

Add one new section to your dojo page.

EXPERIMENT 11 — SWITCH TRIGGERPurpose: Train switching between modesFocus: Awareness and timingThinking → Switch → DoingThis component creates a deliberate transition.

You have thought enough.

↓ SWITCH ↓

Now build something.

EXPERIMENT 12 — MINIMAL DASHBOARDPurpose: Show only what matters right nowFocus: clarity, reduction of overwhelmNow → Next → LaterThis component removes noise.

NOW

Work on current task

NEXT

Prepare next step

LATER

Future ideas

EXPERIMENT 13 — LOCKED STATEPurpose: Represent progression and requirementsFocus: clarity and constraintLocked → Unlock → AdvanceThis component enforces progression.

🔒 Skill Locked
🔓 Skill Unlocked

EXPERIMENT 14 — REFLECTION BLOCKPurpose: Capture feedback after actionFocus: awareness and refinementAction → Reflection → AdjustmentThis component closes the loop.

Reflection

What worked?

What didn’t?

What will I change next?

EXPERIMENT 15 — QUEST STATUS PANELPurpose: Visualize quest progression and status
Focus: clarity, motivation, and state awarenessLocked → Available → Active → In Progress → CompleteEach quest should clearly communicate its current state.The goal is to see what to do next instantly.

🔒 Final Publish — Locked
🟥 Proofreading — Available
🔷 Copy Editing — ACTIVE QUEST
🟨 Formatting — In Progress
🟩 Line Editing — Completed

EXPERIMENT 16 — QUEST PAGE MOCKUPPurpose: Build a full quest page interface for the dojo
Focus: orientation, action, and quest flowContext → Active Quest → Next Action → Procedure → ProgressionThis component is meant to function like an operational quest screen.It should:
- orient the user quickly
- show the current active quest clearly
- make the next action obvious
- connect the current quest to the larger arcThe goal is to reduce friction between understanding and action.TestCan you tell what the active quest is immediately?Can you see the next action without hunting for it?Does the page feel like a real operational dojo screen?

ADHD DOJO — QUEST PAGE
HubCharacterSkillsDojoQuest

Quest: Build the Book of Five Rings Editing Path

Arc: Musashi Translation & Publishing Workflow Saga: Build the Dojo Core Library

Snapshot

Current Stage: Ha

Focus: Editing workflow and quest structure

Quest Status:Active

Primary Goal: Turn the editing process into a visible quest chain

Active Quest

Copy Editing

Review and refine the manuscript for clarity, consistency, grammar, and readability while preserving the intended voice of the text.

Requirements: Completed line edit, working manuscript, reference notes

Unlocks: Proofreading, final formatting, publish preparation

Next Action

Open the current manuscript and complete one focused copy-editing pass on the next section.

Start with the next unfinished paragraph block. Make one visible pass. Stop after one clean rep.

Procedure

Step 1

Open the manuscript and locate the current unfinished section.

Step 2

Read through once for clarity and awkward phrasing.

Step 3

Make direct copy edits on grammar, wording, and consistency.

Step 4

Stop after one meaningful visible pass and log the result.

Quest Chain

🟩 Line Editing — Completed
🔷 Copy Editing — Active Quest
🟨 Formatting Review — In Progress
🟥 Proofreading — Available
🔒 Final Publish Package — Locked

EXPERIMENT 17 — CLICKABLE QUEST PROGRESSPurpose: Test interactive quest trackingFocus: progress visibility, task completion, and feedbackTask → Click → Progress UpdatesThis experiment tests a simple interactive quest tracker.Each task represents a section of the Earth Scroll line edit.When a section is clicked:
- its status changes
- the progress bar updates
- visible progress becomes immediateThe goal is to make completion feel tangible.TestDoes clicking feel satisfying?Is progress clear at a glance?Would this make quest work easier to follow?

Earth Scroll — Line Editing Quest

Click a section to toggle it complete or incomplete.

Progress: 0 / 9 Complete
(function () { const buttons = document.querySelectorAll('.task-btn'); const progressText = document.getElementById('progressText'); const progressBar = document.getElementById('progressBar'); function updateProgress() { const total = buttons.length; const complete = Array.from(buttons).filter(btn => btn.dataset.complete === 'true').length; const percent = (complete / total) * 100; progressText.textContent = complete + ' / ' + total + ' Complete'; progressBar.style.width = percent + '%'; } buttons.forEach(btn => { btn.addEventListener('click', function () { const isComplete = this.dataset.complete === 'true'; this.dataset.complete = isComplete ? 'false' : 'true'; this.classList.toggle('complete', !isComplete); updateProgress(); }); }); updateProgress(); })();

EXPERIMENT 18 — QUEST SNAPSHOT PANELPurpose: Provide instant orientation and action
Focus: clarity, context, and executionWhere am I → What matters → What do I doThis component compresses the quest into a single view.It should eliminate:
- confusion
- hesitation
- searchingThe goal is immediate clarity and action.TestCan you understand the situation in under 5 seconds?Can you act without thinking further?Does this remove the need to search the page?

Snapshot

Quest: Earth Scroll — Line Editing

Arc: Musashi Translation

Stage: Ha

Next Action

Open Section 4 and complete one focused line-edit pass.

Procedure
  • Read through once for clarity
  • Refine sentence structure
  • Correct grammar and wording
  • Stop after one complete pass

EXPERIMENT 18B — QUEST SNAPSHOT PANEL (FORK)Purpose: Compress the quest into a clear operational view
Focus: orientation, next action, and executionSee → Decide → ActThis version emphasizes immediacy.It should:
- reduce reading
- increase clarity
- direct action instantlyThe goal is to eliminate hesitation.TestCan you act immediately after reading?Does anything feel unnecessary?Is the next step unmistakably clear?

🎯 ACTIVE QUEST

SNAPSHOT — ORIENTATION

Name: Earth Scroll — Line Editing

Arc: Musashi Translation Workflow

Status:Active

Complete a clean line-edit pass across all sections of the Earth Scroll.

Progress: 3 / 9 Sections Complete

NEXT STEP — ACTION

👉 Open Section 4 and complete one focused line-edit pass.

OBJECTIVES
  • ☑ Sections 1–3 completed
  • ☐ Section 4 in progress
  • ☐ Sections 5–9 remaining
SUPPORT

Rewards: Unlock proofreading stage

Requirements: Completed line edits

Notes: Focus on clarity, not perfection

EXPERIMENT 19 — SINGLE ACTIVE QUEST SYSTEMPurpose: Enforce focus by allowing only one active quest at a time
Focus: commitment, clarity, and constraintChoose → Commit → FocusThis component trains deliberate selection.Only one quest can be active at a time.The goal is to reduce split attention and make the current focus unmistakably clear.TestDoes the active quest stand out immediately?Does switching feel intentional?Would this help reduce scattered effort?

Single Active Quest System

Click a quest to make it the only active quest.

Current Active Quest: None Selected
(function () { const buttons = document.querySelectorAll('.quest19-btn'); const label = document.getElementById('activeQuestLabel'); buttons.forEach(btn => { btn.addEventListener('click', function () { buttons.forEach(b => b.classList.remove('active')); this.classList.add('active'); label.innerHTML = 'Current Active Quest: ' + this.dataset.quest + ''; }); }); })();

EXPERIMENT 20 — NEXT ACTION AUTO-UPDATEPurpose: Automatically update the next step as tasks are completed
Focus: momentum, continuity, and reduced decision fatigueComplete → AdvanceThis component moves the system forward automatically.When a task is completed, the next action updates.The goal is to keep progress moving without rethinking what comes next.TestDoes the next action update clearly?Does it feel easier to continue?Would this reduce hesitation between steps?

Next Action Auto-Update

Next Action:
Start Section 1 — Opening Passage
(function () { const buttons = Array.from(document.querySelectorAll('.task20-btn')); const nextAction = document.getElementById('nextAction20'); function updateNextAction() { const nextIncomplete = buttons.find(btn => !btn.classList.contains('complete')); if (nextIncomplete) { nextAction.innerHTML = 'Next Action:
Start ' + nextIncomplete.textContent + '
'; } else { nextAction.innerHTML = 'Quest Complete
All sections completed.
'; } } buttons.forEach(btn => { btn.addEventListener('click', function () { this.classList.toggle('complete'); updateNextAction(); }); }); updateNextAction(); })();

EXPERIMENT 21 — QUEST MODE SWITCH (THINK / DO)Purpose: Train switching between thinking mode and doing modeFocus: mode awareness, transition, and intentionalityThink ↔ DoThis component makes the two swords explicit.Think Mode shows planning-oriented information.Do Mode shows execution-oriented information.The goal is to practice switching on purpose.TestDoes each mode feel distinct?Does switching help reduce confusion?Would this help you move out of overthinking?

Quest Mode Switch

(function () { const panel = document.getElementById('modePanel21'); const thinkBtn = document.getElementById('thinkBtn21'); const doBtn = document.getElementById('doBtn21'); const thinkHTML = `

Think Mode

Focus: Clarify the quest before acting.

Questions:

  • What is the current goal?
  • What is the bottleneck?
  • What is the smallest useful action?
`; const doHTML = `

Do Mode

Focus: Execute the next visible rep.

Action:

  • Open the current file
  • Complete one meaningful pass
  • Stop after one visible result
`; thinkBtn.addEventListener('click', () => panel.innerHTML = thinkHTML); doBtn.addEventListener('click', () => panel.innerHTML = doHTML); panel.innerHTML = thinkHTML; })();

EXPERIMENT 22 — TIMEBOX / POMODORO TRACKERPurpose: Track focused work reps and make time visibleFocus: rhythm, effort, and session completionStart → Work → CompleteThis component represents a single focused rep.The goal is to make effort measurable and reinforce repeatable work sessions.TestDoes starting feel simple?Does the session feel bounded?Would this help you trust small reps?

Timebox Tracker

15:00
Ready for one focused rep.
(function () { const display = document.getElementById('timerDisplay22'); const status = document.getElementById('timerStatus22'); const startBtn = document.getElementById('start22'); const resetBtn = document.getElementById('reset22'); let totalSeconds = 15 * 60; let remaining = totalSeconds; let interval = null; let running = false; function render() { const mins = String(Math.floor(remaining / 60)).padStart(2, '0'); const secs = String(remaining % 60).padStart(2, '0'); display.textContent = mins + ':' + secs; } function complete() { clearInterval(interval); interval = null; running = false; status.innerHTML = 'Rep Complete — One focused session finished.'; } startBtn.addEventListener('click', function () { if (running) return; running = true; status.textContent = 'Session in progress...'; interval = setInterval(() => { remaining--; render(); if (remaining <= 0) { remaining = 0; render(); complete(); } }, 1000); }); resetBtn.addEventListener('click', function () { clearInterval(interval); interval = null; running = false; remaining = totalSeconds; render(); status.textContent = 'Ready for one focused rep.'; }); render(); })();

EXPERIMENT 23 — QUEST REWARD FEEDBACKPurpose: Reinforce completion with visible reward feedbackFocus: motivation, recognition, and completionComplete → Reward → ReinforceThis component celebrates finished work.The goal is to make completion feel tangible and rewarding.TestDoes completion feel more satisfying?Does the reward message matter?Would this help reinforce follow-through?

Quest Reward Feedback

Complete all tasks to unlock reward feedback.
XP: 0
(function () { const buttons = Array.from(document.querySelectorAll('.reward23-task')); const message = document.getElementById('reward23Message'); const xp = document.getElementById('xp23'); function updateReward() { const completeCount = buttons.filter(b => b.dataset.complete === 'true').length; xp.textContent = 'XP: ' + (completeCount * 25); if (completeCount === buttons.length) { message.innerHTML = 'Quest Complete
Reward unlocked. Momentum reinforced.'; message.style.boxShadow = '0 0 18px rgba(77,255,136,0.35)'; } else { message.innerHTML = 'Complete all tasks to unlock reward feedback.'; message.style.boxShadow = 'none'; } } buttons.forEach(btn => { btn.addEventListener('click', function () { const isComplete = this.dataset.complete === 'true'; this.dataset.complete = isComplete ? 'false' : 'true'; this.classList.toggle('complete', !isComplete); updateReward(); }); }); updateReward(); })();

EXPERIMENT 24 — UNIFIED QUEST MODULEPurpose: Combine the core quest systems into a single operational component
Focus: clarity, progression, action, and feedbackQuest → Task → Progress → Next Action → CompletionThis component unifies the dojo quest loop into one module.It should:
- show the active quest clearly
- make progress visible
- update the next action automatically
- reinforce completionThe goal is to reduce friction and create a real sense of guided movement.TestCan you tell what the quest is immediately?Does the next action stay clear as tasks are completed?Does the module feel like something you would actually use every day?

ACTIVE QUEST

Earth Scroll — Line Editing

Arc: Musashi Translation Workflow
Win Condition: Complete a clean line-edit pass across all 9 sections of the Earth Scroll.

Quest Progress0 / 9 Sections Complete
Next Action
Start Section 1 — Opening Passage
Sections
Complete sections to build progress and unlock completion feedback.
XP: 0
(function () { const buttons = Array.from(document.querySelectorAll('.task24-btn')); const progressText = document.getElementById('progressText24'); const progressBar = document.getElementById('progressBar24'); const nextAction = document.getElementById('nextAction24'); const rewardBox = document.getElementById('rewardBox24'); const xp = document.getElementById('xp24'); function updateModule() { const total = buttons.length; const completeCount = buttons.filter(btn => btn.classList.contains('complete')).length; const percent = (completeCount / total) * 100; const nextIncomplete = buttons.find(btn => !btn.classList.contains('complete')); progressText.textContent = completeCount + ' / ' + total + ' Sections Complete'; progressBar.style.width = percent + '%'; xp.textContent = 'XP: ' + (completeCount * 25); if (nextIncomplete) { nextAction.innerHTML = ` Next Action
Start ${nextIncomplete.textContent}
`; } else { nextAction.innerHTML = ` Quest Complete
All sections are complete. Advance to the next quest.
`; } if (completeCount === total) { rewardBox.innerHTML = ` Quest Complete
Earth Scroll line editing finished. Next stage unlocked. `; rewardBox.style.boxShadow = '0 0 18px rgba(77,255,136,0.35)'; } else { rewardBox.innerHTML = 'Complete sections to build progress and unlock completion feedback.'; rewardBox.style.boxShadow = 'none'; } } buttons.forEach(btn => { btn.addEventListener('click', function () { this.classList.toggle('complete'); updateModule(); }); }); updateModule(); })();

EXPERIMENT 25 — UNIFIED QUEST MODULE WITH ONE ACTIVE TASKPurpose: Focus attention on a single current task within the quest
Focus: clarity, sequence, and commitmentQuest → Active Task → ProgressThis component extends the unified quest module by enforcing one active task.Only one incomplete task should be highlighted as the current focus.The goal is to reduce scattered attention and make the next move obvious.TestDoes the active task stand out immediately?Does the task flow feel more directed?Would this make it easier to stay focused on one thing at a time?

ACTIVE QUEST

Earth Scroll — Line Editing

Arc: Musashi Translation Workflow
Win Condition: Complete all 9 sections with a clean line-edit pass.

Quest Progress0 / 9 Sections Complete
Current Focus
Start Section 1 — Opening Passage
Sections
Complete the current active section, then advance.
(function () { const buttons = Array.from(document.querySelectorAll('.task25-btn')); const progressText = document.getElementById('progressText25'); const progressBar = document.getElementById('progressBar25'); const nextAction = document.getElementById('nextAction25'); const rewardBox = document.getElementById('rewardBox25'); function updateModule() { const total = buttons.length; const completeCount = buttons.filter(btn => btn.classList.contains('complete')).length; const percent = (completeCount / total) * 100; const nextIncomplete = buttons.find(btn => !btn.classList.contains('complete')); buttons.forEach(btn => btn.classList.remove('active')); if (nextIncomplete) nextIncomplete.classList.add('active'); progressText.textContent = completeCount + ' / ' + total + ' Sections Complete'; progressBar.style.width = percent + '%'; if (nextIncomplete) { nextAction.innerHTML = ` Current Focus
Start ${nextIncomplete.textContent}
`; rewardBox.innerHTML = 'Complete the current active section, then advance.'; rewardBox.style.boxShadow = 'none'; } else { nextAction.innerHTML = ` Quest Complete
All sections complete. Advance to the next quest.
`; rewardBox.innerHTML = 'All sections complete.
The quest has been fully cleared.'; rewardBox.style.boxShadow = '0 0 18px rgba(77,255,136,0.35)'; } } buttons.forEach(btn => { btn.addEventListener('click', function () { this.classList.toggle('complete'); updateModule(); }); }); updateModule(); })();

EXPERIMENT 26 — COLLAPSIBLE QUEST DETAILSPurpose: Hide supporting details until needed
Focus: clarity, density reduction, and optional depthSee core → Expand details → Return to actionThis component keeps the main interface clean while preserving deeper support.The goal is to reduce clutter without losing useful information.TestDoes the page feel lighter with details hidden?Is it still easy to access notes, rewards, and requirements?Would this help keep the quest page focused?

Collapsible Quest Details

Active Quest
Copy Editing — Earth Scroll
Requirements
Line edit completed, manuscript version locked, reference notes open.
Rewards / XP
Unlock proofreading stage + 150 XP + next quest visibility.
Notes
Focus on clarity and consistency. Avoid perfectionism. Stop after one meaningful pass.

EXPERIMENT 27 — SKILL TREE NODE PANELPurpose: Represent a skill path with nodes, states, and progression
Focus: visibility, hierarchy, and growthLocked → Available → Active → CompleteThis component turns skills into a visible progression path.The goal is to make development feel structured and game-like.TestCan you tell what is locked, what is available, and what is active?Does the progression path feel motivating?Would this help make growth more visible?

Skill Tree — Thinking & Doing Integration

🟩 White Belt
Core Loop
Complete
🟨 Yellow Belt
Switching Practice
In Progress
🔷 Blue Belt
Quest Execution
Active
🟥 Red Belt
Advanced Rhythm
Available
🔒 Black Belt
Embodied Flow
Locked

EXPERIMENT 28 — HUB PAGE MODULEPurpose: Create a central command view for the dojo
Focus: orientation, current focus, and visible progressSee → Select → ActThis component functions like a game hub.It should show:
- what matters now
- where to go next
- what progress is visibleThe goal is to create one screen that reorients the user instantly.TestCan you understand your current situation immediately?Does the hub reduce searching?Would this work as a daily starting page?

ADHD DOJO — HUB

Your central command screen for orientation, action, and progress.

Active Quest

Earth Scroll — Line Editing

Current Focus: Section 4 — Carpenter Analogy

Next Action

Open Section 4 and do one complete pass.

Stop after one visible result.

Progress

3 / 9 sections complete

Mode

Current Mode: Do

Use action blocks only. Avoid unnecessary planning.

Go to Quests
Open Forge
View Skills
Review Battle Log

EXPERIMENT 29 — INTERACTIVE HUB SCREENPurpose: Create a central interactive command screen for the dojo
Focus: orientation, navigation, and immediate actionSee → Select → Focus → ActThis component turns the hub into a live control screen.It should:
- show the current state clearly
- allow focus to shift intentionally
- update visible information
- reduce searching and hesitationThe goal is to create a daily starting point that guides action immediately.TestCan you tell what matters right now in a few seconds?Does clicking different panels feel clear and useful?Would this work as your real starting screen each day?

ADHD DOJO — INTERACTIVE HUB

Select a focus area to update the hub state.

CURRENT FOCUS
Quests
NEXT ACTION
Open Section 4 and complete one pass.
VISIBLE PROGRESS
Earth Scroll: 3 / 9 complete
Quests
This is your current operational focus. Use the quest system to reduce ambiguity, select one active target, and make visible progress immediately.
(function () { const buttons = Array.from(document.querySelectorAll('.hub29-btn')); const focus = document.getElementById('hubFocus29'); const action = document.getElementById('hubAction29'); const progress = document.getElementById('hubProgress29'); const detail = document.getElementById('hubDetail29'); const descriptions = { "Quests": "This is your current operational focus. Use the quest system to reduce ambiguity, select one active target, and make visible progress immediately.", "Forge": "The Forge is where ideas become components. Build, test, and refine one piece at a time until it becomes reusable.", "Skills": "The Skills layer tracks your growth path. Use it to understand what you are training and what needs to be integrated next.", "Battle Log": "The Battle Log captures what happened in real conditions. Use it to convert action into feedback and refine the way." }; buttons.forEach(btn => { btn.addEventListener('click', function () { buttons.forEach(b => b.classList.remove('active')); this.classList.add('active'); const current = this.dataset.focus; focus.textContent = current; action.textContent = this.dataset.action; progress.textContent = this.dataset.progress; const colors = { "Quests": "#4dd2ff", "Forge": "#ffd24d", "Skills": "#4dff88", "Battle Log": "#ff6666" }; detail.style.borderLeftColor = colors[current] || "#4dd2ff"; detail.innerHTML = `${current}
${descriptions[current] || ""}`; }); }); })();

EXPERIMENT 30 — BELT / STRIPE TRACKER WITH SHU-HA-RI STATESPurpose: Visualize progression through belts, stripes, and Shu-Ha-Ri stages
Focus: development, visibility, and recursive skill trackingBelt → Stripe → Shu / Ha / RiThis component represents growth through structured progression.Belts represent broader levels of complexity.
Stripes represent individual skills or loops.
Shu-Ha-Ri represents the depth of mastery within each skill.The goal is to make development visible and trackable at multiple levels.TestCan you tell what level you are at immediately?Does the relationship between belts, stripes, and Shu-Ha-Ri make sense?Would this help track real growth without confusion?

Belt / Stripe Tracker — Shu-Ha-Ri

Track broader belt progression, individual skill stripes, and stage depth.

White Belt
Core Loop
Yellow Belt
Switching Practice
Blue Belt
Quest Execution
Red Belt
Advanced Rhythm
Black Belt
Embodied Flow
Current Belt Focus
Blue Belt — Quest Execution
This belt tracks your ability to move from quest context into visible action while maintaining one active focus and a stable loop.
Stripes (Skill Components)
Stripe 1 — Active Quest Selection
Train the ability to choose one quest and commit.
ShuHaRi
Stripe 2 — Next Action Clarity
Train the ability to make the next step explicit and visible.
ShuHaRi
Stripe 3 — Visible Progress Reps
Train the ability to complete visible reps consistently.
ShuHaRi
Stripe 4 — Thinking ↔ Doing Switching
Train deliberate transition between planning and execution.
ShuHaRi

EXPERIMENT 31 — INTERACTIVE BELT / STRIPE TRACKERPurpose: Make belt, stripe, and Shu-Ha-Ri progression interactive
Focus: visibility, progression, and mastery trackingBelt → Stripe → Shu / Ha / RiThis component turns progression into an interactive system.Clicking a stripe should update:
- the selected skill
- its current stage
- the progression summaryThe goal is to make growth feel visible and navigable.TestCan you understand the current progression state quickly?Does clicking between stripes feel useful?Would this help track real development over time?

Interactive Belt / Stripe Tracker

Click a stripe to inspect its current Shu-Ha-Ri state.

Current Belt
Blue Belt — Quest Execution
This belt focuses on integrating quest structure, next action clarity, and visible progress.
(function () { const buttons = Array.from(document.querySelectorAll('.stripe31-btn')); const detail = document.getElementById('stripeDetail31'); function renderDetail(btn) { const name = btn.dataset.name; const stage = btn.dataset.stage; const color = btn.dataset.color; const desc = btn.dataset.desc; detail.innerHTML = ` ${name}
Current Stage: ${stage}
Meaning:
${desc}
`; detail.style.borderLeft = `4px solid ${color}`; } buttons.forEach(btn => { btn.addEventListener('click', function () { buttons.forEach(b => b.classList.remove('active')); this.classList.add('active'); renderDetail(this); }); }); renderDetail(buttons[0]); })();

EXPERIMENT 32 — FULL GAME HUBPurpose: Combine core dojo systems into one central operational screen
Focus: orientation, focus, progression, and actionHub → Active Quest → Progress → GrowthThis component acts as the central game hub.It should pull together:
- current focus
- active quest
- progress state
- belt / stripe development
- next actionThe goal is to create one screen that feels like the real command center of the dojo.TestCan you orient yourself immediately?Does the hub reduce searching and confusion?Would this work as your daily startup page?

ADHD DOJO — FULL GAME HUB

One screen to orient, focus, and act.

Active Quest

Earth Scroll — Line Editing

Section 4 is the current focus.

Next Action

Open Section 4 and complete one clean pass.

Stop after one visible rep.

Quest Progress

3 / 9 sections complete

Current Belt

Blue Belt — Quest Execution

Ha stage emphasis on integration and refinement.

Hub Modules

Quests
Forge
Skills
Battle Log

Current Focus Summary

Your current training priority is to strengthen the thinking → doing loop through visible quest reps. Keep one active target, complete one meaningful rep, and record the result.

EXPERIMENT 33 — CHARACTER SHEETPurpose: Represent the user as a progressing character within the dojo
Focus: identity, strengths, bottlenecks, and progression stateCharacter → Role → Stats → BottlenecksThis component turns the user into a visible player-character.It should show:
- current role
- current belt
- strengths
- active bottlenecks
- current missionThe goal is to make identity and growth feel embodied.TestDoes this feel motivating or gimmicky?Does it make your current state easier to understand?Would this help reinforce identity-based growth?

Character Sheet

A snapshot of current role, state, and development.

Character Identity

Name: Ben

Role: Dojo Builder

Current Belt: Blue Belt

Current Mission: Build the Earth Scroll quest path

Core Stats

IdeationHigh
ExecutionModerate
SwitchingDeveloping
Visible Progress RepsGrowing

Strengths

  • High ideation and vision
  • Strong systems thinking
  • Deep pattern recognition
  • High intrinsic motivation for meaningful work

Current Bottlenecks

  • Transition friction from thinking → doing
  • Difficulty maintaining one active focus
  • Need for more stable visible reps
  • Task switching under resistance

EXPERIMENT 34 — INTERACTIVE CHARACTER SHEETPurpose: Make the character sheet interactive and actionable
Focus: identity, bottlenecks, strengths, and recommended actionIdentity → Diagnosis → RecommendationThis component turns the character sheet into an active guidance tool.Clicking a strength or bottleneck should update the guidance panel.The goal is to connect self-understanding directly to action.TestDoes clicking the traits feel useful?Does the recommendation feel specific and relevant?Would this help translate identity into training decisions?

Interactive Character Sheet

Click a strength or bottleneck to update the guidance panel.

Strengths

Bottlenecks

(function () { const buttons = Array.from(document.querySelectorAll('.char34-btn')); const detail = document.getElementById('charDetail34'); function renderDetail(btn) { const title = btn.dataset.title; const color = btn.dataset.color; const desc = btn.dataset.desc; const action = btn.dataset.action; const type = btn.dataset.type; detail.style.borderLeftColor = color; detail.innerHTML = ` ${title}
Type:${type}
Description:
${desc}
Recommended Action:
${action}
`; } buttons.forEach(btn => { btn.addEventListener('click', function () { buttons.forEach(b => b.classList.remove('active')); this.classList.add('active'); renderDetail(this); }); }); renderDetail(buttons[0]); })();

EXPERIMENT 35 — FULL DOJO NAVIGATION SHELLPurpose: Create a persistent app-like shell for the dojo
Focus: navigation, consistency, and environmental feelNavigate → Orient → EnterThis component gives the dojo a unified shell.It should feel less like isolated pages and more like one connected environment.The goal is to create the sense of moving through one coherent dojo system.TestDoes this feel more like an app than a page?Does the navigation feel clear and grounded?Would this help the dojo feel more real and unified?

ADHD DOJO
HubQuestsSkillsForgeBattle LogCharacter
Current Environment
Hub Overview
Active Quest
Current Belt
Daily Rep

Hub Shell Preview

This is a shell view for how the dojo might feel as one connected environment instead of isolated pages. The left side holds stable orientation. The right side holds the current working screen.

Active Quest

Earth Scroll — Line Editing

Next Action

Complete one pass on Section 4.

Visible Progress

3 / 9 sections complete

EXPERIMENT 36 — DAILY QUEST CARDPurpose: Create a single focused card for today’s mission
Focus: simplicity, constraint, and immediate executionToday → One Mission → One RepThis component strips everything down to one daily mission.It should:
- remove overwhelm
- make one objective visible
- support immediate actionThe goal is to make the day feel conquerable.TestDoes this reduce complexity enough?Does it make the day feel more manageable?Would this help you start faster?

TODAY'S QUEST

Earth Scroll — Section 4

Complete one focused line-edit pass on the Carpenter Analogy section and stop after one meaningful visible result.

Next Step
Open the manuscript and begin the first clean pass.
Definition of Done
One visible, completed editing pass on Section 4.

EXPERIMENT 37 — MEDIEVAL QUEST LOG SHELLPurpose: Test a more immersive, game-like quest log interface
Focus: atmosphere, hierarchy, and operational layoutFrame → Orient → Track → ActThis component explores a more stylized quest page.It combines:
- a saga column
- an active quest center panel
- an arc progression column
- a bottom navigation barThe goal is to see whether a more immersive visual shell improves clarity, motivation, and the feeling of entering a real dojo environment.What this experiment is testing- Can a more atmospheric design still remain readable?
- Does the three-column layout improve orientation?
- Does the central quest card feel like a real operational screen?
- Does the interface strengthen the “dojo” feeling without becoming cluttered?What to watch for- readability on desktop and mobile
- whether the side columns help or distract
- whether the parchment center feels useful or just decorative
- whether the overall shell feels exciting, grounded, and usableImportant noteThis is a larger component than previous experiments.The purpose here is not just function.
It is also to test visual identity, immersion, and whether a richer shell supports the way of training.If it works, it can become a foundation for future dojo screens.
If it feels too heavy, it may need to be simplified into smaller modules.

✦✦
QUEST LOG
SAGAS
⚔️Musashi Project
ACTIVE
💻Build the Engine
LOCKED
🔥
ACTIVE QUEST
THE MUSASHI PROJECT · LINE EDITING ARC
— ✦ —
Edit the Earth Scroll
Win Condition: +150 XP | Complete all sections of the Earth Scroll line edit
PROGRESSSections: 3 / 7
✓
Section 1 — The Ground of Strategy
✓
Section 2 — The Way of the Warrior
✓
Section 3 — Carpenter Analogy
Section 4 — The Path of Strategy
Section 5 — Advantages of Weapons
Section 6 — Timing in Strategy
Section 7 — Conclusion
Breadcrumb
Stopped mid-section 4. Next: read the paragraph aloud, check for rhythm, then cut any word that doesn't earn its place.
Next Step
Open Earth Scroll doc → navigate to Section 4 → begin line edit from the top of the paragraph.
Procedure — Line Edit Loop
1. Read paragraph aloud
2. Identify weak/redundant words
3. Cut or replace — earn every word
4. Read aloud again to check rhythm
5. Mark section complete → log rep
QUEST DETAILS
✓
Organize research notes COMPLETED ✓
Compile all notes and references in preparation for editing.
+15 XP
🔒
Edit Earth Scroll LOCKED
Complete all 7 sections of the Earth Scroll.
+30 XP · Focus + Discipline
ARCS
Musashi Project
✓ Manuscript Prep
✓ Organize notes
✓ Source materials
⚔️ Line Editing Arc
▶ Edit Earth Scroll
🔒 Edit Water Scroll
🔒 Edit Fire Scroll
🔒 Edit Wind Scroll
🔒 Edit Void Scroll
🔒 Publishing Arc
🔒 Format Chapters
🔒 Proofread
🔒 Submit
📜
function toggleRep(el) { el.classList.toggle('done'); updateProgress(); } function updateProgress() { const wrap = document.querySelector('.questlog-wrap'); const reps = wrap.querySelectorAll('.rep-item'); const done = wrap.querySelectorAll('.rep-item.done').length; const pct = (done / reps.length * 100).toFixed(0); wrap.querySelector('.progress-fill').style.width = pct + '%'; wrap.querySelector('.progress-labels span:last-child').textContent = `Sections: ${done} / ${reps.length}`; } function selectSaga(el) { const wrap = document.querySelector('.questlog-wrap'); wrap.querySelectorAll('.saga-item').forEach(s => s.classList.remove('active')); el.classList.add('active'); } function resumeQuest() { const btn = document.querySelector('.questlog-wrap .resume-btn'); const oldText = btn.textContent; btn.textContent = '⚔️ QUEST RESUMED — GO!'; btn.style.background = 'linear-gradient(180deg, #3a7a5a 0%, #1a4a3a 100%)'; setTimeout(() => { btn.textContent = oldText; btn.style.background = 'linear-gradient(180deg, #4a6a9a 0%, #2a4a7a 100%)'; }, 2000); }

EXPERIMENT 38 — SYSTEM PREVIEW TABSPurpose: Test a tabbed preview shell for multiple dojo systems
Focus: navigation, modularity, and system previewSelect → View → CompareThis experiment tests a multi-panel interface with tabs for:
- Hub
- Character
- Quests
- Dojo
- More IdeasThe goal is to see whether a tabbed shell helps organize multiple dojo views inside one clean component.TestDoes switching tabs feel smooth and clear?Does each panel feel distinct enough?Would this help preview different layers of the dojo without clutter?

Game System · Build Preview

What Can Be Built

A preview of possible outputs for your productivity system

🏠 Hub Dashboard
Your daily orientation screen — open this first, every time.
Edit the Earth Scroll
Stopped mid-section 4. Next: read the paragraph aloud, check for rhythm, then cut anything that does not earn its place.
NEXT ACTIONOpen Earth Scroll doc → Section 4
The Musashi Project
Line Editing Arc
· · ·
1 of 5 scrolls complete
Line Editing
Shu · Beginner65 / 100 XP
Character Lv.1120 / 300 XP
Reps Today3
XP Today+45
Day Streak7
Active Quests2
🧙 Character Sheet
Your identity, vision, and stats.
The Scholar-Editor
CLASS: SCHOLAR-EDITOR · LEVEL 1 · 120 XP

Translate the Book of Five Rings into a prototype book and audiobook. Ship something real.

📜 Quest Board
Saga → Arc → Quest hierarchy.
The Musashi Project
⚔️ Edit the Earth Scroll 150 XP
🔒 Edit the Water Scroll 150 XP
🔒 Edit the Fire Scroll 150 XP
🥋 Dojo Session Sheet
Pick your mode. Log your reps.
📖 Sensei's Lessons
🎯 Training Drills
🌿 Sandbox Practice
⚡ Sparring Challenges
✦ More Ideas
Other systems and tools you could build.
XP Progress Charts
Visual charts for skill XP, levels, and growth.
Quest Planning Worksheet
A structured template for building quests from scratch.
Skill Tree Visualizer
Interactive map of belts, skills, and Shu-Ha-Ri progression.
function showDojoPanel(name, el) { const wrap = document.querySelector('.dojo-tabs-wrap'); wrap.querySelectorAll('.dojo-panel').forEach(p => p.classList.remove('active')); wrap.querySelectorAll('.dojo-tab').forEach(t => t.classList.remove('active')); wrap.querySelector('#dojo-panel-' + name).classList.add('active'); el.classList.add('active'); }

EXPERIMENT 39 — INTERACTIVE SKILL TREE MAPPurpose: Test an interactive skill tree for the dojo
Focus: progression visibility, filtering, and skill inspectionView → Filter → InspectThis experiment tests a visual skill tree with:
- clickable skill nodes
- type-based filtering
- a live detail panel
- XP and progression displayThe goal is to make skill development feel visible, structured, and game-like.TestDoes the tree feel readable and meaningful?Do the filters help reduce visual clutter?Does clicking a node make the skill feel more real and understandable?

Game System · Skills

Skill Tree

Domain Skill
Meta Skill
Attribute
Locked
(function () { const skills = [ { id:'root', label:'Scholar\\nEditor', type:'root', x:450, y:60, xp:120, maxXp:300, belt:'Level 1', shr:'', icon:'🧙', desc:'Your character — the root from which all skills grow.', locked:false }, { id:'line-edit', label:'Line\\nEditing', type:'domain', x:180, y:180, xp:65, maxXp:100, belt:'Beginner', shr:'Shu', icon:'✏️', desc:'The craft of sharpening prose at the sentence level — rhythm, clarity, economy of language.', locked:false }, { id:'translation', label:'Translation', type:'domain', x:320, y:200, xp:20, maxXp:100, belt:'Beginner', shr:'Shu', icon:'📜', desc:'Converting meaning across languages while preserving voice, nuance, and intent.', locked:false }, { id:'dev-edit', label:'Develop.\\nEditing', type:'domain', x:100, y:320, xp:0, maxXp:100, belt:'Beginner', shr:'Shu', icon:'📖', desc:'Big-picture editing — structure, argument, narrative flow. Deferred to v2.', locked:true }, { id:'coding', label:'Coding', type:'domain', x:240, y:330, xp:40, maxXp:100, belt:'Beginner', shr:'Shu', icon:'💻', desc:'Building the custom engine. A future Saga in its own right.', locked:false }, { id:'audio-prod', label:'Audio\\nProd.', type:'domain', x:360, y:310, xp:0, maxXp:100, belt:'Beginner', shr:'Shu', icon:'🎙️', desc:'Audiobook production — the final output of the Musashi Project.', locked:true }, { id:'comprehension', label:'Compre-\\nhension', type:'meta', x:580, y:180, xp:280, maxXp:250, belt:'Intermediate', shr:'Ha', icon:'🔍', desc:'Deep reading comprehension — extracting meaning beyond the surface of a text.', locked:false }, { id:'analysis', label:'Analysis', type:'meta', x:700, y:200, xp:80, maxXp:100, belt:'Beginner', shr:'Shu', icon:'⚖️', desc:'Breaking down complex ideas into their component parts and relationships.', locked:false }, { id:'grammar', label:'Grammar', type:'meta', x:800, y:310, xp:55, maxXp:100, belt:'Beginner', shr:'Shu', icon:'📐', desc:'Structural understanding of language.', locked:false }, { id:'synthesis', label:'Synthesis', type:'meta', x:680, y:340, xp:0, maxXp:150, belt:'Beginner', shr:'Shu', icon:'🌐', desc:'Combining ideas from multiple sources into a new, coherent whole.', locked:true }, { id:'focus', label:'Focus', type:'attr', x:450, y:370, xp:60, maxXp:100, belt:'12', shr:'', icon:'🎯', desc:'The ability to sustain directed attention on difficult work.', locked:false }, { id:'discipline', label:'Discipline', type:'attr', x:550, y:410, xp:75, maxXp:100, belt:'14', shr:'', icon:'⚔️', desc:'Showing up consistently, especially when motivation is absent.', locked:false }, { id:'creativity', label:'Creativity', type:'attr', x:360, y:420, xp:30, maxXp:100, belt:'10', shr:'', icon:'🌿', desc:'Finding novel connections and solutions.', locked:false }, { id:'reasoning', label:'Reasoning', type:'attr', x:460, y:460, xp:50, maxXp:100, belt:'13', shr:'', icon:'💡', desc:'Logical clarity under complexity.', locked:false } ]; const connections = [ ['root','line-edit'], ['root','translation'], ['root','comprehension'], ['root','analysis'], ['root','focus'], ['root','discipline'], ['line-edit','dev-edit'], ['line-edit','coding'], ['translation','audio-prod'], ['comprehension','synthesis'], ['analysis','grammar'], ['focus','creativity'], ['focus','reasoning'], ['discipline','reasoning'] ]; const typeColors = { root: '#c9a84c', domain: '#c9a84c', meta: '#4a70a0', attr: '#8a5ab0' }; const svg = document.getElementById('dojo-skilltree-svg'); const NS = 'http://www.w3.org/2000/svg'; function el(tag, attrs = {}) { const e = document.createElementNS(NS, tag); for (const [k, v] of Object.entries(attrs)) e.setAttribute(k, v); return e; } function getSkill(id) { return skills.find(s => s.id === id); } const lineGroup = el('g'); svg.appendChild(lineGroup); connections.forEach(([a,b]) => { const sa = getSkill(a), sb = getSkill(b); if (!sa || !sb) return; const locked = sa.locked || sb.locked; const color = locked ? 'rgba(255,255,255,0.08)' : (typeColors[sb.type] || '#c9a84c'); const line = el('line', { x1: sa.x, y1: sa.y, x2: sb.x, y2: sb.y, stroke: color, 'stroke-width': locked ? 1 : 1.5, opacity: locked ? 0.12 : 0.22, 'stroke-dasharray': locked ? '4 4' : 'none', 'data-type': sb.type, class: 'skilltree-line' }); lineGroup.appendChild(line); }); const nodeGroup = el('g'); svg.appendChild(nodeGroup); skills.forEach(skill => { const g = el('g', { class: 'skilltree-node', transform: `translate(${skill.x}, ${skill.y})`, 'data-id': skill.id, 'data-type': skill.type }); const baseR = skill.type === 'root' ? 28 : 20; const color = skill.locked ? 'rgba(255,255,255,0.1)' : typeColors[skill.type]; const strokeColor = skill.locked ? 'rgba(255,255,255,0.15)' : typeColors[skill.type]; const fillOpacity = skill.locked ? 0.05 : (skill.type === 'root' ? 0.25 : 0.12); if (!skill.locked && skill.xp > 0) { const glow = el('circle', { r: baseR + 8, fill: 'none', stroke: color, 'stroke-width': 1, opacity: 0.12 }); g.appendChild(glow); } const circle = el('circle', { r: baseR, fill: color, 'fill-opacity': fillOpacity, stroke: strokeColor, 'stroke-width': skill.type === 'root' ? 2 : 1.5, opacity: skill.locked ? 0.4 : 1 }); g.appendChild(circle); if (!skill.locked && skill.xp > 0 && skill.type !== 'root') { const r2 = baseR + 5; const pct = Math.min(skill.xp / skill.maxXp, 1); const circ = 2 * Math.PI * r2; const dash = pct * circ; const arc = el('circle', { r: r2, fill: 'none', stroke: color, 'stroke-width': 2, opacity: 0.5, 'stroke-dasharray': `${dash} ${circ - dash}`, 'stroke-dashoffset': circ * 0.25, transform: 'rotate(-90)' }); g.appendChild(arc); } const icon = el('text', { 'text-anchor': 'middle', 'dominant-baseline': 'middle', y: skill.label.includes('\\n') ? -4 : 0, 'font-size': skill.type === 'root' ? '16' : '13', opacity: skill.locked ? 0.35 : 1 }); icon.textContent = skill.icon; g.appendChild(icon); const lines = skill.label.split('\\n'); lines.forEach((line, i) => { const t = el('text', { 'text-anchor': 'middle', 'dominant-baseline': 'middle', y: baseR + 12 + (i * 13), 'font-size': '9', 'letter-spacing': '0.08em', fill: skill.locked ? 'rgba(255,255,255,0.2)' : typeColors[skill.type], opacity: skill.locked ? 0.5 : 0.9 }); t.textContent = line.toUpperCase(); g.appendChild(t); }); g.addEventListener('click', () => showSkillDetail(skill)); nodeGroup.appendChild(g); }); function showSkillDetail(skill) { const card = document.getElementById('skilltree-detail-card'); document.getElementById('st-icon').textContent = skill.icon; document.getElementById('st-name').textContent = skill.label.replace('\\n', ' '); const typeLabel = { domain: 'Domain Skill', meta: 'Meta Skill', attr: 'Attribute', root: 'Character' }[skill.type]; const color = typeColors[skill.type]; const metaEl = document.getElementById('st-meta'); metaEl.style.color = color; let metaStr = typeLabel; if (skill.shr) metaStr += ` · ${skill.shr} Stage`; if (skill.belt) metaStr += ` · ${skill.type === 'attr' ? 'Stat ' : ''}${skill.belt}`; if (skill.locked) metaStr += ' · Locked'; metaEl.textContent = metaStr; document.getElementById('st-body').textContent = skill.desc; const barsEl = document.getElementById('st-bars'); barsEl.innerHTML = ''; if (skill.type !== 'root' && !skill.locked) { const xpPct = Math.min((skill.xp / skill.maxXp) * 100, 100).toFixed(0); barsEl.innerHTML = `
XP Progress${skill.xp} / ${skill.maxXp}
`; } if (skill.type === 'root') { const pct = (skill.xp / skill.maxXp * 100).toFixed(0); barsEl.innerHTML = `
Character XP${skill.xp} / ${skill.maxXp}
`; } card.classList.add('visible'); card.style.borderColor = color + '44'; } window.filterSkillTree = function(type, btn) { const wrap = document.querySelector('.dojo-skilltree-wrap'); wrap.querySelectorAll('.skilltree-filter-btn').forEach(b => b.classList.remove('active')); btn.classList.add('active'); wrap.querySelectorAll('.ski
Game System · Skills

Skill Tree

🧙SCHOLAREDITOR✏️LINEEDITING📜TRANSLATION💻CODING🔍COMPRE-HENSION⚖️ANALYSIS📐GRAMMAR🎯FOCUS⚔️DISCIPLINE🌿CREATIVITY💡REASONING
🧙
Scholar Editor
Character · Level 1
Your character — the root from which all skills grow.
Character XP120 / 300
Domain Skill
Meta Skill
Attribute
Locked
function showSkillDetailStatic(name, meta, desc, icon, color, xpText) { document.getElementById('st-icon').textContent = icon; document.getElementById('st-name').textContent = name; const metaEl = document.getElementById('st-meta'); metaEl.textContent = meta; metaEl.style.color = color; document.getElementById('st-body').textContent = desc; let pct = 0; if (xpText && xpText.includes('/')) { const parts = xpText.split('/').map(s => parseFloat(s.trim())); if (parts.length === 2 && parts[1] > 0) pct = Math.min((parts[0] / parts[1]) * 100, 100); } document.getElementById('st-bars').innerHTML = `
XP Progress${xpText}
`; const card = document.getElementById('skilltree-detail-card'); card.style.borderColor = color + '44'; } function filterSkillTreeStatic(type, btn) { const wrap = document.querySelector('.dojo-skilltree-wrap'); wrap.querySelectorAll('.skilltree-filter-btn').forEach(b => b.classList.remove('active')); btn.classList.add('active'); wrap.querySelectorAll('.skilltree-node').forEach(node => { const t = node.getAttribute('data-type'); const show = type === 'all' || t === type || t === 'root'; node.style.opacity = show ? '1' : '0.12'; node.style.pointerEvents = show ? 'auto' : 'none'; }); wrap.querySelectorAll('.skilltree-line').forEach(line => { const t = line.getAttribute('data-type'); line.style.opacity = (type === 'all' || t === type) ? '0.25' : '0.04'; }); }

EXPERIMENT 40 — QUEST CHAIN PANELPurpose: Show the relationship between previous, current, and next quests
Focus: progression, dependency, and visible pathPrevious → Current → NextThis component represents the quest chain as a progression path.It should show:
- what has been completed
- what is currently active
- what is next
- what remains lockedThe goal is to make quest flow visible without opening a full quest page.TestCan you understand the path at a glance?Does the current quest stand out clearly?Would this help reduce uncertainty about what comes next?

Quest Chain Panel

Completed
Line Editing Prep
→
Active Quest
Edit the Earth Scroll
→
Available
Edit the Water Scroll
→
Locked
Edit the Fire Scroll

EXPERIMENT 41 — DAILY STARTUP CARDPurpose: Create a minimal daily starting point
Focus: clarity, constraint, and immediate executionToday → One Mission → BeginThis component compresses the day into one actionable card.It should show:
- today’s quest
- the next action
- the definition of done
- one warning or guardrailThe goal is to make starting fast and simple.TestDoes this reduce overwhelm?Is the day immediately understandable?Would this help you start faster without overthinking?

DAILY STARTUP

Edit the Earth Scroll

Today’s mission is one focused line-edit pass on the current section.

Next Action
Open Section 4 and begin one complete pass.
Definition of Done
One visible, completed editing pass on Section 4.
Guardrail
Do not redesign the whole system before placing one real brick.

EXPERIMENT 42 — RESUME PANELPurpose: Solve the “where was I?” problem
Focus: re-entry, continuity, and restart clarityLast State → Restart Cue → ResumeThis component helps resume interrupted work.It should show:
- the last active quest
- the last completed rep
- the breadcrumb
- the exact restart instructionThe goal is to reduce friction when returning to work.TestWould this make it easier to restart after interruption?Is the breadcrumb specific enough?Does the resume cue eliminate hesitation?

Resume Panel

Last Active Quest
Edit the Earth Scroll
Last Completed Rep
Section 3 — Carpenter Analogy
Breadcrumb
Stopped at the start of Section 4. Need to read aloud from the first paragraph and begin cutting weak wording.
Resume Cue
Open Section 4 and complete one visible pass before doing anything else.

EXPERIMENT 43 — BOTTLENECK DETECTOR PANELPurpose: Identify the current constraint in the system
Focus: diagnosis, clarity, and next training targetProblem → Bottleneck → Next Training FocusThis component helps diagnose what is actually blocking progress.It should identify:
- the visible problem
- the likely bottleneck
- the skill or behavior to train nextThe goal is to stop vague overwhelm and replace it with a clear target.TestDoes the diagnosis feel specific and useful?Would this help you stop guessing what to do next?Does it point clearly to one trainable issue?

Bottleneck Detector

Visible Problem
You know what matters, but you are not starting.
Likely Bottleneck
Thinking → Doing Friction
The issue is not lack of ideas. The issue is the handoff from thought into visible action.
Train Next
Define one smallest visible rep and do it immediately.

EXPERIMENT 44 — SHU-HA-RI SKILL CARDPurpose: Represent one skill through Shu, Ha, and Ri stages
Focus: progression, clarity, and stage requirementsSkill → Stage → Next RequirementThis component compresses progression for one skill into a simple card.It should show:
- the current skill
- current stage
- what each stage means
- what is required nextThe goal is to make development clearer without needing a full skill tree.TestDoes this make the stage progression understandable?Can you tell what “next” means?Would this work better than a more complex visual tree for some uses?

Shu-Ha-Ri Skill Card

Skill
Thinking ↔ Doing Switching
Shu
Learn the form
You can identify the loop and perform it with support.
Ha
Refine the form
You can perform the loop under variation and recover when it breaks.
Ri
Embody the form
You can switch naturally without needing to think about the form.
Current Stage
Shu → approaching Ha
Next Requirement
Complete multiple visible reps where you define the next action quickly and transition into execution without stalling.

EXPERIMENT 45 — SESSION END REFLECTION CARDPurpose: Close the loop after action and capture feedback
Focus: reflection, learning, and restart preparationAction → Reflection → Next Restart CueThis component helps end a session intentionally.It should capture:
- what was completed
- what broke down
- what was learned
- what the next restart cue isThe goal is to turn action into usable feedback.TestWould this help preserve momentum across sessions?Does it capture just enough without becoming heavy?Would this improve your next startup?

Session End Reflection

Completed
Finished one full line-edit pass on Section 4.
Broke Down
Wanted to keep redesigning the whole quest system instead of finishing the rep.
Learned
The smallest visible rep is enough to create momentum. Planning past that point becomes drag.
Next Restart Cue
Open Section 5 and begin the first read-aloud pass.

EXPERIMENT 46 — BELT PROMOTION TEST CARDPurpose: Test readiness for advancement to the next level
Focus: criteria, demonstration, and honest assessmentRequirements → Demonstration → Pass / Not YetThis component represents a promotion test.It should show:
- the current belt
- the target belt
- required skills
- demonstration criteria
- pass or not-yet statusThe goal is to make advancement concrete instead of vague.TestDoes this make progression feel more real?Would this help prevent premature advancement?Does the pass / not-yet framing feel clear and useful?

Belt Promotion Test

Current Belt
Blue Belt
→
Target Belt
Red Belt
Required Skills
  • Active Quest Selection at Ha
  • Next Action Clarity at Ha
  • Visible Progress Reps at Ha
  • Thinking ↔ Doing Switching at Ha
Demonstration Criteria
Complete a full quest loop with one active focus, visible rep completion, and reliable switching from thought into action without stalling.
Status: NOT YET
One or more required skills have not reached the minimum threshold.

EXPERIMENT 47A — UI FOUNDATION KIT (CLEAN)Purpose: Build the most basic structural version of the dojo UI system
Focus: clarity, modularity, and scalabilityStructure → Reuse → ExpandThis experiment tests the cleanest possible version of the core dojo components.It includes:
- title banner
- panel
- card
- status badge
- progress bar
- action buttonThe goal is to validate the structure before layering heavier visual style.TestDoes the structure make sense without decoration?Are the components readable and reusable?Would this be a stable base for scaling upward?

GAME

Character

Scholar-Editor
Level 12
Active
XP3450 / 4800

Current Objective

Line Edit Chapter 1

Refine the first chapter of the manuscript.

Quest Summary

Sagas
Musashi Project
Arcs
Manuscript Editing
Active Quest
Line Edit Chapter 1

EXPERIMENT 47B — UI FOUNDATION KIT (HYBRID)Purpose: Add light thematic styling to the dojo foundation kit
Focus: atmosphere, readability, and modular designStructure → Theme → ReuseThis experiment applies a light dojo / game aesthetic without sacrificing clarity.It keeps the same core components as the clean version, but adds:
- stronger color hierarchy
- themed headers
- richer panels
- more game-like buttonsThe goal is to find the middle ground between function and atmosphere.TestDoes this feel more alive without becoming cluttered?Are the components still easy to scan?Would this be the best base for building the real dojo?

GAME

Character

Scholar-Editor
Level 12
Active
XP3450 / 4800

Current Objective

Line Edit Chapter 1

Refine the first chapter of the manuscript.

Quest Summary

Sagas
Musashi Project
Arcs
Manuscript Editing
Active Quest
Line Edit Chapter 1

EXPERIMENT 47C — UI FOUNDATION KIT (STYLIZED)Purpose: Test a more advanced visual shell for the dojo components
Focus: immersion, hierarchy, and game-like identityStructure → Theme → ImmersionThis experiment pushes the same core components into a more atmospheric and stylized direction.It keeps the modular structure, but adds:
- ornamental framing
- richer materials
- stronger game-like presentation
- heavier visual identityThe goal is to test how far the dojo can lean into the game aesthetic without losing usability.TestDoes the style strengthen immersion?Is anything becoming harder to read or use?Does this feel exciting enough to justify the added complexity?

GAME

CHARACTER
Scholar-Editor
Level 12
ACTIVE
XP3450 / 4800
CAMPAIGN HUB
Current Objective:
Line Edit Chapter 1

Refine the first chapter of the manuscript.

QUESTS
SAGAS
Musashi Project
ARCS
Manuscript Editing
ACTIVE QUEST
Line Edit Chapter 1

EXPERIMENT 48A — HYBRID QUEST LOG PAGEPurpose: Build a readable, game-inspired quest log using the hybrid foundation
Focus: clarity, structure, and light thematic immersionSaga → Active Quest → ArcThis experiment rebuilds the Quest Log page using the hybrid style layer.It includes:
- sagas panel
- active quest panel
- arcs panel
- quest details area
- progress and resume flowThe goal is to create a version that feels thematic and structured without becoming visually heavy.TestIs the page easy to scan?Does the active quest stand out clearly?Would this be a strong working version even without the full stylized shell?

QUEST LOG

Sagas

⚔️ Musashi Project
Manuscript Preparation
Completed
Manuscript Editing
Active

Active Quest

Musashi Project
Line Edit Chapter 1

Win Condition: +25 XP | Improve the clarity and flow of the first chapter.

Pages Edited: 10 / 20
Quest Details
✓ Organize research notes — Completed
🔒 Edit Chapter 2 — Locked

Arcs

Musashi Project
✓ Manuscript Preparation
Completed
Manuscript Editing
In Progress
🔒 Manuscript Publishing

EXPERIMENT 48B — STYLIZED QUEST LOG PAGEPurpose: Rebuild the Quest Log as a fully interactive stylized dojo screen
Focus: immersion, progression, and responsive quest behaviorSaga → Active Quest → Progress → ResumeThis experiment rebuilds the Quest Log in a richer stylized shell.It includes:
- sagas panel
- active quest center panel
- arcs panel
- live checklist
- progress bar
- status feedback
- resume interactionThe goal is to create a real interactive dojo quest screen, not just a mockup.TestDoes the page feel immersive and still usable?Do the checklist and progress updates feel satisfying?Would this be something you would actually want to use as part of the real dojo?

QUEST LOG
SAGAS
⚔ Musashi Project
Manuscript Preparation COMPLETED
Manuscript Editing
🕯️
ACTIVE QUEST
Musashi Project
Line Edit Chapter 1
Win Condition: +25 XP | Improve the clarity and flow of the first chapter.
Pages Edited: 10 / 20
QUEST DETAILS
✓ Organize research notes COMPLETED
🔒 Edit Chapter 2 LOCKED
ARCS
Musashi Project
✓ Manuscript Preparation COMPLETED
Manuscript Editing IN PROGRESS
🔒 Edit Chapter 2
🔒 Edit Chapter 3
🔒 Manuscript Publishing
📜
(function () { const wrap = document.querySelector('.dojo48b-wrap'); if (!wrap) return; const checklist = wrap.querySelectorAll('.dojo48b-check-item'); const progressFill = wrap.querySelector('#dojo48bProgressFill'); const progressLabel = wrap.querySelector('#dojo48bProgressLabel'); const resumeBtn = wrap.querySelector('#dojo48bResumeBtn'); const arcProgress = wrap.querySelector('.dojo48b-arc-item.progress'); const detailsLocked = wrap.querySelector('.dojo48b-detail-item.locked'); function updateQuestState() { const total = checklist.length; let done = 0; checklist.forEach(item => { const input = item.querySelector('input'); if (input.checked) { item.classList.add('complete'); done++; } else { item.classList.remove('complete'); } }); const pagesDone = done * 5; const pct = (done / total) * 100; progressFill.style.width = pct + '%'; progressLabel.textContent = `Pages Edited: ${pagesDone} / 20`; if (done === total) { resumeBtn.textContent = 'QUEST COMPLETE'; resumeBtn.style.background = 'linear-gradient(180deg,#2f6d3f,#234e2f)'; arcProgress.innerHTML = '✓ Manuscript Editing COMPLETED'; arcProgress.classList.remove('progress'); arcProgress.classList.add('complete'); if (detailsLocked) { detailsLocked.innerHTML = '✓ Edit Chapter 2 UNLOCKED'; detailsLocked.classList.remove('locked'); detailsLocked.classList.add('complete'); detailsLocked.style.color = '#4dff88'; } } else { resumeBtn.textContent = 'RESUME QUEST'; resumeBtn.style.background = 'linear-gradient(180deg,#8b5a1e,#5f3b12)'; } } checklist.forEach(item => { const input = item.querySelector('input'); input.addEventListener('change', updateQuestState); }); resumeBtn.addEventListener('click', function () { const original = this.textContent; this.textContent = 'QUEST RESUMED'; this.style.filter = 'brightness(1.12)'; setTimeout(() => { this.textContent = original; this.style.filter = ''; }, 1200); }); updateQuestState(); })();

EXPERIMENT 49A — HYBRID GAME HUBPurpose: Rebuild the Game Hub using the hybrid dojo foundation
Focus: orientation, readability, and functional atmosphereCharacter → Skills → Quests → DojoThis experiment rebuilds the Game Hub as a practical, themed dashboard.It includes:
- character summary
- skills shortcuts
- quest summary
- current objective
- dojo entry
- bottom navigationThe goal is to create a usable command center that still feels like part of the dojo.TestIs the layout easy to understand at a glance?Does the current objective stand out enough?Would this work as a daily starting screen?

GAME

Character

🧙
Scholar-Editor
Level 12
Focus 15
Knowledge 20
XP3450 / 4800

Skills

Skill Trees
Meta Skills
Domain Skills
Current Objective:
Line Edit Chapter 1

Refine the first chapter of the manuscript.

Campaign Hub

Quests

Sagas
Musashi Project
Arcs
Manuscript Editing
Active Quest
Line Edit Chapter 1

Dojo

🥋

EXPERIMENT 49B — STYLIZED GAME HUBPurpose: Rebuild the Game Hub as a rich stylized dojo command screen
Focus: immersion, orientation, and high-impact visual identityCharacter → Skills → Quests → DojoThis experiment rebuilds the Game Hub in a more fully stylized visual shell.It includes:
- character summary panel
- skills shortcuts
- campaign hub
- current objective
- quest summary
- dojo entry
- bottom navigationThe goal is to create a screen that feels like the true front door of the dojo.TestDoes this feel exciting enough to open daily?Is the current objective still easy to understand?Would this create momentum just by entering the screen?

GAME
CHARACTER
🧙
⚔ Level 12
💎 Focus 15
🧠 Knowledge 20
XP3,450 / 4,880
SKILLS
Campaign Hub
Current Objective:
Line Edit Chapter 1
Refine the first chapter of the manuscript.
QUESTS
SAGAS: Musashi Project
ARCS: Manuscript Editing
ACTIVE QUEST: Line Edit Chapter 1
DOJO
🥋

EXPERIMENT 50A — HYBRID CHARACTER PAGEPurpose: Rebuild the Character page using the hybrid dojo foundation
Focus: identity, progression, and readable stat organizationIdentity → Stats → Skills → ProgressThis experiment rebuilds the Character page as a practical, themed dashboard.It includes:
- character identity block
- attributes / stats
- active skills
- level and XP
- profile actionsThe goal is to create a clear character overview that feels like part of the dojo without becoming visually heavy.TestDoes the page communicate identity and progression clearly?Are the stats easy to scan?Would this work as a reliable character overview screen?

CHARACTER

🧙
Scholar-Editor
Level 12
A builder of systems, manuscripts, and mastery loops. Current mission: turn thought into visible work and ship meaningful artifacts.

Progress

Character XP3450 / 4800
Dojo RankBlue Belt

Attributes

Focus
15
Discipline
14
Reasoning
13
Creativity
10

Active Skills

Comprehension
Intermediate · 280 XP
Line Editing
Beginner · 65 XP
Translation
Beginner · 20 XP
Current Mission

Train the thinking → doing loop through visible quest reps and turn the dojo into a working system.

EXPERIMENT 50B — STYLIZED CHARACTER PAGEPurpose: Rebuild the Character page as a rich stylized dojo profile screen
Focus: immersion, progression, and identityIdentity → Attributes → Skills → MissionThis experiment rebuilds the Character page in a fully stylized visual shell.It includes:
- portrait / role block
- attributes panel
- active skills panel
- progression bars
- mission statement
- themed action buttonsThe goal is to make the character screen feel like a true status page inside the dojo.TestDoes this strengthen identity and motivation?Is the page still easy to read despite the heavier style?Would this feel rewarding to revisit regularly?

CHARACTER
PROFILE
🧙
Scholar-Editor
LEVEL 12
A builder of systems, manuscripts, and mastery loops. Current path: transform ideas into visible work and ship meaningful artifacts.
PROGRESSION
Character XP3,450 / 4,800
Dojo RankBlue Belt
ATTRIBUTES
FOCUS
15
DISCIPLINE
14
REASONING
13
CREATIVITY
10
ACTIVE SKILLS
ComprehensionIntermediate · 280 XP
Line EditingBeginner · 65 XP
TranslationBeginner · 20 XP
MISSION
Train the thinking → doing loop through visible quest reps and turn the dojo into a working system.

EXPERIMENT 51A — HYBRID SKILLS PAGEPurpose: Rebuild the Skills page using the hybrid dojo foundation
Focus: progression, clarity, and structured trainingCategory → Skill → Stage → ProgressThis experiment rebuilds the Skills page as a practical, themed dashboard.It includes:
- skill categories
- active skills
- Shu-Ha-Ri context
- XP / progress bars
- related training targetsThe goal is to make the skills system easy to scan and easy to train from.TestAre the skill categories easy to understand?Does the progression information feel useful?Would this work as a practical skills overview page?

SKILLS

Categories

Meta Skills
Thinking, reasoning, comprehension
Domain Skills
Editing, translation, coding
Attributes
Focus, discipline, creativity
Active Skill Focus
Line Editing

Current goal: improve clarity, rhythm, and word economy through visible reps.

Tracked Skills

Line EditingShu
XP65 / 100
ComprehensionHa
XP280 / 300
TranslationShu
XP20 / 100

Shu-Ha-Ri

Shu
Learn the form
Ha
Refine the form
Ri
Embody the form

Training Target

Complete multiple visible line-edit reps with minimal hesitation between deciding and doing.

Related Quest

Edit the Earth Scroll

EXPERIMENT 51B — STYLIZED SKILLS PAGEPurpose: Rebuild the Skills page as a rich stylized dojo training screen
Focus: immersion, progression, and visible masteryCategory → Skill → Stage → TrainThis experiment rebuilds the Skills page in a fully stylized visual shell.It includes:
- categories panel
- active skill focus
- skill progression cards
- Shu-Ha-Ri stage area
- related training target
- related quest connectionThe goal is to make skills feel like a real system of growth inside the dojo.TestDoes the page make skill progression feel meaningful?Is the active skill focus strong enough?Would this make training feel more intentional and rewarding?

SKILLS
CATEGORIES
META SKILLSThinking, reasoning, comprehension
DOMAIN SKILLSEditing, translation, coding
ATTRIBUTESFocus, discipline, creativity
ACTIVE SKILL
Current Skill Focus
Line Editing
Improve clarity, rhythm, and word economy through visible reps.
TRACKED SKILLS
Line EditingShu
65 / 100 XP
ComprehensionHa
280 / 300 XP
TranslationShu
20 / 100 XP
SHU-HA-RI
SHULearn the form
HARefine the form
RIEmbody the form
TRAINING TARGET
Complete multiple visible line-edit reps with minimal hesitation between deciding and doing.
RELATED QUEST
Edit the Earth Scroll

EXPERIMENT 52A — HYBRID DOJO PAGEPurpose: Rebuild the Dojo page using the hybrid dojo foundation
Focus: training mode, current session, and deliberate practiceChoose Mode → Train Skill → Log RepsThis experiment rebuilds the Dojo page as a practical training screen.It includes:
- training mode cards
- session focus
- current rep target
- session log
- training actionsThe goal is to create a working practice page that feels clear, useful, and connected to the rest of the dojo.TestDoes the page make it easy to begin training?Are the training modes distinct enough?Would this work as a practical practice screen?

DOJO

Training Modes

Sensei’s Lessons
Guided instruction and conceptual learning.
Training Drills
Focused repetition for skill improvement.
Sandbox Practice
Open experimentation and exploration.
Sparring Challenge
Test skill under pressure and variation.
Current Session Focus
Line Editing Drill

Practice cutting weak wording and improving sentence rhythm through short deliberate reps.

Current Rep

Read one paragraph aloud, identify weak words, revise once, then read aloud again.

Session Log

Rep 1 — Completed
+10 XP
Rep 2 — Completed
+10 XP
Rep 3 — In Progress
Current active rep

Training Target

Complete 5 deliberate editing reps with visible output and no drift into redesigning the whole system.

Related Skill

Line Editing

EXPERIMENT 52B — STYLIZED DOJO PAGEPurpose: Rebuild the Dojo page as a rich stylized training screen
Focus: immersion, mode selection, and deliberate practiceEnter Dojo → Choose Mode → TrainThis experiment rebuilds the Dojo page in a fully stylized visual shell.It includes:
- training mode cards
- current session focus
- current rep area
- session log
- related skill and training targetThe goal is to make the Dojo feel like a real place of practice inside the system.TestDoes the page make training feel more intentional?Are the modes visually distinct enough?Would this make you want to actually enter the dojo and practice?

DOJO
TRAINING MODES
SENSEI’S LESSONSGuided instruction and conceptual learning.
TRAINING DRILLSFocused repetition for skill improvement.
SANDBOX PRACTICEOpen experimentation and exploration.
SPARRING CHALLENGETest skill under pressure and variation.
TRAINING TARGET
Complete 5 deliberate editing reps with visible output and no drift into redesigning the whole system.
CURRENT SESSION
Session Focus
Line Editing Drill
Practice cutting weak wording and improving sentence rhythm through short deliberate reps.
CURRENT REP
Read one paragraph aloud, identify weak words, revise once, then read aloud again.
SESSION LOG
Rep 1 — Completed+10 XP
Rep 2 — Completed+10 XP
Rep 3 — In ProgressCurrent active rep
RELATED SKILL
Line Editing

EXPERIMENT 53 — SHOWPIECE GAME HUBPurpose: Explore a top-tier stylized version of the dojo interface
Focus: immersion, atmosphere, hierarchy, and premium presentationEnter → Orient → Choose → ActThis experiment is a showcase page.It is not meant to be the immediate production version.
It is meant to explore what the dojo could look like at a much more advanced visual level.It includes:
- cinematic top banner
- premium character panel
- current campaign hub
- active quest presentation
- skills / dojo panels
- premium bottom navigationThe goal is to create a true “north star” mockup for the dojo.TestDoes this feel exciting and aspirational?What parts feel worth carrying into the real system?What parts feel too heavy for practical daily use?

EXPERIMENT 54 — SHARED PANEL + LAYOUT SYSTEMPurpose: Create a shared inline foundation for the dojo UI
Focus: consistency, reuse, and visual cohesionShell → Panel → Card → ActionThis experiment creates a shared visual system for future dojo screens.It includes:
- outer shell
- title banner
- shared panel style
- shared card style
- button system
- status badges
- progress / meter stylesThe goal is to make future screens easier to build, more consistent, and more unified.TestDo these pieces feel cohesive together?Would this make future pages easier to build?Does this feel like the beginning of one real app language?

ADHD DOJO · SHARED SYSTEM
FOUNDATION KIT
Reusable shell, panels, cards, buttons, and meters
PANEL HEADER
CARD LABEL
Shared Card Style
This is the default dark content card for panels, summaries, logs, and structured information.
ACTIVEIN PROGRESSFOCUSLOCKED
PARCHMENT CARD
CURRENT OBJECTIVE
Shared Highlight Card
Use this for quest focus, mission statements, current objective, current session, or training target.
METERS
CHARACTER XP3,450 / 4,800
DOJO RANKBLUE BELT
QUEST PROGRESS10 / 20 PAGES
BUTTON SYSTEM
STAT ROWS
⚔ Level12
🎯 Focus15
🧠 Knowledge20
🔥 Momentum7-Day Streak
SHORTCUT BOXES

EXPERIMENT 55 — SHARED STYLIZED APP SHELLPurpose: Create a reusable top-level shell for the dojo app
Focus: navigation, cohesion, and shared page structureBanner → Navigation → Content → FooterThis experiment creates a shared app shell for future dojo screens.It includes:
- top banner
- shared navigation
- page title area
- main content frame
- bottom nav
- optional utility areaThe goal is to give every major page a common structure so the dojo feels like one unified system.TestDoes this make the interface feel more like one real app?Would this make future screens easier to plug in?Does the shell feel strong enough to support Game, Character, Skills, Quests, and Dojo pages?

✦ADHD DOJO✦
SHARED APP SHELL
COMMAND FRAME
A unified shell for Game, Character, Skills, Quests, and Dojo screens.
MAIN SCREEN AREA
ACTIVE SCREEN CONTENT
Drop In Any Page
This is where your Game Hub, Character page, Skills page, Quest Log, or Dojo content would live.
(function () { const btn = document.getElementById('dojo55MusicBtn'); const audio = document.getElementById('dojo55Music'); if (!btn || !audio) return; let started = false; btn.addEventListener('click', function () { if (!started) { audio.muted = false; audio.volume = 0.5; audio.play().then(() => { btn.textContent = 'MUSIC: ON'; started = true; }).catch(() => { btn.textContent = 'TAP AGAIN'; }); } else { if (audio.paused) { audio.play(); btn.textContent = 'MUSIC: ON'; } else { audio.pause(); btn.textContent = 'MUSIC: OFF'; } } }); })();
(function () { const btn = document.getElementById('playTest'); const audio = document.getElementById('audioTest'); if (!btn || !audio) return; btn.addEventListener('click', function () { audio.play() .then(() => { btn.textContent = 'Pause Music'; }) .catch((err) => { btn.textContent = 'Blocked'; console.log(err); }); }); })();
(function () { var btn = document.getElementById('dojoMusicBtn'); var audio = document.getElementById('dojoMusic'); if (!btn || !audio) return; btn.onclick = function () { if (audio.paused) { audio.play().then(function () { btn.textContent = 'MUSIC: ON'; }).catch(function () { btn.textContent = 'BLOCKED'; }); } else { audio.pause(); btn.textContent = 'MUSIC: OFF'; } }; })();

EXPERIMENT 56 — APP SHELL WITH MUSIC TOGGLEPurpose: Integrate the working music control into the shared dojo shell
Focus: stability, cohesion, and atmosphereShell → Control → ContentThis experiment adds the working music toggle to the shared app shell.It includes:
- top app bar
- music toggle
- shared page shell
- navigation
- content frameThe goal is to unify the working music button into the real dojo interface without adding extra complexity.TestDoes the music control feel like part of the shell?Does it remain stable when integrated?Does this make the dojo feel more alive without becoming distracting?

✦ADHD DOJO✦
SHARED APP SHELL
COMMAND FRAME
Unified shell with integrated atmosphere control.
MAIN SCREEN AREA
ACTIVE SCREEN CONTENT
Shell + Music Unified
This shell now includes a working on/off music toggle in the top utility bar.
(function () { var btn = document.getElementById('dojoMusicBtn'); var audio = document.getElementById('dojoMusic'); if (!btn || !audio) return; btn.onclick = function () { if (audio.paused) { audio.play().then(function () { btn.textContent = 'MUSIC: ON'; }).catch(function () { btn.textContent = 'BLOCKED'; }); } else { audio.pause(); btn.textContent = 'MUSIC: OFF'; } }; })();

EXPERIMENT 57A — HYBRID QUEST ARCHITECTUREPurpose: Translate the Mermaid quest architecture into a clean, usable page layout.Structure:
- Left: Quest List Panel
- Center: Quest Detail + Objective Tracker + Progress
- Right: Rewards, Requirements, Context, Metadata, Controls
- Bottom: Notes / JournalFocus: clarity, hierarchy, modular separation

QUEST DETAILS
Edit the Earth Scroll
Complete all sections of the Earth Scroll.
OBJECTIVES
☑ Section 1
☑ Section 2
☐ Section 3
PROGRESS
NOTES
Stopped mid section 3.

EXPERIMENT 57B — STYLIZED QUEST ARCHITECTUREPurpose: Same structure as 57A, but expressed in full dojo/game UI style.Focus:
- immersion
- visual hierarchy
- atmosphere

ACTIVE QUEST
Edit the Earth Scroll
Complete all sections.
✓ Section 1
✓ Section 2
☐ Section 3
JOURNAL
Paused mid section 3.

EXPERIMENT 57C — QUEST ARCHITECTURE IN SHARED SHELLPurpose: Place the quest architecture inside the unified stylized app shell
Focus: cohesion, structure, and shell fitShell → Quest List → Active Quest → Support Panels → NotesThis experiment takes the Mermaid quest architecture and places it inside the shared stylized shell.It includes:
- shared shell header and nav
- quest list panel
- quest detail / task tracker
- rewards / requirements / metadata / controls
- notes / journalThe goal is to test whether the shell can hold the quest architecture cleanly before extracting components.TestDoes the quest architecture feel at home inside the shared shell?Does the shell strengthen the layout?Which panels feel essential, and which feel secondary?

✦ADHD DOJO✦
QUEST SYSTEM · ARCHITECTURE VIEW
QUEST LOG
Shared shell + Mermaid-based quest architecture
QUEST DETAILS
ACTIVE QUEST
Edit the Earth Scroll
Complete all sections of the Earth Scroll through visible line-edit reps.
STATUSACTIVE
DIFFICULTYMEDIUM
CATEGORYEDITORIAL
OBJECTIVE / TASK TRACKER
✓ Section 1 complete
✓ Section 2 complete
☐ Section 3 in progress
☐ Section 4 remaining
PROGRESS INDICATORS
QUEST PROGRESS2 / 4 SECTIONS
NOTES / JOURNAL LOG
QUEST LOG
Last update: paused midway through Section 3. Next step is to read aloud and tighten redundant phrasing.

EXPERIMENT 58 — QUEST ARCHITECTURE COMPONENT EXTRACTIONPurpose: Extract reusable quest UI modules from the quest architecture page
Focus: modularity, reuse, and later layout controlQuest System → Reusable ComponentsThis experiment extracts the main quest modules into reusable blocks.It includes:
- Quest List Panel
- Quest Detail Panel
- Objective / Task Tracker
- Progress Indicators Block
- Rewards / Requirements Block
- Tracking Controls Block
- Notes / Journal PanelThe goal is to make the quest system easier to reuse, rearrange, and debug in later shell layouts.TestDo these components feel clean enough to reuse elsewhere?Would this make later page assembly easier?Do these extracted parts reflect the real quest system clearly?

QUEST LIST
⚔ Edit the Earth Scroll
Active · Main Quest
Edit the Water Scroll
Available
🔒 Edit the Fire Scroll
Locked
SORT / FILTER
Status · Difficulty · Tags
QUEST DETAILS
ACTIVE QUEST
Edit the Earth Scroll
Complete all sections of the Earth Scroll through visible line-edit reps.
STATUSACTIVE
DIFFICULTYMEDIUM
CATEGORYEDITORIAL
OBJECTIVE / TASK TRACKER
✓ Section 1 complete
✓ Section 2 complete
☐ Section 3 in progress
☐ Section 4 remaining
PROGRESS INDICATORS
QUEST PROGRESS2 / 4 SECTIONS
SUPPORT PANELS
REWARDS
+150 XP
Unlock: Water Scroll editing arc
REQUIREMENTS / CONSTRAINTS
Requires Line Editing skill at Shu stage and Earth Scroll source materials.
TRACKING CONTROLS
NOTES / JOURNAL LOG
QUEST LOG
Last update: paused midway through Section 3. Next step is to read aloud and tighten redundant phrasing.

EXPERIMENT 59 — QUEST ARCHITECTURE REASSEMBLYPurpose: Reassemble the extracted quest components into a cleaner integrated page
Focus: modular layout, readability, and shell-fitComponents → Reassembly → Usable PageThis experiment rebuilds the quest architecture page using only the extracted quest modules.It includes:
- Quest List Panel
- Quest Detail Panel
- Objective / Task Tracker
- Progress Indicators
- Rewards / Requirements
- Tracking Controls
- Notes / JournalThe goal is to test whether a modular reassembly produces a cleaner and more stable quest page than the earlier direct build.TestDoes the modular version fit together better?Do the panel regions feel clearer?Does this seem easier to maintain and improve?

✦ADHD DOJO✦
QUEST SYSTEM · REASSEMBLY VIEW
QUEST LOG
Rebuilt from extracted modular quest components
QUEST DETAILS
ACTIVE QUEST
Edit the Earth Scroll
Complete all sections of the Earth Scroll through visible line-edit reps.
STATUSACTIVE
DIFFICULTYMEDIUM
CATEGORYEDITORIAL
OBJECTIVE / TASK TRACKER
✓ Section 1 complete
✓ Section 2 complete
☐ Section 3 in progress
☐ Section 4 remaining
PROGRESS INDICATORS
QUEST PROGRESS2 / 4 SECTIONS
NOTES / JOURNAL LOG
QUEST LOG
Last update: paused midway through Section 3. Next step is to read aloud and tighten redundant phrasing.

EXPERIMENT 60 — GAMEPLAY LOOP DASHBOARDPurpose: Visualize the full gameplay loop and highlight the player’s current position
Focus: orientation, progression awareness, and next-step clarityLoop → State → Next MoveThis dashboard represents the full gameplay loop:Starting Character → Choose Game → Select Role → Begin Story
→ Train in Dojo → Attempt Quests → Gain XP → Growth
→ Unlock → Mastery → Win ConditionFeatures
- Visual loop map (horizontal progression)
- Current stage highlight
- Loop feedback (XP + growth)
- Next step promptTestCan the user instantly answer:
- Where am I in the loop?
- What comes next?
- What should I do right now?

GAMEPLAY LOOP
Your progression cycle — from action to mastery
Start
Game
Role
Story
Dojo
Quests
XP
Growth
Unlock
Mastery
Win
CURRENT STAGE
DOJO — TRAINING
You are currently building skill through focused reps before returning to quest execution.
LAST ACTION
Completed Section 2 — gained +15 XP
NEXT MOVE
→ Continue Section 3 or return to quest execution
XP PROGRESSION120 / 300
SKILL GROWTHLine Editing · Shu

EXPERIMENT 61 — DOJO FLOW SCREENPurpose: Turn the Dojo flow diagram into a navigable training screen
Focus: mode selection, training pathways, and readinessDojo → Mode → Path → ReadinessThis screen maps the dojo into five core areas:
- Learning
- Training
- Practice Modes
- Development
- ReadinessEach area contains its own specific sub-modes, so the dojo becomes a place you can navigate intentionally.TestCan the user quickly choose the right kind of dojo work?Do the categories feel distinct enough?Does this make the dojo feel like a real training environment?

DOJO FLOW
Choose the training path that fits your current need
LEARNING
Tutorials
Study
Guided Learning
TRAINING
Drills
Repetition
Focused Practice
PRACTICE MODES
Sparring
Play
Experimentation
Sandbox
DEVELOPMENT
Character Development
Meta Skill Development
Domain Skill Development
READINESS
Quest Preparation
Skill Refinement
Confidence Building
CURRENT RECOMMENDATION
TRAINING → DRILLS
Best fit when you know what to do, but still need repetition and smoother execution.

EXPERIMENT 63 — ALIGNMENT & CAPABILITY DIAGNOSTIC WIZARDPurpose: Turn the decision tree into a guided self-diagnostic screen
Focus: clarity, alignment, capability, and next-step guidanceStart Here → Diagnose → RedirectThis screen helps the user identify what kind of problem they are facing:- clarity problem
- alignment problem
- capability problem
- integrated stateIt then points them toward the right kind of work:
- develop character
- develop skill
- develop both
- return to dojo workTestCan the user identify the real problem more quickly?Does the decision path feel useful?Would this reduce confusion and improve next-step selection?

START HERE
Alignment & Capability Diagnostic
1. Do I know who I am?
If not, this is a clarity problem and a shadow risk.
↓
2. Do my game + role + quests align?
If not, this is an alignment problem and leads toward the shadow path.
↓
3. Am I realizing results?
If yes, you are moving toward integration. If not, something is underdeveloped.
↓
Develop Character
Increase discipline, identity, and stability.
Develop Skill
Improve capability, reps, and execution.
Develop Both
Strengthen both character and skill together.
↓
4. Return to Dojo Work
Use the dojo as the place where development becomes visible action.
↓
5. Integrated State
Aligned path + developed capability + results.
CURRENT DIAGNOSTIC RESULT
ALIGNMENT PROBLEM
Your next move is not “more effort.” It is clarifying the game, role, and quest alignment first.

EXPERIMENT 62 — LEAN MVP BACKEND DASHBOARDPurpose: Turn the Lean MVP Backend diagram into a visual system dashboard
Focus: core system entities, relationships, and MVP architectureQuests → Reps → Skills → Procedures → Dojo PracticeThis dashboard represents the lean backend structure of the dojo MVP.It includes:
- Quests
- Reps
- Skills
- Procedures
- Dojo PracticeIt also reflects the relationships between them, so the system can be understood as a functional engine rather than isolated pages.TestDoes this make the MVP backend easier to understand?Do the core databases feel sufficient for a first build?Does the relationship between reps, skills, procedures, and quests feel clear?

LEAN MVP BACKEND
Core entities and relationships for the dojo engine
QUESTS
Quest Name
Status
Objective
Done Criteria
Relevant Skill(s)
Next Rep
Active Procedure
Breadcrumb
XP Reward
REPS
Rep Name
Status
Quest
Skill Applied
Procedure
Definition of Done
Resume Point
Chunk Size
XP Earned
SKILLS
Skill Name
Category
Stage
Related Quests
Related Reps
Current XP
PROCEDURES
Procedure Name
Procedure Type
Purpose
Entry Step
Procedure Steps
Completion Check
Resume Cue
DOJO PRACTICE
Practice Name
Mode
Skill Trained
Associated Procedure
Practice Objective
XP Earned
KEY RELATIONSHIPS
QUESTS → REPS
QUESTS → SKILLS
REPS → SKILLS
REPS → PROCEDURES
PRACTICE → SKILLS
PRACTICE → PROCEDURES

EXPERIMENT 64 — START HERE COMMAND SCREENPurpose: Create a front-door command screen for the dojo
Focus: orientation, diagnosis, and next-step guidanceWho am I? → Where am I? → What should I do?This screen is designed to be the true entry point of the system.It combines:
- current state awareness
- gameplay loop position
- dojo training recommendation
- diagnostic guidance
- next action promptThe goal is to reduce friction and confusion by telling the user what matters right now.TestDoes this help the user orient quickly?Does it reduce uncertainty about what to do next?Could this function as the main command center of the dojo?

START HERE
Command screen for orientation, diagnosis, and next action
CURRENT STATE
You are in the Dojo
Current focus: training before returning to quest execution.
GAMEPLAY LOOP
StartGameRoleStoryDojoQuestsXPGrowth
DIAGNOSTIC
Alignment Problem
Clarify the game, role, and quest alignment before forcing more action.
DOJO RECOMMENDATION
Training → Drills
Best fit when you know what to do but need smoother repetition and execution.
NEXT ACTION
Resume Section 3 line-editing rep
Read the paragraph aloud, identify weak wording, revise once, and log the rep.

EXPERIMENT 65 — INTERACTIVE START HERE COMMAND SCREENPurpose: Turn the Start Here screen into an interactive command router
Focus: diagnosis, recommendation, and next-step guidanceChoose State → Update Guidance → ActThis experiment upgrades the Start Here screen so the user can select their current situation and receive updated guidance.Interactive states:
- Alignment Problem
- Skill Problem
- Character Problem
- Both
- Integrated StateThe screen updates:
- Diagnostic
- Dojo Recommendation
- Next ActionTestDoes the screen feel more useful when it responds?Do the recommendation and next action feel clear?Could this become the true front door of the dojo?

START HERE
Interactive command screen for diagnosis and next-step selection
SELECT YOUR CURRENT STATE
GAMEPLAY LOOP
StartGameRoleStoryDojoQuestsXPGrowth
DIAGNOSTIC
Alignment Problem
Your game, role, and current quests are not fully aligned.
DOJO RECOMMENDATION
Learning → Study
Best when you need clarity before pushing harder.
NEXT ACTION
Clarify the active game, role, and quest.
Step back and decide what the current game is, what role you are playing, and which quest actually matters now.
(function () { var states = { alignment: { diagnostic: 'Alignment Problem', diagnosticText: 'Your game, role, and current quests are not fully aligned.', recommendation: 'Learning → Study', recommendationText: 'Best when you need clarity before pushing harder.', action: 'Clarify the active game, role, and quest.', actionText: 'Step back and decide what the current game is, what role you are playing, and which quest actually matters now.' }, skill: { diagnostic: 'Skill Problem', diagnosticText: 'You know what to do, but your capability is underdeveloped.', recommendation: 'Training → Drills', recommendationText: 'Best when execution needs repetition and smoother reps.', action: 'Run one focused rep on the weak skill.', actionText: 'Choose the exact skill that is failing and complete one clean, deliberate rep.' }, character: { diagnostic: 'Character Problem', diagnosticText: 'The issue is less about knowledge and more about follow-through, discipline, or stability.', recommendation: 'Development → Character', recommendationText: 'Best when consistency and identity need strengthening.', action: 'Choose one commitment-building rep.', actionText: 'Do one short rep that proves reliability and reinforces the desired identity.' }, both: { diagnostic: 'Character + Skill Problem', diagnosticText: 'Both capability and follow-through need development.', recommendation: 'Development → Character + Skill', recommendationText: 'Best when both execution and stability need strengthening.', action: 'Run one structured rep with a tight done criteria.', actionText: 'Use a small, clearly defined rep that develops both competence and consistency.' }, integrated: { diagnostic: 'Integrated State', diagnosticText: 'Alignment is strong and capability is producing results.', recommendation: 'Quests → Execute', recommendationText: 'Best when the system is working and it is time to advance the game.', action: 'Resume the active quest immediately.', actionText: 'You do not need more reflection right now. Enter execution and continue the current meaningful quest.' } }; var buttons = document.querySelectorAll('.dojo65-state-btn'); var diagnostic = document.getElementById('dojo65Diagnostic'); var diagnosticText = document.getElementById('dojo65DiagnosticText'); var recommendation = document.getElementById('dojo65Recommendation'); var recommendationText = document.getElementById('dojo65RecommendationText'); var action = document.getElementById('dojo65Action'); var actionText = document.getElementById('dojo65ActionText'); buttons.forEach(function (btn) { btn.addEventListener('click', function () { var state = btn.getAttribute('data-state'); var data = states[state]; if (!data) return; buttons.forEach(function (b) { b.classList.remove('active'); }); btn.classList.add('active'); diagnostic.textContent = data.diagnostic; diagnosticText.textContent = data.diagnosticText; recommendation.textContent = data.recommendation; recommendationText.textContent = data.recommendationText; action.textContent = data.action; actionText.textContent = data.actionText; }); }); })();

EXPERIMENT 66 — BUILDER / ADMIN DASHBOARDPurpose: Turn the MVP backend map into a builder-facing admin screen
Focus: system overview, entity structure, and drill-down inspectionOverview → Select Module → Inspect StructureThis dashboard represents the core backend entities of the dojo MVP:
- Quests
- Reps
- Skills
- Procedures
- Dojo PracticeThe builder can click one module and inspect its role, fields, and relationships.TestDoes this feel like a real system console?Can the builder understand the data model more quickly?Would this help guide the actual backend setup?

BUILDER / ADMIN
Lean MVP backend control view
CORE MODULES
SYSTEM OVERVIEW
Core Entities5
Main LoopQuest → Rep → XP
Training EnginePractice + Procedures
Progression LogicSkills + XP + Stage
SELECTED MODULE
QUESTS
The main quest object defines the meaningful unit of progression work.
CORE FIELDS
Quest Name
Status
Objective
Done Criteria
Relevant Skill(s)
Next Rep
Active Procedure
Breadcrumb
XP Reward
RELATIONSHIPS
Links to Reps
Links to Skills
(function () { var modules = { quests: { title: 'QUESTS', desc: 'The main quest object defines the meaningful unit of progression work.', fields: [ 'Quest Name','Status','Objective','Done Criteria','Relevant Skill(s)', 'Next Rep','Active Procedure','Breadcrumb','XP Reward' ], relations: ['Links to Reps','Links to Skills'] }, reps: { title: 'REPS', desc: 'Reps are the smallest visible unit of execution inside a quest.', fields: [ 'Rep Name','Status','Quest','Skill Applied','Procedure', 'Definition of Done','Resume Point','Chunk Size','XP Earned' ], relations: ['Belongs to Quest','Uses Skill','Uses Procedure'] }, skills: { title: 'SKILLS', desc: 'Skills track capability, stage, and accumulated development.', fields: [ 'Skill Name','Category','Stage','Related Quests','Related Reps','Current XP' ], relations: ['Links to Quests','Links to Reps'] }, procedures: { title: 'PROCEDURES', desc: 'Procedures define how reps and practice are executed in a repeatable way.', fields: [ 'Procedure Name','Procedure Type','Purpose','Entry Step', 'Procedure Steps','Completion Check','Resume Cue' ], relations: ['Used by Reps','Used by Practice'] }, practice: { title: 'DOJO PRACTICE', desc: 'Dojo practice defines broader training sessions outside direct quest execution.', fields: [ 'Practice Name','Mode','Skill Trained','Associated Procedure','Practice Objective','XP Earned' ], relations: ['Links to Skills','Links to Procedures'] } }; var buttons = document.querySelectorAll('.dojo66-module-btn'); var title = document.getElementById('dojo66Title'); var desc = document.getElementById('dojo66Desc'); var fields = document.getElementById('dojo66Fields'); var relations = document.getElementById('dojo66Relations'); buttons.forEach(function (btn) { btn.addEventListener('click', function () { var key = btn.getAttribute('data-module'); var data = modules[key]; if (!data) return; buttons.forEach(function (b) { b.classList.remove('active'); }); btn.classList.add('active'); title.textContent = data.title; desc.textContent = data.desc; fields.innerHTML = ''; data.fields.forEach(function (field) { var div = document.createElement('div'); div.className = 'dojo66-field'; div.textContent = field; fields.appendChild(div); }); relations.innerHTML = ''; data.relations.forEach(function (rel) { var div = document.createElement('div'); div.className = 'dojo66-rel'; div.textContent = rel; relations.appendChild(div); }); }); }); })();

EXPERIMENT 67 — DOJO DASHBOARD SCREENPurpose: Turn the dashboard Mermaid diagram into a real dojo hub screen
Focus: current state, active work, and progression visibilityCharacter → Skills → Quests → Objectives → Tasks → ProgressThis dashboard acts as the operational center of the dojo.It includes:
- Character snapshot
- Skills snapshot
- Quest groups
- Current objective
- Active tasks
- Progress / XP feedbackThe goal is to make the user’s current state and meaningful work visible in one place.TestDoes this feel like the actual hub of the dojo?Can the user quickly see what matters now?Does the flow from quests to objectives to tasks to progress feel clear?

DOJO DASHBOARD
Character, skills, quests, tasks, and progress in one operational hub
CHARACTER
Scholar-Editor
Level 12 · Focus 15 · Discipline 14
Total XP3450 / 4800
SKILLS
Line Editing65 XP
Comprehension280 XP
Translation20 XP
QUESTS
Current
Edit the Earth Scroll
Available
Edit the Water Scroll
Completed
Organize Notes
By Arc
Line Editing Arc
CURRENT OBJECTIVE
Complete the active Earth Scroll line-edit rep
Move the current quest forward by completing the next meaningful unit of work.
TASKS
✓ Section 1 complete
✓ Section 2 complete
☐ Section 3 in progress
☐ Section 4 remaining
PROGRESS / XP
Quest Progress2 / 4
Skill XPLine Editing · Shu

EXPERIMENT 68 — FULL DATA ARCHITECTURE SCREENPurpose: Turn the Dojo Data System diagram into a builder-facing architecture screen
Focus: database structure, field visibility, and system relationshipsCore System → Databases → FieldsThis screen represents the broader data architecture of the dojo system.It includes:
- Character DB
- Skills DB
- Quests DB
- Inventory DB
- Journal DBThe goal is to make the full system structure visible at a glance so the dojo can be designed and maintained more intentionally.TestDoes this make the full data structure easier to understand?Do the five major database areas feel well separated?Would this help guide actual database design and system planning?

DOJO DATA SYSTEM
Full architecture view of the core databases
CHARACTER DB
Name / Profile
Level
Total XP
Class
Attributes
Meta Skills
SKILLS DB
Skill Name
Level
XP
Category
Belts / Rank
Related Quests
QUESTS DB
Quest Name
Status
Arc / Saga
Objectives
Progress %
XP Reward
Related Skills
INVENTORY DB
Item Name
Type
Use / Function
Related Skills
Notes
JOURNAL DB
Entry Title
Date
Related Quest
Notes / Reflection
Tags
SYSTEM INSIGHT
The dojo is built from five major data families.
Character defines the player, Skills define capability, Quests define progression, Inventory defines usable resources, and Journal defines reflection and memory.

EXPERIMENT 71 — SOP ENGINE SCREENPurpose: Turn the SOP Engine diagram into a builder-facing generation screen
Focus: SOP inputs, core system, and output generationSOPs → Core System → New ContentThis screen shows how subsystem SOPs feed the core dojo system and generate expansion outputs.Inputs:
- Skill Tree SOP
- Quest SOP
- Dojo SOP
- Campaign SOPOutputs:
- New Adventures
- New Training Content
- New Skill Paths
- New Quest LinesThe goal is to make the dojo feel like an expandable engine rather than a static build.TestDoes this clearly show how SOPs generate new content?Does the core system feel like an engine?Would this help guide future scaling and content creation?

SOP ENGINE
How the dojo generates expansion through structured systems
INPUT SOPs
Skill Tree SOP
Quest SOP
Dojo SOP
Campaign SOP
CORE ENGINE
CORE DOJO SYSTEM
Stable structure that receives SOPs and turns them into usable adventures, content, and quest paths.
OUTPUTS
New Adventures
New Training Content
New Skill Paths
New Quest Lines
SOP LOOP
New Adventure / Goal→Apply SOP→Generate Structure→Add to System→Playtest & Refine

EXPERIMENT 75 — ACTION TROUBLESHOOTING WIZARDPurpose: Turn the action troubleshooting diagrams into a guided interactive tool
Focus: knowledge gaps, action readiness, and feedback-based refinementNeed to Perform → Diagnose → Learn / Apply → FeedbackThis wizard helps the user answer:
- Do I know enough to act?
- If not, what is missing?
- If I act, was it effective?
- What should I reinforce or refine next?The goal is to reduce hesitation and confusion around action by making the troubleshooting path explicit.TestDoes this make action barriers easier to diagnose?Can the user identify whether the issue is missing knowledge or weak execution?Would this improve the transition from learning to doing?

ACTION TROUBLESHOOTING
Diagnose why action is failing and choose the next correction
SELECT YOUR SITUATION
DIAGNOSTIC
Missing Knowledge
The barrier is not yet action itself. The barrier is insufficient understanding to act with confidence.
NEXT STEP
Clarify what is missing
Identify the exact knowledge gap, then study, observe, or ask until the missing piece is clear.
ACTION FLOW
Need to Perform → Clarify Missing Knowledge → Study / Observe / Ask → Try Again
(function () { var states = { missing: { diagnostic: 'Missing Knowledge', diagnosticText: 'The barrier is not yet action itself. The barrier is insufficient understanding to act with confidence.', step: 'Clarify what is missing', stepText: 'Identify the exact knowledge gap, then study, observe, or ask until the missing piece is clear.', flow: 'Need to Perform → Clarify Missing Knowledge → Study / Observe / Ask → Try Again' }, ineffective: { diagnostic: 'Ineffective Application', diagnosticText: 'You acted, but the result shows that the model or execution needs refinement.', step: 'Analyze feedback and refine the model', stepText: 'Observe what failed, determine whether the issue was understanding or execution, then adjust and retry.', flow: 'Apply → Observe Result → Analyze Feedback → Refine Model → Retry' }, effective: { diagnostic: 'Effective Action', diagnosticText: 'The action worked well enough to reinforce and continue.', step: 'Reinforce and continue', stepText: 'Keep using the effective pattern, log the success, and continue building consistency.', flow: 'Apply → Get Feedback → Effective → Reinforce and Continue' } }; var buttons = document.querySelectorAll('.dojo75-state-btn'); var diagnostic = document.getElementById('dojo75Diagnostic'); var diagnosticText = document.getElementById('dojo75DiagnosticText'); var step = document.getElementById('dojo75Step'); var stepText = document.getElementById('dojo75StepText'); var flow = document.getElementById('dojo75Flow'); buttons.forEach(function (btn) { btn.addEventListener('click', function () { var key = btn.getAttribute('data-state'); var data = states[key]; if (!data) return; buttons.forEach(function (b) { b.classList.remove('active'); }); btn.classList.add('active'); diagnostic.textContent = data.diagnostic; diagnosticText.textContent = data.diagnosticText; step.textContent = data.step; stepText.textContent = data.stepText; flow.textContent = data.flow; }); }); })();

EXPERIMENT 76 — MASTER SYSTEMS DASHBOARDPurpose: Turn the grouped master systems map into a unified dashboard screen
Focus: high-level orientation, system grouping, and flow between layersInput → Systems → Cognition → Learning → Behavior → FeedbackThis screen organizes the system into six major sections:
- Dual Systems
- Organization and Attention
- Cognition
- Learning
- Behavior Loop
- Systems LayerThe goal is to make the full system visible in grouped form, so the user can understand how the layers connect and where they are operating at any given time.TestDoes this help the user see the whole system more clearly?Do the grouped sections feel distinct and understandable?Does the flow from life input to refinement feel coherent?

MASTER SYSTEMS DASHBOARD
Grouped view of the dojo operating system
INPUT
Life Input / Stimuli
DUAL SYSTEMS
Natural System
Intentional System
Needs / Emotion / Implicit Memory
Values / Goals / Decisions
ORGANIZATION & ATTENTION
Organization
Awareness
Focus
Concentration
COGNITION
Sense-Making
Mental Models
Visualization
LEARNING
Knowledge
Practice
Execution
BEHAVIOR LOOP
Behavior
Outcome
Feedback
Reflection / Refinement
SYSTEMS LAYER
Skill Trees / SOPs / Frameworks
Diagnostics
SYSTEM FLOW
Life Input→Dual Systems→Organization→Attention→Cognition→Learning→Behavior→Feedback→Refinement
CURRENT SYSTEM FOCUS
Organization → Attention → Practice
The current work appears to be about structuring the system clearly enough that attention can be directed into deliberate practice and meaningful execution.

EXPERIMENT 77 — SKILL UNLOCK TREEPurpose: Turn the skill progression diagram into an interactive unlock system
Focus: practice loop, requirement gating, and visible progressionPractice → Requirement Met → Unlock → Advanced → MasteryThis system represents how skills are developed and unlocked.Flow:
- Start with a basic skill
- Practice until requirements are met
- Unlock the next level
- Progress toward masteryThe goal is to make skill development feel tangible, gated, and rewarding.TestDoes the practice → unlock loop feel satisfying?Does the locked/unlocked state feel clear?Does this make progression more motivating?

SKILL UNLOCK TREE
Practice → Unlock → Advance → Mastery
START NODE
Basic Skill
Foundational ability. Must be practiced before progression.
Progress0 / 5
CHECK
Requirement Met?
Not yet. Continue practicing.
UNLOCK
Advanced Skill
Unlocked after mastering the basic skill.
MASTERY
Mastery Path
Refinement and high-level execution.
Practice → Requirement → Unlock → Advanced → Mastery
let progress = 0; const max = 5; function practice(){ if(progress >= max) return; progress++; const pct = (progress/max)*100; document.getElementById('progressFill').style.width = pct + '%'; document.getElementById('progressText').textContent = progress + " / " + max; if(progress >= max){ unlockAdvanced(); } } function unlockAdvanced(){ document.getElementById('requirementStatus').textContent = "Requirement met. Skill unlocked."; const advanced = document.getElementById('advancedSkill'); advanced.classList.remove('locked'); advanced.classList.add('active'); advanced.querySelector('button').textContent = "Unlocked"; advanced.querySelector('button').classList.remove('disabled'); const mastery = document.getElementById('masteryPath'); mastery.classList.remove('locked'); }

EXPERIMENT 78 — ROOT CAUSE TROUBLESHOOTING WIZARDPurpose: Turn the root cause diagram into an interactive diagnostic wizard
Focus: problem analysis, root cause discovery, intervention choice, and evaluationProblem → Analyze → Root Cause → Intervention → Result → EvaluateThis wizard helps the user move from:
- a visible problem
- to likely causes
- to a root cause
- to an intervention
- to evaluationThe goal is to reduce vague frustration and turn it into a structured troubleshooting process.TestDoes this help the user move from confusion to diagnosis?Do the root cause and intervention suggestions feel useful?Would this improve problem-solving inside the dojo?

ROOT CAUSE TROUBLESHOOTING
Diagnose the real issue before forcing the wrong solution
SELECT THE PROBLEM
ANALYSIS
Possible Causes
Unclear next step, weak structure, low confidence, or too much friction.
ROOT CAUSE
Lack of clarity
The system does not yet make the next meaningful action obvious enough.
INTERVENTION
Clarify the next rep
Define one specific rep with done criteria, a resume point, and a visible output.
EVALUATION LOOP
Apply intervention → observe result → evaluate again
Do not assume the first intervention is correct forever. Test it, observe the outcome, and return to analysis if needed.
(function () { var problems = { stuck: { analysis: 'Possible Causes', analysisText: 'Unclear next step, weak structure, low confidence, or too much friction.', root: 'Lack of clarity', rootText: 'The system does not yet make the next meaningful action obvious enough.', intervention: 'Clarify the next rep', interventionText: 'Define one specific rep with done criteria, a resume point, and a visible output.', evalMain: 'Apply intervention → observe result → evaluate again', evalText: 'If clarity improves action, keep the fix. If not, return to analysis and test a different cause.' }, inconsistent: { analysis: 'Possible Causes', analysisText: 'Weak routines, poor environmental support, emotional resistance, or unstable commitment.', root: 'Lack of behavioral stability', rootText: 'The issue is not understanding alone. The issue is unreliable execution patterns.', intervention: 'Reduce scope and strengthen repetition', interventionText: 'Shrink the action into a repeatable minimum and reinforce consistency with visible wins.', evalMain: 'Stabilize behavior → track repetition → evaluate consistency', evalText: 'If consistency rises, keep the habit structure. If not, inspect emotional friction or environmental cues.' }, confused: { analysis: 'Possible Causes', analysisText: 'Missing knowledge, weak mental model, conflicting inputs, or insufficient sense-making.', root: 'Weak understanding', rootText: 'The knowledge has not yet been organized into a usable model.', intervention: 'Study and simplify the model', interventionText: 'Clarify the missing concept, reduce complexity, and restate it in a usable form.', evalMain: 'Clarify model → try again → check for usable understanding', evalText: 'If confusion drops and action becomes easier, the intervention worked. If not, the model still needs refinement.' }, poorresults: { analysis: 'Possible Causes', analysisText: 'Incorrect technique, weak feedback, wrong strategy, or incomplete skill development.', root: 'Execution or model mismatch', rootText: 'The current method is not producing the intended outcome.', intervention: 'Adjust the method and test again', interventionText: 'Use feedback to refine technique, simplify the action, and test a cleaner version.', evalMain: 'Refine method → rerun → compare results', evalText: 'If results improve, reinforce the better method. If not, continue root cause analysis.' } }; var buttons = document.querySelectorAll('.dojo78-state-btn'); var analysis = document.getElementById('dojo78Analysis'); var analysisText = document.getElementById('dojo78AnalysisText'); var root = document.getElementById('dojo78Root'); var rootText = document.getElementById('dojo78RootText'); var intervention = document.getElementById('dojo78Intervention'); var interventionText = document.getElementById('dojo78InterventionText'); var evalMain = document.getElementById('dojo78EvalMain'); var evalText = document.getElementById('dojo78EvalText'); buttons.forEach(function (btn) { btn.addEventListener('click', function () { var key = btn.getAttribute('data-problem'); var data = problems[key]; if (!data) return; buttons.forEach(function (b) { b.classList.remove('active'); }); btn.classList.add('active'); analysis.textContent = data.analysis; analysisText.textContent = data.analysisText; root.textContent = data.root; rootText.textContent = data.rootText; intervention.textContent = data.intervention; interventionText.textContent = data.interventionText; evalMain.textContent = data.evalMain; evalText.textContent = data.evalText; }); }); })();

EXPERIMENT 79 — UNDERSTANDING ENGINE DASHBOARDPurpose: Turn the understanding diagram into a learning engine screen
Focus: interpretation, meaning, mental models, visualization, application, and refinementInformation → Interpretation → Meaning → Model → Visualization → Application → FeedbackThis dashboard represents the process of turning raw information into usable understanding.It includes:
- attention and interpretation
- meaning and mental model formation
- visualization
- application
- feedback and refinementThe goal is to make the learning-to-use pipeline visible and actionable.TestDoes this help the user understand how learning becomes usable?Does the progression from interpretation to application feel clear?Would this help diagnose where understanding is breaking down?

UNDERSTANDING ENGINE
How information becomes usable understanding
Information→Attention→Interpretation→Meaning→Mental Model→Visualization→Application→Feedback→Refined Understanding
INPUT LAYER
Information → Attention → Interpretation
Raw information enters awareness, receives attention, and begins to be interpreted.
MEANING LAYER
Meaning → Mental Model
Interpretation becomes meaning, and meaning becomes a usable internal model.
REPRESENTATION
Visualization
The mental model is externalized or stabilized through imagery, structure, or spatial representation.
USE LAYER
Application
Understanding is tested in action. This is where the model proves itself or breaks down.
FEEDBACK LAYER
Feedback → Refined Understanding
Results from application reshape interpretation and improve the model.
CURRENT BREAKPOINT
Mental Model → Visualization
Understanding may exist conceptually, but it has not yet been turned into a stable enough representation to support reliable use.

EXPERIMENT 80 — ATTENTION PIPELINE DASHBOARDPurpose: Turn the attention pipeline diagram into a staged dashboard
Focus: awareness, focus, concentration, deep processing, filtering, and encodingStimuli → Awareness → Focus → Concentration → Processing → EncodingThis dashboard represents how raw input becomes usable encoded information.It includes:
- awareness
- focus
- concentration
- deep processing
- filtering noise
- memory encoding
- sense-makingThe goal is to make the attention pipeline visible so breakdown points can be identified.TestDoes this make the stages of attention feel distinct?Can the user see where attention is likely breaking down?Would this help guide better focus and filtering?

ATTENTION PIPELINE
How input becomes focused processing and encoded information
Stimuli / Input→Awareness→Focus→Concentration→Deep Processing→Encoding
ENTRY
Stimuli → Awareness
Raw inputs first register in awareness before they can be intentionally directed.
ATTENTION
Focus → Concentration
Focus selects the target. Concentration sustains attention on it long enough for real processing.
PROCESSING
Deep Processing → Sense-Making
Once concentration stabilizes, the mind can extract meaning instead of just noticing surface details.
FILTERING
Filtering Noise
Distractions are removed so processing can remain on target rather than diffusing into clutter.
OUTPUT
Memory Encoding → Stored Information
Useful information is encoded and stabilized so it can later be recalled or applied.
CURRENT BREAKPOINT
Focus → Concentration
Attention may be reaching the target, but not staying there long enough for deep processing and stable encoding.

EXPERIMENT 81 — MEMORY RETENTION DASHBOARDPurpose: Turn the memory process diagram into a retention and recall screen
Focus: registration, retention, recall, and the factors that strengthen memoryExperience → Registration → Retention → Recall → Application → FeedbackThis dashboard shows how memory moves from initial registration to usable recall.It includes:
- registration
- retention
- recall
- attention strength
- repetition
- emotional significance
- organization
- application and feedbackThe goal is to make retention factors visible and show how memory improves through use.TestDoes this help distinguish registration from retention and recall?Do the retention factors feel clear?Would this help explain why some things stick and others fade?

MEMORY RETENTION
How experience becomes stable recall and usable application
Experience / Input→Registration→Retention→Recall→Application→Feedback
MEMORY STAGES
Registration → Retention → Recall
Information must first register, then be retained, and only then can it be reliably recalled.
RETENTION FACTORS
Attention Strength
Repetition
Emotional Significance
Organization
USE LOOP
Recall → Application → Feedback
Memory is strengthened when recalled and applied, then reinforced or corrected by feedback.
CURRENT BREAKPOINT
Retention
Information may register initially, but without repetition, emotion, or organization it may not remain stable enough for recall.

EXPERIMENT 82 — ORGANIZATION LAYERS SCREENPurpose: Turn the organization layers diagram into a layered behavior screen
Focus: implicit structure, habits, explicit systems, and behavioral convergenceImplicit + Habit + Explicit → BehaviorThis screen shows three layers of organization:
- implicit
- habit
- explicitEach layer contributes to behavior in a different way.The goal is to make it clear that behavior is not shaped only by conscious systems, but also by automatic associations and conditioned patterns.TestDoes this help distinguish implicit, habitual, and explicit organization?Does the convergence into behavior feel clear?Would this help explain why behavior changes slowly or unevenly?

ORGANIZATION LAYERS
How implicit, habitual, and explicit systems converge into behavior
IMPLICIT LAYER
Automatic Associations
Emotion-Driven Patterns
HABIT LAYER
Repeated Behavior
Conditioned Patterns
EXPLICIT LAYER
Conscious Structuring
Systems / Frameworks
CONVERGENCE
Implicit + Habit + Explicit → Behavior
Behavior emerges from all three layers together, which is why conscious systems alone do not always override automatic or conditioned patterns.

EXPERIMENT 83 — DECISION ROUTING WIZARDPurpose: Turn the decision routing diagram into an interactive action-choice tool
Focus: act, delay, avoid, outcome, and feedbackSituation → Evaluate → Decide → Act / Delay / AvoidThis wizard helps the user route a situation into a choice:
- act
- delay
- avoidThen it shows the likely consequence and the return to evaluation.The goal is to make decisions more visible and reduce unconscious drifting into delay or avoidance.TestDoes this make the decision branches feel clearer?Can the user see the cost of delay or avoidance more explicitly?Would this help strengthen deliberate action?

DECISION ROUTING
Choose the branch you are actually taking
SITUATION
A task or decision appears
You encounter a situation that requires a choice.
DECISION
OUTCOME
Action Taken
A result is produced, which creates feedback and returns you to evaluation.
FEEDBACK LOOP
Situation → Evaluate → Act → Outcome → Feedback → Evaluate Again
Action creates the most direct learning loop because it produces real outcomes to evaluate.
(function () { var states = { act: { outcome: 'Action Taken', outcomeText: 'A result is produced, which creates feedback and returns you to evaluation.', loop: 'Situation → Evaluate → Act → Outcome → Feedback → Evaluate Again', loopText: 'Action creates the most direct learning loop because it produces real outcomes to evaluate.' }, delay: { outcome: 'Information Gathering', outcomeText: 'No direct result yet. Delay may help if it is intentional, but it can also postpone learning.', loop: 'Situation → Evaluate → Delay → Gather Info → Re-evaluate', loopText: 'Delay is useful only when it is purposeful. Otherwise it becomes disguised avoidance.' }, avoid: { outcome: 'No Action Taken', outcomeText: 'Avoidance prevents immediate discomfort, but also prevents outcome-based learning.', loop: 'Situation → Evaluate → Avoid → No Outcome → Return Later', loopText: 'Avoidance usually keeps uncertainty unresolved, which means the decision returns without useful feedback.' } }; var buttons = document.querySelectorAll('.dojo83-state-btn'); var outcome = document.getElementById('dojo83Outcome'); var outcomeText = document.getElementById('dojo83OutcomeText'); var loop = document.getElementById('dojo83Loop'); var loopText = document.getElementById('dojo83LoopText'); buttons.forEach(function (btn) { btn.addEventListener('click', function () { var key = btn.getAttribute('data-state'); var data = states[key]; if (!data) return; buttons.forEach(function (b) { b.classList.remove('active'); }); btn.classList.add('active'); outcome.textContent = data.outcome; outcomeText.textContent = data.outcomeText; loop.textContent = data.loop; loopText.textContent = data.loopText; }); }); })();

EXPERIMENT 84 — KNOWLEDGE GAP DIAGNOSTIC DASHBOARDPurpose: Turn the knowledge gap formula into a diagnostic dashboard
Focus: desired outcome, current schema, required schema, visible gap, and gap-closing pathsDesired Outcome → Compare Schemas → Visible Gap → Build Missing Node → Clearer ActionThis dashboard helps make knowledge gaps visible by comparing:
- what is already known
- what the target outcome requiresGap types include:
- missing concept
- missing method
- missing procedure / skill
- missing connection between known ideasThe goal is to transform vague uncertainty into a visible, actionable gap.TestDoes this make the gap more concrete?Can the user tell what kind of gap they are dealing with?Does the suggested path to close the gap feel clear?

KNOWLEDGE GAP DIAGNOSTIC
Compare what you know to what the outcome requires
DESIRED OUTCOME
Build a usable quest page system
The target is a functional quest page that supports orientation, task tracking, progression, and action.
WHAT I ALREADY KNOW
Quest page shell concepts
HTML block experiments
Status-based UI states
Basic interaction patterns
WHAT THE OUTCOME REQUIRES
Stable page layout logic
Reusable modular components
Clear interaction rules
Reliable shell integration
VISIBLE GAP TYPE
DIAGNOSTIC
Missing Concept
The gap is primarily conceptual: the structure needed is not yet clearly understood enough to guide design.
GAP-CLOSING PATH
Research / Learn → Add New Node to Knowledge Schema
Study the missing idea, map it clearly, integrate it into your schema, then return to action with a stronger model.
RESULT
Gap Closes → Clearer Action
Once the missing node is integrated, the path forward becomes easier to see and execute.
(function () { var gaps = { concept: { diagnostic: 'Missing Concept', diagnosticText: 'The gap is primarily conceptual: the structure needed is not yet clearly understood enough to guide design.', path: 'Research / Learn → Add New Node to Knowledge Schema', pathText: 'Study the missing idea, map it clearly, integrate it into your schema, then return to action with a stronger model.' }, method: { diagnostic: 'Missing Method', diagnosticText: 'The target outcome is understood in principle, but the process for achieving it is not yet defined well enough.', path: 'Research / Learn Method → Integrate Workflow → Retry', pathText: 'Find or build the missing method, add it to the workflow, then return to execution with a clearer process.' }, skill: { diagnostic: 'Missing Procedure / Skill', diagnosticText: 'The issue is not just knowledge — the required procedural ability has not yet been practiced enough to support action.', path: 'Practice / Proceduralize → Add New Skill Node → Retry', pathText: 'Identify the missing skill, practice it directly, proceduralize it, and then return to the larger outcome.' }, connection: { diagnostic: 'Missing Connection Between Known Ideas', diagnosticText: 'The needed parts may already exist, but the relationship between them is not yet visible enough to form a usable path.', path: 'Synthesize / Re-map → Build Missing Connection → Integrate', pathText: 'Reorganize the map, compare the nodes, and create the missing bridge so the system becomes actionable.' } }; var buttons = document.querySelectorAll('.dojo84-gap-btn'); var diagnostic = document.getElementById('dojo84Diagnostic'); var diagnosticText = document.getElementById('dojo84DiagnosticText'); var path = document.getElementById('dojo84Path'); var pathText = document.getElementById('dojo84PathText'); buttons.forEach(function (btn) { btn.addEventListener('click', function () { var key = btn.getAttribute('data-gap'); var data = gaps[key]; if (!data) return; buttons.forEach(function (b) { b.classList.remove('active'); }); btn.classList.add('active'); diagnostic.textContent = data.diagnostic; diagnosticText.textContent = data.diagnosticText; path.textContent = data.path; pathText.textContent = data.pathText; }); }); })();

EXPERIMENT 85 — KNOWLEDGE-TO-ACTION ENGINEPurpose: Turn the knowledge/action workflow into a full research-to-action engine
Focus: current schema, gap detection, source extraction, integration, next action, and refinementGoal → Map What I Know → Detect Gaps → Extract → Integrate → Reorganize → Next Action → Apply → RefineThis engine represents the full loop of moving from:
- a desired outcome
- to mapping what is already known
- to detecting gaps
- to finding and extracting the right source
- to integrating new structure
- to identifying the next action
- to practice, application, and refinementThe goal is to make the full knowledge-to-action cycle visible and usable.TestDoes this make the full loop from research to application clearer?Can the user see how mapping and gap detection support action?Does this feel like a usable engine instead of a vague study process?

KNOWLEDGE-TO-ACTION ENGINE
How research becomes structure, action, and refinement
Goal→Map What I Know→Detect Gaps→Find Source→Extract→Integrate→Reorganize→Next Action→Practice / Apply→Refine
RESEARCH GOAL
Build a usable quest architecture system
The desired outcome is not just understanding the idea, but building a functional system that supports action.
CURRENT SCHEMA
Quest UI experiments already built
Shell and component language exists
State logic and dashboard concepts exist
Mermaid-based architecture maps exist
VISIBLE GAP
Stable integration logic is still incomplete
The system is visually rich, but the missing pieces include stronger layout logic, clearer modular fit, and more reliable action routing.
SOURCE + EXTRACTION
Find the missing source / method / skill
Study the relevant source, extract its structure, create a source map, and pull out the missing method or conceptual chunk.
INTEGRATION
Add new structure to the knowledge system
Integrate the extracted structure into your map, reorganize by relevance, domain, or workflow, and update the schema.
NEXT ACTION
Practice / Apply / Build
Convert the updated map into one visible action: build the next screen, test the interaction, or refine the active component.
REFINEMENT LOOP
Apply → Reflect → Update Map → Re-enter the loop
The loop closes when action produces feedback, feedback updates the map, and the map improves the next action. This keeps research tied to reality instead of floating as unused information.

EXPERIMENT 86 — SCHEMA OVERLAY DIAGNOSTIC SCREENPurpose: Turn the visual schema overlay into a comparison dashboard
Focus: current schema, target schema, visible gap, resolution paths, and reintegrationCurrent Schema + Target Schema → Compare → Visible Gap → Resolve → IntegrateThis screen compares:
- what is currently known
- what the target outcome requiresThe comparison reveals a visible gap, which can then be addressed through:
- research
- practice
- method building
- connection buildingThe goal is to make the mismatch between current capability and target requirement visually explicit.TestDoes the side-by-side comparison make the gap easier to see?Can the user tell what kind of missing piece is preventing progress?Does the resolution path feel actionable?

SCHEMA OVERLAY DIAGNOSTIC
Compare current knowledge to target requirements
CURRENT KNOWLEDGE SCHEMA
Known Tool
Known Concept
Known Method
Known Supporting Skill
TARGET / REQUIRED SCHEMA
Needed Concept
Needed Method
Needed Practice Skill
Needed Connection
VISIBLE GAP
RESOLUTION PATH
Research Missing Idea
Study the missing concept, define it clearly, and add it to the schema so the outcome becomes more reachable.
COMPARE → RESOLVE → INTEGRATE
Visible Gap → Research → Integrate into Map
The current schema and target schema are not yet aligned. The missing piece must be built, practiced, or connected before the system becomes actionable.
RESULT
Integrated Schema
Once the missing node is added, the schema becomes more complete and the path toward the target outcome becomes clearer.
(function () { var gaps = { research: { resolution: 'Research Missing Idea', resolutionText: 'Study the missing concept, define it clearly, and add it to the schema so the outcome becomes more reachable.', main: 'Visible Gap → Research → Integrate into Map', mainText: 'The mismatch is conceptual. A missing idea must be researched and integrated before the system can support the target outcome.' }, practice: { resolution: 'Practice Missing Skill', resolutionText: 'The target requires a skill that is not yet embodied. Practice is needed before the schema becomes truly usable.', main: 'Visible Gap → Practice → Procedural Integration', mainText: 'The mismatch is procedural. The knowledge exists in part, but it must be reinforced through repetition and action.' }, method: { resolution: 'Build Missing Method', resolutionText: 'The outcome requires a process that is not yet defined. Build the missing workflow so the gap can be crossed reliably.', main: 'Visible Gap → Build Method → Add to Workflow', mainText: 'The mismatch is methodological. A missing method must be created and integrated into the system.' }, connection: { resolution: 'Create Missing Connection', resolutionText: 'The parts may already exist, but the bridge between them is missing. Build the relationship so the path becomes visible.', main: 'Visible Gap → Connect Nodes → Integrate Schema', mainText: 'The mismatch is relational. The needed concepts or skills are present, but the connection between them is not yet clear.' } }; var buttons = document.querySelectorAll('.dojo86-gap-btn'); var resolution = document.getElementById('dojo86Resolution'); var resolutionText = document.getElementById('dojo86ResolutionText'); var main = document.getElementById('dojo86Main'); var mainText = document.getElementById('dojo86MainText'); buttons.forEach(function (btn) { btn.addEventListener('click', function () { var key = btn.getAttribute('data-gap'); var data = gaps[key]; if (!data) return; buttons.forEach(function (b) { b.classList.remove('active'); }); btn.classList.add('active'); resolution.textContent = data.resolution; resolutionText.textContent = data.resolutionText; main.textContent = data.main; mainText.textContent = data.mainText; }); }); })();

EXPERIMENT 87 — BOOK EXTRACTION WORKFLOW SCREENPurpose: Turn the book extraction workflow into a staged SOP screen
Focus: multi-pass extraction, source tracking, terrain mapping, reorganization, and actionable outputSource → Multi-Pass Extraction → Tracking → Terrain Map → Reorganize → Actionable UnitsThis screen represents a structured extraction process for books and other sources.It includes:
- Pass 1: Chapters
- Pass 2: Major Headings
- Pass 3: Subheadings
- Pass 4: Main Points / Conceptual Chunks
- Pass 5: Procedures / Lists / Frameworks
- Source + Page Tracking
- Book Terrain Map
- Reorganize into Personal Structure
- Extract Cards / Methods / Actionable UnitsThe goal is to make the extraction process visible, repeatable, and usable.TestDoes this make the extraction process easier to understand?Do the passes feel distinct enough?Would this help turn sources into actionable structures more reliably?

BOOK EXTRACTION WORKFLOW
A staged process for turning sources into usable structures
Book / Source→Chapters→Headings→Subheadings→Main Points→Procedures / Frameworks→Tracking→Terrain Map→Reorganize→Actionable Units
SOURCE
Book / Source
Begin with the text or source material you want to understand and extract.
EXTRACTION PASSES
Pass 1: Chapters
Pass 2: Major Headings
Pass 3: Subheadings
Pass 4: Main Points / Conceptual Chunks
Pass 5: Procedures / Lists / Frameworks
TRACKING
Source + Page Tracking
Preserve source references so extracted structures remain traceable and reviewable.
MAP
Book Terrain Map
Turn the extracted structure into a terrain map that shows where concepts live and how they connect.
REORGANIZE
Personal Conceptual Structure
Reorganize the source-derived map into your own conceptual system by relevance, domain, or workflow.
OUTPUT
Cards / Methods / Actionable Units
Extract what is usable: cards, procedures, frameworks, methods, and other action-ready units.
CURRENT STAGE
Pass 4 → Main Points / Conceptual Chunks
The source has already been outlined at the chapter, heading, and subheading levels. The current work is to identify the conceptual chunks that matter most before extracting procedures and frameworks.

EXPERIMENT 88 — KNOWLEDGE SYSTEM ARCHITECTURE DASHBOARDPurpose: Turn the knowledge system architecture diagram into a layered dashboard
Focus: input, extraction, representation, storage, synthesis, and applicationInput → Extraction → Representation → Storage → Synthesis → ActionThis dashboard represents the full knowledge system architecture.It includes:
- Input Layer
- Extraction Layer
- Representation Layer
- Storage / Organization Layer
- Synthesis Layer
- Application LayerThe goal is to make the full knowledge pipeline visible so research, maps, storage, synthesis, and action all feel like parts of one system.TestDoes this make the full knowledge system easier to understand?Do the layers feel distinct enough?Does the flow from input to action feel coherent and usable?

KNOWLEDGE SYSTEM ARCHITECTURE
How inputs become maps, storage, synthesis, and action
Input→Extraction→Representation→Storage→Synthesis→Action
INPUT LAYER
Sources of raw material
Books
Articles / Videos / Courses
Experience / Reflection
Problems / Goals / Projects
EXTRACTION LAYER
Pull structure from the source
Structural Extraction
Chapter / Heading / Subheading Mapping
Source + Page Tracking
REPRESENTATION LAYER
Make structure visible
Color-Coded Mermaid Maps
Terrain Maps
Knowledge Schemas
STORAGE / ORGANIZATION
Hold and index the system
Curated Index
Zettelkasten / Card System
Domain / Author / Topic Databases
SYNTHESIS LAYER
Rebuild into your own structure
Re-chunk / Re-group
Cross-Source Pattern Matching
Build Methods / Frameworks
APPLICATION LAYER
Turn structure into use
Troubleshooting Maps
Decision Trees
Practice / Execution
Curriculum / Skill Trees
SYSTEM INSIGHT
Knowledge becomes powerful only after it is restructured for use.
Input alone is not enough. Extraction reveals structure, representation makes it visible, storage preserves it, synthesis personalizes it, and application proves whether the system is actually useful.

EXPERIMENT 89 — TERRAIN MAP → CARD SYSTEM → ACTIONPurpose: Bridge maps to execution
Focus: structure (terrain map), extraction (cards), and use (action)Source → Terrain Map → Identify Zone → Extract Card → Store → UseThis system shows:- Terrain Map = structure + relationships
- Card System = extracted, usable units
- Workflow = selecting relevant zones and converting them into actionThe goal is to prevent maps from becoming passive and instead turn them into active tools.TestDoes this clarify what to do after building a map?Can the user easily move from map → card → action?Does it reduce overwhelm when working with large sources?

TERRAIN MAP → CARD SYSTEM
Turning structure into usable action
Source→Terrain Map→Identify Zone→Extract Card→Store→Use
SOURCE
Book / Content
The original material containing ideas, structures, and concepts.
TERRAIN MAP
Shows structure
Shows relationships
Shows where ideas live
SELECT ZONE
Identify Relevant Area
Focus on one region of the map instead of the whole system.
CARD / UNIT
Extract Actionable Idea
Pull out a method, concept, or procedure that can be used directly.
STORAGE
Zettelkasten / DB
Store cards in a system that allows retrieval and connection.
USE
Apply / Teach / Build
Use the extracted unit in real workflows, systems, or execution.
KEY INSIGHT
Maps show where things are. Cards let you use them.
The terrain map gives orientation. The card system gives action. Together, they turn knowledge into a usable system instead of passive understanding.

EXPERIMENT 90 — CHATGPT MAPPING WORKFLOWPurpose: Turn ChatGPT into a structured mapping tool
Focus: extraction, map building, refinement, and integrationRead → Input → Build Map → Expand → Track → Render → Review → ReorganizeThis workflow shows how ChatGPT is used as a tool inside the system:
1. Read a source (book, article, etc.)
2. Speak or type structure into ChatGPT
3. Generate a Mermaid map
4. Expand with deeper layers (subheadings, chunks)
5. Add source + page tracking
6. Render a terrain map
7. Review for gaps and missing connections
8. Reorganize based on personal useThe goal is to:
• accelerate extraction
• externalize thinking
• and build structured maps quicklyTestDoes this make ChatGPT feel like a tool instead of a crutch?Can the user follow this without guessing what to do next?Does this reduce friction when building maps?

CHATGPT MAPPING WORKFLOW
Using AI to build structured knowledge maps
Read→Input→Build Map→Expand→Track→Render→Review→Reorganize
INPUT
Read Source
Read a chapter or section and identify structure (chapters, headings, key ideas).
CHATGPT INPUT
Speak / Type Structure
Input headings, subheadings, or ideas into ChatGPT to begin building the map.
MAP BUILDING
Generate Mermaid Map
ChatGPT converts your structure into a visual schema or terrain map.
EXPANSION
Add Depth
Add subheadings, conceptual chunks, and deeper layers to refine the map.
TRACKING
Source + Page
Add references so ideas remain grounded and traceable.
RENDER
Terrain Map
Visualize the full structure to see relationships and layout.
REVIEW
Find Gaps
Identify missing connections, unclear areas, or structural weaknesses.
INTEGRATION
Reorganize for Use
Adapt the map into your own system, based on goals, workflow, or domain.
KEY INSIGHT
ChatGPT is not the source of truth — it is the map builder.
You supply the structure. ChatGPT accelerates the visualization. The quality of the map depends on your input and refinement.

EXPERIMENT 91 — BELT LOGIC PROGRESSION SYSTEMPurpose: Turn learning into a structured path of progression
Focus: scaffolding, practice, mastery, and system creationLearn → Practice → Apply → Understand → Build → AdaptThis system represents progression through stages:WHITE BELT (Foundations)
• Learn the simplest complete form
• Follow structured guidance
• Use provided maps and systemsCORE TRAINING
• Practice core skills
• Apply fundamentals consistently
• Build reliability through repetitionBLACK BELT (Mastery)
• Understand underlying systems
• Diagnose your own gaps
• Build your own maps and workflowsADVANCED LEVELS
• Adapt systems across domains
• Create new learning paths
• Refine and expand frameworksThe goal is to move from:
• following structure
• to understanding structure
• to creating structureTestDoes this clarify what progression actually looks like?Can the user identify where they are?Does it reduce confusion about what to do next?

BELT PROGRESSION SYSTEM
From structured learning to adaptive mastery
White Belt→Core Practice→Black Belt→Advanced Levels
WHITE BELT
Learn the Simplest Form
Follow structured scaffolding
Use ready-made maps
Focus on clarity over complexity
CORE TRAINING
Practice and Apply
Practice core skills
Apply fundamentals repeatedly
Build consistency
BLACK BELT
Understand the System
Diagnose your own gaps
Build your own maps
Create your own workflows
ADVANCED LEVELS
Adapt and Expand
Apply system across domains
Create new learning paths
Refine frameworks
CURRENT POSITION
Select Your Stage
Focus: follow structure, learn foundations, avoid overcomplication.
KEY INSIGHT
Mastery is not knowing more — it is building and adapting systems.
The shift happens when you move from consuming structure to creating and refining it yourself.
(function () { const states = { white: "Focus: follow structure, learn foundations, avoid overcomplication.", practice: "Focus: repetition, consistency, applying what you know.", black: "Focus: diagnose gaps, build systems, create workflows.", advanced: "Focus: adapt systems, expand across domains, refine frameworks." }; const buttons = document.querySelectorAll('.dojo91-btn'); const status = document.getElementById('dojo91Status'); buttons.forEach(btn => { btn.addEventListener('click', () => { buttons.forEach(b => b.classList.remove('active')); btn.classList.add('active'); status.textContent = states[btn.dataset.stage]; }); }); })();

EXPERIMENT 92 — ORGANIZATIONAL LEVELS SYSTEMPurpose: Show the progression from simple classification to hierarchical organization to systemic organization
Focus: structure, complexity, and how information can be arranged at different levelsSimple → Hierarchical → SystemicThis system represents three levels of organization:LEVEL 1 — Simple Classification
- Group by one variable
- Example: animals / four-legged animalsLEVEL 2 — Hierarchical Organization
- Main idea → subpoints → details
- Example: essay / presentation / outlineLEVEL 3 — Systemic Organization
- Multiple variables + relationships
- Supports / depends on / leads to / fits within
- Example: workflow / UI system / learning systemThe goal is to help the user understand that not all organization is the same.
Some things only need simple grouping.
Others require layered hierarchy.
Still others require full systems thinking.TestDoes this clarify the difference between types of organization?Can the user tell when a simple list is enough versus when a system map is needed?Does this support better design and thinking decisions?

ORGANIZATIONAL LEVELS
From simple grouping to full systems thinking
Simple Classification→Hierarchical Organization→Systemic Organization
LEVEL 1
Simple Classification
Organize by one variable only.
Group by one trait
Minimal complexity
Useful for quick sorting
Example: Animals / Four-Legged Animals
LEVEL 2
Hierarchical Organization
Organize by levels of importance or structure.
Main idea → subpoints → details
Layered structure
Useful for outlines and presentations
Example: Essay / Presentation / Outline
LEVEL 3
Systemic Organization
Organize by multiple variables and relationships.
Supports / depends on / leads to / fits within
Multiple linked elements
Useful for workflows and frameworks
Example: Workflow / UI System / Learning System
CURRENT FOCUS
Choose the organizational level
Best when you only need one-variable grouping and quick sorting.
KEY INSIGHT
The right kind of organization depends on the complexity of what you are trying to handle.
Simple classification is enough for basic grouping. Hierarchy is needed for structured depth. Systemic organization is needed when relationships between parts matter.
(function () { const states = { simple: "Best when you only need one-variable grouping and quick sorting.", hierarchy: "Best when you need layered depth, such as main points, subpoints, and details.", system: "Best when relationships between parts matter and multiple variables interact." }; const buttons = document.querySelectorAll('.dojo92-btn'); const status = document.getElementById('dojo92Status'); buttons.forEach(btn => { btn.addEventListener('click', () => { buttons.forEach(b => b.classList.remove('active')); btn.classList.add('active'); status.textContent = states[btn.dataset.level]; }); }); })();

EXPERIMENT 93 — RESEARCH DATABASE FLOWPurpose: Turn research into a structured, retrievable system
Focus: source tracking, tagging, cross-referencing, and updating knowledge mapsResearch → Extract → Store → Tag → Cross-Reference → Retrieve → UpdateThis system represents how research flows through a database:- Start with a research topic or problem
- Survey sources
- Extract structure and track pages
- Store in a source index
- Tag by domain, author, topic, and method
- Cross-reference results
- Identify relevant clusters
- Fill knowledge gaps
- Update the master knowledge mapThe goal is to:
- make knowledge retrievable
- connect ideas across sources
- and continuously improve your systemTestCan you find what you need quickly?Do tags help you discover connections?Does the system make it easier to fill specific gaps?

RESEARCH DATABASE FLOW
From raw research to organized, retrievable knowledge
Research→Extract→Store→Tag→Cross-Reference→Retrieve→Update
RESEARCH
Topic / Problem
Start with a specific question, goal, or problem to investigate.
EXTRACTION
Map Source Structure
Headings / subheadings
Conceptual chunks
Procedures / frameworks
STORAGE
Source Index
Store extracted content with source and page references.
TAGGING
Domain
Author
Topic / Heading
Method / Procedure
CROSS-REFERENCE
Find Connections
Combine tags to discover relationships between ideas and sources.
CLUSTERS
Relevant Groupings
Identify clusters of related information to solve specific problems.
GAP FILLING
Target Missing Knowledge
Use clusters to fill specific knowledge gaps efficiently.
UPDATE
Master Knowledge Map
Integrate new knowledge into your system and refine your maps.
KEY INSIGHT
A database is not storage—it is a retrieval and connection engine.
The value of the system comes from how easily you can find, connect, and apply knowledge—not just store it.

EXPERIMENT 94 — KNOWLEDGE SUBSYSTEM HUBPurpose: Integrate the knowledge-engine screens into one command hub
Focus: routing, orientation, workflow visibility, and next-step guidanceGap → Extraction → Mapping → Storage → Synthesis → ActionThis hub connects the knowledge subsystem into one usable entry point.It integrates these major screens:
- Knowledge Gap Diagnostic
- Knowledge-to-Action Engine
- Schema Overlay Diagnostic
- Book Extraction Workflow
- Knowledge System Architecture
- Terrain Map → Card System
- ChatGPT Mapping Workflow
- Research Database FlowThe goal is to make the knowledge subsystem feel like one coherent engine instead of separate experiments.TestDoes this make the knowledge subsystem easier to navigate?Can the user see where they are in the workflow?Does the hub make it easier to choose the right next step?

KNOWLEDGE SUBSYSTEM HUB
Command center for research, mapping, extraction, storage, and action
Gap→Extract→Map→Store→Synthesize→Act
CURRENT STAGE
Gap Detection → Extraction
The current work is focused on identifying missing knowledge and extracting the structure needed to close it.
NEXT ACTION
Run a source through the extraction workflow
Choose a relevant source, map its structure, track pages, and convert the terrain into usable cards or methods.
ROUTING
84 — Knowledge Gap Diagnostic
85 — Knowledge-to-Action Engine
86 — Schema Overlay Diagnostic
87 — Book Extraction Workflow
ARCHITECTURE
88 — Knowledge System Architecture
89 — Terrain Map → Card System
90 — ChatGPT Mapping Workflow
93 — Research Database Flow
WORKFLOW STAGE GUIDE
If the problem is unclear → start at 84
If the path is unclear → go to 85
If the mismatch is visible → use 86
If you need structure from a source → use 87
If you need system context → use 88
If you need retrieval / storage → use 93
KEY INSIGHT
The knowledge subsystem is not a note pile. It is a directed engine.
Its job is to move from uncertainty to visible structure, from structure to usable action, and from action back into refinement. The hub exists to keep those pieces connected.

EXPERIMENT 95 — INTEGRATED LIFE SYSTEM HUBPurpose: Integrate life vision, outer quests, and inner development into one unified system
Focus: vision, role/quest direction, and character/skill growthVision (WHY) ↔ Quest Path (WHAT) ↔ Development (HOW)This hub represents the integrated life system.It includes:
- Vision / Game Goals (WHY)
- Role / Quest Goals (WHAT)
- Character & Skill Development Goals (HOW)The goal is to make it clear that:
- vision chooses the game
- quests express the outer journey
- development makes action possible
- all three continually shape one anotherThis screen acts as a top-level life-system dashboard.TestDoes this help the user see how life direction, work, and growth fit together?Can the user identify which area needs attention right now?Does the relationship between vision, quests, and development feel coherent?

INTEGRATED LIFE SYSTEM
Vision, quests, and development working as one system
Vision / WHY↔Quest Path / WHAT↔Development / HOW
VISION / GAME GOALS (WHY)
Inner Compass
True Desire
Inner Peace
Family Presence
Freedom and Meaning
Contribution and Legacy
ROLE / QUEST GOALS (WHAT)
Outer Journey
Right Game
Right Role
Right Quests
Financial Security
Financial Freedom
Outer Achievement
DEVELOPMENT GOALS (HOW)
Inner Journey
Character
Skills
Capability
Transformation
Learn / Drill / Simulate
Experiment / Forge / Refine
CURRENT EMPHASIS
Select where the tension is
Focus on clarifying desire, direction, and what game is worth playing.
SYSTEM RELATIONSHIPS
Vision chooses the game
Vision calls forth growth
Development makes action possible
Quests realize the vision
Quest feedback refines development
Development bridges inner and outer life
KEY INSIGHT
A meaningful life system must align what you want, what you pursue, and what you become.
Vision without quests stays abstract. Quests without development become frustrating. Development without vision loses meaning. The system works when all three are connected.
(function () { const states = { vision: "Focus on clarifying desire, direction, and what game is worth playing.", quest: "Focus on choosing the right role, the right work, and the right outer objectives.", development: "Focus on building the character and skill needed to make meaningful action possible." }; const buttons = document.querySelectorAll('.dojo95-btn'); const status = document.getElementById('dojo95Status'); buttons.forEach(btn => { btn.addEventListener('click', () => { buttons.forEach(b => b.classList.remove('active')); btn.classList.add('active'); status.textContent = states[btn.dataset.zone]; }); }); })();

EXPERIMENT 96 — IMMEDIATE CORE GOALS DASHBOARDPurpose: Provide a simple, actionable model of life progression
Focus: capability, occupation, finance, and life outcomesCapability → Occupation → Finance → LifeThis system represents a practical progression model:CAPABILITY (HOW)
- Skills, systems, execution ability
- Overcoming ADHD-related challenges
- Building consistency and follow-throughOCCUPATION (VEHICLE)
- Career or business path
- Creating value aligned with strengths
- Choosing the right workFINANCE (WHAT)
- Financial security
- Financial freedom
- Resource generationLIFE (WHY)
- Peace of mind
- Lifestyle flexibility
- Family presenceThe goal is to show how:
- capability enables occupation
- occupation generates financial outcomes
- financial outcomes support life quality
- life meaning reinforces growthTestDoes this make it clear what to focus on right now?Can the user identify where the bottleneck is?Does this simplify decision-making?

IMMEDIATE CORE GOALS
A practical model for directing progress
Capability→Occupation→Finance→Life
CAPABILITY (HOW)
Build the Engine
Overcome ADHD execution challenges
Develop required skills
Build systems
Learn through application
Cultivate discipline and habits
OCCUPATION (VEHICLE)
Right Work
Settle into suitable occupation
Align work with strengths
Create value through business or career
FINANCE (WHAT)
Resources and Stability
Financial security
Financial freedom
Reduced stress
Expanded options
LIFE (WHY)
Desired State
Peace of mind
Lifestyle flexibility
Family presence
Freedom and stability
BOTTLENECK DETECTOR
Where is the constraint?
Focus on building execution ability, systems, and consistent action.
KEY INSIGHT
Most problems are upstream problems.
If life feels off, check finance. If finance is weak, check occupation. If occupation is unclear, check capability. Fix the root, not the symptom.
(function () { const states = { capability: "Focus on building execution ability, systems, and consistent action.", occupation: "Focus on choosing or refining the right work and value creation path.", finance: "Focus on stabilizing income, reducing stress, and improving financial flow.", life: "Focus on alignment, presence, and the quality of your lived experience." }; const buttons = document.querySelectorAll('.dojo96-btn'); const status = document.getElementById('dojo96Status'); buttons.forEach(btn => { btn.addEventListener('click', () => { buttons.forEach(b => b.classList.remove('active')); btn.classList.add('active'); status.textContent = states[btn.dataset.zone]; }); }); })();

EXPERIMENT 97 — CORE GOALS ARCHITECTURE DASHBOARDPurpose: Organize life goals into a structured system with clear categories and subcomponents
Focus: WHAT (results), WHY (purpose), HOW (capability)WHY → WHAT → HOW (with continuous feedback between all three)This system organizes goals into three core layers:WHY — Personal / Life / Meaning
- Relationships
- Emotional state
- Meaning and purpose
- Identity and expression
- EnvironmentWHAT — Business / Career / Financial
- Business engine
- Income system
- Financial freedom
- Life designHOW — Growth / Development
- Execution (discipline, consistency, follow-through)
- Regulation (emotional control)
- Control (attention and time management)
- Systems (workflows, structure)
- Learning (frameworks, mastery)
- Memory (visual maps, systems)The goal is to:
- clarify what belongs where
- break complexity into structured chunks
- support better planning and system designTestCan the user clearly distinguish between WHY, WHAT, and HOW?Do the subcategories feel complete and useful?Does this make it easier to organize goals into actionable structure?

CORE GOALS ARCHITECTURE
Structured system of WHY, WHAT, and HOW
WHY↔WHAT↔HOW
WHY (PURPOSE / LIFE)
Relationships
Family presence
Emotional security
Communication
Emotional State
Reduce stress
Freedom and peace
Meaning
Purpose and alignment
Identity & Expression
Music and writing
Curiosity and authenticity
Environment
Organized home
Reduced friction
WHAT (RESULTS / OUTER WORLD)
Business Engine
Build business
Develop Dojo / Fretboard Freedom
Create content and offers
Income System
Reliable income
Accumulate capital
Financial Freedom
Achieve independence
Life Design
Lifestyle flexibility
Aligned work
Creative path
HOW (DEVELOPMENT / CAPABILITY)
Execution
Discipline
Focus
Consistency
Follow-through
Regulation
Emotional regulation
Control
Attention management
Time management
Systems
Goodrich OS
Structured workflows
Learning & Memory
Knowledge frameworks
Meta-learning
Visual knowledge maps
FOCUS LAYER
Where are you working?
Focus on meaning, alignment, and what actually matters.
KEY INSIGHT
Clarity comes from separating purpose, results, and capability.
Confusion happens when these layers mix. This structure keeps them distinct while still connected.
(function(){ const states={ why:"Focus on meaning, alignment, and what matters most.", what:"Focus on outcomes, work, and tangible progress.", how:"Focus on skills, systems, and execution." }; const btns=document.querySelectorAll('.dojo97-btn'); const status=document.getElementById('dojo97Status'); btns.forEach(b=>{ b.onclick=()=>{ btns.forEach(x=>x.classList.remove('active')); b.classList.add('active'); status.textContent=states[b.dataset.zone]; }; }); })();

EXPERIMENT 98 — WHAT / WHY / HOW RELATIONSHIP LOOPPurpose: Show the dynamic relationship between WHY (purpose), WHAT (results), and HOW (capability)
Focus: interdependence and feedback between goal layersWHY ↔ WHAT ↔ HOW (continuous feedback loop)This system represents the core relationship between:WHY — Purpose / Life Direction
WHAT — Results / Work / Outcomes
HOW — Skills / Systems / ExecutionKey relationships:WHY → WHAT
- Purpose drives goals and directionHOW → WHAT
- Capability enables executionWHAT → WHY
- Results support desired life conditionsWHY → HOW
- Purpose motivates growthHOW → WHY
- Growth improves quality of lifeThe goal is to:
- understand how each layer influences the others
- avoid isolating goals into disconnected categories
- create a loop of continuous alignment and progressTestCan the user see how all three layers depend on each other?Does this reduce confusion about where to focus?Does this help diagnose imbalance between purpose, action, and capability?

WHAT / WHY / HOW LOOP
Interdependent system of purpose, results, and capability
WHY
WHAT
HOW
WHY
Purpose / Direction
Defines meaning, values, and what makes the journey worth pursuing.
WHAT
Results / Outcomes
Represents goals, work, achievements, and external progress.
HOW
Capability / Execution
Skills, systems, and behaviors that make results possible.
RELATIONSHIPS
WHY → WHAT: Purpose directs goals
HOW → WHAT: Capability enables results
WHAT → WHY: Results support life
WHY → HOW: Purpose drives growth
HOW → WHY: Growth improves life quality
DIAGNOSTIC
Where is the imbalance?
If WHY is unclear, direction and motivation will feel weak.
KEY INSIGHT
Problems arise when one layer is overdeveloped and the others are neglected.
Strong WHY without HOW leads to frustration. Strong HOW without WHY leads to emptiness. Strong WHAT without either leads to burnout or confusion.
(function(){ const states={ why:"If WHY is unclear, direction and motivation will feel weak.", what:"If WHAT is unclear, progress and outcomes will stall.", how:"If HOW is weak, execution and consistency will break down." }; const btns=document.querySelectorAll('.dojo98-btn'); const status=document.getElementById('dojo98Status'); btns.forEach(b=>{ b.onclick=()=>{ btns.forEach(x=>x.classList.remove('active')); b.classList.add('active'); status.textContent=states[b.dataset.zone]; }; }); })();

EXPERIMENT 99 — CORE LIFE GOALS DASHBOARDPurpose: Provide a complete overview of all major life domains and priorities
Focus: broad categorization and high-level clarityLife Domains → Organized Categories → Guiding Areas of FocusThis dashboard represents a panoramic view of core life goals:SELF-MASTERY
- Discipline, focus, consistency
- Emotional regulation (ADHD)
- Clarity and follow-throughSYSTEMS
- Goodrich OS
- Knowledge organization
- Workflow designLEARNING
- Memory systems
- Visual knowledge maps
- Meta-learning masteryBUSINESS
- Fretboard Freedom / Dojo
- Content and offers
- Framework monetizationFINANCE
- Stable income
- Financial freedomFAMILY
- Presence and dependability
- Emotional security
- CommunicationEXPRESSION
- Music and writing
- Identity exploration
- Purpose alignmentENVIRONMENT
- Home organization
- Friction reductionThe goal is to:
- see all life areas at once
- ensure nothing important is neglected
- support balanced growth across domainsTestCan the user see their entire life system clearly?Are any categories being ignored?Does this help with prioritization and balance?

CORE LIFE DASHBOARD
Panoramic view of all major life domains
SELF-MASTERY
Discipline, focus, consistency
Emotional regulation (ADHD)
Clarity and follow-through
SYSTEMS
Goodrich OS
Knowledge organization
Workflow design
LEARNING
Memory systems
Visual knowledge maps
Meta-learning mastery
BUSINESS
Fretboard Freedom / Dojo
Content and offers
Framework monetization
FINANCE
Stable income
Financial freedom
FAMILY
Presence and dependability
Emotional security
Communication
EXPRESSION
Music and writing
Identity exploration
Purpose alignment
ENVIRONMENT
Home organization
Friction reduction
CURRENT FOCUS
Focus on internal stability, discipline, and execution.
KEY INSIGHT
A well-designed life requires attention across multiple domains—not just one.
Over-focusing on one area while neglecting others creates imbalance. This dashboard keeps the full picture visible.
(function(){ const states={ mastery:"Focus on internal stability, discipline, and execution.", business:"Focus on building and refining your value engine.", family:"Focus on presence, connection, and emotional security.", systems:"Focus on building structures that reduce chaos." }; const btns=document.querySelectorAll('.dojo99-btn'); const status=document.getElementById('dojo99Status'); btns.forEach(b=>{ b.onclick=()=>{ btns.forEach(x=>x.classList.remove('active')); b.classList.add('active'); status.textContent=states[b.dataset.zone]; }; }); })();

EXPERIMENT 100 — MASTER SYSTEM HUBPurpose: Integrate the major subsystems into one top-level command center
Focus: routing, orientation, subsystem visibility, and next-step navigationLife ↔ Knowledge ↔ Dojo ↔ Diagnostics ↔ LearningThis hub connects the major subsystems of the overall operating system:LIFE SYSTEM
- Vision, goals, capability, life domainsKNOWLEDGE SYSTEM
- Knowledge gaps, extraction, maps, storage, synthesis, actionDOJO / GAMEPLAY SYSTEM
- Quests, skills, progression, training, executionDIAGNOSTICS
- Alignment, realization, no-progress troubleshootingLEARNING / ASSESSMENT
- Quality assessment, thinking skills, dimensions of learningThe goal is to make the full system navigable from one screen.This hub should:
- orient the user
- show current emphasis
- route to the right subsystem
- support top-level decision-makingTestDoes this make the entire system easier to understand?Can the user tell where they should go next?Does this feel like a true command center?

MASTER SYSTEM HUB
Top-level command center for life, knowledge, dojo, diagnostics, and learning
Life↔Knowledge↔Dojo↔Diagnostics↔Learning
LIFE SYSTEM
Purpose, goals, capability, domains
95 — Integrated Life System Hub
96 — Immediate Core Goals
97 — Core Goals Architecture
98 — What / Why / How Loop
99 — Core Life Dashboard
KNOWLEDGE SYSTEM
Research, mapping, storage, action
84 — Knowledge Gap Diagnostic
85 — Knowledge-to-Action Engine
86 — Schema Overlay
87 — Book Extraction Workflow
88–94 — Architecture, maps, DB flow, hub
DOJO / GAMEPLAY
Quests, skills, progression, execution
60 — Gameplay Loop
61 — Dojo Flow
64–67 — Start Here, Hub, Dashboard
77 — Skill Unlock Tree
78–83 — Troubleshooting, understanding, attention, decision
DIAGNOSTICS
Alignment, peace, progress, path
101 — Start Here Alignment Hub
102 — Compass Reading
103 — Progress Block Troubleshooting
107 — Fear Resolution Path
LEARNING / ASSESSMENT
Assessment, cognition, learning design
104 — Assessment Quality Dashboard
105 — Core Thinking Skills
106 — Dimensions of Learning
CURRENT FOCUS
Which subsystem needs attention?
Focus on life direction, goals, priorities, and overall alignment.
KEY INSIGHT
This is one system with multiple subsystems—not separate projects.
Life provides direction. Knowledge provides structure. The dojo provides execution. Diagnostics provide correction. Learning provides refinement. The hub exists to keep them connected.
(function(){ const states = { life: "Focus on life direction, goals, priorities, and overall alignment.", knowledge: "Focus on knowledge gaps, extraction, maps, and research-to-action.", dojo: "Focus on quests, reps, skills, and visible execution.", diagnostic: "Focus on alignment, peace, progress, and finding the real bottleneck.", learning: "Focus on assessment quality, thinking skills, and learning design." }; const btns = document.querySelectorAll('.dojo100-btn'); const status = document.getElementById('dojo100Status'); btns.forEach(btn => { btn.addEventListener('click', () => { btns.forEach(b => b.classList.remove('active')); btn.classList.add('active'); status.textContent = states[btn.dataset.zone]; }); }); })();

EXPERIMENT 101 — START HERE ALIGNMENT DIAGNOSTIC HUBPurpose: Route the user into the correct path based on identity, alignment, and capability
Focus: self-knowledge, path alignment, development needsSelf → Alignment → Results → DevelopmentThis hub helps diagnose:
- whether the path is aligned
- whether capability is sufficient
- whether the problem is clarity, alignment, or developmentThe goal is to make the first diagnostic step simple and clear.TestCan the user quickly identify whether the issue is path or capability?Does this reduce confusion at the start?Does it help determine the right next subsystem?

START HERE — ALIGNMENT
Check self, path, and development before forcing action
QUESTION 1
Do I know who I am?
If not, the issue is clarity before anything else.
QUESTION 2
Do my game, role, and quests align?
If not, the issue is alignment, not effort.
QUESTION 3
Am I realizing results?
If not, the issue is likely development, skill, or execution.
ROUTING
Choose your state
Go inward first: clarify self, values, and true direction.
(function(){ const states = { clarity: "Go inward first: clarify self, values, and true direction.", alignment: "Adjust the game, role, or quests before pushing harder.", development: "Return to the dojo and build the capability that is missing." }; const btns = document.querySelectorAll('.dojo101-btn'); const status = document.getElementById('dojo101Status'); btns.forEach(btn => { btn.addEventListener('click', () => { btns.forEach(b => b.classList.remove('active')); btn.classList.add('active'); status.textContent = states[btn.dataset.state]; }); }); })();

EXPERIMENT 102 — COMPASS READING SCREENPurpose: Use inner peace and progress as top-level diagnostic signals
Focus: alignment and realizationInner Peace + Progress = Compass ReadingThis screen uses two signals:
- Inner Peace
- ProgressThese signals indicate:
- right path
- underdevelopment
- shadow success
- misalignmentThe goal is to simplify life diagnosis into a readable compass.

COMPASS READING
Use peace and progress to interpret your state
SIGNAL 1
Inner Peace
A signal of alignment, congruence, and being on the right path.
SIGNAL 2
Progress
A signal of realization, development, and movement forward.
READING
Right path. Stay the course.
(function(){ const states = { green: "Right path. Stay the course.", yellow: "Aligned, but underdeveloped. Build capability.", red: "Shadow success. Reconsider the path.", orange: "Misaligned and underdeveloped. Reset both path and growth." }; const btns = document.querySelectorAll('.dojo102-btn'); const status = document.getElementById('dojo102Status'); btns.forEach(btn => { btn.addEventListener('click', () => { btns.forEach(b => b.classList.remove('active')); btn.classList.add('active'); status.textContent = states[btn.dataset.state]; }); }); })();

EXPERIMENT 103 — PROGRESS BLOCK TROUBLESHOOTING WIZARDPurpose: Diagnose why progress is not happening
Focus: clarity, belief, fear/safety, executionNo Progress → Diagnose Cause → Correct the Real BottleneckThis screen routes no-progress problems into:
- clarity issue
- belief issue
- fear / safety issue
- execution system issueThe goal is to prevent treating all stagnation as laziness.

PROGRESS BLOCK TROUBLESHOOTING
Find the real reason progress is not happening
ENTRY
No Progress
Start with the symptom, not the assumption.
DIAGNOSIS
Refine the vision until the goal is visible and concrete.
(function(){ const states = { clarity: "Refine the vision until the goal is visible and concrete.", belief: "Rebuild belief that the outcome is possible for you.", fear: "Resolve emotional interference and restore felt safety.", execution: "Fix the action system, reps, and follow-through mechanics." }; const btns = document.querySelectorAll('.dojo103-btn'); const status = document.getElementById('dojo103Status'); btns.forEach(btn => { btn.addEventListener('click', () => { btns.forEach(b => b.classList.remove('active')); btn.classList.add('active'); status.textContent = states[btn.dataset.state]; }); }); })();

EXPERIMENT 104 — ASSESSMENT QUALITY DASHBOARDPurpose: Turn the five keys of assessment quality into a design dashboard
Focus: purpose, targets, design, communication, student involvementThe five keys are:
- Clear Purpose
- Clear Targets
- Sound Design
- Effective Communication
- Student InvolvementThe goal is to use assessment as a design tool, not just a measurement tool.

ASSESSMENT QUALITY
Five keys to better design and feedback
KEY 1
Clear Purpose
KEY 2
Clear Targets
KEY 3
Sound Design
KEY 4
Effective Communication
KEY 5
Student Involvement
KEY INSIGHT
Good assessment improves learning by improving feedback and clarity.

EXPERIMENT 105 — CORE THINKING SKILLS DASHBOARDPurpose: Organize core thinking skills into a usable dashboard
Focus: focusing, gathering, remembering, organizing, analyzing, generating, integrating, evaluatingThe goal is to make cognitive skills visible as categories of trainable operations.

CORE THINKING SKILLS
Trainable categories of cognitive work
Focusing
Defining problems, setting goals
Information Gathering
Observing, formulating questions
Remembering
Encoding, recalling
Organizing
Comparing, classifying, ordering, representing
Analyzing
Patterns, parts, attributes, errors
Generating
Inferring, predicting, elaborating
Integrating
Summarizing, restructuring
Evaluating
Criteria, verifying

EXPERIMENT 106 — DIMENSIONS OF LEARNING FRAMEWORK SCREENPurpose: Present the Dimensions of Learning as a structured framework
Focus: attitudes, knowledge acquisition, refinement, meaningful use, habits of mindThe goal is to show how the dimensions support and guide one another.

DIMENSIONS OF LEARNING
A framework for designing deeper learning
Dimension 1
Attitudes and Perceptions
Dimension 2
Acquiring and Integrating Knowledge
Dimension 3
Extending and Refining Knowledge
Dimension 4
Using Knowledge Meaningfully
Dimension 5
Habits of Mind
Learning deepens when attitude, refinement, use, and habits all support one another.

EXPERIMENT 107 — FEAR RESOLUTION PATH SCREENPurpose: Show two valid approaches for resolving fear blocks
Focus: action-first versus belief-first resolutionThe two paths are:
- Outer → Inner: act first, gather evidence
- Inner → Outer: reframe belief first, then actBoth lead toward reduced fear and greater safety for action.The goal is to help the user choose an effective path instead of freezing.

FEAR RESOLUTION PATH
Two ways to reduce fear and restore action
ENTRY
Blocked by Fear
Fear can be approached from action or belief.
OUTER → INNER
Act First
Use exposure, small action, and real-world contact to generate new evidence.
INNER → OUTER
Reframe Belief
Use belief work, interpretation shifts, and inner clarification before action.
CONVERGENCE
New Evidence → Fear Reduces
Both paths work by producing evidence that safety and possibility are greater than fear predicts.

EXPERIMENT 108 — DIFFERENT KIND OF CLASSROOM FRAMEWORK HUBPurpose: Turn Marzano’s framework into a navigable learning architecture
Focus: dimensions, planning, and instructional design layersBook → Dimensions → Substructures → ApplicationThis screen represents:A Different Kind of Classroom
by Robert J. MarzanoCore Structure:
- Dimension 1: Attitudes and Perceptions
- Dimension 2: Acquiring and Integrating Knowledge
- Dimension 3: Extending and Refining Knowledge
- Dimension 4: Using Knowledge Meaningfully
- Dimension 5: Habits of Mind
- Chapter 7: Integration and Instructional ModelsThis is not just a book outline.
It is a full learning system.Key Insight:
This framework aligns with staged learning models such as Shu–Ha–Ri and structured learning pipelines.The goal:
- Navigate the framework
- Understand each dimension
- Apply it to system design and teachingTestCan I quickly explore the structure?Does selecting a dimension reveal usable insight?Does this feel like a system, not just content?

A DIFFERENT KIND OF CLASSROOM
Robert J. Marzano • Learning Architecture Framework
DIMENSIONS
STRUCTURE
Dimension 1 — Attitudes and Perceptions
Learning Climate
Classroom Tasks
Planning
DETAILS
Acceptance
Comfort and Order
Task Value
Task Clarity
Resources
KEY INSIGHT
This framework behaves like a staged learning system.
Dimension 2 builds knowledge. Dimension 3 refines it. Dimension 4 applies it. This mirrors structured learning models such as Shu–Ha–Ri and your own system architecture.
(function(){ const data = { d1: { title: "Dimension 1 — Attitudes and Perceptions", list: ["Learning Climate","Classroom Tasks","Planning"], sub: ["Acceptance","Comfort and Order","Task Value","Task Clarity","Resources"] }, d2: { title: "Dimension 2 — Acquiring and Integrating Knowledge", list: ["Nature of Knowledge","Declarative Knowledge","Procedural Knowledge"], sub: ["Constructing Meaning","Organizing Knowledge","Storing Knowledge","Constructing Models","Internalizing"] }, d3: { title: "Dimension 3 — Extending and Refining Knowledge", list: ["Questioning Framework","Refinement Activities","Teaching Processes"], sub: ["Comparison","Classification","Induction","Deduction","Error Analysis","Abstracting"] }, d4: { title: "Dimension 4 — Using Knowledge Meaningfully", list: ["Decision Making","Investigation","Problem Solving","Invention"], sub: ["Application Tasks","Long-Term Tasks","Student-Directed Tasks"] }, d5: { title: "Dimension 5 — Habits of Mind", list: ["Self-Regulation","Critical Thinking","Creative Thinking"], sub: ["Personal Goals","Structured Problems","Dialogue and Debate"] }, c7: { title: "Chapter 7 — Integration", list: ["Planning Models","Workshop vs Presentation","Assessment"], sub: ["Learning Logs","Portfolios","Conferencing"] } }; const btns = document.querySelectorAll('.dojo108-btn'); const title = document.getElementById('dojo108Title'); const list = document.getElementById('dojo108List'); const sub = document.getElementById('dojo108SubList'); btns.forEach(btn=>{ btn.addEventListener('click', ()=>{ btns.forEach(b=>b.classList.remove('active')); btn.classList.add('active'); const d = data[btn.dataset.dim]; title.textContent = d.title; list.innerHTML = d.list.map(i=>`
${i}
`).join(''); sub.innerHTML = d.sub.map(i=>`
${i}
`).join(''); }); }); })();

EXPERIMENT 109 — DIMENSION 2: KNOWLEDGE ACQUISITION ENGINEPurpose: Turn knowledge intake into a structured, repeatable system
Focus: declarative + procedural knowledge, encoding, organizationInput → Meaning → Organization → Storage → UseThis system handles:DECLARATIVE KNOWLEDGE (What)
- Facts
- Concepts
- PrinciplesPROCEDURAL KNOWLEDGE (How)
- Skills
- Processes
- MethodsCore Phases:
1. Construct Meaning
2. Organize Knowledge
3. Store Knowledge
4. Build Models (Procedural)
5. InternalizeKey Insight:
If encoding is weak, everything downstream collapses.This layer determines:
- clarity
- retention
- usabilityTestDo I actually understand what I just learned?Can I organize it visually or structurally?Can I explain it or use it?

DIMENSION 2 — KNOWLEDGE ACQUISITION
Turn information into structured, usable knowledge
KNOWLEDGE TYPES
Declarative (WHAT)
Facts • Concepts • Principles
Procedural (HOW)
Skills • Methods • Processes
PHASE
DESCRIPTION
Construct Meaning
Connect new information to what you already know. Build understanding, not memorization.
OPERATIONS
Ask: What does this mean?
Relate to prior knowledge
Explain in your own words
SYSTEM CONNECTION
This is your intake layer for the entire system.
Weak input leads to weak refinement and weak execution. Strong encoding creates clarity, retention, and action-ready knowledge.
(function(){ const data = { meaning: { title: "Construct Meaning", text: "Understand the information by connecting it to prior knowledge.", ops: [ "Ask: What does this mean?", "Relate to what you already know", "Explain in your own words" ] }, organize: { title: "Organize Knowledge", text: "Structure the information so it can be understood and retrieved.", ops: [ "Create diagrams or maps", "Group and categorize ideas", "Use patterns and frameworks" ] }, store: { title: "Store Knowledge", text: "Encode the knowledge for later recall.", ops: [ "Use repetition and review", "Attach emotion or meaning", "Use memory systems (visual, spatial)" ] }, model: { title: "Construct Models", text: "Turn knowledge into usable procedures or systems.", ops: [ "Break into steps", "Create workflows", "Simulate or visualize execution" ] }, internalize: { title: "Internalize", text: "Make the knowledge automatic and usable without effort.", ops: [ "Practice repeatedly", "Apply in real situations", "Refine through feedback" ] } }; const btns = document.querySelectorAll('.dojo109-btn'); const title = document.getElementById('dojo109Title'); const text = document.getElementById('dojo109Text'); const ops = document.getElementById('dojo109Ops'); btns.forEach(btn=>{ btn.addEventListener('click', ()=>{ btns.forEach(b=>b.classList.remove('active')); btn.classList.add('active'); const d = data[btn.dataset.phase]; title.textContent = d.title; text.textContent = d.text; ops.innerHTML = d.ops.map(i=>`
${i}
`).join(''); }); }); })();

EXPERIMENT 110 — DIMENSION 3: REFINEMENT ENGINEPurpose: Transform raw knowledge into precise, flexible understanding
Focus: analysis, relationships, patterns, truth-testingUnderstanding → Stress Test → Clarify → StrengthenThis layer answers:
Do I actually understand this… or just recognize it?Core Processes:
• Comparison
• Classification
• Induction
• Deduction
• Error Analysis
• Constructing Support
• Abstracting
• Analyzing PerspectivesKey Insight:
Refinement is what turns knowledge into intelligence.Without this:
• knowledge stays shallow
• mistakes repeat
• application failsTestCan I compare this to something else?Can I break it apart and reassemble it?Can I explain why it works?

DIMENSION 3 — REFINEMENT
Sharpen understanding through analysis and testing
REFINEMENT PROCESS
DESCRIPTION
Comparison
Identify similarities and differences between concepts.
OPERATIONS
What is similar?
What is different?
When would I use each?
KEY INSIGHT
This is where understanding becomes flexible.
Refinement connects ideas, reveals errors, and builds true comprehension. This aligns directly with your thinking skill maps and troubleshooting workflows.
(function(){ const data={ compare:{title:"Comparison",text:"Identify similarities and differences.",ops:["What is similar?","What is different?","When to use each?"]}, classify:{title:"Classification",text:"Group items based on shared traits.",ops:["What categories exist?","What belongs where?"]}, induction:{title:"Induction",text:"Infer general patterns.",ops:["What pattern exists?","What rule emerges?"]}, deduction:{title:"Deduction",text:"Apply rules to specific cases.",ops:["If rule is true, what follows?"]}, error:{title:"Error Analysis",text:"Find and correct mistakes.",ops:["What went wrong?","Why?"]}, abstract:{title:"Abstracting",text:"Extract the core principle.",ops:["What is essential here?"]} }; const btns=document.querySelectorAll('.dojo110-btn'); const title=document.getElementById('dojo110Title'); const text=document.getElementById('dojo110Text'); const ops=document.getElementById('dojo110Ops'); btns.forEach(btn=>{ btn.onclick=()=>{ btns.forEach(b=>b.classList.remove('active')); btn.classList.add('active'); const d=data[btn.dataset.mode]; title.textContent=d.title; text.textContent=d.text; ops.innerHTML=d.ops.map(i=>`
${i}
`).join(''); }; }); })();

EXPERIMENT 111 — DIMENSION 4: APPLICATION ENGINEPurpose: Turn knowledge into real-world results
Focus: action, decision-making, problem solvingKnowledge → Action → Outcome → FeedbackThis layer answers:
Can I actually use this?Core Modes:
• Decision Making
• Investigation
• Experimental Inquiry
• Problem Solving
• InventionKey Insight:
Application is the only place where truth is tested.Without this:
• knowledge stays theoretical
• confidence never builds
• progress stallsTestCan I apply this right now?Can I solve a real problem with it?Did it work?

DIMENSION 4 — APPLICATION
Turn knowledge into action and results
APPLICATION MODE
DESCRIPTION
Decision Making
Use knowledge to choose between options.
OPERATIONS
Evaluate options
Predict outcomes
Choose best path
FEEDBACK LOOP
Action produces feedback → feedback refines the system
This is where your dojo reps, XP system, and real-world execution connect. Everything feeds back into refinement and learning.
(function(){ const data={ decision:{title:"Decision Making",text:"Choose between options using knowledge.",ops:["Evaluate options","Predict outcomes","Choose"]}, investigation:{title:"Investigation",text:"Explore questions deeply.",ops:["Define problem","Gather info","Analyze"]}, experiment:{title:"Experimental Inquiry",text:"Test ideas through action.",ops:["Form hypothesis","Test","Observe"]}, problem:{title:"Problem Solving",text:"Resolve challenges.",ops:["Identify problem","Apply method","Evaluate"]}, invent:{title:"Invention",text:"Create something new.",ops:["Combine ideas","Prototype","Refine"]} }; const btns=document.querySelectorAll('.dojo111-btn'); const title=document.getElementById('dojo111Title'); const text=document.getElementById('dojo111Text'); const ops=document.getElementById('dojo111Ops'); btns.forEach(btn=>{ btn.onclick=()=>{ btns.forEach(b=>b.classList.remove('active')); btn.classList.add('active'); const d=data[btn.dataset.mode]; title.textContent=d.title; text.textContent=d.text; ops.innerHTML=d.ops.map(i=>`
${i}
`).join(''); }; }); })();

EXPERIMENT 112 — UNIFIED LEARNING ENGINEPurpose: Integrate acquisition, refinement, and application into one learning pipeline
Focus: input, processing, and actionAcquire → Refine → ApplyThis screen unifies three major dimensions of learning:ACQUIRE
- Construct meaning
- Organize knowledge
- Store knowledge
- Build models
- InternalizeREFINE
- Compare
- Classify
- Induce
- Deduce
- Analyze errors
- AbstractAPPLY
- Decide
- Investigate
- Experiment
- Solve problems
- InventThe goal is to show that learning is not complete until all three layers work together.Key Idea:
- Acquisition gives structure
- Refinement gives depth
- Application gives realityThis is the core learning engine for the system.TestCan the user see the full learning process at a glance?Does it feel clear how information becomes capability?Does this create a better bridge between learning and execution?

UNIFIED LEARNING ENGINE
Acquire, refine, and apply knowledge as one system
Acquire→Refine→Apply
STAGE 1 — ACQUIRE
Build usable knowledge
Construct meaning
Organize knowledge
Store knowledge
Build models
Internalize
STAGE 2 — REFINE
Sharpen understanding
Comparison
Classification
Induction
Deduction
Error analysis
Abstracting
STAGE 3 — APPLY
Turn knowledge into results
Decision making
Investigation
Experimental inquiry
Problem solving
Invention
CURRENT EMPHASIS
Where is the current bottleneck?
Focus on intake, structure, and encoding. The issue is not yet application — it is making the knowledge usable.
HOW THE STAGES RELATE
Acquisition without refinement stays shallow
Refinement without application stays theoretical
Application without acquisition becomes weak or random
The full loop produces capability
KEY INSIGHT
Learning becomes powerful only when it flows all the way through to application.
This engine unifies your learning system, your knowledge system, and your dojo philosophy. Acquisition gives structure, refinement gives flexibility, and application gives proof.
(function(){ const states = { acquire: "Focus on intake, structure, and encoding. The issue is not yet application — it is making the knowledge usable.", refine: "Focus on analysis, differentiation, and truth-testing. The issue is shallow understanding, not lack of exposure.", apply: "Focus on action, feedback, and real-world use. The issue is not learning more — it is using what is already known." }; const btns = document.querySelectorAll('.dojo112-btn'); const status = document.getElementById('dojo112Status'); btns.forEach(btn => { btn.addEventListener('click', () => { btns.forEach(b => b.classList.remove('active')); btn.classList.add('active'); status.textContent = states[btn.dataset.zone]; }); }); })();

EXPERIMENT 113 — LEAN MVP BACKEND ARCHITECTUREPurpose: Define the smallest viable dojo backend that can support execution
Focus: core entities and their relationshipsCore MVP Entities:
- Quests
- Reps
- Skills
- Procedures
- Dojo PracticeCore Logic:
- Quests link to reps and skills
- Reps link to quests, skills, and procedures
- Skills connect to quests, reps, procedures, and practice
- Procedures support reps and dojo practice
- Dojo practice trains skills and proceduresThe goal is to establish the minimum viable backend that supports:
- action
- progression
- training
- feedbackThis is the structural foundation of the dojo system.TestIs this enough to run the system without unnecessary complexity?Are the core relationships clear?Can this support quests, reps, skills, and practice in a usable way?

LEAN MVP BACKEND
Minimum viable data structure for the dojo system
Quests↔Reps↔Skills↔Procedures↔Dojo Practice
QUESTS
Quest Name
Status
Objective
Done Criteria
Relevant Skills
Next Rep
XP Reward
REPS
Rep Name
Quest
Skill Applied
Procedure
Definition of Done
Breadcrumb
XP Earned
SKILLS
Skill Name
Category
Stage
Related Quests
Related Reps
Current XP
PROCEDURES
Procedure Name
Procedure Type
Purpose
Entry Step
Procedure Steps
Completion Check
DOJO PRACTICE
Practice Name
Mode
Skill Trained
Associated Procedure
Practice Objective
XP Earned
KEY INSIGHT
This is the minimum system that can actually run the dojo.
Quests handle meaningful progress. Reps handle execution. Skills handle growth. Procedures handle repeatability. Dojo Practice handles training.

EXPERIMENT 114 — QUESTS DATABASE ARCHITECTUREPurpose: Define the quest object as the main unit of meaningful progress
Focus: identity, structure, execution, rewards, time, and reflectionQuest DB Groups:
- Core Identity
- Structural Placement
- Logic / Meaning
- Execution Control
- Reward / Growth
- Time / Tracking
- Review / ReflectionThe goal is to make quests rich enough to guide action without losing clarity.TestDoes the Quest DB hold enough information to guide execution?Can a quest track both meaning and progress?Does it support planning, action, and review?

QUESTS DATABASE
The main container for meaningful progress
CORE IDENTITY
Quest Name
Quest ID
Status
Priority
STRUCTURAL PLACEMENT
Mission / Game
Arc
Saga
Parent Project
LOGIC / MEANING
Objective
Done Criteria
Why It Matters
Role Context
Relevant Skills
EXECUTION CONTROL
Next Rep
Active Procedure
Breadcrumb
Current Block / Friction
Quest Progress %
REWARD / GROWTH
XP Reward
Skill XP Reward
Unlocks
Character Growth Notes
TIME / REVIEW
Start Date
Due Date
Last Worked On
Lessons Learned
Retrospective Notes
KEY INSIGHT
A quest is more than a task. It is a meaningful, structured progress container.

EXPERIMENT 115 — REPS DATABASE ARCHITECTUREPurpose: Define the rep as the smallest meaningful execution unit
Focus: execution details, measurement, reward, energy fit, and reviewThe rep is the atomic action unit of the dojo.It must support:
- doing
- measuring
- resuming
- rewarding
- calibrating

REPS DATABASE
The atomic execution unit of the dojo
CORE IDENTITY
Rep Name
Rep ID
Status
Rep Type
STRUCTURAL PLACEMENT
Quest
Skill Applied
Procedure
EXECUTION DETAILS
Rep Objective
Definition of Done
Output / Deliverable
Current Step
Resume Point
TIMEBOXING / MEASUREMENT
Planned Chunk Size
Actual Time Spent
Timed?
Measured Output
REWARD / PROGRESS
XP Earned
Skill XP Earned
Counts Toward Quest Progress
ENERGY / REVIEW
Energy Required
Cognitive Load
Best Context
Outcome Notes
Calibration Result
KEY INSIGHT
If quests are the mission, reps are the actual moves.

EXPERIMENT 116 — SKILLS DATABASE ARCHITECTUREPurpose: Define the skill object as the core capability-growth layer
Focus: mastery structure, relationships, growth tracking, and design notesSkills are the bridge between quests, reps, practice, and progression.

SKILLS DATABASE
Capability growth, mastery, and progression structure
CORE IDENTITY
Skill Name
Skill ID
Category
Subcategory
MASTERY STRUCTURE
Stage
Current Level
Stripe Count
Belt Level
FUNCTIONAL MEANING
Skill Description
Why It Matters
Related Roles
Parent Skill
Child Skills
SYSTEM RELATIONSHIPS
Related Quests
Related Reps
Related Procedures
Related Dojo Practice
GROWTH TRACKING
Current XP
XP to Next Stage
Last Practiced
Practice Needed?
Weakness / Gap
REFLECTION / DESIGN
Training Notes
Common Mistakes
Improvement Plan
KEY INSIGHT
Skills are the true progression layer of the dojo.

EXPERIMENT 117 — PROCEDURES DATABASE ARCHITECTUREPurpose: Define reusable methods that support repeatable action
Focus: steps, completion logic, execution fit, and maintenanceProcedures are the reusable "how" layer of the dojo.

PROCEDURES DATABASE
Reusable methods for repeatable execution
CORE IDENTITY
Procedure Name
Procedure ID
Procedure Type
PURPOSE / FUNCTION
Purpose
Applies To
Outcome Produced
SYSTEM RELATIONSHIPS
Related Quests
Related Reps
Related Skills
Related Dojo Practice
PROCEDURE CONTENT
Entry Step
Procedure Steps
Completion Check
Resume Cue
Troubleshooting Notes
EXECUTION FIT
Estimated Use Time
Cognitive Load
Requires Materials?
Required Tools / Inputs
MAINTENANCE
Stable?
Version
Needs Revision?
Last Reviewed
KEY INSIGHT
Procedures prevent you from reinventing execution every time.

EXPERIMENT 118 — DOJO PRACTICE DATABASE ARCHITECTUREPurpose: Define the structured training layer separate from real-world quest execution
Focus: modes, objectives, exercise design, practice rewards, and reflectionDojo Practice is where capability is built in controlled conditions.

DOJO PRACTICE DATABASE
Structured training for skill development
CORE IDENTITY
Practice Name
Practice ID
Mode
Status
FUNCTIONAL MEANING
Practice Objective
Skill Trained
Associated Procedure
Related Quest
PRACTICE DESIGN
Exercise / Prompt
Definition of Done
Difficulty
Environment / Setup
REWARD / PROGRESS
XP Earned
Skill XP Earned
Reps Completed
Transfer to Real Work?
REFLECTION
What Improved?
Observed Weakness
Next Practice Step
TIME FIELDS
Created On
Completed On
Last Practiced
KEY INSIGHT
Dojo Practice is where skills are built before they are tested in quests.

EXPERIMENT 119 — QUEST PAGE ARCHITECTURE SCREENPurpose: Define what the Quest page must display and control
Focus: active quest, navigation, grouping, detail display, and backend accessThe Quest page is the action-control center of the dojo.

QUEST PAGE ARCHITECTURE
The action-control center for quests and execution
ACTIVE QUEST PANEL
Quest Name
Overview
Saga / Arc
Progress Bar
Objectives
Tasks
Next Step
Rewards / XP
Unlocks / Requirements
Notes
QUEST NAVIGATION PANEL
Current
Started
Available
Completed
All
Locked / Unlocked
ARC / SAGA NAVIGATION
Sagas
Arcs
Questline View
BACKEND TOGGLE
Switch from player view to admin/backend editing view
KEY INSIGHT
The quest page must both orient and drive action.
It is not just a list. It is a control panel for what matters now.

EXPERIMENT 120 — DOJO BUILD ROADMAP SCREENPurpose: Show the staged implementation path for building the dojo system
Focus: pages, databases, logic, UI, and testingBuild Sequence:
1. Create core UI pages
2. Define page roles
3. Define subsystem elements
4. Build core databases
5. Link databases
6. Add logic
7. Build UI
8. Test and adjustThis is the build-order map for turning the dojo into a working system.

DOJO BUILD ROADMAP
From page shells to a working system
STEP 1
Create Core UI Pages
Game Hub
Character
Skills
Quests
Dojo
STEP 2
Define Page Roles
Character = stats & identity
Skills = progression system
Quests = missions
Dojo = training
STEP 3
Build Core Databases
Quests
Reps
Skills
Procedures
Dojo Practice
STEP 4
Link + Add Logic
Relations
Progress %
Character XP
Status logic
STEP 5
Build UI Layers
Game Hub
Quest Screen
Task / Rep View
STEP 6
Test and Adjust
Create Quest
Add Reps
Link Skills
Check Progress
Adjust UI
KEY INSIGHT
Build the minimum system that can actually be played.
Do not build everything at once. Build the shell, define the entities, link the logic, then test through real use.

EXPERIMENT 121 — DOJO BACKEND HUBPurpose: Integrate the dojo backend architecture into one unified subsystem hub
Focus: backend entities, page architecture, and build sequenceBackend Core → Entity Models → UI Architecture → Build RoadmapThis hub connects the dojo backend subsystem into one command screen.It integrates:BACKEND CORE
- Lean MVP BackendENTITY MODELS
- Quests DB
- Reps DB
- Skills DB
- Procedures DB
- Dojo Practice DBUI / PAGE ARCHITECTURE
- Quest Page ArchitectureBUILD SEQUENCE
- Dojo Build RoadmapThe goal is to make the dojo backend feel like one coherent subsystem instead of separate experiments.TestDoes this make the backend easier to understand?Can the user see how data, UI, and build order relate?Does this help decide what to build next?

DOJO BACKEND HUB
Command center for dojo data architecture, UI structure, and build order
Backend Core→Entity Models→UI Architecture→Build Roadmap
CURRENT STAGE
Entity models are defined; subsystem integration is the next step
The dojo backend now has enough structure to function as a real subsystem. The current need is to unify the data architecture, page architecture, and build sequence into one working picture.
NEXT ACTION
Connect backend objects to the page and workflow layers
Use this hub to determine which backend entity drives which UI panel, workflow, and progression mechanic.
BACKEND CORE
113 — Lean MVP Backend Architecture
ENTITY MODELS
114 — Quests DB
115 — Reps DB
116 — Skills DB
117 — Procedures DB
118 — Dojo Practice DB
UI ARCHITECTURE
119 — Quest Page Architecture
BUILD ROADMAP
120 — Dojo Build Roadmap
STAGE GUIDE
If defining minimum structure → start at 113
If clarifying object properties → use 114–118
If clarifying display requirements → use 119
If deciding build order → use 120
KEY INSIGHT
The dojo backend is not just storage. It is the hidden logic that makes gameplay, progression, and execution possible.
Quests organize meaningful progress. Reps handle action. Skills track growth. Procedures stabilize execution. Practice builds capability. The hub exists to show how those pieces work together.

EXPERIMENT 122 — MASTER SYSTEM HUB v2Purpose: Integrate the dojo backend subsystem into the top-level command center
Focus: life, knowledge, dojo gameplay, dojo backend, diagnostics, and learningLife ↔ Knowledge ↔ Dojo Gameplay ↔ Dojo Backend ↔ Diagnostics ↔ LearningThis upgraded hub connects the major subsystems of the operating system:LIFE SYSTEM
- Vision, goals, capability, life domainsKNOWLEDGE SYSTEM
- Gaps, extraction, mapping, storage, synthesis, actionDOJO GAMEPLAY
- Quests, skills, progression, training, executionDOJO BACKEND
- Backend core
- Quests DB
- Reps DB
- Skills DB
- Procedures DB
- Dojo Practice DB
- Page architecture
- Build roadmapDIAGNOSTICS
- Alignment, progress blocks, fear, realizationLEARNING / ASSESSMENT
- Assessment quality
- Thinking skills
- Dimensions of learning
- Learning engineThe goal is to make the full system visible from one screen, including both:
- the player-facing experience
- and the builder-facing architectureTestDoes this feel more complete than the original master hub?Can the user now see both front-end and back-end layers?Does this help route not only action, but also design and build decisions?

MASTER SYSTEM HUB v2
Top-level command center with dojo backend integration
Life↔Knowledge↔Dojo Gameplay↔Dojo Backend↔Diagnostics↔Learning
LIFE SYSTEM
Direction, goals, capability, domains
95 — Integrated Life System
96 — Immediate Core Goals
97 — Core Goals Architecture
98 — What / Why / How Loop
99 — Core Life Dashboard
KNOWLEDGE SYSTEM
Research, mapping, storage, action
84 — Knowledge Gap Diagnostic
85 — Knowledge-to-Action Engine
86 — Schema Overlay
87–94 — Extraction, architecture, hub
DOJO GAMEPLAY
Quests, reps, skills, execution
60 — Gameplay Loop
61 — Dojo Flow
64–67 — Hub and dashboard views
77–83 — Skill, troubleshooting, decision, attention
DOJO BACKEND
Data layer, UI architecture, build order
113 — Lean MVP Backend
114 — Quests DB
115 — Reps DB
116 — Skills DB
117 — Procedures DB
118 — Dojo Practice DB
119 — Quest Page Architecture
120 — Build Roadmap
121 — Dojo Backend Hub
DIAGNOSTICS
Alignment, blocks, path correction
101 — Start Here Alignment Hub
102 — Compass Reading
103 — Progress Block Troubleshooting
107 — Fear Resolution Path
LEARNING / ASSESSMENT
Learning design and engine
104 — Assessment Quality
105 — Core Thinking Skills
106 — Dimensions of Learning
108 — Classroom Framework Hub
109–112 — Unified Learning Engine
CURRENT FOCUS
Which subsystem needs attention right now?
Focus on life direction, goals, priorities, and overall alignment.
KEY INSIGHT
The system now includes both player-facing and builder-facing layers.
Life gives direction. Knowledge gives structure. Gameplay gives execution. Backend gives implementation. Diagnostics give correction. Learning gives refinement. The upgraded hub keeps both action and architecture visible at the same time.
(function(){ const states = { life: "Focus on life direction, goals, priorities, and overall alignment.", knowledge: "Focus on knowledge gaps, extraction, maps, and research-to-action.", gameplay: "Focus on quests, reps, skills, and visible execution.", backend: "Focus on databases, relationships, page architecture, and implementation structure.", diagnostics: "Focus on alignment, peace, progress, and finding the real bottleneck.", learning: "Focus on assessment, cognition, learning design, and the unified learning engine." }; const btns = document.querySelectorAll('.dojo122-btn'); const status = document.getElementById('dojo122Status'); btns.forEach(btn => { btn.addEventListener('click', () => { btns.forEach(b => b.classList.remove('active')); btn.classList.add('active'); status.textContent = states[btn.dataset.zone]; }); }); })();

EXPERIMENT 123 — DOJO MVP NOTION IMPLEMENTATION PLANPurpose: Turn the dojo backend architecture into a practical, staged Notion build plan
Focus: databases, properties, relations, formulas, views, and build orderBuild Order → Databases → Relations → Logic → Views → TestThis implementation plan is designed to help build the Dojo MVP in Notion one phase at a time.PHASES
1. Create core databases
2. Add MVP properties
3. Add relations
4. Add logic and formulas
5. Build page views
6. Test with real dataMVP DATABASES
- Quests
- Reps
- Skills
- Procedures
- Dojo PracticeBUILD PRINCIPLE
Start with the smallest system that can actually be used:
- one quest
- a few reps
- one or two skills
- one procedure
- one practice entryThe goal is not to build everything at once.
The goal is to build the minimum system that works, test it, then expand.This screen is interactive so you can:
- click each phase
- see what to build
- and follow the plan step by stepTestCan I see exactly what to build first?Can I find the MVP fields without getting overwhelmed?Does this make the Dojo system feel buildable in Notion?

DOJO MVP — NOTION IMPLEMENTATION PLAN
Interactive build guide for translating the dojo architecture into a working Notion MVP
Create DBs→Add Properties→Add Relations→Add Logic→Build Views→Test
BUILD PHASES
PHASE DESCRIPTION
Phase 1 — Create Core Databases
Create the five core databases first: Quests, Reps, Skills, Procedures, and Dojo Practice. Do not add every property yet. Just get the containers in place.
WHAT TO BUILD
Create Quests database
Create Reps database
Create Skills database
Create Procedures database
Create Dojo Practice database
IMPLEMENTATION NOTES
Use simple table views first
Do not worry about dashboards yet
Name databases clearly and consistently
MVP FOCUS
Minimum usable version
Build only enough structure to run one real quest from start to finish.
CHECKPOINT
All 5 databases exist
Each database has a title property
You can open and enter a test row in each one
KEY INSIGHT
Build the smallest possible system that can actually be played.
The goal is not maximum completeness. The goal is minimum viability. Build the structure, run a real quest through it, then improve what breaks.
(function(){ const data = { phase1: { title: "Phase 1 — Create Core Databases", text: "Create the five core databases first: Quests, Reps, Skills, Procedures, and Dojo Practice. Do not add every property yet. Just get the containers in place.", steps: [ "Create Quests database", "Create Reps database", "Create Skills database", "Create Procedures database", "Create Dojo Practice database" ], notes: [ "Use simple table views first", "Do not worry about dashboards yet", "Name databases clearly and consistently" ], mvpTitle: "Minimum usable version", mvpText: "Build only enough structure to run one real quest from start to finish.", checklist: [ "All 5 databases exist", "Each database has a title property", "You can open and enter a test row in each one" ], focusMain: "Build the smallest possible system that can actually be played.", focusText: "The goal is not maximum completeness. The goal is minimum viability. Build the structure, run a real quest through it, then improve what breaks." }, phase2: { title: "Phase 2 — Add MVP Properties", text: "Add only the essential properties each database needs to function. Skip advanced fields for now.", steps: [ "Quests: Name, Status, Objective, XP Reward", "Reps: Name, Status, Definition of Done, XP Earned", "Skills: Name, Category, Stage, Current XP", "Procedures: Name, Type, Purpose, Entry Step", "Dojo Practice: Name, Mode, Practice Objective" ], notes: [ "Prioritize usability over completeness", "Use select/status properties where possible", "Avoid property bloat early" ], mvpTitle: "MVP fields only", mvpText: "If a property is not needed to run a real quest yet, leave it for later.", checklist: [ "Each DB has the minimum fields needed to be used", "You can create a quest, rep, skill, procedure, and practice entry", "No database feels overloaded" ], focusMain: "A smaller, usable database is better than a perfect but overwhelming one.", focusText: "Your first version should reduce friction. You can always expand later." }, phase3: { title: "Phase 3 — Add Relations", text: "Now connect the databases so the system starts behaving like one system rather than separate lists.", steps: [ "Reps → Quest", "Reps → Skill Applied", "Reps → Procedure", "Quests → Relevant Skills", "Procedures → Related Skills", "Dojo Practice → Skill Trained", "Dojo Practice → Associated Procedure" ], notes: [ "Start with the most essential links only", "Test each relation with real example entries", "Make sure the link direction feels intuitive" ], mvpTitle: "Relational minimum", mvpText: "You do not need every relation at once. Add the few that create real workflow value.", checklist: [ "A rep can link to its quest", "A rep can link to a skill", "A rep can link to a procedure", "A practice entry can link to a skill or procedure" ], focusMain: "Relations are what turn isolated databases into a playable system.", focusText: "Without relations, the dojo is just containers. With relations, it becomes a real model of action and growth." }, phase4: { title: "Phase 4 — Add Logic and Formulas", text: "Add just enough logic to support progress visibility and simple automation.", steps: [ "Quest progress %", "Skill XP rollups or totals", "Character XP logic later if needed", "Status logic such as Active / Done / Locked", "Optional: simple 'Needs Practice?' flags" ], notes: [ "Do formulas only after relations exist", "Keep formulas simple at first", "Make sure logic supports decisions, not decoration" ], mvpTitle: "Useful logic", mvpText: "Only add formulas that help you know what to do next.", checklist: [ "Quest progress can be seen", "XP fields are usable", "Status logic helps navigation" ], focusMain: "Logic should reduce thinking friction, not create more complexity.", focusText: "Good formulas answer practical questions like: What is active? What is done? What should I work on next?" }, phase5: { title: "Phase 5 — Build Views and Pages", text: "Once the data works, shape it into pages that match your workflow: Game Hub, Quests, Skills, and Dojo.", steps: [ "Build Game Hub view with active quest and quick stats", "Build Quest page with Current / Started / Available / Completed views", "Build Skills page grouped by category or stage", "Build Dojo page for practice modes", "Optionally add filtered rep/task views" ], notes: [ "Views should support action, not just look nice", "Begin with the pages you actually use most", "Player-facing views come after data clarity" ], mvpTitle: "Action-facing UI", mvpText: "Build the page views that help you act right now, not every possible dashboard.", checklist: [ "You can find the active quest quickly", "You can see related reps or skills", "The pages support orientation and action" ], focusMain: "Pages are where the data becomes usable in daily life.", focusText: "A good view reduces overwhelm and points you toward the next meaningful move." }, phase6: { title: "Phase 6 — Test With Real Data", text: "Now run a real quest through the system. Add reps, link skills, use procedures, and see what breaks.", steps: [ "Create one real quest", "Add several reps under it", "Link at least one skill", "Use one procedure", "Add one dojo practice entry", "Watch what feels confusing or clunky" ], notes: [ "Do not test with fake complexity", "Use an actual current project", "Revise based on friction, not theory" ], mvpTitle: "Reality test", mvpText: "A system is not proven by structure alone. It is proven by use.", checklist: [ "One real quest has been run through the MVP", "The weak points are now visible", "You know what to improve next" ], focusMain: "Testing reveals the real design truth.", focusText: "The architecture is only the beginning. Real use shows what matters, what is missing, and what should be simplified." } }; const btns = document.querySelectorAll('.dojo123-btn'); const title = document.getElementById('dojo123Title'); const text = document.getElementById('dojo123Text'); const steps = document.getElementById('dojo123Steps'); const notes = document.getElementById('dojo123Notes'); const mvpTitle = document.getElementById('dojo123MvpTitle'); const mvpText = document.getElementById('dojo123MvpText'); const checklist = document.getElementById('dojo123Checklist'); const focusMain = document.getElementById('dojo123FocusMain'); const focusText = document.getElementById('dojo123FocusText'); btns.forEach(btn => { btn.addEventListener('click', () => { btns.forEach(b => b.classList.remove('active')); btn.classList.add('active'); const d = data[btn.dataset.phase]; title.textContent = d.title; text.textContent = d.text; steps.innerHTML = d.steps.map(i => `
${i}
`).join(''); notes.innerHTML = d.notes.map(i => `
${i}
`).join(''); mvpTitle.textContent = d.mvpTitle; mvpText.textContent = d.mvpText; checklist.innerHTML = d.checklist.map(i => `
${i}
`).join(''); focusMain.textContent = d.focusMain; focusText.textContent = d.focusText; }); }); })();

EXPERIMENT 124 — SUBSYSTEM DOCUMENTATION HUBPurpose: Organize all dojo experiments into a navigable system of subsystemsThis hub is not a feature screen.
It is a navigation and orientation system.Each subsystem represents a domain of function within the Dojo OS.SUBSYSTEMS1. Life System
- Alignment
- Purpose
- Values
- Identity
- Compass2. Knowledge System
- Mapping
- Zettelkasten
- Source extraction
- Knowledge schemas
- Terrain maps3. Learning System
- Attention → Encoding → Recall
- Practice loops
- Feedback cycles
- Skill acquisition4. Dojo System
- Training modes
- Practice structures
- Skill refinement
- Readiness5. Quest System
- Missions
- Objectives
- Tasks / reps
- Progress tracking6. Backend System
- Databases
- Relations
- Logic
- XP / progression7. Diagnostic System
- Alignment checks
- Capability checks
- Execution troubleshooting
- Fear / resistance pathways8. Execution System
- Reps
- Procedures
- Timeboxing
- Action loopsPURPOSE OF THIS HUB- Know where you are
- Know what system you’re in
- Know what problem you’re solving
- Know where to go nextThis is the map of the entire dojo.TestCan I quickly find the right subsystem for a problem?Does this reduce confusion about where things belong?Does this help me navigate the system without thinking too hard?

DOJO SUBSYSTEM HUB
Navigate the entire system by function. Select a subsystem to explore its purpose and structure.
SUBSYSTEM
Life System
Governs alignment, purpose, identity, and direction. This system determines whether you are playing the right game.
CORE COMPONENTS
Alignment
Values
Purpose
Identity
Inner Compass
WHEN TO USE THIS
Feeling off or misaligned
Unclear direction
Lack of meaning or motivation
CONNECTS TO
Quest System
Diagnostic System
SYSTEM INSIGHT
If alignment is wrong, everything downstream breaks.
This system determines the correctness of your direction. All execution systems depend on this being accurate.
(function(){ const data = { life:{ title:"Life System", desc:"Governs alignment, purpose, identity, and direction.", components:["Alignment","Values","Purpose","Identity","Inner Compass"], use:["Feeling misaligned","Unclear direction","Lack of meaning"], connect:["Quest System","Diagnostic System"], focus:"If alignment is wrong, everything downstream breaks.", focusText:"This system determines whether you're playing the right game." }, knowledge:{ title:"Knowledge System", desc:"Organizes information into usable structures.", components:["Maps","Zettelkasten","Schemas","Extraction"], use:["Confusion","Information overload","Learning gaps"], connect:["Learning System","Execution System"], focus:"Unorganized knowledge creates friction.", focusText:"Structure determines usability." }, learning:{ title:"Learning System", desc:"Transforms information into skill and capability.", components:["Attention","Encoding","Practice","Feedback"], use:["Learning new skills","Retention issues"], connect:["Dojo System","Execution System"], focus:"Learning requires cycles, not intake.", focusText:"Practice and feedback close the loop." }, dojo:{ title:"Dojo System", desc:"Controlled training environment for skill development.", components:["Drills","Practice","Simulation","Sandbox"], use:["Skill development","Preparation"], connect:["Learning System","Execution System"], focus:"Train before you perform.", focusText:"Skill is forged in controlled environments." }, quest:{ title:"Quest System", desc:"Structures real-world action into missions and objectives.", components:["Quests","Objectives","Tasks","Progress"], use:["Projects","Goals","Execution"], connect:["Execution System","Backend System"], focus:"Quests turn intention into action.", focusText:"Without quests, action is scattered." }, backend:{ title:"Backend System", desc:"Data layer powering the entire system.", components:["Databases","Relations","Logic","XP"], use:["System building","Tracking"], connect:["Quest System","Execution System"], focus:"Structure determines behavior.", focusText:"The backend defines how the system works." }, diagnostic:{ title:"Diagnostic System", desc:"Identifies why things are not working.", components:["Alignment checks","Capability checks","Execution checks"], use:["Stuck","Confused","Blocked"], connect:["Life System","Execution System"], focus:"Correct diagnosis prevents wasted effort.", focusText:"Fix the right problem." }, execution:{ title:"Execution System", desc:"Where action happens in reality.", components:["Reps","Procedures","Timeboxing"], use:["Doing work","Progressing"], connect:["Quest System","Dojo System"], focus:"Execution is where results are created.", focusText:"Everything leads here." } }; const btns = document.querySelectorAll('.dojo124-btn'); btns.forEach(btn=>{ btn.addEventListener('click',()=>{ btns.forEach(b=>b.classList.remove('active')); btn.classList.add('active'); const d = data[btn.dataset.sys]; sysTitle.textContent=d.title; sysDesc.textContent=d.desc; sysComponents.innerHTML=d.components.map(i=>`
${i}
`).join(''); sysUse.innerHTML=d.use.map(i=>`
${i}
`).join(''); sysConnect.innerHTML=d.connect.map(i=>`
${i}
`).join(''); sysFocus.textContent=d.focus; sysFocusText.textContent=d.focusText; }); }); })();

EXPERIMENT 125 — ROUTING SYSTEM / DECISION ENGINEPurpose: Route problems to the correct subsystem and next action
Focus: problem type, subsystem selection, and action guidanceProblem → Diagnosis → Subsystem → ActionThis routing system helps answer:- What kind of problem is this?
- Which subsystem does it belong to?
- What should I do next?CORE ROUTES1. LIFE / ALIGNMENT
Use when:
- direction feels wrong
- motivation feels empty
- identity or purpose feels unclearRoutes to:
- Life System
- Diagnostic System2. KNOWLEDGE / CLARITY
Use when:
- information is confusing
- ideas are scattered
- a concept is not clear enough to act onRoutes to:
- Knowledge System
- Learning System3. LEARNING / SKILL BUILDING
Use when:
- you understand too little
- retention is weak
- skill has not yet been builtRoutes to:
- Learning System
- Dojo System4. EXECUTION / ACTION
Use when:
- you know what to do but are not doing it
- follow-through is breaking down
- progress is stalling in real workRoutes to:
- Execution System
- Quest System
- Dojo Gameplay5. SYSTEM / DESIGN
Use when:
- the system itself feels clunky
- databases or pages are unclear
- implementation needs refinementRoutes to:
- Backend System
- Dojo Backend Hub6. FEAR / RESISTANCE
Use when:
- hesitation, avoidance, or fear is blocking action
- emotional safety feels low
- inner resistance is stronger than logicRoutes to:
- Diagnostic System
- Fear Resolution PathThe goal is to reduce wasted effort by sending each problem to the correct part of the system.TestCan I quickly identify what kind of problem I’m having?Does the routing suggest the right subsystem?Does this reduce spinning, confusion, and misdiagnosis?

ROUTING SYSTEM
Decision engine for finding the right subsystem and next action
Problem→Diagnosis→Subsystem→Action
PROBLEM TYPE
DIAGNOSIS
Life / Alignment
Use this route when direction feels wrong, purpose feels weak, or the game itself may be misaligned.
ROUTE TO SUBSYSTEM
Life System
Diagnostic System
NEXT ACTION
Clarify values, identity, and direction
Check alignment before forcing effort
COMMON SIGNALS
No inner peace
Low meaning
Wrong game / wrong role feeling
KEY INSIGHT
Do not solve an alignment problem with more execution.
Many problems feel like laziness or lack of discipline when they are really misdiagnosed. Correct routing saves energy and increases accuracy.
(function(){ const data = { life: { title: "Life / Alignment", text: "Use this route when direction feels wrong, purpose feels weak, or the game itself may be misaligned.", subsystems: ["Life System", "Diagnostic System"], actions: [ "Clarify values, identity, and direction", "Check alignment before forcing effort" ], signals: [ "No inner peace", "Low meaning", "Wrong game / wrong role feeling" ], focusMain: "Do not solve an alignment problem with more execution.", focusText: "Many problems feel like laziness or lack of discipline when they are really misdiagnosed. Correct routing saves energy and increases accuracy." }, knowledge: { title: "Knowledge / Clarity", text: "Use this route when information is confusing, ideas are scattered, or a concept is not clear enough to act on.", subsystems: ["Knowledge System", "Learning System"], actions: [ "Map the concept or source", "Extract structure before trying to apply it" ], signals: [ "Confusion", "Too many disconnected ideas", "You cannot explain it clearly" ], focusMain: "Do not force action on knowledge that is still unstructured.", focusText: "When clarity is weak, the right move is mapping, extraction, and learning design—not brute execution." }, learning: { title: "Learning / Skill", text: "Use this route when you do not yet know enough, retention is weak, or the skill itself has not been built.", subsystems: ["Learning System", "Dojo System"], actions: [ "Use the unified learning engine", "Train in controlled conditions before real-world application" ], signals: [ "Weak recall", "Low competence", "Understanding without capability" ], focusMain: "Skill gaps are solved through training cycles, not wishful thinking.", focusText: "If the ability is not there yet, go to acquisition, refinement, and practice before expecting stable performance." }, execution: { title: "Execution / Action", text: "Use this route when you already know what to do but are not doing it consistently or progress is stalling in real work.", subsystems: ["Execution System", "Quest System", "Dojo Gameplay"], actions: [ "Break work into reps", "Use procedures, timeboxing, and quest structure" ], signals: [ "Follow-through breakdown", "Stalling in active work", "Too much thinking, not enough doing" ], focusMain: "Do not solve an execution problem by researching more.", focusText: "When the next step is already known, the answer is better action structure, not more input." }, system: { title: "System / Design", text: "Use this route when the system itself feels clunky, unclear, or hard to build and maintain.", subsystems: ["Backend System", "Dojo Backend Hub"], actions: [ "Review data architecture", "Simplify DBs, relations, logic, or views" ], signals: [ "Too much friction in the system", "Confusing databases or views", "The architecture feels heavier than the work" ], focusMain: "A bad system creates fake personal problems.", focusText: "Sometimes the issue is not you. It is the design. Fix architecture when the tool is causing the drag." }, fear: { title: "Fear / Resistance", text: "Use this route when hesitation, emotional interference, or lack of felt safety blocks action even when logic is clear.", subsystems: ["Diagnostic System", "Fear Resolution Path"], actions: [ "Identify whether action-first or belief-first is needed", "Reduce fear through evidence, safety, and reframing" ], signals: [ "Avoidance", "Freezing despite knowing what to do", "Strong inner resistance" ], focusMain: "Do not call fear a discipline problem too quickly.", focusText: "When fear or safety is the real bottleneck, forcing harder often makes things worse. Route correctly first." } }; const btns = document.querySelectorAll('.dojo125-btn'); const title = document.getElementById('dojo125Title'); const text = document.getElementById('dojo125Text'); const subsystems = document.getElementById('dojo125Subsystems'); const actions = document.getElementById('dojo125Actions'); const signals = document.getElementById('dojo125Signals'); const focusMain = document.getElementById('dojo125FocusMain'); const focusText = document.getElementById('dojo125FocusText'); btns.forEach(btn => { btn.addEventListener('click', () => { btns.forEach(b => b.classList.remove('active')); btn.classList.add('active'); const d = data[btn.dataset.route]; title.textContent = d.title; text.textContent = d.text; subsystems.innerHTML = d.subsystems.map(i => `
${i}
`).join(''); actions.innerHTML = d.actions.map(i => `
${i}
`).join(''); signals.innerHTML = d.signals.map(i => `
${i}
`).join(''); focusMain.textContent = d.focusMain; focusText.textContent = d.focusText; }); }); })();

EXPERIMENT 126 — DAILY COMMAND SCREENPurpose: Create a daily-use cockpit that brings together orientation, routing, active work, and next action
Focus: current state, active quest, next rep, subsystem focus, and routingState → Focus → Active Quest → Next Rep → Route → ActionThis screen is meant to be used daily.It brings together:CURRENT STATE
- how things feel
- what type of problem is present
- where attention should goFOCUS SYSTEM
- life
- knowledge
- dojo gameplay
- dojo backend
- diagnostics
- learningACTIVE WORK
- active quest
- next rep
- current bottleneck
- immediate actionROUTING
- if the problem is alignment, go to life/diagnostics
- if the problem is clarity, go to knowledge/learning
- if the problem is execution, go to quests/reps
- if the problem is system friction, go to backend
- if the problem is fear, go to diagnostics/fearThe goal is to provide one daily command surface for deciding and acting.TestCan I orient myself quickly?Can I tell what I should do next?Does this reduce friction at the moment of action?

DAILY COMMAND
Daily cockpit for direction, routing, and immediate action
State→Focus→Active Quest→Next Rep→Route→Action
CURRENT STATE
Quick Read
Things are stable enough to keep moving. Use the current plan and continue.
FOCUS SYSTEM
Dojo Gameplay
The current need is direct execution: quests, reps, progress, and visible movement.
ACTIVE QUEST
Build Dojo MVP in Notion
Arc: Dojo System Buildout
Status: In Progress
Current bottleneck: System translation into build steps
NEXT REP
Open Quests DB and create MVP fields
Create or review Quest Name
Add Status
Add Objective
Add XP Reward
ROUTING
Execution Route
Go to Quest System
Use Reps and Procedures
Work the next visible action
TODAY'S MODE
Stay close to visible action. Prefer done reps over more thinking.
COMMAND INSIGHT
The point of this screen is not to think more. It is to re-enter action correctly.
Use this screen to orient, choose the correct subsystem, identify the next rep, and move. Daily command should reduce startup friction.
(function(){ const stateData = { steady: { stateStatus: "Things are stable enough to keep moving. Use the current plan and continue.", focusTitle: "Dojo Gameplay", focusText: "The current need is direct execution: quests, reps, progress, and visible movement.", repTitle: "Continue the active rep", repList: [ "Use current quest", "Finish the next visible rep", "Log progress and continue" ], routeTitle: "Execution Route", routeList: [ "Go to Quest System", "Use Reps and Procedures", "Work the next visible action" ], focusMain: "Stability is a signal to keep momentum.", focusText2: "Do not overdiagnose when simple continuation is the right move." }, unclear: { stateStatus: "The issue is lack of clarity. The next move is not force — it is clarification.", focusTitle: "Knowledge / Learning", focusText: "You need structure, understanding, or a better map before acting.", repTitle: "Clarify the target or concept", repList: [ "Map the problem", "Define the actual goal", "Extract the missing structure" ], routeTitle: "Clarity Route", routeList: [ "Go to Knowledge System", "Use Learning Engine", "Reduce ambiguity before action" ], focusMain: "Do not call unclear work an execution problem too early.", focusText2: "When you cannot see the shape of the work, the right action is clarification." }, stuck: { stateStatus: "Progress is blocked. The system needs diagnosis before more effort.", focusTitle: "Diagnostics", focusText: "The issue may be alignment, capability, or execution friction.", repTitle: "Run a troubleshooting rep", repList: [ "Check alignment", "Check clarity", "Check skill gap", "Check execution system" ], routeTitle: "Diagnostic Route", routeList: [ "Go to Routing System", "Use Progress Block Troubleshooting", "Identify the real bottleneck" ], focusMain: "More effort on the wrong problem creates more frustration.", focusText2: "Use diagnostics to identify whether the issue is path, skill, clarity, fear, or system design." }, resistant: { stateStatus: "The block is emotional or resistance-based. Safety and fear may be involved.", focusTitle: "Diagnostics / Fear", focusText: "This is not necessarily a discipline failure. Route through resistance correctly.", repTitle: "Reduce resistance first", repList: [ "Check fear / safety", "Choose outer-first or inner-first", "Take the smallest safe move" ], routeTitle: "Fear Route", routeList: [ "Go to Fear Resolution Path", "Reduce resistance", "Create safety for action" ], focusMain: "Do not mistake fear for laziness.", focusText2: "When resistance is the real bottleneck, the next rep should reduce fear and restore movement." }, building: { stateStatus: "The current mode is design, architecture, or system construction.", focusTitle: "Dojo Backend", focusText: "This is builder-facing work: databases, relations, logic, and page architecture.", repTitle: "Build one implementation step", repList: [ "Open the implementation plan", "Choose one phase", "Build one clean layer" ], routeTitle: "Backend Route", routeList: [ "Go to Dojo Backend Hub", "Use Notion Implementation Plan", "Build the smallest viable layer" ], focusMain: "Builder mode should still be routed through next actions.", focusText2: "Even system design should be broken into concrete build reps so it stays actionable." } }; const modeData = { execute: "Stay close to visible action. Prefer done reps over more thinking.", learn: "Shift into acquisition, refinement, or application. Use the learning engine intentionally.", diagnose: "Pause action long enough to identify the real bottleneck, then reroute.", design: "Work on architecture, backend, pages, or implementation structure—one layer at a time." }; const stateBtns = document.querySelectorAll('.dojo126-btn'); const modeBtns = document.querySelectorAll('.dojo126-mode-btn'); const stateStatus = document.getElementById('dojo126StateStatus'); const focusTitle = document.getElementById('dojo126FocusTitle'); const focusText = document.getElementById('dojo126FocusText'); const repTitle = document.getElementById('dojo126RepTitle'); const repList = document.getElementById('dojo126RepList'); const routeTitle = document.getElementById('dojo126RouteTitle'); const routeList = document.getElementById('dojo126RouteList'); const focusMain = document.getElementById('dojo126FocusMain'); const focusText2 = document.getElementById('dojo126FocusText2'); const modeStatus = document.getElementById('dojo126ModeStatus'); stateBtns.forEach(btn => { btn.addEventListener('click', () => { stateBtns.forEach(b => b.classList.remove('active')); btn.classList.add('active'); const d = stateData[btn.dataset.state]; stateStatus.textContent = d.stateStatus; focusTitle.textContent = d.focusTitle; focusText.textContent = d.focusText; repTitle.textContent = d.repTitle; repList.innerHTML = d.repList.map(i => `
${i}
`).join(''); routeTitle.textContent = d.routeTitle; routeList.innerHTML = d.routeList.map(i => `
${i}
`).join(''); focusMain.textContent = d.focusMain; focusText2.textContent = d.focusText2; }); }); modeBtns.forEach(btn => { btn.addEventListener('click', () => { modeBtns.forEach(b => b.classList.remove('active')); btn.classList.add('active'); modeStatus.textContent = modeData[btn.dataset.mode]; }); }); })();

EXPERIMENT 127 — REASSEMBLY / COMPILATION PLANPurpose: Convert the system from many diagrams and components into usable, assembled screensThis is the transition from:
"Understanding the system"
→
"Using the system"---CORE IDEAWe are no longer building new pieces.We are COMPOSING existing pieces into:1. Daily-use screens
2. Role-based views
3. Mode-based interfaces
4. RPG-style dashboards---LEVELS OF REASSEMBLYLEVEL 1 — CORE SCREENS (Already started)- Daily Command Screen (126)
- Master Hub (100)
- Backend Hub (114)These are anchor points.---LEVEL 2 — FUNCTIONAL SCREENSThese are assembled from subsystems:- Execution Screen
(Quest + Rep + Procedure + Progress)- Learning Screen
(Knowledge + Extraction + Mapping + Practice)- Diagnostics Screen
(Alignment + Progress + Troubleshooting + Fear)- Builder Screen
(Databases + Procedures + System Design)---LEVEL 3 — MODE-BASED VIEWSUser selects a mode:- Execute Mode
- Learn Mode
- Diagnose Mode
- Design ModeEach mode:- Highlights different panels
- Hides irrelevant complexity
- Routes attention correctly---LEVEL 4 — RPG UI LAYERTranslate all of the above into:- Quest Log UI
- Character Screen
- Skill Tree Screen
- Inventory Screen
- Dojo Training ScreenThis is NOT decoration.This is:→ Cognitive compression
→ Familiar interaction patterns
→ Faster decision making---REASSEMBLY PRINCIPLEEvery screen must answer:1. Where am I?
2. What matters now?
3. What type of problem is this?
4. What is the next rep?If it does not answer these, it is not a usable screen.---COMPILATION STRATEGYSTEP 1 — Choose a Screen Type
- Daily Command
- Execution
- Learning
- Diagnostics
- BuilderSTEP 2 — Pull Relevant Components
- From diagrams
- From databases
- From subsystemsSTEP 3 — Reduce to Essential Panels
- Active Panel
- Navigation Panel
- Context Panel
- Action PanelSTEP 4 — Define Interaction
- Click → Set Active
- Scroll → Preview
- Button → Route systemSTEP 5 — Test
- Can I act within 5–10 seconds?
- Can I find next rep without thinking?---RULES1. No screen should require interpretation before action
2. No screen should show everything
3. Every screen should reduce options, not expand them
4. Every screen should point to ONE next action---TESTCan I open a screen and immediately know:- what to do
- where to go
- what kind of problem I’m facingIf yes → system is becoming usable
If no → continue reassembly

REASSEMBLY ENGINE
Compile system components into usable screens
REASSEMBLY LEVEL
COMPILATION PRINCIPLE
The system becomes real when components are assembled into screens that guide action.
(function(){ const data = { core: { items: [ "Daily Command Screen", "Master Hub", "Backend Hub" ], insight: "Core screens are anchors. Everything else connects to them." }, functional: { items: [ "Execution Screen (Quest + Rep + Action)", "Learning Screen (Extraction + Mapping + Practice)", "Diagnostics Screen (Alignment + Progress + Fear)", "Builder Screen (Databases + System Design)" ], insight: "Functional screens group systems into usable workflows." }, mode: { items: [ "Execute Mode (Do the work)", "Learn Mode (Build knowledge)", "Diagnose Mode (Fix problems)", "Design Mode (Build systems)" ], insight: "Modes reduce noise by showing only what matters for the current state." }, rpg: { items: [ "Quest Log UI", "Character Screen", "Skill Tree", "Inventory", "Dojo Training" ], insight: "RPG UI is cognitive compression, not decoration." } }; const display = document.getElementById('dojo127Display'); const insight = document.getElementById('dojo127Insight'); document.querySelectorAll('.dojo127-btn').forEach(btn=>{ btn.addEventListener('click',()=>{ document.querySelectorAll('.dojo127-btn').forEach(b=>b.classList.remove('active')); btn.classList.add('active'); const d = data[btn.dataset.level]; display.innerHTML = d.items.map(i=>`
${i}
`).join(''); insight.textContent = d.insight; }); }); // initialize const first = data.core; display.innerHTML = first.items.map(i=>`
${i}
`).join(''); })();

EXPERIMENT 128 — WITCHER 3 QUEST SCREEN HTML EMULATIONPurpose: Practice translating a real RPG menu layout into HTML, CSS, and JavaScript
Focus: direct UI imitation, panel structure, selection states, and layout logicReference target:
- The Witcher 3 quest/menu screen structureCore layout:
- top title bar
- left quest/category list
- right quest details panel
- selected quest highlight
- objective list
- footer actions / hintsThe goal is not originality yet.
The goal is to learn how to faithfully translate an existing game UI pattern into HTML.What this teaches:
- panel layout
- hierarchy
- menu state
- selected item logic
- interaction structureTestDoes it feel like a real RPG quest menu?Can I click quests and see details update?Does the HTML capture the structure of the original style clearly?

QUESTS
GLOSSARYALCHEMYQUESTSINVENTORYWORLD MAP
CATEGORIES
MAIN QUESTS
WITCHER CONTRACTS
TREASURE HUNTS
SECONDARY QUESTS
MAIN QUEST
Lilac and Gooseberries
Suggested Level: 3
DESCRIPTION
Geralt begins his search for Yennefer. Rumors place her near White Orchard, and several locals may know more.
OBJECTIVES
Talk to the innkeeper at White Orchard.
Ask travelers if they’ve seen Yennefer.
Follow the Nilfgaardian lead.
NOTES
This imitation focuses on the quest-screen layout logic: left navigation, right detail view, highlighted selection, and objective state changes.
ESC Back
Enter Track Quest
(function(){ const questData = { griffin: { type: "MAIN QUEST", name: "Lilac and Gooseberries", level: "Suggested Level: 3", description: "Geralt begins his search for Yennefer. Rumors place her near White Orchard, and several locals may know more.", objectives: [ { text: "Talk to the innkeeper at White Orchard.", state: "done" }, { text: "Ask travelers if they’ve seen Yennefer.", state: "current" }, { text: "Follow the Nilfgaardian lead.", state: "" } ], notes: "This entry mirrors the classic left-nav / right-detail quest layout found in RPG menus." }, ciri: { type: "MAIN QUEST", name: "In Ciri's Footsteps", level: "Suggested Level: 5", description: "Geralt follows leads across Velen to learn what happened to Ciri and where she may have gone next.", objectives: [ { text: "Question the baron’s men.", state: "done" }, { text: "Search the room for clues.", state: "current" }, { text: "Track the next lead through Velen.", state: "" } ], notes: "Good reference for a story-heavy quest with staged objectives." }, contract: { type: "WITCHER CONTRACT", name: "Devil by the Well", level: "Suggested Level: 2", description: "A noonwraith has made the nearby fields deadly. Investigate the haunting and prepare the right countermeasures.", objectives: [ { text: "Talk to the villagers about the ghost.", state: "done" }, { text: "Read the bestiary entry and prepare oils or signs.", state: "current" }, { text: "Defeat the noonwraith.", state: "" } ], notes: "This shows how contract quests can emphasize preparation and layered objectives." }, gear: { type: "TREASURE HUNT", name: "Scavenger Hunt: Wolf School Gear", level: "Suggested Level: 14", description: "Follow old witcher clues to uncover diagrams and gear tied to the Wolf School.", objectives: [ { text: "Find the first diagram location.", state: "done" }, { text: "Recover the armor diagram.", state: "current" }, { text: "Continue the hunt for remaining pieces.", state: "" } ], notes: "Treasure hunts are useful references for list-driven menu structure." }, fistfight: { type: "SECONDARY QUEST", name: "Fists of Fury: Velen", level: "Suggested Level: 7", description: "Challenge the local champions of Velen and prove your skill in a string of fistfights.", objectives: [ { text: "Defeat the first challenger.", state: "done" }, { text: "Find and challenge the next champion.", state: "current" }, { text: "Defeat all remaining opponents.", state: "" } ], notes: "Useful for emulating repeated-goal quest structures." } }; const buttons = document.querySelectorAll('.witcher128-quest-btn'); const typeEl = document.getElementById('witcher128Type'); const nameEl = document.getElementById('witcher128Name'); const levelEl = document.getElementById('witcher128Level'); const descEl = document.getElementById('witcher128Description'); const objEl = document.getElementById('witcher128Objectives'); const notesEl = document.getElementById('witcher128Notes'); function renderObjectives(items){ objEl.innerHTML = items.map(item => { const cls = item.state ? `witcher128-objective ${item.state}` : 'witcher128-objective'; return `
${item.text}
`; }).join(''); } buttons.forEach(btn => { btn.addEventListener('click', () => { buttons.forEach(b => b.classList.remove('active')); btn.classList.add('active'); const data = questData[btn.dataset.quest]; typeEl.textContent = data.type; nameEl.textContent = data.name; levelEl.textContent = data.level; descEl.textContent = data.description; renderObjectives(data.objectives); notesEl.textContent = data.notes; }); }); })();

EXPERIMENT 129 — DOJO QUEST SCREEN IN WITCHER-STYLE LAYOUTPurpose: Translate the dojo quest system into the layout logic of a Witcher-style RPG quest screen
Focus: quest selection, active quest display, objectives, next rep, rewards, and notesLayout Translation:
- Top bar → dojo menu shell
- Left panel → quest categories and quest list
- Right panel → active quest detail command screen
- Footer → action hints and control cuesDojo Adaptation:
- Quest list grouped by category/status
- Active quest shown as the central command object
- Objectives shown as stateful steps
- Next Rep shown as the immediate actionable unit
- XP, unlocks, and notes shown as progression contextThe goal is:
- keep the visual hierarchy of a real RPG menu
- while translating it into a usable dojo execution interfaceTestDoes this feel like your dojo inside a real RPG quest menu?Can you quickly identify the active quest and next rep?Does the screen support action, not just aesthetics?

QUEST LOG
GAME HUBCHARACTERSKILLSQUESTSDOJO
QUEST CATEGORIES
CURRENT
STARTED
AVAILABLE
COMPLETED
CURRENT QUEST
Build Dojo MVP in Notion
Saga: Dojo Buildout • Arc: MVP Systems • Priority: High
OVERVIEW
Translate the dojo backend architecture into a minimum viable Notion implementation so that one real quest can be run through the system end to end.
OBJECTIVES
Create core databases: Quests, Reps, Skills, Procedures, Dojo Practice.
Add MVP properties to the Quests database.
Create relations between Quests, Reps, and Skills.
Run one real quest through the system.
NEXT REP
Open the Quests database and add: Quest Name, Status, Objective, XP Reward.
REWARDS / XP
Quest XP: +150
Skill XP: Systems +40
Unlocks: MVP Quest Loop
UNLOCKS / REQUIREMENTS
Requires: backend entity clarity
Requires: implementation sequence
Unlocks: stable daily command use
NOTES
This screen adapts your active quest panel into a Witcher-style detail layout. The right panel is no longer just descriptive — it acts as a command panel.
ESC Back
Enter Set Active
Space Track Next Rep
(function(){ const dojoQuestData = { dojo_mvp: { type: "CURRENT QUEST", name: "Build Dojo MVP in Notion", meta: "Saga: Dojo Buildout • Arc: MVP Systems • Priority: High", description: "Translate the dojo backend architecture into a minimum viable Notion implementation so that one real quest can be run through the system end to end.", objectives: [ { text: "Create core databases: Quests, Reps, Skills, Procedures, Dojo Practice.", state: "done" }, { text: "Add MVP properties to the Quests database.", state: "current" }, { text: "Create relations between Quests, Reps, and Skills.", state: "" }, { text: "Run one real quest through the system.", state: "" } ], nextRep: "Open the Quests database and add: Quest Name, Status, Objective, XP Reward.", rewards: [ "Quest XP: +150", "Skill XP: Systems +40", "Unlocks: MVP Quest Loop" ], unlocks: [ "Requires: backend entity clarity", "Requires: implementation sequence", "Unlocks: stable daily command use" ], notes: "This is a builder-facing quest translated into RPG quest-menu logic." }, life_hub: { type: "STARTED QUEST", name: "Refine Life System Hub", meta: "Saga: Life Architecture • Arc: Integration • Priority: Medium", description: "Tighten the relationship between life direction, diagnostics, and daily command so the life system supports action more directly.", objectives: [ { text: "Review life subsystem screens.", state: "done" }, { text: "Identify overlapping panels and logic.", state: "current" }, { text: "Reassemble into stronger command views.", state: "" } ], nextRep: "Compare Life Hub, Core Goals, and Routing screens for overlap and missing links.", rewards: [ "Quest XP: +90", "Skill XP: Systems Thinking +20", "Unlocks: clearer life-routing layer" ], unlocks: [ "Requires: subsystem clarity", "Unlocks: improved daily command routing" ], notes: "This is more architectural than execution-heavy, but still structured as a quest." }, learning_engine: { type: "STARTED QUEST", name: "Expand Learning Engine", meta: "Saga: Learning Architecture • Arc: Training Model • Priority: Medium", description: "Strengthen the unified learning engine by connecting acquisition, refinement, and application more explicitly to dojo practice and quest execution.", objectives: [ { text: "Complete unified learning engine screen.", state: "done" }, { text: "Clarify links to skills and practice.", state: "current" }, { text: "Connect to execution layers.", state: "" } ], nextRep: "Map which backend objects correspond to Acquire, Refine, and Apply.", rewards: [ "Quest XP: +100", "Skill XP: Learning Design +25", "Unlocks: stronger learning-dojo bridge" ], unlocks: [ "Requires: dimensions of learning clarity", "Unlocks: integrated training workflows" ], notes: "This quest strengthens the relationship between learning theory and system mechanics." }, rpg_ui: { type: "AVAILABLE QUEST", name: "Emulate RPG Inventory Screen", meta: "Saga: UI Emulation • Arc: RPG Patterns • Priority: Medium", description: "Study an existing RPG inventory or character interface and translate its structure into HTML for dojo use.", objectives: [ { text: "Choose a reference screen.", state: "" }, { text: "Break layout into regions and states.", state: "" }, { text: "Rebuild it in HTML/CSS/JS.", state: "" } ], nextRep: "Pick the next Witcher-style or related RPG panel to imitate directly.", rewards: [ "Quest XP: +120", "Skill XP: UI Translation +35", "Unlocks: stronger game-feel shell" ], unlocks: [ "Requires: one successful direct imitation", "Unlocks: reusable UI patterns" ], notes: "This is a design-pattern quest focused on interface translation." }, backend_polish: { type: "AVAILABLE QUEST", name: "Polish Backend Hub", meta: "Saga: Backend Architecture • Arc: Builder Systems • Priority: Medium", description: "Refine the dojo backend hub and related entity models so the builder-facing architecture becomes cleaner and easier to implement.", objectives: [ { text: "Review backend entity screens.", state: "" }, { text: "Identify redundant fields or missing links.", state: "" }, { text: "Refine implementation sequence.", state: "" } ], nextRep: "Review Quests DB and Reps DB together for cleaner implementation sequencing.", rewards: [ "Quest XP: +85", "Skill XP: Backend Design +20", "Unlocks: cleaner implementation planning" ], unlocks: [ "Requires: backend hub clarity", "Unlocks: easier Notion translation" ], notes: "This quest is for system simplification, not new subsystem creation." }, master_hub: { type: "COMPLETED QUEST", name: "Build Master System Hub", meta: "Saga: Core Architecture • Arc: Integration • Status: Complete", description: "Created the top-level hub that connects life, knowledge, dojo, backend, diagnostics, and learning subsystems.", objectives: [ { text: "Define major subsystems.", state: "done" }, { text: "Create unified hub screen.", state: "done" }, { text: "Integrate backend layer.", state: "done" } ], nextRep: "No active rep — completed.", rewards: [ "Quest XP: +200", "Skill XP: Architecture +50", "Unlocks: system-wide navigation" ], unlocks: [ "Unlocked: unified routing and documentation layers" ], notes: "This completed quest now serves as a structural anchor for the broader system." } }; const buttons = document.querySelectorAll('.dojo129-quest-btn'); const typeEl = document.getElementById('dojo129Type'); const nameEl = document.getElementById('dojo129Name'); const metaEl = document.getElementById('dojo129Meta'); const descEl = document.getElementById('dojo129Description'); const objEl = document.getElementById('dojo129Objectives'); const nextRepEl = document.getElementById('dojo129NextRep'); const rewardsEl = document.getElementById('dojo129Rewards'); const unlocksEl = document.getElementByI

EXPERIMENT 130 — WITCHER-STYLE DOJO CHARACTER SCREENPurpose: Translate the dojo character system into a Witcher 3-style character menu
Focus: identity, stats, role, progression, equipped focus, and character overviewLayout Translation:
- Top bar → dojo shell navigation
- Left panel → character stats, identity, and category tabs
- Center / right panel → equipped focus + visual character presentation
- Footer → controls / menu hintsDojo Adaptation:
- Character identity becomes dojo role/class
- Levels and XP become progression panel
- Attributes become visible stats
- Equipped slots become active focus areas / current loadout
- Character notes become growth / development summaryThe goal:
- preserve the feeling of a real RPG character screen
- while translating it into dojo-specific progression logicTestDoes this feel like a real RPG character menu?Can I switch tabs and see the character panel update?Does it make your dojo character concept feel more tangible?

CHARACTER
GAME HUBCHARACTERSKILLSQUESTSDOJO
CHARACTER PANELS
PROFILE
Name: Ben the Builder
Role: System Architect
Class: Dojo Founder
Level: 17
CURRENT FOCUS
Primary Arc: Dojo Buildout
Training Focus: Systems + Execution
Current Mode: Design
IDENTITY
Ben the Builder
System Architect • Dojo Founder • Level 17
SUMMARY
A systems-focused builder character oriented toward architecture, learning design, and transforming abstract frameworks into usable operating systems.
TRAITS
High pattern recognition
Strong synthesis drive
Learns by mapping and reassembly
Needs clear structure for consistent action
DOJO CHARACTER
Mind
Role
Skill
Quest
System
Mode
ESC Back
Enter Select Panel
Space Inspect Loadout
(function(){ const panelData = { identity: { type: "IDENTITY", name: "Ben the Builder", sub: "System Architect • Dojo Founder • Level 17", description: "A systems-focused builder character oriented toward architecture, learning design, and transforming abstract frameworks into usable operating systems.", listTitle: "TRAITS", list: [ "High pattern recognition", "Strong synthesis drive", "Learns by mapping and reassembly", "Needs clear structure for consistent action" ], slots: { mind: "Mind\nStrategic", role: "Role\nArchitect", skill: "Skill\nSynthesis", quest: "Quest\nBuildout", system: "System\nDojo OS", mode: "Mode\nDesign" } }, stats: { type: "STATS", name: "Character Attributes", sub: "Current build emphasis • cognitive + structural profile", description: "The stat layer represents the character’s functional strengths and current development profile inside the dojo system.", listTitle: "ATTRIBUTES", list: [ "Clarity: 8/10", "Focus: 6/10", "Concentration: 5/10", "Persistence: 7/10", "Systems Thinking: 10/10", "Execution Stability: 5/10" ], slots: { mind: "Mind\nClarity 8", role: "Role\nFocus 6", skill: "Skill\nSystems 10", quest: "Quest\nPersistence 7", system: "System\nExec 5", mode: "Mode\nAssess" } }, loadout: { type: "LOADOUT", name: "Current Character Loadout", sub: "Equipped focus areas • current active setup", description: "This panel translates gear slots into functional dojo slots: what mindset, role, skill, quest, system, and mode are currently equipped.", listTitle: "EQUIPPED LOADOUT", list: [ "Mindset: Builder / Integrator", "Role: Architect", "Primary Skill: System Design", "Active Quest: Dojo MVP in Notion", "System Layer: Backend + Daily Command", "Current Mode: Design" ], slots: { mind: "Mind\nBuilder", role: "Role\nArchitect", skill: "Skill\nDesign", quest: "Quest\nMVP", system: "System\nBackend", mode: "Mode\nDesign" } }, growth: { type: "GROWTH", name: "Progression and Development", sub: "Character advancement • growth notes • current trajectory", description: "This panel tracks the current growth arc: what is being developed, what is lagging, and what kind of next-stage evolution is underway.", listTitle: "GROWTH NOTES", list: [ "Primary growth arc: implementation discipline", "Secondary arc: clearer action routing", "Current weakness: execution consistency", "Current gain: stronger system integration", "Next evolution: buildable Notion translation" ], slots: { mind: "Mind\nGrowth", role: "Role\nEvolving", skill: "Skill\nExecution", quest: "Quest\nTranslate", system: "System\nIntegrate", mode: "Mode\nAdvance" } } }; const buttons = document.querySelectorAll('.dojo130-tab-btn'); const typeEl = document.getElementById('dojo130Type'); const nameEl = document.getElementById('dojo130Name'); const subEl = document.getElementById('dojo130Sub'); const descEl = document.getElementById('dojo130Description'); const listTitleEl = document.getElementById('dojo130ListTitle'); const listEl = document.getElementById('dojo130InfoList'); const slotMind = document.getElementById('slotMind'); const slotRole = document.getElementById('slotRole'); const slotSkill = document.getElementById('slotSkill'); const slotQuest = document.getElementById('slotQuest'); const slotSystem = document.getElementById('slotSystem'); const slotMode = document.getElementById('slotMode'); function renderSlot(el, text){ el.innerHTML = text.replace(/\n/g, "
"); } buttons.forEach(btn => { btn.addEventListener('click', () => { buttons.forEach(b => b.classList.remove('active')); btn.classList.add('active'); const d = panelData[btn.dataset.panel]; typeEl.textContent = d.type; nameEl.textContent = d.name; subEl.textContent = d.sub; descEl.textContent = d.description; listTitleEl.textContent = d.listTitle; listEl.innerHTML = d.list.map(item => `
${item}
`).join(''); renderSlot(slotMind, d.slots.mind); renderSlot(slotRole, d.slots.role); renderSlot(slotSkill, d.slots.skill); renderSlot(slotQuest, d.slots.quest); renderSlot(slotSystem, d.slots.system); renderSlot(slotMode, d.slots.mode); }); }); })();

EXPERIMENT 131 — WITCHER-STYLE DOJO SKILLS PROGRESSIONPurpose: Translate dojo skills into a Witcher-style progression screenCore Idea:
Skills are not static—they are trained, leveled, and actively equipped.Layout:
- Left → Skill Categories (Domains)
- Center → Skill Tree / Nodes
- Right → Selected Skill Detail
- Footer → XP / Progression FeedbackDojo Mapping:
- Skill nodes → abilities being trained
- Level → current stage of mastery
- XP → accumulated reps
- Unlocks → next capabilityTest:Does this feel like a real progression system?Can I clearly see:
- what I’m training
- where I’m going
- what to do next?

SKILLS
GAME HUBCHARACTERSKILLSQUESTSDOJO
DOMAINS
SKILL
System Design
Level 7 • XP 420
DESCRIPTION
Ability to design structured systems that organize knowledge and action.
NEXT UNLOCK
Advanced System Integration
XP: 1240Next Level: 1600
(function(){ const data = { systems:[ {name:"System Design", xp:420, level:7, desc:"Design structured systems", next:"Integration"}, {name:"Workflow Design", xp:260, level:5, desc:"Build workflows", next:"Automation"}, {name:"Architecture Thinking", xp:180, level:4, desc:"Map systems", next:"Scaling"} ], execution:[ {name:"Consistency", xp:200, level:5, desc:"Act regularly", next:"Discipline"}, {name:"Task Initiation", xp:150, level:4, desc:"Start tasks", next:"Momentum"} ], learning:[ {name:"Knowledge Mapping", xp:300, level:6, desc:"Map knowledge", next:"Synthesis"}, {name:"Memory Systems", xp:220, level:5, desc:"Recall info", next:"Mastery"} ], focus:[ {name:"Focus Control", xp:190, level:4, desc:"Control attention", next:"Deep Work"}, {name:"Distraction Resistance", xp:120, level:3, desc:"Reduce distraction", next:"Flow"} ] }; const tree = document.getElementById("dojo131Tree"); const nameEl = document.getElementById("dojo131Name"); const levelEl = document.getElementById("dojo131Level"); const descEl = document.getElementById("dojo131Desc"); const nextEl = document.getElementById("dojo131Next"); function render(cat){ tree.innerHTML=""; data[cat].forEach((s,i)=>{ const div=document.createElement("div"); div.className="dojo131-node"; div.innerHTML=`${s.name}
Lv ${s.level}`; div.onclick=()=>{ document.querySelectorAll(".dojo131-node").forEach(n=>n.classList.remove("active")); div.classList.add("active"); nameEl.textContent=s.name; levelEl.textContent=`Level ${s.level} • XP ${s.xp}`; descEl.textContent=s.desc; nextEl.textContent=s.next; }; if(i===0) div.click(); tree.appendChild(div); }); } document.querySelectorAll(".dojo131-cat").forEach(btn=>{ btn.onclick=()=>{ document.querySelectorAll(".dojo131-cat").forEach(b=>b.classList.remove("active")); btn.classList.add("active"); render(btn.dataset.cat); }; }); render("systems"); })();

EXPERIMENT 132 — DIABLO-STYLE DOJO SKILL TREEPurpose: Translate dojo skills into a Diablo-style branching progression tree
Focus: branching paths, unlock dependencies, build strategy, and skill progressionCore Idea:
Skills are not just listed.
They branch, unlock, and shape the build.Layout:
- Left → Domain categories
- Center → Branching skill tree
- Right → Selected skill detail
- Bottom → XP / unlock contextDojo Mapping:
- branches = progression paths
- nodes = skills
- locked nodes = future development
- active nodes = current build
- selected node = current training focusTest:Does this feel more like a true build path?Can I see what is unlocked, what is locked, and where I could go next?Does this give the dojo a different flavor from the Witcher version?

SKILL TREE
GAME HUBCHARACTERSKILLSQUESTSDOJO
DOMAINS
BUILD NOTES
Current build emphasizes systems architecture and workflow design.
SELECTED NODE
System Design
Rank 3 • XP 420 • Unlocked
DESCRIPTION
Ability to design structured systems that organize action, knowledge, and progression.
PREREQUISITES
Base Systems Awareness
NEXT UNLOCKS
Workflow Design
System Integration
TRAINING EFFECT
Improves your ability to build clean architectures and reduce system chaos.
Total XP: 1240Spent Points: 9Available Points: 2
(function(){ const data = { systems: { notes: "Current build emphasizes systems architecture, workflow logic, and integration paths.", nodes: [ {id:"base", name:"Systems Awareness", rank:1, x:40, y:240, status:"unlocked", desc:"Basic awareness of system structure and relationships.", reqs:["None"], next:["System Design"], effect:"Unlocks the systems branch."}, {id:"design", name:"System Design", rank:3, x:220, y:160, status:"unlocked", desc:"Design structured systems that organize action and knowledge.", reqs:["Systems Awareness"], next:["Workflow Design","System Integration"], effect:"Improves architecture clarity."}, {id:"workflow", name:"Workflow Design", rank:2, x:420, y:90, status:"unlocked", desc:"Build workflows that translate structure into action.", reqs:["System Design"], next:["Automation Logic"], effect:"Improves action flow and repeatability."}, {id:"integration", name:"System Integration", rank:1, x:420, y:250, status:"unlocked", desc:"Connect subsystems into coherent operating layers.", reqs:["System Design"], next:["Master Architecture"], effect:"Improves cross-system cohesion."}, {id:"automation", name:"Automation Logic", rank:0, x:640, y:60, status:"locked", desc:"Formalize rules, rollups, and system automation paths.", reqs:["Workflow Design"], next:[""], effect:"Reduces manual friction."}, {id:"master", name:"Master Architecture", rank:0, x:640, y:250, status:"locked", desc:"Unify life, knowledge, learning, and dojo systems.", reqs:["System Integration"], next:[""], effect:"Creates system-wide coherence."} ], edges: [ ["base","design"], ["design","workflow"], ["design","integration"], ["workflow","automation"], ["integration","master"] ] }, execution: { notes: "This build path improves consistency, task initiation, and action completion.", nodes: [ {id:"base", name:"Initiation", rank:2, x:40, y:220, status:"unlocked", desc:"Start action with less friction.", reqs:["None"], next:["Consistency"], effect:"Reduces delay before starting."}, {id:"consistency", name:"Consistency", rank:3, x:240, y:140, status:"unlocked", desc:"Act regularly and sustain output.", reqs:["Initiation"], next:["Follow-Through","Timeboxing"], effect:"Improves regular action."}, {id:"follow", name:"Follow-Through", rank:2, x:460, y:80, status:"locked", desc:"Finish what has been started.", reqs:["Consistency"], next:[""], effect:"Increases completion rate."}, {id:"timebox", name:"Timeboxing", rank:2, x:460, y:240, status:"unlocked", desc:"Use boundaries to limit and direct effort.", reqs:["Consistency"], next:["Execution Stability"], effect:"Improves action control."}, {id:"stability", name:"Execution Stability", rank:0, x:680, y:240, status:"locked", desc:"Maintain reliable execution under varying conditions.", reqs:["Timeboxing"], next:[""], effect:"Creates dependable output."} ], edges: [ ["base","consistency"], ["consistency","follow"], ["consistency","timebox"], ["timebox","stability"] ] }, learning: { notes: "This branch develops acquisition, refinement, and application.", nodes: [ {id:"base", name:"Knowledge Intake", rank:2, x:40, y:240, status:"unlocked", desc:"Take in information in structured form.", reqs:["None"], next:["Mapping"], effect:"Improves learning entry."}, {id:"mapping", name:"Knowledge Mapping", rank:3, x:240, y:160, status:"unlocked", desc:"Turn information into visible structure.", reqs:["Knowledge Intake"], next:["Refinement","Application"], effect:"Improves clarity."}, {id:"refine", name:"Refinement", rank:2, x:460, y:90, status:"unlocked", desc:"Analyze, compare, and sharpen understanding.", reqs:["Knowledge Mapping"], next:[""], effect:"Builds flexible understanding."}, {id:"apply", name:"Application", rank:1, x:460, y:250, status:"unlocked", desc:"Use knowledge in real situations.", reqs:["Knowledge Mapping"], next:["Master Learning Loop"], effect:"Turns learning into results."}, {id:"master", name:"Master Learning Loop", rank:0, x:680, y:170, status:"locked", desc:"Unify acquisition, refinement, and application into one engine.", reqs:["Refinement","Application"], next:[""], effect:"Creates a full learning pipeline."} ], edges: [ ["base","mapping"], ["mapping","refine"], ["mapping","apply"], ["refine","master"], ["apply","master"] ] }, focus: { notes: "This branch helps regulate attention, resistance, and control.", nodes: [ {id:"base", name:"Attention Awareness", rank:2, x:40, y:220, status:"unlocked", desc:"Notice where attention is going.", reqs:["None"], next:["Focus Control"], effect:"Improves awareness."}, {id:"focus", name:"Focus Control", rank:2, x:240, y:140, status:"unlocked", desc:"Direct attention intentionally.", reqs:["Attention Awareness"], next:["Distraction Resistance","Concentration"], effect:"Improves target control."}, {id:"distraction", name:"Distraction Resistance", rank:1, x:460, y:70, status:"locked", desc:"Stay with a target despite competing stimuli.", reqs:["Focus Control"], next:[""], effect:"Reduces derailment."}, {id:"concentration", name:"Concentration", rank:1, x:460, y:230, status:"unlocked", desc:"Sustain depth on one object.", reqs:["Focus Control"], next:["Deep Work"], effect:"Improves immersion."}, {id:"deep", name:"Deep Work", rank:0, x:680, y:230, status:"locked", desc:"Extended immersion in meaningful work.", reqs:["Concentration"], next:[""], effect:"Produces high-value output."} ], edges: [ ["base","focus"], ["focus","distraction"], ["focus","concentration"], ["concentration","deep"] ] } }; const treeEl = document.getElementById('dojo132Tree'); const nameEl = document.getElementById('dojo132Name'); const levelEl = document.getElementById('dojo132Level'); const descEl = document.getElementById('dojo132Desc'); const reqsEl = document.getElementById('dojo132Reqs'); const nextEl = document.getElementById('dojo132Next'); const effectEl = document.getElementById('dojo132Effect'); const notesEl = document.getElementById('dojo132BuildNotes'); function getNode(cat, id){ return data[cat].nodes.find(n => n.id === id); } function drawLine(from, to){ const x1 = from.x + 120; const y1 = from.y + 27; const x2 = to.x; const y2 = to.y + 27; const dx = x2 - x1; const dy = y2 - y1; const len = Math.sqrt(dx*dx + dy*dy); const angle = Math.atan2(dy, dx) * 180 / Math.PI; const line = document.createElement('div'); line.className = 'dojo132-line'; line.style.left = x1 + 'px'; line.style.top = y1 + 'px'; line.style.width = len + 'px'; line.style.transform = `rotate(${angle}deg)`; return line; } function selectNode(node, el){ treeEl.querySelectorAll('.dojo132-node').forEach(n => n.classList.remove('active')); el.classList.add('active'); nameEl.textContent = node.name; levelEl.textContent = `Rank ${node.rank} • XP ${node.rank * 140} • ${node.status === 'locked' ? 'Locked' : 'Unlocked'}`; descEl.textContent = node.desc; reqsEl.innerHTML = (node.reqs && node.reqs.length ? node.reqs : ['None']).map(i => `
${i}
`).join(''); nextEl.innerHTML = (node.next && node.next.filter(Boolean).length ? node.next.filter(Boolean) : ['No further unlocks shown']).map(i => `
${i}
`).join(''); effectEl.textContent = node.effect; } function renderCategory(cat){ treeEl.innerHTML = ''; notesEl.textContent = data[cat].notes; data[cat].edges.forEach(edge => { const from = getNode(cat, edge[0]); const to = getNode(cat, edge[1]); treeEl.appendChild(drawLine(from, to)); }); data[cat].nodes.forEach((node, index) => { const div = document.createElement('div'); div.className = `dojo132-node ${node.status}`; div.style.left = node.x + 'px'; div.style.top = node.y + 'px'; div.innerHTML = `${node.name}Rank ${node.rank}`; div.addEventListener('click', () => selectNode(node, div)); treeEl.appendChild(div); if(index === 1 || (index === 0 && data[cat].nodes.length === 1)){ setTimeout(() => selectNode(node, div), 0); } }); } document.querySelectorAll('.dojo132-cat').forEach(btn => { btn.addEventListener('click', () => { document.querySelectorAll('.dojo132-cat').forEach(b => b.classList.remove('active')); btn.classList.add('active'); renderCategory(btn.dataset.cat); }); }); renderCategory('systems'); })();

EXPERIMENT 133 — DOJO COMMAND VOLVELLEPurpose: Turn the dojo system into a rotational command interface
Focus: subsystem selection, symbolic navigation, and next-action routingRotate → Select → Reveal → ActThis screen represents the dojo as a wheel of functional systems.Outer Ring Domains:
- Life
- Knowledge
- Learning
- Dojo
- Quest
- Backend
- Diagnostics
- ExecutionCenter:
- Current active subsystem
- Core meaning
- Next actionSide Panel:
- When to use this system
- What problem it solves
- What to do nextThe goal is:
- reduce the feeling of a flat menu
- create a more spatial, symbolic command interface
- express the dojo as a living wheel instead of a listTestDoes the wheel feel intuitive?Can I select a subsystem and understand what it is for?Does this feel like a breakthrough interface rather than a standard dashboard?

DOJO COMMAND VOLVELLE
A rotational interface for navigating the dojo system
ACTIVE SYSTEM
Life
Alignment, identity, meaning, and right direction.
WHEN TO USE
When direction feels wrong
When meaning feels weak
When identity or values need clarification
WHAT IT SOLVES
Prevents you from solving the wrong problem through more effort.
NEXT ACTION
Clarify values
Check alignment
Adjust the game, role, or quests
WHEEL INSIGHT
If the center is wrong, the wheel turns badly.
Life governs right direction. A misaligned center causes confusion across every other subsystem.
(function(){ const order = ["life","knowledge","learning","dojo","quest","backend","diagnostic","execution"]; let currentIndex = 0; const data = { life: { title: "Life", center: "Alignment, identity, meaning, and right direction.", use: [ "When direction feels wrong", "When meaning feels weak", "When identity or values need clarification" ], solve: "Prevents you from solving the wrong problem through more effort.", action: [ "Clarify values", "Check alignment", "Adjust the game, role, or quests" ], focusMain: "If the center is wrong, the wheel turns badly.", focusText: "Life governs right direction. A misaligned center causes confusion across every other subsystem." }, knowledge: { title: "Knowledge", center: "Mapping, extraction, organization, and usable structure.", use: [ "When ideas feel scattered", "When you cannot explain something clearly", "When information needs structure before action" ], solve: "Turns confusion into visible structure.", action: [ "Map the concept", "Extract the source structure", "Organize by use" ], focusMain: "Unstructured knowledge creates fake execution problems.", focusText: "If the knowledge is still foggy, the right move is mapping before action." }, learning: { title: "Learning", center: "Acquire, refine, apply, and close the feedback loop.", use: [ "When the skill is not built yet", "When retention is weak", "When understanding has not become capability" ], solve: "Transforms information into trainable ability.", action: [ "Acquire clearly", "Refine through analysis", "Apply and test" ], focusMain: "Learning is not intake. It is a cycle.", focusText: "The wheel turns through acquisition, refinement, and application—not just exposure." }, dojo: { title: "Dojo", center: "Controlled training, drills, practice, and readiness building.", use: [ "When skill needs safe training conditions", "When repetition and refinement are needed", "When preparing for real execution" ], solve: "Builds capability before high-stakes performance.", action: [ "Choose a practice mode", "Train the target skill", "Review what improved" ], focusMain: "Train before you test.", focusText: "The dojo exists to build competence under controlled conditions before quests demand performance." }, quest: { title: "Quest", center: "Meaningful progress through active missions and objectives.", use: [ "When work needs clear structure", "When goals need concrete progression", "When there must be one active mission" ], solve: "Turns intention into structured, trackable progress.", action: [ "Set the active quest", "Review objectives", "Identify the next rep" ], focusMain: "No quest, no clear progress.", focusText: "Quests convert abstract goals into visible movement." }, backend: { title: "Backend", center: "Databases, relations, logic, implementation, and architecture.", use: [ "When the system feels clunky", "When data structure needs refinement", "When implementation planning is required" ], solve: "Makes the dojo buildable and stable.", action: [ "Review entity models", "Check relations and logic", "Simplify the implementation layer" ], focusMain: "A bad system can create fake personal failures.", focusText: "Sometimes the friction is architectural, not motivational." }, diagnostic: { title: "Diagnostics", center: "Routing, troubleshooting, and correct problem identification.", use: [ "When stuck", "When effort is not working", "When the bottleneck is unclear" ], solve: "Prevents wasted effort on the wrong issue.", action: [ "Check alignment", "Check clarity", "Check skill, fear, or execution" ], focusMain: "Correct diagnosis saves enormous energy.", focusText: "A system that routes well avoids treating every problem as the same kind of problem." }, execution: { title: "Execution", center: "Reps, procedures, timeboxing, and real-world action.", use: [ "When the next step is already known", "When work must become movement", "When consistency and completion matter" ], solve: "Converts clarity into real output.", action: [ "Run the next rep", "Use the procedure", "Log completion and continue" ], focusMain: "Everything eventually cashes out in execution.", focusText: "If the path is clear enough, stop thinking and start moving." } }; const segments = Array.from(document.querySelectorAll('.dojo133-segment')); const centerTitle = document.getElementById('dojo133CenterTitle'); const centerText = document.getElementById('dojo133CenterText'); const useEl = document.getElementById('dojo133Use'); const solveEl = document.getElementById('dojo133Solve'); const actionEl = document.getElementById('dojo133Action'); const focusMainEl = document.getElementById('dojo133FocusMain'); const focusTextEl = document.getElementById('dojo133FocusText'); const prevBtn = document.getElementById('dojo133Prev'); const nextBtn = document.getElementById('dojo133Next'); function render(key){ const d = data[key]; centerTitle.textContent = d.title; centerText.textContent = d.center; useEl.innerHTML = d.use.map(i => `
${i}
`).join(''); solveEl.textContent = d.solve; actionEl.innerHTML = d.action.map(i => `
${i}
`).join(''); focusMainEl.textContent = d.focusMain; focusTextEl.textContent = d.focusText; segments.forEach(seg => seg.classList.toggle('active', seg.dataset.key === key)); currentIndex = order.indexOf(key); } segments.forEach(seg => { seg.addEventListener('click', () => render(seg.dataset.key)); }); prevBtn.addEventListener('click', () => { currentIndex = (currentIndex - 1 + order.length) % order.length; render(order[currentIndex]); }); nextBtn.addEventListener('click', () => { currentIndex = (currentIndex + 1) % order.length; render(order[currentIndex]); }); render("life"); })();

EXPERIMENT 134 — KANJI SENTENCE MODULE PROTOTYPEPurpose: Create a one-screen interactive study module for a single Book of Five Rings sentence
Focus: kanji study, structure, compounds, and active recallPassage:
兵法の道
二天一流
と号し数年鍛錬の事初て書物に書き顕はさんと思ふThis module includes:
- full passage display
- clickable kanji study panel
- compound/phrase references
- simple practice prompts
- one-screen navigationThe goal is:
- keep the lesson small
- support active recall
- avoid scrolling through static notesThis is a sentence-level dojo lesson prototype.

BOOK OF FIVE RINGS — SENTENCE MODULE
Interactive kanji study prototype • sentence-level lesson
PASSAGE
兵法の道
二天一流
と号し数年鍛錬の事初て書物に書き顕はさんと思ふ
KANJI IN THIS SENTENCE
CHARACTER STUDY
兵
兵
MEANINGS
Modern: soldier, military
Classical: warrior, arms, warfare
READINGS
On: へい (hei)
Kun: つわもの (tsuwamono)
RADICALS
八 → divide
廾 (variant form) → two hands
EXPLANATION
Suggests handling or organizing weapons; associated with military action.
NOTES
Often appears in martial contexts.
COMPOUNDS / PRACTICE
COMPOUNDS / PHRASES
兵法 → conceptual system of warfare
兵法の道 → philosophical path of strategy
二天一流 → proper noun (school name structure)
RECALL PROMPTS
What are the core meanings of this kanji?
What radicals or components shape it?
How does it function in one of the compounds above?
SELF-TEST
PASSAGE NOTE
Full English sentence translation is not finalized yet, so this module emphasizes structure, compounds, and character-level study rather than a polished translation.
(function(){ const kanjiData = { "兵": { meanings: "Modern: soldier, military
Classical: warrior, arms, warfare", readings: "On: へい (hei)
Kun: つわもの (tsuwamono)", radicals: "八 → divide
廾 (variant form) → two hands", explain: "Suggests handling or organizing weapons; associated with military action.", notes: "Often appears in martial contexts.", compounds: [ "兵法 → conceptual system of warfare", "兵法の道 → philosophical path of strategy" ] }, "法": { meanings: "Modern: law, method
Classical: principle, rule, doctrine", readings: "On: ほう (hō), はっ (hatsu)", radicals: "氵 → water
去 → go, remove", explain: "Water flowing in a fixed path → order, rule, method.", notes: "Central to philosophical and technical systems.", compounds: [ "兵法 → conceptual system of warfare", "兵法の道 → philosophical path of strategy" ] }, "道": { meanings: "Modern: road, path
Classical: the Way, discipline", readings: "On: どう (dō)
Kun: みち (michi)", radicals: "辶 → movement
首 → head", explain: "Movement guided by the head → a path or guiding way.", notes: "Core concept in martial and philosophical traditions.", compounds: [ "兵法の道 → philosophical path of strategy" ] }, "二": { meanings: "Modern: two
Classical: duality, pairing", readings: "On: に (ni)", radicals: "二 → two", explain: "Two parallel lines → concept of duality.", notes: "Often symbolic beyond numeric value.", compounds: [ "二天一流 → proper noun (school name structure)" ] }, "天": { meanings: "Modern: heaven, sky
Classical: divine order, natural law", readings: "On: てん (ten)", radicals: "大 → great
一 → one (above)", explain: "Great being under one → highest, above all.", notes: "Often denotes cosmic or universal principle.", compounds: [ "二天一流 → proper noun (school name structure)" ] }, "一": { meanings: "Modern: one
Classical: unity, origin", readings: "On: いち (ichi), いつ (itsu)", radicals: "一 → one", explain: "Single line → unity, beginning.", notes: "Philosophically associated with singularity.", compounds: [ "二天一流 → proper noun (school name structure)" ] }, "流": { meanings: "Modern: flow, style
Classical: school, tradition", readings: "On: りゅう (ryū)", radicals: "氵 → water
㐬 → flow component", explain: "Flowing water → transmission, lineage.", notes: "Used for martial arts schools.", compounds: [ "二天一流 → proper noun (school name structure)" ] }, "号": { meanings: "Modern: number, name
Classical: title, designation", readings: "On: ごう (gō)", radicals: "口 → mouth
丂 → breath/voice", explain: "Voice expressing → naming or designation.", notes: "Often used for pen names or titles.", compounds: [ "号し" ] }, "数": { meanings: "Modern: number, count
Classical: several, many", readings: "On: すう (sū)
Kun: かず (kazu)", radicals: "攵 → action
娄 → cluster", explain: "Repeated action of grouping → counting.", notes: "Can imply approximation in classical text.", compounds: [ "数年" ] }, "年": { meanings: "Modern: year
Classical: time span, cycle", readings: "On: ねん (nen)
Kun: とし (toshi)", radicals: "干 → dry", explain: "Originally tied to harvest cycles → year.", notes: "", compounds: [ "数年" ] }, "鍛": { meanings: "Modern: forge, train
Classical: discipline, temper (skill/body)", readings: "On: たん (tan)", radicals: "金 → metal
段 → step/process", explain: "Working metal step-by-step → refinement through effort.", notes: "Strong association with martial training.", compounds: [ "鍛錬", "鍛錬の事" ] }, "錬": { meanings: "Modern: refine
Classical: practice, polish skill", readings: "On: れん (ren)", radicals: "金 → metal
柬 → refine/select", explain: "Refining metal → honing ability.", notes: "", compounds: [ "鍛錬", "鍛錬の事" ] }, "事": { meanings: "Modern: matter, thing
Classical: affair, undertaking", readings: "On: じ (ji), ず (zu)
Kun: こと (koto)", radicals: "亅 → hook
一 → one", explain: "Structured action → event or matter.", notes: "", compounds: [ "鍛錬の事" ] }, "初": { meanings: "Modern: first, beginning
Classical: initial stage", readings: "On: しょ (sho)
Kun: はじ（め） (hajime)", radicals: "衤 → clothing
刀 → knife", explain: "Cutting cloth → first step of making clothing → beginning.", notes: "", compounds: [ "初て" ] }, "書": { meanings: "Modern: write
Classical: record, document", readings: "On: しょ (sho)
Kun: か（く） (kaku)", radicals: "曰 → say
聿 → writing brush", explain: "Speaking with a brush → writing/recording.", notes: "", compounds: [ "書物", "書き顕はす" ] }, "物": { meanings: "Modern: thing, object
Classical: matter, phenomenon", readings: "On: ぶつ (butsu), もつ (motsu)
Kun: もの (mono)", radicals: "牛 → cow
勿 → do not", explain: "Originally tied to tangible objects → generalized to things.", notes: "", compounds: [ "書物" ] }, "顕": { meanings: "Modern: appear, reveal
Classical: make manifest, clarify", readings: "On: けん (ken)", radicals: "頁 → head
見 → see", explain: "Seeing clearly → making visible or evident.", notes: "", compounds: [ "書き顕はす" ] }, "思": { meanings: "Modern: think
Classical: reflect, intend", readings: "On: し (shi)
Kun: おも（う） (omou)", radicals: "心 → heart
田 → field", explain: "Heart working over a field → contemplation.", notes: "", compounds: [ "思ふ" ] } }; const order = ["兵","法","道","二","天","一","流","号","数","年","鍛","錬","事","初","書","物","顕","思"]; const btnWrap = document.getElementById("kanji134Buttons"); const charEl = document.getElementById("kanji134Char"); const nameEl = document.getElementById("kanji134Name"); const meaningsEl = document.getElementById("kanji134Meanings"); const readingsEl = document.getElementById("kanji134Readings"); const radicalsEl = document.getElementById("kanji134Radicals"); const explainEl = document.getElementById("kanji134Explain"); const notesEl = document.getElementById("kanji134Notes"); const compoundsEl = document.getElementById("kanji134Compounds"); function renderKanji(k){ const d = kanjiData[k]; charEl.textContent = k; nameEl.textContent = k; meaningsEl.innerHTML = d.meanings; readingsEl.innerHTML = d.readings; radicalsEl.innerHTML = d.radicals; explainEl.textContent = d.explain; notesEl.textContent = d.notes || "—"; compoundsEl.innerHTML = d.compounds.map(item => `
${item}
`).join(''); document.querySelectorAll('.kanji134-kanji-btn').forEach(b => { b.classList.toggle('active', b.dataset.k === k); }); } order.forEach((k, i) => { const btn = document.createElement("button"); btn.className = "kanji134-kanji-btn"; btn.dataset.k = k; btn.textContent = k; btn.addEventListener("click", () => renderKanji(k)); btnWrap.appendChild(btn); if(i === 0) renderKanji(k); }); const revealBtn = document.getElementById("kanji134RevealBtn"); const revealBox = document.getElementById("kanji134Reveal"); revealBtn.addEventListener("click", () => { const open = revealBox.style.display === "block"; revealBox.style.display = open ? "none" : "block"; revealBtn.textContent = open ? "Reveal Study Hint" : "Hide Study Hint"; }); })();

EXPERIMENT 135 — KANJI FLASHCARD MODULEPurpose: Turn a sentence-level kanji set into a focused one-card-at-a-time study module
Focus: flashcard-style practice, reveal control, and low-distraction studyThis module is designed to:
- show one kanji at a time
- reduce clutter
- support active recall before reveal
- allow previous / next movement through the sentence kanji setCore interactions:
- Next card
- Previous card
- Reveal meanings
- Reveal readings
- Reveal radicals
- Reveal notes / compoundsThis is a flashcard-style dojo lesson.

KANJI FLASHCARD MODULE
One-card-at-a-time study mode • Book of Five Rings sentence set
PASSAGE SET
兵法の道　二天一流　と号し数年鍛錬の事初て書物に書き顕はさんと思ふ
1 / 18
兵
Recall the meaning, reading, and function before revealing.
JUMP TO KANJI
(function(){ const kanjiData = { "兵": { meanings: "Modern: soldier, military
Classical: warrior, arms, warfare", readings: "On: へい (hei)
Kun: つわもの (tsuwamono)", radicals: "八 → divide
廾 (variant form) → two hands", explain: "Suggests handling or organizing weapons; associated with military action.", notes: "Often appears in martial contexts.", compounds: ["兵法 → conceptual system of warfare","兵法の道 → philosophical path of strategy"] }, "法": { meanings: "Modern: law, method
Classical: principle, rule, doctrine", readings: "On: ほう (hō), はっ (hatsu)", radicals: "氵 → water
去 → go, remove", explain: "Water flowing in a fixed path → order, rule, method.", notes: "Central to philosophical and technical systems.", compounds: ["兵法 → conceptual system of warfare","兵法の道 → philosophical path of strategy"] }, "道": { meanings: "Modern: road, path
Classical: the Way, discipline", readings: "On: どう (dō)
Kun: みち (michi)", radicals: "辶 → movement
首 → head", explain: "Movement guided by the head → a path or guiding way.", notes: "Core concept in martial and philosophical traditions.", compounds: ["兵法の道 → philosophical path of strategy"] }, "二": { meanings: "Modern: two
Classical: duality, pairing", readings: "On: に (ni)", radicals: "二 → two", explain: "Two parallel lines → concept of duality.", notes: "Often symbolic beyond numeric value.", compounds: ["二天一流 → proper noun (school name structure)"] }, "天": { meanings: "Modern: heaven, sky
Classical: divine order, natural law", readings: "On: てん (ten)", radicals: "大 → great
一 → one (above)", explain: "Great being under one → highest, above all.", notes: "Often denotes cosmic or universal principle.", compounds: ["二天一流 → proper noun (school name structure)"] }, "一": { meanings: "Modern: one
Classical: unity, origin", readings: "On: いち (ichi), いつ (itsu)", radicals: "一 → one", explain: "Single line → unity, beginning.", notes: "Philosophically associated with singularity.", compounds: ["二天一流 → proper noun (school name structure)"] }, "流": { meanings: "Modern: flow, style
Classical: school, tradition", readings: "On: りゅう (ryū)", radicals: "氵 → water
㐬 → flow component", explain: "Flowing water → transmission, lineage.", notes: "Used for martial arts schools.", compounds: ["二天一流 → proper noun (school name structure)"] }, "号": { meanings: "Modern: number, name
Classical: title, designation", readings: "On: ごう (gō)", radicals: "口 → mouth
丂 → breath/voice", explain: "Voice expressing → naming or designation.", notes: "Often used for pen names or titles.", compounds: ["号し"] }, "数": { meanings: "Modern: number, count
Classical: several, many", readings: "On: すう (sū)
Kun: かず (kazu)", radicals: "攵 → action
娄 → cluster", explain: "Repeated action of grouping → counting.", notes: "Can imply approximation in classical text.", compounds: ["数年"] }, "年": { meanings: "Modern: year
Classical: time span, cycle", readings: "On: ねん (nen)
Kun: とし (toshi)", radicals: "干 → dry", explain: "Originally tied to harvest cycles → year.", notes: "—", compounds: ["数年"] }, "鍛": { meanings: "Modern: forge, train
Classical: discipline, temper (skill/body)", readings: "On: たん (tan)", radicals: "金 → metal
段 → step/process", explain: "Working metal step-by-step → refinement through effort.", notes: "Strong association with martial training.", compounds: ["鍛錬","鍛錬の事"] }, "錬": { meanings: "Modern: refine
Classical: practice, polish skill", readings: "On: れん (ren)", radicals: "金 → metal
柬 → refine/select", explain: "Refining metal → honing ability.", notes: "—", compounds: ["鍛錬","鍛錬の事"] }, "事": { meanings: "Modern: matter, thing
Classical: affair, undertaking", readings: "On: じ (ji), ず (zu)
Kun: こと (koto)", radicals: "亅 → hook
一 → one", explain: "Structured action → event or matter.", notes: "—", compounds: ["鍛錬の事"] }, "初": { meanings: "Modern: first, beginning
Classical: initial stage", readings: "On: しょ (sho)
Kun: はじ（め） (hajime)", radicals: "衤 → clothing
刀 → knife", explain: "Cutting cloth → first step of making clothing → beginning.", notes: "—", compounds: ["初て"] }, "書": { meanings: "Modern: write
Classical: record, document", readings: "On: しょ (sho)
Kun: か（く） (kaku)", radicals: "曰 → say
聿 → writing brush", explain: "Speaking with a brush → writing/recording.", notes: "—", compounds: ["書物","書き顕はす"] }, "物": { meanings: "Modern: thing, object
Classical: matter, phenomenon", readings: "On: ぶつ (butsu), もつ (motsu)
Kun: もの (mono)", radicals: "牛 → cow
勿 → do not", explain: "Originally tied to tangible objects → generalized to things.", notes: "—", compounds: ["書物"] }, "顕": { meanings: "Modern: appear, reveal
Classical: make manifest, clarify", readings: "On: けん (ken)", radicals: "頁 → head
見 → see", explain: "Seeing clearly → making visible or evident.", notes: "—", compounds: ["書き顕はす"] }, "思": { meanings: "Modern: think
Classical: reflect, intend", readings: "On: し (shi)
Kun: おも（う） (omou)", radicals: "心 → heart
田 → field", explain: "Heart working over a field → contemplation.", notes: "—", compounds: ["思ふ"] } }; const order = ["兵","法","道","二","天","一","流","号","数","年","鍛","錬","事","初","書","物","顕","思"]; let index = 0; const indexEl = document.getElementById("kanji135Index"); const charEl = document.getElementById("kanji135Char"); const meaningsEl = document.getElementById("kanji135Meanings"); const readingsEl = document.getElementById("kanji135Readings"); const radicalsEl = document.getElementById("kanji135Radicals"); const explainEl = document.getElementById("kanji135Explain"); const notesEl = document.getElementById("kanji135Notes"); const compoundsEl = document.getElementById("kanji135Compounds"); const jumpGrid = document.getElementById("kanji135JumpGrid"); const boxes = { meanings: document.getElementById("kanji135-meanings"), readings: document.getElementById("kanji135-readings"), radicals: document.getElementById("kanji135-radicals"), explain: document.getElementById("kanji135-explain"), notes: document.getElementById("kanji135-notes"), compounds: document.getElementById("kanji135-compounds") }; function hideAllBoxes(){ Object.values(boxes).forEach(box => box.style.display = "none"); document.querySelectorAll('.kanji135-toggle').forEach(btn => { const label = btn.dataset.box; btn.textContent = "Reveal " + label.charAt(0).toUpperCase() + label.slice(1); }); } function render(){ const k = order[index]; const d = kanjiData[k]; indexEl.textContent = `${index + 1} / ${order.length}`; charEl.textContent = k; meaningsEl.innerHTML = d.meanings; readingsEl.innerHTML = d.readings; radicalsEl.innerHTML = d.radicals; explainEl.textContent = d.explain; notesEl.textContent = d.notes || "—"; compoundsEl.innerHTML = d.compounds.map(item => `
${item}
`).join(''); document.querySelectorAll('.kanji135-jump-btn').forEach((btn, i) => { btn.classList.toggle('active', i === index); }); hideAllBoxes(); } document.getElementById("kanji135Prev").addEventListener("click", () => { index = (index - 1 + order.length) % order.length; render(); }); document.getElementById("kanji135Next").addEventListener("click", () => { index = (index + 1) % order.length; render(); }); document.querySelectorAll('.kanji135-toggle').forEach(btn => { btn.addEventListener('click', () => { const box = boxes[btn.dataset.box]; const open = box.style.display === "block"; box.style.display = open ? "none" : "block"; const label = btn.dataset.box.charAt(0).toUpperCase() + btn.dataset.box.slice(1); btn.textContent = (open ? "Reveal " : "Hide ") + label; }); }); order.forEach((k, i) => { const btn = document.createElement("button"); btn.className = "kanji135-jump-btn"; btn.textContent = k; btn.addEventListener("click", () => { index = i; render(); }); jumpGrid.appendChild(btn); }); render(); })();

EXPERIMENT 136 — KANJI FLASHCARD (STUDY + TEST MODE)Purpose:
Upgrade the flashcard system to support real recall training.Modes:
- Study Mode → free exploration + reveal
- Test Mode → forced recall + self-evaluationCore Flow (Test Mode):
1. See kanji
2. Recall meaning/readings
3. Reveal answer
4. Mark Correct / Missed
5. Move forwardThis transforms the module from reference → training system.

KANJI TRAINING MODULE
Study Mode • Test Mode • Active Recall
✔ 0 ✖ 0 Total: 0
1 / 18
兵
Recall meaning and readings before revealing.
(function(){ const data = { "兵":{m:"soldier, military",r:"へい",rad:"八 + 廾"}, "法":{m:"law, method",r:"ほう",rad:"氵 + 去"}, "道":{m:"path, the Way",r:"どう",rad:"辶 + 首"}, "二":{m:"two",r:"に",rad:"二"}, "天":{m:"heaven",r:"てん",rad:"大 + 一"}, "一":{m:"one",r:"いち",rad:"一"}, "流":{m:"style, school",r:"りゅう",rad:"氵"}, "号":{m:"name, title",r:"ごう",rad:"口"}, "数":{m:"number",r:"すう",rad:"攵"}, "年":{m:"year",r:"ねん",rad:"干"}, "鍛":{m:"forge",r:"たん",rad:"金"}, "錬":{m:"refine",r:"れん",rad:"金"}, "事":{m:"thing, matter",r:"じ",rad:"亅"}, "初":{m:"beginning",r:"しょ",rad:"刀"}, "書":{m:"write",r:"しょ",rad:"曰"}, "物":{m:"thing",r:"ぶつ",rad:"牛"}, "顕":{m:"reveal",r:"けん",rad:"頁"}, "思":{m:"think",r:"し",rad:"心"} }; const keys = Object.keys(data); let i=0; let mode="study"; let correct=0, missed=0, total=0; function render(){ document.getElementById("kanji").textContent = keys[i]; document.getElementById("index").textContent = (i+1)+" / "+keys.length; document.getElementById("info").style.display="none"; document.getElementById("correctBtn").style.display="none"; document.getElementById("missedBtn").style.display="none"; } function reveal(){ let d = data[keys[i]]; document.getElementById("meanings").textContent=d.m; document.getElementById("readings").textContent=d.r; document.getElementById("radicals").textContent=d.rad; document.getElementById("info").style.display="block"; if(mode==="test"){ document.getElementById("correctBtn").style.display="inline-block"; document.getElementById("missedBtn").style.display="inline-block"; } } function next(){ i=(i+1)%keys.length; render(); } function prev(){ i=(i-1+keys.length)%keys.length; render(); } document.getElementById("next").onclick=next; document.getElementById("prev").onclick=prev; document.getElementById("reveal").onclick=reveal; document.getElementById("modeStudy").onclick=()=>{ mode="study"; document.getElementById("modeStudy").classList.add("active"); document.getElementById("modeTest").classList.remove("active"); }; document.getElementById("modeTest").onclick=()=>{ mode="test"; document.getElementById("modeTest").classList.add("active"); document.getElementById("modeStudy").classList.remove("active"); }; document.getElementById("correctBtn").onclick=()=>{ correct++; total++; updateScore(); next(); }; document.getElementById("missedBtn").onclick=()=>{ missed++; total++; updateScore(); next(); }; function updateScore(){ document.getElementById("correct").textContent=correct; document.getElementById("missed").textContent=missed; document.getElementById("total").textContent=total; } render(); })();

EXPERIMENT 137 — DIAGNOSTIC CARD WIZARDWhat it doesThis turns the flashcard pattern into:
• one question at a time
• one answer at a time
• simple routing
• practical next-step outputSo instead of studying information, you’re diagnosing:
• Is this an alignment problem?
• A clarity problem?
• A fear problem?
• An execution problem?
• A system problem?

DIAGNOSTIC CARD WIZARD
One-question-at-a-time routing for finding the real bottleneck
Step 1
What feels most true right now?
(function(){ const steps = { start: { step: "Step 1", question: "What feels most true right now?", options: [ { label: "I do not feel clear.", next: "clarity1" }, { label: "I know what to do, but I am not doing it.", next: "execution1" }, { label: "I feel resistance, fear, or avoidance.", next: "fear1" }, { label: "The direction itself feels wrong.", next: "alignment1" }, { label: "The system or workflow feels clunky.", next: "system1" } ] }, clarity1: { step: "Step 2", question: "Is the main issue confusion about the concept, structure, or next step?", options: [ { label: "Concept / structure confusion", result: "knowledge" }, { label: "I need more skill, not more explanation", result: "learning" } ] }, execution1: { step: "Step 2", question: "Do you already know the next physical action?", options: [ { label: "Yes, I know the next action", result: "execution" }, { label: "No, the next action is still fuzzy", result: "knowledge" } ] }, fear1: { step: "Step 2", question: "Does the block feel more emotional than logical?", options: [ { label: "Yes, it feels emotional / fear-based", result: "fear" }, { label: "No, it may actually be clarity or skill", result: "learning" } ] }, alignment1: { step: "Step 2", question: "Does it feel like the game, role, or goal itself may be wrong?", options: [ { label: "Yes, the direction feels off", result: "alignment" }, { label: "No, the direction is right but I am underdeveloped", result: "learning" } ] }, system1: { step: "Step 2", question: "Is the friction mostly coming from tool/setup complexity?", options: [ { label: "Yes, the structure is causing drag", result: "system" }, { label: "No, the issue is more personal behavior", result: "execution" } ] } }; const results = { knowledge: { title: "Knowledge / Clarity Route", text: "This is probably a structure or understanding problem. You need mapping, extraction, or a clearer mental model before acting.", actions: [ "Go to the Knowledge System", "Map the concept or source", "Clarify the next actionable unit" ] }, learning: { title: "Learning / Skill Route", text: "This looks like a capability problem. You likely need training, practice, or a better learning loop.", actions: [ "Go to the Learning System", "Use Acquire → Refine → Apply", "Train in the Dojo before pushing execution" ] }, execution: { title: "Execution Route", text: "You likely already know enough. The issue is follow-through, action structure, or friction at the moment of doing.", actions: [ "Go to the Quest / Rep layer", "Define the next rep clearly", "Use timeboxing or procedure support" ] }, fear: { title: "Fear / Resistance Route", text: "This appears to be an emotional interference problem. More force may make it worse if fear is the real bottleneck.", actions: [ "Use the fear-resolution path", "Reduce threat and shrink the next move", "Choose the smallest safe action" ] }, alignment: { title: "Life / Alignment Route", text: "This looks like a path problem, not just a productivity problem. The direction may need correction.", actions: [ "Go to the Life System", "Check values, role, and true aim", "Adjust the game before forcing effort" ] }, system: { title: "System / Design Route", text: "The problem may be architectural. The tool or workflow may be creating unnecessary friction.", actions: [ "Go to the Backend / Builder layer", "Simplify the workflow or interface", "Reduce structure until it supports action cleanly" ] } }; let current = "start"; const stepEl = document.getElementById("diag137Step"); const questionEl = document.getElementById("diag137Question"); const optionsEl = document.getElementById("diag137Options"); const resultWrap = document.getElementById("diag137Result"); const resultTitle = document.getElementById("diag137ResultTitle"); const resultText = document.getElementById("diag137ResultText"); const actionList = document.getElementById("diag137ActionList"); const restartBtn = document.getElementById("diag137Restart"); function renderStep(key){ resultWrap.style.display = "none"; const s = steps[key]; stepEl.textContent = s.step; questionEl.textContent = s.question; optionsEl.innerHTML = ""; s.options.forEach(opt => { const btn = document.createElement("button"); btn.className = "diag137-option"; btn.textContent = opt.label; btn.addEventListener("click", () => { if(opt.next){ current = opt.next; renderStep(current); } else if(opt.result){ renderResult(opt.result); } }); optionsEl.appendChild(btn); }); } function renderResult(key){ const r = results[key]; resultTitle.textContent = r.title; resultText.textContent = r.text; actionList.innerHTML = r.actions.map(a => `
${a}
`).join(""); resultWrap.style.display = "block"; } restartBtn.addEventListener("click", () => { current = "start"; renderStep(current); }); renderStep(current); })();

EXPERIMENT 138 — PROCEDURE CARD TRAINERWhat it doesThis turns the card pattern into:
• one step at a time
• minimal visual overload
• next / previous movement
• focused procedure executionThis is ideal for:
• routines
• workflows
• SOPs
• checklists you actually want to followI’ll make this first version around a generic capture/process workflow so you can see the shell clearly.

PROCEDURE CARD TRAINER
One-step-at-a-time workflow execution
Step 1 / 6
Collect the item
Capture the open loop, note, task, or idea in one place instead of holding it in your head.
JUMP TO STEP
(function(){ const steps = [ { title: "Collect the item", body: "Capture the open loop, note, task, or idea in one place instead of holding it in your head.", extra: "The purpose of this step is to reduce mental load and prevent dropped loops." }, { title: "Clarify what it is", body: "Decide whether the item is actionable, reference material, a future idea, or something to discard.", extra: "This prevents vague piles of stuff from becoming overwhelming." }, { title: "Define the next action", body: "If it is actionable, identify the smallest visible next step you can actually do.", extra: "This is where vague obligation becomes executable movement." }, { title: "Assign the right container", body: "Put it where it belongs: quest, rep, calendar, reference, someday, or archive.", extra: "Good placement reduces later friction and improves retrieval." }, { title: "Add support if needed", body: "Attach notes, procedure, context, or materials if the action requires them.", extra: "This reduces restart friction when you return to the item." }, { title: "Return to action", body: "Exit processing and move back into doing. Do not stay in organizing mode longer than needed.", extra: "The point of the procedure is to support action, not replace it." } ]; let i = 0; const indexEl = document.getElementById("proc138Index"); const titleEl = document.getElementById("proc138Title"); const bodyEl = document.getElementById("proc138Body"); const extraWrap = document.getElementById("proc138Extra"); const extraText = document.getElementById("proc138ExtraText"); const prevBtn = document.getElementById("proc138Prev"); const nextBtn = document.getElementById("proc138Next"); const revealBtn = document.getElementById("proc138Reveal"); const jumpGrid = document.getElementById("proc138JumpGrid"); function render(){ indexEl.textContent = `Step ${i + 1} / ${steps.length}`; titleEl.textContent = steps[i].title; bodyEl.textContent = steps[i].body; extraText.textContent = steps[i].extra; extraWrap.style.display = "none"; revealBtn.textContent = "Reveal Why / Cue"; document.querySelectorAll('.proc138-jump-btn').forEach((btn, idx) => { btn.classList.toggle('active', idx === i); }); } prevBtn.addEventListener("click", () => { i = (i - 1 + steps.length) % steps.length; render(); }); nextBtn.addEventListener("click", () => { i = (i + 1) % steps.length; render(); }); revealBtn.addEventListener("click", () => { const open = extraWrap.style.display === "block"; extraWrap.style.display = open ? "none" : "block"; revealBtn.textContent = open ? "Reveal Why / Cue" : "Hide Why / Cue"; }); steps.forEach((step, idx) => { const btn = document.createElement("button"); btn.className = "proc138-jump-btn"; btn.textContent = `Step ${idx + 1}`; btn.addEventListener("click", () => { i = idx; render(); }); jumpGrid.appendChild(btn); }); render(); })();

EXPERIMENT 136R — KANJI TRAINER REVISIONPurpose:
Upgrade the kanji flashcard trainer into a more usable practice loop.New Features:
- Reset score
- Track missed cards
- Review missed only
- Re-run sessions cleanlyModes:
- Study Mode
- Test Mode
- Missed Review ModeThis version is designed for repeated practice rather than one-off testing.

KANJI TRAINER REVISION
Study • Test • Missed Review
✔ 0 ✖ 0 Total: 0
1 / 18
兵
Recall meaning and readings before revealing.
MISSED CARDS
No missed cards yet.
(function(){ const data = { "兵":{m:"soldier, military",r:"へい",rad:"八 + 廾"}, "法":{m:"law, method",r:"ほう",rad:"氵 + 去"}, "道":{m:"path, the Way",r:"どう",rad:"辶 + 首"}, "二":{m:"two",r:"に",rad:"二"}, "天":{m:"heaven",r:"てん",rad:"大 + 一"}, "一":{m:"one",r:"いち",rad:"一"}, "流":{m:"style, school",r:"りゅう",rad:"氵"}, "号":{m:"name, title",r:"ごう",rad:"口"}, "数":{m:"number",r:"すう",rad:"攵"}, "年":{m:"year",r:"ねん",rad:"干"}, "鍛":{m:"forge",r:"たん",rad:"金"}, "錬":{m:"refine",r:"れん",rad:"金"}, "事":{m:"thing, matter",r:"じ",rad:"亅"}, "初":{m:"beginning",r:"しょ",rad:"刀"}, "書":{m:"write",r:"しょ",rad:"曰"}, "物":{m:"thing",r:"ぶつ",rad:"牛"}, "顕":{m:"reveal",r:"けん",rad:"頁"}, "思":{m:"think",r:"し",rad:"心"} }; const masterKeys = Object.keys(data); let activeKeys = [...masterKeys]; let i = 0; let mode = "study"; let correct = 0, missed = 0, total = 0; let missedSet = []; function currentKey(){ return activeKeys[i]; } function render(){ const key = currentKey(); if(!key){ document.getElementById("kanjiR").textContent = "—"; document.getElementById("indexR").textContent = "0 / 0"; document.getElementById("promptR").textContent = "No cards available in this mode."; document.getElementById("infoR").style.display = "none"; document.getElementById("correctBtnR").style.display = "none"; document.getElementById("missedBtnR").style.display = "none"; return; } document.getElementById("kanjiR").textContent = key; document.getElementById("indexR").textContent = (i+1) + " / " + activeKeys.length; document.getElementById("promptR").textContent = mode === "study" ? "Study freely. Reveal whenever you want." : mode === "test" ? "Recall meaning and readings before revealing." : "Review missed cards only. Try to recover the weak ones."; document.getElementById("infoR").style.display = "none"; document.getElementById("correctBtnR").style.display = "none"; document.getElementById("missedBtnR").style.display = "none"; } function reveal(){ const d = data[currentKey()]; if(!d) return; document.getElementById("meaningsR").textContent = d.m; document.getElementById("readingsR").textContent = d.r; document.getElementById("radicalsR").textContent = d.rad; document.getElementById("infoR").style.display = "block"; if(mode === "test" || mode === "missed"){ document.getElementById("correctBtnR").style.display = "inline-block"; document.getElementById("missedBtnR").style.display = "inline-block"; } } function next(){ if(activeKeys.length === 0) return; i = (i + 1) % activeKeys.length; render(); } function prev(){ if(activeKeys.length === 0) return; i = (i - 1 + activeKeys.length) % activeKeys.length; render(); } function updateScore(){ document.getElementById("correctR").textContent = correct; document.getElementById("missedR").textContent = missed; document.getElementById("totalR").textContent = total; } function updateMissedList(){ const wrap = document.getElementById("missedListR"); if(missedSet.length === 0){ wrap.innerHTML = '
No missed cards yet.
'; return; } wrap.innerHTML = missedSet.map(k => `
${k}
`).join(""); } function setMode(newMode){ mode = newMode; document.getElementById("modeStudyR").classList.toggle("active", mode === "study"); document.getElementById("modeTestR").classList.toggle("active", mode === "test"); document.getElementById("modeMissedR").classList.toggle("active", mode === "missed"); if(mode === "missed"){ activeKeys = [...missedSet]; i = 0; } else { activeKeys = [...masterKeys]; i = 0; } render(); } function resetSession(){ correct = 0; missed = 0; total = 0; missedSet = []; updateScore(); updateMissedList(); setMode("study"); } document.getElementById("nextR").onclick = next; document.getElementById("prevR").onclick = prev; document.getElementById("revealR").onclick = reveal; document.getElementById("modeStudyR").onclick = () => setMode("study"); document.getElementById("modeTestR").onclick = () => setMode("test"); document.getElementById("modeMissedR").onclick = () => setMode("missed"); document.getElementById("correctBtnR").onclick = () => { correct++; total++; updateScore(); if(mode === "missed"){ const k = currentKey(); missedSet = missedSet.filter(x => x !== k); activeKeys = [...missedSet]; if(i >= activeKeys.length) i = 0; updateMissedList(); render(); } else { next(); } }; document.getElementById("missedBtnR").onclick = () => { const k = currentKey(); missed++; total++; if(!missedSet.includes(k)) missedSet.push(k); updateScore(); updateMissedList(); next(); }; document.getElementById("resetR").onclick = resetSession; updateScore(); updateMissedList(); render(); })();

EXPERIMENT 139 — UNIVERSAL LESSON SHELLPurpose:
Create a reusable one-item-at-a-time trainer shell that can load different content types.Core idea:
Same interface, different datasets.Supports:
- Study mode
- Test mode
- Previous / next
- Reveal / hide
- Self-rating
- Reset sessionExample datasets:
- Kanji
- Concepts
- ProceduresThis is the reusable lesson engine that later systems can plug into.

UNIVERSAL LESSON SHELL
Reusable one-item-at-a-time trainer engine
DATASET
MODE
✔ 0 ✖ 0 Total: 0
1 / 3
FRONT
兵
Recall what this means before revealing.
ITEMS
(function(){ const datasets = { kanji: { prompt: "Recall what this means before revealing.", items: [ { front: "兵", back: "soldier, military", extra: [ "Reading: へい", "Radicals: 八 + 廾", "Note: martial context" ] }, { front: "法", back: "law, method", extra: [ "Reading: ほう", "Radicals: 氵 + 去", "Note: principle, doctrine" ] }, { front: "道", back: "path, the Way", extra: [ "Reading: どう / みち", "Radicals: 辶 + 首", "Note: discipline, path" ] } ] }, concepts: { prompt: "Recall the definition or function before revealing.", items: [ { front: "Knowledge Gap", back: "The distance between what is known and what is required for the desired outcome.", extra: [ "Use: diagnose what is missing", "Helps: research, learning, execution" ] }, { front: "Acquire → Refine → Apply", back: "A unified learning loop that turns input into usable capability.", extra: [ "Acquire = intake", "Refine = understanding", "Apply = reality test" ] }, { front: "Next Rep", back: "The smallest visible, actionable unit of progress in the dojo system.", extra: [ "Use: reduce friction", "Belongs to: Quest / Execution layer" ] } ] }, procedures: { prompt: "Recall the purpose of this step before revealing.", items: [ { front: "Capture the item", back: "Get the open loop out of your head and into a trusted place.", extra: [ "Why: reduces mental load", "Context: capture workflow" ] }, { front: "Clarify what it is", back: "Decide whether it is actionable, reference, someday, or trash.", extra: [ "Why: prevents vague piles", "Context: processing workflow" ] }, { front: "Define next action", back: "Turn it into the smallest visible next step.", extra: [ "Why: enables execution", "Context: quest / rep logic" ] } ] } }; let currentSet = "kanji"; let mode = "study"; let index = 0; let correct = 0; let missed = 0; let total = 0; const frontEl = document.getElementById("lesson139Front"); const backWrap = document.getElementById("lesson139Back"); const backMain = document.getElementById("lesson139BackMain"); const extraWrap = document.getElementById("lesson139ExtraWrap"); const indexEl = document.getElementById("lesson139Index"); const promptEl = document.getElementById("lesson139Prompt"); const jumpGrid = document.getElementById("lesson139JumpGrid"); const correctEl = document.getElementById("lesson139Correct"); const missedEl = document.getElementById("lesson139Missed"); const totalEl = document.getElementById("lesson139Total"); const studyBtn = document.getElementById("lesson139Study"); const testBtn = document.getElementById("lesson139Test"); const correctBtn = document.getElementById("lesson139CorrectBtn"); const missedBtn = document.getElementById("lesson139MissedBtn"); function getItems(){ return datasets[currentSet].items; } function currentItem(){ return getItems()[index]; } function updateScore(){ correctEl.textContent = correct; missedEl.textContent = missed; totalEl.textContent = total; } function buildJumpButtons(){ jumpGrid.innerHTML = ""; getItems().forEach((item, i) => { const btn = document.createElement("button"); btn.className = "lesson139-jump-btn"; btn.textContent = item.front; if(i === index) btn.classList.add("active"); btn.addEventListener("click", () => { index = i; render(); }); jumpGrid.appendChild(btn); }); } function render(){ const item = currentItem(); frontEl.textContent = item.front; indexEl.textContent = `${index + 1} / ${getItems().length}`; promptEl.textContent = datasets[currentSet].prompt; backWrap.style.display = "none"; correctBtn.style.display = "none"; missedBtn.style.display = "none"; buildJumpButtons(); } function reveal(){ const item = currentItem(); backMain.textContent = item.back; extraWrap.innerHTML = item.extra.map(x => `
${x}
`).join(""); backWrap.style.display = "block"; if(mode === "test"){ correctBtn.style.display = "inline-block"; missedBtn.style.display = "inline-block"; } } function next(){ index = (index + 1) % getItems().length; render(); } function prev(){ index = (index - 1 + getItems().length) % getItems().length; render(); } function setDataset(name){ currentSet = name; index = 0; document.querySelectorAll('.lesson139-dataset-btn').forEach(btn => { btn.classList.toggle('active', btn.dataset.set === name); }); render(); } function setMode(newMode){ mode = newMode; studyBtn.classList.toggle("active", mode === "study"); testBtn.classList.toggle("active", mode === "test"); render(); } document.getElementById("lesson139Prev").addEventListener("click", prev); document.getElementById("lesson139Next").addEventListener("click", next); document.getElementById("lesson139Reveal").addEventListener("click", reveal); document.getElementById("lesson139Reset").addEventListener("click", () => { correct = 0; missed = 0; total = 0; updateScore(); render(); }); correctBtn.addEventListener("click", () => { correct++; total++; updateScore(); next(); }); missedBtn.addEventListener("click", () => { missed++; total++; updateScore(); next(); }); studyBtn.addEventListener("click", () => setMode("study")); testBtn.addEventListener("click", () => setMode("test")); document.querySelectorAll('.lesson139-dataset-btn').forEach(btn => { btn.addEventListener("click", () => setDataset(btn.dataset.set)); }); updateScore(); render(); })();

EXPERIMENT 140 — SENTENCE NAVIGATION WRAPPER (136R-BASED)Purpose:
Add sentence-level navigation to the 136R kanji trainer.Structure:
- Sentence selector
- Active sentence passage display
- 136R-style kanji trainer underneathThis allows:
- moving sentence by sentence
- keeping the better flashcard shell
- practicing one sentence set at a timeThe goal is:
- immediate usefulness for Book of Five Rings study
- no unnecessary abstraction
- preserve the shell that already feels right

BOOK OF FIVE RINGS — SENTENCE NAVIGATION
136R-based trainer with sentence-level navigation
SENTENCE SELECTOR
ACTIVE SENTENCE
✔ 0 ✖ 0 Total: 0
1 / 18
兵
Recall meaning and readings before revealing.
MISSED CARDS
No missed cards yet.
JUMP TO KANJI
(function(){ const sentenceData = [ { id: "s1", label: "Sentence 1", passage: "兵法の道　二天一流　と号し数年鍛錬の事初て書物に書き顕はさんと思ふ", kanji: { "兵":{m:"soldier, military",r:"へい",rad:"八 + 廾"}, "法":{m:"law, method",r:"ほう",rad:"氵 + 去"}, "道":{m:"path, the Way",r:"どう / みち",rad:"辶 + 首"}, "二":{m:"two",r:"に",rad:"二"}, "天":{m:"heaven",r:"てん",rad:"大 + 一"}, "一":{m:"one",r:"いち",rad:"一"}, "流":{m:"style, school",r:"りゅう",rad:"氵"}, "号":{m:"name, title",r:"ごう",rad:"口"}, "数":{m:"number",r:"すう",rad:"攵"}, "年":{m:"year",r:"ねん",rad:"干"}, "鍛":{m:"forge",r:"たん",rad:"金"}, "錬":{m:"refine",r:"れん",rad:"金"}, "事":{m:"thing, matter",r:"じ / こと",rad:"亅"}, "初":{m:"beginning",r:"しょ / はじめ",rad:"刀"}, "書":{m:"write",r:"しょ / かく",rad:"曰"}, "物":{m:"thing",r:"ぶつ / もの",rad:"牛"}, "顕":{m:"reveal",r:"けん",rad:"頁"}, "思":{m:"think",r:"し / おもう",rad:"心"} }, order: ["兵","法","道","二","天","一","流","号","数","年","鍛","錬","事","初","書","物","顕","思"] }, { id: "s2", label: "Sentence 2", passage: "（Placeholder sentence for future entry）", kanji: { "心":{m:"heart, mind",r:"しん / こころ",rad:"心"}, "見":{m:"see",r:"けん / みる",rad:"見"}, "書":{m:"write",r:"しょ / かく",rad:"曰"} }, order: ["心","見","書"] } ]; let sentenceIndex = 0; let mode = "study"; let cardIndex = 0; let correct = 0; let missed = 0; let total = 0; let missedSet = []; function currentSentence(){ return sentenceData[sentenceIndex]; } function currentOrder(){ return mode === "missed" ? [...missedSet] : currentSentence().order; } function currentKey(){ return currentOrder()[cardIndex]; } function currentCardData(){ return currentSentence().kanji[currentKey()]; } const sentenceButtons = document.getElementById("kanji140SentenceButtons"); const passageEl = document.getElementById("kanji140Passage"); const indexEl = document.getElementById("index140"); const kanjiEl = document.getElementById("kanji140"); const promptEl = document.getElementById("prompt140"); const infoEl = document.getElementById("info140"); const meaningsEl = document.getElementById("meanings140"); const readingsEl = document.getElementById("readings140"); const radicalsEl = document.getElementById("radicals140"); const missedListEl = document.getElementById("missedList140"); const jumpGrid = document.getElementById("jumpGrid140"); const correctEl = document.getElementById("correct140"); const missedEl = document.getElementById("missed140"); const totalEl = document.getElementById("total140"); const modeStudy = document.getElementById("modeStudy140"); const modeTest = document.getElementById("modeTest140"); const modeMissed = document.getElementById("modeMissed140"); const correctBtn = document.getElementById("correctBtn140"); const missedBtn = document.getElementById("missedBtn140"); function updateScore(){ correctEl.textContent = correct; missedEl.textContent = missed; totalEl.textContent = total; } function updateSentenceButtons(){ sentenceButtons.innerHTML = ""; sentenceData.forEach((s, i) => { const btn = document.createElement("button"); btn.className = "kanji140-sentence-btn"; if(i === sentenceIndex) btn.classList.add("active"); btn.textContent = s.label; btn.addEventListener("click", () => { sentenceIndex = i; cardIndex = 0; missedSet = []; render(); }); sentenceButtons.appendChild(btn); }); } function updateMissedList(){ if(missedSet.length === 0){ missedListEl.innerHTML = '
No missed cards yet.
'; return; } missedListEl.innerHTML = missedSet.map(k => `
${k}
`).join(""); } function updateJumpGrid(){ const order = currentOrder(); jumpGrid.innerHTML = ""; order.forEach((k, i) => { const btn = document.createElement("button"); btn.className = "kanji140-jump-btn"; if(i === cardIndex) btn.classList.add("active"); btn.textContent = k; btn.addEventListener("click", () => { cardIndex = i; renderCard(); }); jumpGrid.appendChild(btn); }); } function renderCard(){ const order = currentOrder(); const key = currentKey(); if(!key){ kanjiEl.textContent = "—"; indexEl.textContent = "0 / 0"; promptEl.textContent = "No cards available in this mode for this sentence."; infoEl.style.display = "none"; correctBtn.style.display = "none"; missedBtn.style.display = "none"; updateJumpGrid(); return; } const d = currentCardData(); indexEl.textContent = `${cardIndex + 1} / ${order.length}`; kanjiEl.textContent = key; if(mode === "study"){ promptEl.textContent = "Study freely. Reveal whenever you want."; } else if(mode === "test"){ promptEl.textContent = "Recall meaning and readings before revealing."; } else { promptEl.textContent = "Missed Review mode. Recover the weak cards."; } meaningsEl.textContent = d.m; readingsEl.textContent = d.r; radicalsEl.textContent = d.rad; infoEl.style.display = "none"; correctBtn.style.display = "none"; missedBtn.style.display = "none"; updateJumpGrid(); } function render(){ updateSentenceButtons(); passageEl.textContent = currentSentence().passage; updateMissedList(); renderCard(); } function setMode(modeName){ mode = modeName; cardIndex = 0; modeStudy.classList.toggle("active", mode === "study"); modeTest.classList.toggle("active", mode === "test"); modeMissed.classList.toggle("active", mode === "missed"); renderCard(); } function nextCard(){ const order = currentOrder(); if(order.length === 0) return; cardIndex = (cardIndex + 1) % order.length; renderCard(); } function prevCard(){ const order = currentOrder(); if(order.length === 0) return; cardIndex = (cardIndex - 1 + order.length) % order.length; renderCard(); } document.getElementById("reveal140").addEventListener("click", () => { if(!currentKey()) return; infoEl.style.display = "block"; if(mode === "test" || mode === "missed"){ correctBtn.style.display = "inline-block"; missedBtn.style.display = "inline-block"; } }); document.getElementById("next140").addEventListener("click", nextCard); document.getElementById("prev140").addEventListener("click", prevCard); correctBtn.addEventListener("click", () => { correct++; total++; updateScore(); if(mode === "missed"){ const k = currentKey(); missedSet = missedSet.filter(x => x !== k); if(cardIndex >= currentOrder().length) cardIndex = 0; updateMissedList(); renderCard(); } else { nextCard(); } }); missedBtn.addEventListener("click", () => { const k = currentKey(); missed++; total++; if(!missedSet.includes(k)) missedSet.push(k); updateScore(); updateMissedList(); nextCard(); }); document.getElementById("reset140").addEventListener("click", () => { correct = 0; missed = 0; total = 0; missedSet = []; cardIndex = 0; updateScore(); updateMissedList(); setMode("study"); }); modeStudy.addEventListener("click", () => setMode("study")); modeTest.addEventListener("click", () => setMode("test")); modeMissed.addEventListener("click", () => setMode("missed")); updateScore(); render(); })();

EXPERIMENT 141 — SENTENCE TRAINER UPGRADEWhat this addsThis upgrades the 140/136R flow with:
• Kanji / Compounds toggle
• Local save
• mode
• score
• missed set
• selected sentence
• selected card
• Basic custom entry support
• add a kanji or compound card to the current mode
• saved locally in browserThis is the practical version.

BOOK OF FIVE RINGS — TRAINER UPGRADE
Kanji / Compounds • Local Save • Custom Entry
SENTENCE
ACTIVE PASSAGE
CARD TYPE
MODE
SESSION
✔ 0 ✖ 0 Total: 0
1 / 1
兵
Recall before revealing.
MISSED ITEMS
No missed items yet.
JUMP TO ITEM
ADD CUSTOM ENTRY
(function(){ const STORAGE_KEY = "dojo141_state_v1"; const baseSentences = [ { id: "s1", label: "Sentence 1", passage: "兵法の道　二天一流　と号し数年鍛錬の事初て書物に書き顕はさんと思ふ", kanji: [ {front:"兵", back:"soldier, military", extra:["Reading: へい","Radicals: 八 + 廾"]}, {front:"法", back:"law, method", extra:["Reading: ほう","Radicals: 氵 + 去"]}, {front:"道", back:"path, the Way", extra:["Reading: どう / みち","Radicals: 辶 + 首"]}, {front:"二", back:"two", extra:["Reading: に","Radicals: 二"]}, {front:"天", back:"heaven", extra:["Reading: てん","Radicals: 大 + 一"]}, {front:"一", back:"one", extra:["Reading: いち","Radicals: 一"]}, {front:"流", back:"style, school", extra:["Reading: りゅう","Radicals: 氵"]}, {front:"号", back:"name, title", extra:["Reading: ごう","Radicals: 口"]}, {front:"数", back:"number, several", extra:["Reading: すう","Radicals: 攵"]}, {front:"年", back:"year", extra:["Reading: ねん","Radicals: 干"]}, {front:"鍛", back:"forge, train", extra:["Reading: たん","Radicals: 金"]}, {front:"錬", back:"refine", extra:["Reading: れん","Radicals: 金"]}, {front:"事", back:"matter, thing", extra:["Reading: じ / こと","Radicals: 亅"]}, {front:"初", back:"beginning", extra:["Reading: しょ / はじめ","Radicals: 刀"]}, {front:"書", back:"write", extra:["Reading: しょ / かく","Radicals: 曰"]}, {front:"物", back:"thing", extra:["Reading: ぶつ / もの","Radicals: 牛"]}, {front:"顕", back:"reveal", extra:["Reading: けん","Radicals: 頁"]}, {front:"思", back:"think", extra:["Reading: し / おもう","Radicals: 心"]} ], compounds: [ {front:"兵法", back:"conceptual system of warfare", extra:["Compound","martial strategy term"]}, {front:"兵法の道", back:"the way/path of strategy", extra:["Phrase","philosophical path"]}, {front:"二天一流", back:"Niten Ichi-ryū", extra:["Proper name","school name structure"]}, {front:"鍛錬", back:"training, forging, refinement", extra:["Compound","discipline/polishing"]}, {front:"書物", back:"book, written record", extra:["Compound","written object"]}, {front:"書き顕はす", back:"to write down and make clear", extra:["Compound verb","write + reveal"]}, {front:"思ふ", back:"to think / intend (classical form)", extra:["Verb form","classical spelling"]} ] } ]; let state = { sentenceIndex: 0, cardType: "kanji", mode: "study", cardIndex: 0, correct: 0, missed: 0, total: 0, missedItems: [], customEntries: {} }; function loadState(){ try{ const raw = localStorage.getItem(STORAGE_KEY); if(raw){ state = {...state, ...JSON.parse(raw)}; } }catch(e){} } function saveState(){ localStorage.setItem(STORAGE_KEY, JSON.stringify(state)); } function currentSentence(){ return baseSentences[state.sentenceIndex]; } function currentItemsBase(){ const s = currentSentence(); const customKey = `${s.id}_${state.cardType}`; const custom = state.customEntries[customKey] || []; return [...s[state.cardType], ...custom]; } function currentItems(){ if(state.mode === "missed"){ const missedSet = new Set(state.missedItems); return currentItemsBase().filter(item => missedSet.has(item.front)); } return currentItemsBase(); } function currentItem(){ return currentItems()[state.cardIndex]; } const sentenceButtons = document.getElementById("dojo141SentenceButtons"); const passageEl = document.getElementById("dojo141Passage"); const indexEl = document.getElementById("dojo141Index"); const frontEl = document.getElementById("dojo141Front"); const promptEl = document.getElementById("dojo141Prompt"); const infoEl = document.getElementById("dojo141Info"); const backMainEl = document.getElementById("dojo141BackMain"); const backListEl = document.getElementById("dojo141BackList"); const missedListEl = document.getElementById("dojo141MissedList"); const jumpGrid = document.getElementById("dojo141JumpGrid"); const typeKanjiBtn = document.getElementById("dojo141TypeKanji"); const typeCompoundsBtn = document.getElementById("dojo141TypeCompounds"); const modeStudyBtn = document.getElementById("dojo141ModeStudy"); const modeTestBtn = document.getElementById("dojo141ModeTest"); const modeMissedBtn = document.getElementById("dojo141ModeMissed"); const correctEl = document.getElementById("dojo141Correct"); const missedEl = document.getElementById("dojo141Missed"); const totalEl = document.getElementById("dojo141Total"); const correctBtn = document.getElementById("dojo141CorrectBtn"); const missedBtn = document.getElementById("dojo141MissedBtn"); function setActive(btn, active){ btn.classList.toggle("active", active); } function updateScore(){ correctEl.textContent = state.correct; missedEl.textContent = state.missed; totalEl.textContent = state.total; } function updateSentenceButtons(){ sentenceButtons.innerHTML = ""; baseSentences.forEach((s, i) => { const btn = document.createElement("button"); btn.textContent = s.label; if(i === state.sentenceIndex) btn.classList.add("active"); btn.addEventListener("click", () => { state.sentenceIndex = i; state.cardIndex = 0; state.missedItems = []; saveState(); render(); }); sentenceButtons.appendChild(btn); }); } function updateMissedList(){ if(state.missedItems.length === 0){ missedListEl.innerHTML = '
No missed items yet.
'; return; } missedListEl.innerHTML = state.missedItems.map(item => `
${item}
`).join(""); } function updateJumpGrid(){ const items = currentItems(); jumpGrid.innerHTML = ""; items.forEach((item, i) => { const btn = document.createElement("button"); btn.className = i === state.cardIndex ? "active" : ""; btn.textContent = item.front; btn.addEventListener("click", () => { state.cardIndex = i; saveState(); renderCard(); }); jumpGrid.appendChild(btn); }); } function renderCard(){ const items = currentItems(); const item = currentItem(); if(!item){ indexEl.textContent = "0 / 0"; frontEl.textContent = "—"; promptEl.textContent = "No items available in this mode."; infoEl.style.display = "none"; correctBtn.style.display = "none"; missedBtn.style.display = "none"; updateJumpGrid(); return; } indexEl.textContent = `${state.cardIndex + 1} / ${items.length}`; frontEl.textContent = item.front; promptEl.textContent = state.mode === "study" ? "Study freely. Reveal when ready." : state.mode === "test" ? "Recall before revealing." : "Missed review mode. Recover weak items."; infoEl.style.display = "none"; correctBtn.style.display = "none"; missedBtn.style.display = "none"; backMainEl.textContent = item.back; backListEl.innerHTML = item.extra.map(x => `
${x}
`).join(""); updateJumpGrid(); saveState(); } function render(){ passageEl.textContent = currentSentence().passage; updateSentenceButtons(); setActive(typeKanjiBtn, state.cardType === "kanji"); setActive(typeCompoundsBtn, state.cardType === "compounds"); setActive(modeStudyBtn, state.mode === "study"); setActive(modeTestBtn, state.mode === "test"); setActive(modeMissedBtn, state.mode === "missed"); updateScore(); updateMissedList(); renderCard(); } function setCardType(type){ state.cardType = type; state.cardIndex = 0; saveState(); render(); } function setMode(mode){ state.mode = mode; state.cardIndex = 0; saveState(); render(); } document.getElementById("dojo141Reveal").addEventListener("click", () => { if(!currentItem()) return; infoEl.style.display = "block"; if(state.mode === "test" || state.mode === "missed"){ correctBtn.style.display = "inline-block"; missedBtn.style.display = "inline-block"; } }); document.getElementById("dojo141Prev").addEventListener("click", () => { const items = currentItems(); if(items.length === 0) return; state.cardIndex = (state.cardIndex - 1 + items.length) % items.length; renderCard(); }); document.getElementById("dojo141Next").addEventListener("click", () => { const items = currentItems(); if(items.length === 0) return; state.cardIndex = (state.cardIndex + 1) % items.length; renderCard(); }); correctBtn.addEventListener("click", () => { state.correct++; state.total++; if(state.mode === "missed"){ const f = currentItem().front; state.missedItems = state.missedItems.filter(x => x !== f); if(state.cardIndex >= currentItems().length - 1) state.cardIndex = 0; } else { const items = currentItems(); state.cardIndex = (state.cardIndex + 1) % items.length; } saveState(); render(); }); missedBtn.addEventListener("click", () => { const f = currentItem().front; state.missed++; state.total++; if(!state.missedItems.includes(f)) state.missedItems.push(f); const items = currentItems(); state.cardIndex = (state.cardIndex + 1) % items.length; saveState(); render(); }); document.getElementById("dojo141Reset").addEventListener("click", () => { state.correct = 0; state.missed = 0; state.total = 0; state.missedItems = []; state.cardIndex = 0; state.mode = "study"; saveState(); render(); }); typeKanjiBtn.addEventListener("click", () => setCardType("kanji")); typeCompoundsBtn.addEventListener("click", () => setCardType("compounds")); modeStudyBtn.addEventListener("click", () => setMode("study")); modeTestBtn.addEventListener("click", () => setMode("test")); modeMissedBtn.addEventListener("click", () => setMode("missed")); document.getElementById("dojo141AddEntry").addEventListener("click", () => { const front = document.getElementById("dojo141CustomFront").value.trim(); const back = document.getElementById("dojo141CustomBack").value.trim(); const extra1 = document.getElementById("dojo141CustomExtra1").value.trim(); const extra2 = document.getElementById("dojo141CustomExtra2").value.trim(); if(!front || !back) return; const key = `${currentSentence().id}_${state.cardType}`; if(!state.customEntries[key]) state.customEntries[key] = []; state.customEntries[key].push({ front, back, extra: [extra1, extra2].filter(Boolean) }); document.getElementById("dojo141CustomFront").value = ""; document.getElementById("dojo141CustomBack").value = ""; document.getElementById("dojo141CustomEx

EXPERIMENT 142 — SENTENCE OBSERVATORYWhat this isThis is the creative version.Instead of studying the sentence only as a flashcard deck, this presents it as a layered observatory:
• sentence in the center
• orbit buttons around it
• click a layer to inspect:
• kanji
• compounds
• structure
• notes
• interpretation
• applicationThis is the imaginative version.

SENTENCE OBSERVATORY
Layered sentence exploration for Book of Five Rings
ACTIVE SENTENCE
兵法の道
二天一流
と号し数年鍛錬の事初て書物に書き顕はさんと思ふ
KANJI LAYER
(function(){ const layers = { kanji: { label: "KANJI LAYER", items: [ "兵 • 法 • 道 • 二 • 天 • 一 • 流 • 号 • 数 • 年 • 鍛 • 錬 • 事 • 初 • 書 • 物 • 顕 • 思", "Use this layer to inspect individual character meanings and readings." ] }, compounds: { label: "COMPOUNDS LAYER", items: [ "兵法", "兵法の道", "二天一流", "数年", "鍛錬", "鍛錬の事", "書物", "書き顕はす", "思ふ" ] }, structure: { label: "STRUCTURE LAYER", items: [ "兵法の道 = the way/path of strategy", "二天一流 = school name/proper noun", "と号し = called / designated as", "数年鍛錬の事 = matter of several years of training", "初て書物に書き顕はさんと思ふ = I think to make it manifest in writing for the first time" ] }, notes: { label: "NOTES LAYER", items: [ "The final English rendering is still in progress.", "This sentence combines naming, training duration, and intention to write/reveal.", "Good candidate for phrase-level and structure-level study." ] }, interpretation: { label: "INTERPRETATION LAYER", items: [ "Musashi identifies the path of strategy with his school name.", "He refers to years of training as the basis for what he now intends to write down.", "The sentence frames writing as an act of making the training path visible." ] }, application: { label: "APPLICATION LAYER", items: [ "Use as a model for sentence-by-sentence layered study.", "Use compounds to bridge isolated kanji and actual meaning.", "Use this sentence to practice moving between literal, structural, and interpretive understanding." ] } }; const labelEl = document.getElementById("obs142PanelLabel"); const contentEl = document.getElementById("obs142Content"); const buttons = document.querySelectorAll(".obs142-orbit"); function render(key){ const d = layers[key]; labelEl.textContent = d.label; contentEl.innerHTML = d.items.map(i => `
${i}
`).join(""); buttons.forEach(btn => btn.classList.toggle("active", btn.dataset.layer === key)); } buttons.forEach(btn => { btn.addEventListener("click", () => render(btn.dataset.layer)); }); render("kanji"); })();

EXPERIMENT 143 — SENTENCE WORKBENCHPurpose:
Turn a Book of Five Rings sentence into a small interactive parsing game.Core loop:
- inspect sentence
- drag chunks
- sort into meaning zones
- check result
- refine understandingThis is not a flashcard.
It is a sentence assembly workbench.Target sentence:
兵法の道
二天一流
と号し数年鍛錬の事初て書物に書き顕はさんと思ふ

SENTENCE WORKBENCH
Interactive sentence parsing game • Book of Five Rings
TARGET SENTENCE
兵法の道
二天一流
と号し数年鍛錬の事初て書物に書き顕はさんと思ふ
SESSION
Score: 0
Checks: 0
Placed: 0 / 5
CHUNK TRAY
兵法の道
二天一流
と号し
数年鍛錬の事
初て書物に書き顕はさんと思ふ
TOOLS
NAME / TITLE
TRAINING / DURATION
WRITING / INTENTION
FEEDBACK
Drag the sentence chunks into the meaning zones, then check your work.
NOTES
This prototype is intentionally chunk-based, not grammar-complete. The goal is to create a game-like parsing surface that can later become more precise with additional zones, compound layers, and structure inspection.
(function(){ const correctMap = { c1: "title", c2: "title", c3: "title", c4: "training", c5: "writing" }; const scoreEl = document.getElementById("work143Score"); const checksEl = document.getElementById("work143Checks"); const placedEl = document.getElementById("work143Placed"); const feedbackEl = document.getElementById("work143Feedback"); const hintBox = document.getElementById("work143HintBox"); const tray = document.getElementById("work143Tray"); const zones = Array.from(document.querySelectorAll(".work143-zone")); let dragged = null; let score = 0; let checks = 0; function updatePlaced(){ const placed = document.querySelectorAll(".work143-zone .work143-chip").length; placedEl.textContent = placed; } function bindChip(chip){ chip.addEventListener("dragstart", () => { dragged = chip; chip.classList.add("dragging"); }); chip.addEventListener("dragend", () => { chip.classList.remove("dragging"); dragged = null; }); } document.querySelectorAll(".work143-chip").forEach(bindChip); zones.forEach(zone => { zone.addEventListener("dragover", e => { e.preventDefault(); zone.classList.add("over"); }); zone.addEventListener("dragleave", () => { zone.classList.remove("over"); }); zone.addEventListener("drop", e => { e.preventDefault(); zone.classList.remove("over"); if(dragged){ zone.appendChild(dragged); updatePlaced(); } }); }); tray.addEventListener("dragover", e => e.preventDefault()); tray.addEventListener("drop", e => { e.preventDefault(); if(dragged){ tray.appendChild(dragged); updatePlaced(); } }); function clearZoneStates(){ zones.forEach(z => z.classList.remove("work143-correct","work143-wrong")); } document.getElementById("work143Check").addEventListener("click", () => { checks++; checksEl.textContent = checks; clearZoneStates(); let correct = 0; let totalPlaced = 0; zones.forEach(zone => { const zoneName = zone.dataset.zone; const chips = Array.from(zone.querySelectorAll(".work143-chip")); let zoneGood = true; chips.forEach(chip => { totalPlaced++; const id = chip.dataset.id; if(correctMap[id] === zoneName){ correct++; } else { zoneGood = false; } }); if(chips.length > 0){ zone.classList.add(zoneGood ? "work143-correct" : "work143-wrong"); } }); score = correct; scoreEl.textContent = score; if(totalPlaced === 0){ feedbackEl.textContent = "Nothing has been placed yet. Drag chunks into the zones first."; return; } if(correct === 5){ feedbackEl.innerHTML = "Excellent. You sorted all chunks into the intended meaning zones. The sentence now reads as:

Title / naming → 兵法の道 / 二天一流 / と号し
Training / duration → 数年鍛錬の事
Writing / intention → 初て書物に書き顕はさんと思ふ"; } else { feedbackEl.innerHTML = `You have ${correct} / 5 chunks in their intended zones. The broad logic is:

Title: 兵法の道 / 二天一流 / と号し
Training: 数年鍛錬の事
Writing: 初て書物に書き顕はさんと思ふ`; } }); document.getElementById("work143Hint").addEventListener("click", () => { const open = hintBox.style.display === "block"; hintBox.style.display = open ? "none" : "block"; }); document.getElementById("work143Reset").addEventListener("click", () => { clearZoneStates(); Array.from(document.querySelectorAll(".work143-zone .work143-chip")).forEach(chip => tray.appendChild(chip)); feedbackEl.textContent = "Drag the sentence chunks into the meaning zones, then check your work."; updatePlaced(); }); updatePlaced(); })();

FORGE 2
This is a second page dedicated to curate my favorite experiments from FORGE 1.

EXPERIMENT 135

KANJI FLASHCARD MODULE
One-card-at-a-time study mode • Book of Five Rings sentence set
PASSAGE SET
兵法の道　二天一流　と号し数年鍛錬の事初て書物に書き顕はさんと思ふ
1 / 18
兵
Recall the meaning, reading, and function before revealing.
JUMP TO KANJI
(function(){ const kanjiData = { "兵": { meanings: "Modern: soldier, military
Classical: warrior, arms, warfare", readings: "On: へい (hei)
Kun: つわもの (tsuwamono)", radicals: "八 → divide
廾 (variant form) → two hands", explain: "Suggests handling or organizing weapons; associated with military action.", notes: "Often appears in martial contexts.", compounds: ["兵法 → conceptual system of warfare","兵法の道 → philosophical path of strategy"] }, "法": { meanings: "Modern: law, method
Classical: principle, rule, doctrine", readings: "On: ほう (hō), はっ (hatsu)", radicals: "氵 → water
去 → go, remove", explain: "Water flowing in a fixed path → order, rule, method.", notes: "Central to philosophical and technical systems.", compounds: ["兵法 → conceptual system of warfare","兵法の道 → philosophical path of strategy"] }, "道": { meanings: "Modern: road, path
Classical: the Way, discipline", readings: "On: どう (dō)
Kun: みち (michi)", radicals: "辶 → movement
首 → head", explain: "Movement guided by the head → a path or guiding way.", notes: "Core concept in martial and philosophical traditions.", compounds: ["兵法の道 → philosophical path of strategy"] }, "二": { meanings: "Modern: two
Classical: duality, pairing", readings: "On: に (ni)", radicals: "二 → two", explain: "Two parallel lines → concept of duality.", notes: "Often symbolic beyond numeric value.", compounds: ["二天一流 → proper noun (school name structure)"] }, "天": { meanings: "Modern: heaven, sky
Classical: divine order, natural law", readings: "On: てん (ten)", radicals: "大 → great
一 → one (above)", explain: "Great being under one → highest, above all.", notes: "Often denotes cosmic or universal principle.", compounds: ["二天一流 → proper noun (school name structure)"] }, "一": { meanings: "Modern: one
Classical: unity, origin", readings: "On: いち (ichi), いつ (itsu)", radicals: "一 → one", explain: "Single line → unity, beginning.", notes: "Philosophically associated with singularity.", compounds: ["二天一流 → proper noun (school name structure)"] }, "流": { meanings: "Modern: flow, style
Classical: school, tradition", readings: "On: りゅう (ryū)", radicals: "氵 → water
㐬 → flow component", explain: "Flowing water → transmission, lineage.", notes: "Used for martial arts schools.", compounds: ["二天一流 → proper noun (school name structure)"] }, "号": { meanings: "Modern: number, name
Classical: title, designation", readings: "On: ごう (gō)", radicals: "口 → mouth
丂 → breath/voice", explain: "Voice expressing → naming or designation.", notes: "Often used for pen names or titles.", compounds: ["号し"] }, "数": { meanings: "Modern: number, count
Classical: several, many", readings: "On: すう (sū)
Kun: かず (kazu)", radicals: "攵 → action
娄 → cluster", explain: "Repeated action of grouping → counting.", notes: "Can imply approximation in classical text.", compounds: ["数年"] }, "年": { meanings: "Modern: year
Classical: time span, cycle", readings: "On: ねん (nen)
Kun: とし (toshi)", radicals: "干 → dry", explain: "Originally tied to harvest cycles → year.", notes: "—", compounds: ["数年"] }, "鍛": { meanings: "Modern: forge, train
Classical: discipline, temper (skill/body)", readings: "On: たん (tan)", radicals: "金 → metal
段 → step/process", explain: "Working metal step-by-step → refinement through effort.", notes: "Strong association with martial training.", compounds: ["鍛錬","鍛錬の事"] }, "錬": { meanings: "Modern: refine
Classical: practice, polish skill", readings: "On: れん (ren)", radicals: "金 → metal
柬 → refine/select", explain: "Refining metal → honing ability.", notes: "—", compounds: ["鍛錬","鍛錬の事"] }, "事": { meanings: "Modern: matter, thing
Classical: affair, undertaking", readings: "On: じ (ji), ず (zu)
Kun: こと (koto)", radicals: "亅 → hook
一 → one", explain: "Structured action → event or matter.", notes: "—", compounds: ["鍛錬の事"] }, "初": { meanings: "Modern: first, beginning
Classical: initial stage", readings: "On: しょ (sho)
Kun: はじ（め） (hajime)", radicals: "衤 → clothing
刀 → knife", explain: "Cutting cloth → first step of making clothing → beginning.", notes: "—", compounds: ["初て"] }, "書": { meanings: "Modern: write
Classical: record, document", readings: "On: しょ (sho)
Kun: か（く） (kaku)", radicals: "曰 → say
聿 → writing brush", explain: "Speaking with a brush → writing/recording.", notes: "—", compounds: ["書物","書き顕はす"] }, "物": { meanings: "Modern: thing, object
Classical: matter, phenomenon", readings: "On: ぶつ (butsu), もつ (motsu)
Kun: もの (mono)", radicals: "牛 → cow
勿 → do not", explain: "Originally tied to tangible objects → generalized to things.", notes: "—", compounds: ["書物"] }, "顕": { meanings: "Modern: appear, reveal
Classical: make manifest, clarify", readings: "On: けん (ken)", radicals: "頁 → head
見 → see", explain: "Seeing clearly → making visible or evident.", notes: "—", compounds: ["書き顕はす"] }, "思": { meanings: "Modern: think
Classical: reflect, intend", readings: "On: し (shi)
Kun: おも（う） (omou)", radicals: "心 → heart
田 → field", explain: "Heart working over a field → contemplation.", notes: "—", compounds: ["思ふ"] } }; const order = ["兵","法","道","二","天","一","流","号","数","年","鍛","錬","事","初","書","物","顕","思"]; let index = 0; const indexEl = document.getElementById("kanji135Index"); const charEl = document.getElementById("kanji135Char"); const meaningsEl = document.getElementById("kanji135Meanings"); const readingsEl = document.getElementById("kanji135Readings"); const radicalsEl = document.getElementById("kanji135Radicals"); const explainEl = document.getElementById("kanji135Explain"); const notesEl = document.getElementById("kanji135Notes"); const compoundsEl = document.getElementById("kanji135Compounds"); const jumpGrid = document.getElementById("kanji135JumpGrid"); const boxes = { meanings: document.getElementById("kanji135-meanings"), readings: document.getElementById("kanji135-readings"), radicals: document.getElementById("kanji135-radicals"), explain: document.getElementById("kanji135-explain"), notes: document.getElementById("kanji135-notes"), compounds: document.getElementById("kanji135-compounds") }; function hideAllBoxes(){ Object.values(boxes).forEach(box => box.style.display = "none"); document.querySelectorAll('.kanji135-toggle').forEach(btn => { const label = btn.dataset.box; btn.textContent = "Reveal " + label.charAt(0).toUpperCase() + label.slice(1); }); } function render(){ const k = order[index]; const d = kanjiData[k]; indexEl.textContent = `${index + 1} / ${order.length}`; charEl.textContent = k; meaningsEl.innerHTML = d.meanings; readingsEl.innerHTML = d.readings; radicalsEl.innerHTML = d.radicals; explainEl.textContent = d.explain; notesEl.textContent = d.notes || "—"; compoundsEl.innerHTML = d.compounds.map(item => `
${item}
`).join(''); document.querySelectorAll('.kanji135-jump-btn').forEach((btn, i) => { btn.classList.toggle('active', i === index); }); hideAllBoxes(); } document.getElementById("kanji135Prev").addEventListener("click", () => { index = (index - 1 + order.length) % order.length; render(); }); document.getElementById("kanji135Next").addEventListener("click", () => { index = (index + 1) % order.length; render(); }); document.querySelectorAll('.kanji135-toggle').forEach(btn => { btn.addEventListener('click', () => { const box = boxes[btn.dataset.box]; const open = box.style.display === "block"; box.style.display = open ? "none" : "block"; const label = btn.dataset.box.charAt(0).toUpperCase() + btn.dataset.box.slice(1); btn.textContent = (open ? "Reveal " : "Hide ") + label; }); }); order.forEach((k, i) => { const btn = document.createElement("button"); btn.className = "kanji135-jump-btn"; btn.textContent = k; btn.addEventListener("click", () => { index = i; render(); }); jumpGrid.appendChild(btn); }); render(); })();

EXPERIMENT 135c