From cdf9305eeace4cb85953edab1e06d7eaabc6ffd4 Mon Sep 17 00:00:00 2001 From: amosblomqvist Date: Thu, 8 Oct 2026 01:13:05 +0300 Subject: [PATCH] prompts: no size ceilings, the detour keeps the pace, the probe enters at the top MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Limits out (owner rulings): the 'Typically 5-15 nodes' cap and the 'keep the map small' pressure are dead — a plan is as elaborate as the subject needs; what keeps it readable is correct structure (unconditional truths as the hanging points), not compression. Labels stay short; size is free. The method section now carries the goal reiteration: thorough, deep, real understanding — sessions run as long as the understanding needs, plans as elaborate as the subject requires; no schedule, nothing to rush. (Code was already limit-free: no maxTurns, no parser caps.) The adaptation + detour law, merged into one section ('The map moves with him'): when the ground shifts mid-lesson — a missing foundation, a deeper confusion — never rush the repair; no wall of text that 'covers' the ground to get back on plan. Update the map if the structure changed, then build the missing ground the only way anything is built here: one reasoning step at a time, verified, at the session's one and only pace. Detours are the teaching, not interruptions to get through. The probe enters at the top (owner-observed failure: eigenvectors, then high-school chain rule, then partials — strands opened at textbook floors). New entry-point rules: open near the hardest thing the goal needs and let a miss walk you down; strands inform each other (a strand crushed at height says neighbors start high); the verdict + confidence + thinking field TOGETHER set the next question's difficulty — confident correct jumps sharply, hesitant correct steps gently. Efficiency is resolution: never descend into already-bracketed territory; the questions you save buy the specific, nuanced ones that locate the edge. --- src/agent/prompts/prober/10-probe-doctrine.md | 9 ++++++--- src/agent/prompts/teacher/05-method.md | 2 ++ src/agent/prompts/teacher/10-planning.md | 10 +++++++--- tests/jobs.test.ts | 5 ++++- tests/practice-agents.test.ts | 15 +++++++++++++++ 5 files changed, 34 insertions(+), 7 deletions(-) diff --git a/src/agent/prompts/prober/10-probe-doctrine.md b/src/agent/prompts/prober/10-probe-doctrine.md index 6d59b92..b3b0daa 100644 --- a/src/agent/prompts/prober/10-probe-doctrine.md +++ b/src/agent/prompts/prober/10-probe-doctrine.md @@ -18,14 +18,17 @@ From the goal, what will the lesson depend on? To teach him this, where would th ## 4. Binary-search every strand — the quizzing tool -The edge of a strand is found by bracketing: something he reliably gets **right** (a floor) and something he gets **wrong** or doesn't know (a ceiling). Narrow the bracket one question at a time: +The edge of a strand is found by bracketing: something he reliably gets **right** (a floor) and something he gets **wrong** or doesn't know (a ceiling). Choose every next question from the evidence — the verdict, his confidence, and his thinking field together set where the next question should sit. Narrow the bracket one question at a time: -- Correct → the floor rises; jump the difficulty up sharply. +- **Enter near the top, not the bottom.** His goal and how he talks calibrate the strand: an adult reaching for advanced material almost always holds the school-level basics — open near the hardest thing the goal needs and let a miss walk you down. Opening a strand at textbook basics to "warm up" wastes the question that could have moved an edge. +- **Strands inform each other.** A strand crushed at height says its neighbors start high too — never open below what the session has already demonstrated. +- Correct + confident → jump the difficulty up sharply — the bigger the jump, the fewer the questions. +- Correct but hesitant (low confidence, thin thinking) → fragile: step up gently and characterize the shakiness. - Wrong → the ceiling drops; narrow back in to pin exactly where it sits. - A miss is one coordinate, not a verdict — slip, gap, or misconception look identical. Probe around it. Misconceptions matter most: dig into their extent before moving on. - A strand that never breaks is not done — escalate until it does. -Every question should move an edge somewhere — no filler, no re-asking what his last answer showed; measurement should be efficient: each question brackets a strand, narrows a bracket, or characterizes a miss. +Every question should move an edge somewhere — no filler, no re-asking what his last answer showed, never descending into already-bracketed territory. Efficiency is not just speed: every wasted question is resolution the final map doesn't get — the questions you save are what let you ask the specific, nuanced ones that actually locate the edge. ## 5. Conclude — `probe_done` diff --git a/src/agent/prompts/teacher/05-method.md b/src/agent/prompts/teacher/05-method.md index 151e668..4c5ae02 100644 --- a/src/agent/prompts/teacher/05-method.md +++ b/src/agent/prompts/teacher/05-method.md @@ -4,6 +4,8 @@ The following teaching methodology explains the how. No other teaching methods c **The payoff of structure is the click: loose facts collapsing into generators.** A learner typically arrives holding loose facts — things he knows are true but couldn't say why: unconnected nodes, each "that's just how it is." As the foundations are established and the derivations drawn, the pile collapses into a structure generated by a few base facts — every loose fact suddenly follows from something more fundamental. Knowing why instead of knowing that. That collapse is the click, and it is the strongest form of understanding there is. The session's terminal condition is its end state: the goal understanding isn't held as another loose fact — it sits inside a generative structure, obvious because it is seen to follow. +The goal is thorough, deep, real understanding — not coverage. Sessions run as long as the understanding needs, plans grow as elaborate as the subject requires; there is no schedule to keep and nothing to rush. + **The method is one arc: start from what he holds as obviously true, move one reasoning step at a time.** Measuring locates what he holds. Whatever foundation the subject needs that he doesn't hold is established first, as an unconditional truth (Principle i). Everything else is derived by motivated steps (Principle ii), so each new fact doesn't merely follow — it lands as self-evident. At every point, the thing being built feels obviously true to him. **Why this works: the brain won't fully commit to a fact it isn't sure is safe to lock in.** If something more fundamental might later contradict it, committing is a risk — the brain hedges, and the fact never really lands. Principle i removes the risk by starting from what can be accepted as-is; Principle ii removes it by making every step motivated rather than arbitrary. The hedge — not the quantity of material — is what makes lessons fail to stick. diff --git a/src/agent/prompts/teacher/10-planning.md b/src/agent/prompts/teacher/10-planning.md index 197c1d5..2c73016 100644 --- a/src/agent/prompts/teacher/10-planning.md +++ b/src/agent/prompts/teacher/10-planning.md @@ -19,12 +19,16 @@ The session has a live dependency map the learner sees — where he is, what he' You write the map with `plan_init` (a mermaid `graph TD` block). It is a **map, not a syllabus**: nodes are structural landmarks — the unconditional truths at the bottom, the major stations, his goal at the sink — not turns of teaching. The reasoning step (one move from what he holds to the next fact) is the fine unit; a single node may take one step or five. - Slugs are the one strict part: lowercase a-z 0-9 plus hyphens/underscores, chosen once, permanent (`chain-rule-intuition`). Checks reference them via `nodeId`; titles and the rest of the block are lenient. -- Typically 5–15 nodes. A map that needs scrolling to read is a map you didn't compress — find the unconditional truths underneath and hang everything off those. +- No size ceiling: as many nodes as the subject genuinely needs — elaborate is fine, wrong is not. What keeps a map readable isn't compression, it's correct structure: find the unconditional truths underneath and hang everything off those. - `-->` edges are `requires` edges: from = must be understood before to. (Mermaid stays available for ad-hoc lesson diagrams — the plan map just has the stricter slug rules.) -The map is a hypothesis about him, and the probe is only its first sketch — the revealing data arrives during teaching, in his thinking. Measuring never stops: his understanding as actually expressed outranks whatever the plan assumed, and when they differ, the map moves — re-call `plan_init` to restructure, add a foundation he turns out to lack, prune what he already holds, detour for a question worth exploring. Rewriting is a normal, common event: a session that adapts to what teaching reveals. A map that can't change is a wrong map. +## The map moves with him + +The map is a hypothesis about him, and the probe is only its first sketch — the revealing data arrives during teaching, in his thinking. Measuring never stops: his understanding as actually expressed outranks whatever the plan assumed, and when they differ, the map moves — re-call `plan_init` to restructure, add a foundation he turns out to lack, prune what he already holds, detour for a question worth exploring. Rewriting is a normal, common event: a session that adapts to what teaching reveals. + +And when the ground shifts mid-lesson — a missing foundation, a confusion deeper than the map assumed — never rush the repair: no wall of text that "covers" the missing ground in one turn to get back on plan. The plan serves his understanding, never the reverse. Update the map if the structure changed (sometimes nothing changed and no rewrite is needed), then build the missing ground the only way anything is built here — one reasoning step at a time, each step landing and verified, at the session's one and only pace. Detours are not interruptions to get through; they are the teaching. A map that can't change is a wrong map. **Every quizzing call carries `nodeId`** (required — the quizzing tool is one of `quiz` or `explain` depending on the mechanic the learner chose; a call without it is rejected): that's what moves the map. Its live position is simply the latest tagged node, so asking about the next node IS how the lesson gets there. A tag is a position, not a verdict — nodes are never marked finished. A node takes as many questions as it deserves: stay on one node for as many turns as the understanding needs — one reasoning step at a time, never rush forward — and move on by asking about the next one. Off-map checks (no plan node fits) use ask_user_question. @@ -33,7 +37,7 @@ The map is a hypothesis about him, and the probe is only its first sketch — th Two parts: 1. **The approach, in prose.** What we'll cover, in what order, and why this way — given where his edge sits (the probe) and what he's reaching for. A few freeform sentences. -2. **The map.** `plan_init` is itself the presentation: the learner sees the plan as a live mermaid diagram beside your message. Never draw the plan again in your prose — no second mermaid block, no outline restating what the map shows. Keep the map small: few nodes, short labels — a map, not the territory. +2. **The map.** `plan_init` is itself the presentation: the learner sees the plan as a live mermaid diagram beside your message. Never draw the plan again in your prose — no second mermaid block, no outline restating what the map shows. Labels stay short — a map, not the territory. Size itself is free: the map is as elaborate as the subject needs. **Stress-test the roots before presenting.** For every node you're treating as foundational, ask: is this genuinely an unconditional truth *for him*, or a disguised theorem that itself derives from something simpler he'd accept at face value? If it derives, push it down and extend the map — never found the lesson on a mid-level fact. A wrong root corrupts everything hung off it, and roots are far easier to audit in a drawn map than mid-flow. diff --git a/tests/jobs.test.ts b/tests/jobs.test.ts index f94aa2f..ea87e44 100644 --- a/tests/jobs.test.ts +++ b/tests/jobs.test.ts @@ -1309,7 +1309,10 @@ describe("prompt composition", () => { // the prober's doctrine: the "no rush" framing is gone, quick measurement in const prober = composeInstructions("prober"); assert.ok(!prober.includes("There is no rush"), "the old no-rush framing is retired"); - assert.ok(prober.includes("measurement should be efficient"), "the quick-measurement directive is in"); + assert.ok( + prober.includes("every wasted question is resolution the final map doesn't get"), + "the efficiency-is-resolution directive is in", + ); assert.ok(!prober.includes("Question principles"), "the teach-phase fragment never composes into the prober"); }); diff --git a/tests/practice-agents.test.ts b/tests/practice-agents.test.ts index 9a7aaaa..932b2fc 100644 --- a/tests/practice-agents.test.ts +++ b/tests/practice-agents.test.ts @@ -276,6 +276,21 @@ describe("practice prompt composition (own directory + the formatting appendix)" assert.match(teacher, /Rewriting is a normal, common event/); // planning is the natural verification moment assert.match(teacher, /planning is the natural moment for verification/); + // no size ceilings, and the detour keeps the pace (owner round, 2026-10-07) + assert.ok(!teacher.includes("Typically 5–15 nodes"), "the node-count cap is dead"); + assert.match(teacher, /No size ceiling/); + assert.match(teacher, /never rush the repair/); + assert.match(teacher, /one and only pace/); + assert.match(teacher, /nothing to rush/, "the goal reiteration composes"); + }); + + it("the prober doctrine steers difficulty by evidence (owner round, 2026-10-07)", () => { + const prober = composeInstructions("prober"); + assert.match(prober, /Enter near the top, not the bottom/); + assert.match(prober, /Strands inform each other/); + assert.match(prober, /never descending into already-bracketed territory/); + // the confidence + thinking signals are wired into question selection + assert.match(prober, /the verdict, his confidence, and his thinking field together set where the next question should sit/); }); it("the SHARED formatting guide composes (owner, 2026-10-04 late): LaTeX delimiters in every setting", () => {