diff --git a/.setup b/.setup
new file mode 100644
index 0000000..e69de29
diff --git a/Schedule.md b/Schedule.md
new file mode 100644
index 0000000..58afd05
--- /dev/null
+++ b/Schedule.md
@@ -0,0 +1,127 @@
+# SIN.04028 – Course Schedule
+
+## Autumn Semester 2026
+
+This is a **hands-on course**.
+
+We will learn about distributed systems, Event-Driven Architectures, and Sensor–Actuator Networks by **building things, experimenting, breaking things, repairing them, and trying again**.
+
+At the beginning, we will work through several examples together. Later, you will increasingly have to find your own solutions.
+
+Our short-term goal is rather simple:
+
+> **Make the cars race – and win.**
+
+There is, however, a somewhat more serious goal behind all this:
+
+> **Learn how autonomous and distributed systems can be designed — and understand what makes an architecture truly Event-Driven.**
+
+Do not expect us to tell you everything in advance.
+
+Sometimes the important part of an exercise will be realizing that you are missing something.
+
+---
+
+# Before the course
+
+Please make sure that you have:
+
+- a working installation of **Java 26 or Java 27**;
+- access to a terminal / command line;
+- preferably a relatively simple programming environment;
+- and some curiosity.
+
+We deliberately want to work relatively close to the underlying technologies.
+
+## Working with LLMs
+
+You may use LLMs.
+
+But the exercises in this course are intentionally small enough that the main objective is not generating code. The objective is to make sure that **the important concepts end up in your brain**.
+
+Using an LLM to figure out the syntax of a library, an API call, or a particular implementation detail is perfectly reasonable.
+
+But afterwards, you should still be able to explain what your system is doing and why.
+
+And please ask us questions — including questions that arose while talking to an LLM.
+
+---
+
+# Weekly Schedule
+
+| Date | Mission | What we will do |
+|---|---|---|
+| **15 Sep 2026** | **Getting Ready** | What does it actually mean to control another process? What changes if that process is somewhere else? We introduce the course, distributed systems, different architectural ideas, and our main architectural theme: **Event-Driven Architecture**. Then we begin with something harmless: ROT13. |
+| **22 Sep 2026** | **Fighting to the Metal** | We take ROT13 further than anyone reasonably should. Processes become separated, communication becomes external, and suddenly architecture starts to matter. We will explore the difference between telling another component *what to do* and reacting to *what has happened*. |
+| **29 Sep 2026** | **Something Faster** | Files work. But perhaps there are better ways of exchanging very small pieces of information. We introduce **MQTT**, Publish/Subscribe, clients, brokers, topics, YAML/JSON and MQTT Explorer. Then we revisit an old problem with a new communication mechanism. **Groups will be formed.** |
+| **06 Oct 2026** | **Now You Do It** | Build your own small distributed system. Technology is not the important part. Architecture is. Your system must be **Event-Driven**, and you must be able to convince us that it really is. Continue developing your system. Simplify it. Break it. Repair it. Explain it. We will inspect your architecture and may ask inconvenient questions. |
+| **13 Oct 2026** | **Graded Exercise I** | Present your first system and report. We will look at architecture, simplicity, understanding, explicability, and scientific/technical writing. A working system is useful. Understanding *why* it works is more important. |
+| **20 Oct 2026** | **Disco Time** | A new system appears. It has wheels. First challenge: communicate with it. Second challenge: make something visible happen. You will encounter a separate network, an unfamiliar API, messages, commands and a small vehicle that may or may not listen to you. |
+| **27 Oct 2026** | **Make It Yours** | The vehicle can do more than one thing. Build an **Event-Driven interface** that lets a user interact with it. The technology and design of the interface are up to you. We care about both architecture and user experience. |
+| **03 Nov 2026** | **RaceTrack I – Humans** | There is now a track. Your job is to drive the vehicle around it using your own remote-control interface. Functionality matters. Usability matters too. There may even be a small competition. If you notice that the vehicle or track can do more than we explicitly asked for, feel free to investigate. |
+| **10 Nov 2026** | **RaceTrack II – No Humans** | Same track. Different problem. The human driver disappears. Your vehicle now has to race autonomously. At some point you may discover that simply telling the car to “go fast” is not quite sufficient. |
+| **17 Nov 2026** | **RaceTrack III – That Was Too Easy** | A new track. Different geometry. Different opportunities. A solution that was optimal last week may suddenly no longer be optimal. There might even be ways of travelling through the track that are considerably faster than others. The interesting question is: **how would your system know?** |
+| **24 Nov 2026** | **Concourse / Gymnasium** | Race. Test. Compare. Debug. Improve. It is your autonomous vehicle vs human controlled vehicles. (We will design the track together in advance!)|
+| **01 Dec 2026** | **RaceTrack IV – The Track Knows Things** | Until now, you have mostly concentrated on the vehicle. Perhaps that is not the only interesting source of information. We introduce another piece of the puzzle and see what new Event-Driven behaviours become possible. What you do with that information is up to you. |
+| **24/7 ;-)** | **Build Something Good** | Open development session. Integrate everything you have learned. Experiment. Simplify. Optimize. Add ideas that we did not ask for. Most importantly, make sure that your entire group understands the resulting system. |
+| **15 Dec 2026** | **Finale** | Show us what you managed to build. Race it. Demonstrate it. Explain it. Defend the architecture. Surprise us if you can. It should be a little difficult — but hopefully also fun. |
+
+---
+
+# Assessment
+
+The final course grade consists of:
+
+| Assessment | Weight |
+|---|---:|
+| **Individual graded exercise** | **30%** |
+| **Group graded exercise / final presentation** | **30%** |
+| **Final written examination** | **40%** |
+| **Total** | **100%** |
+
+For practical work, producing something that works is only one part of the exercise.
+
+You should also be able to:
+
+- explain your architecture;
+- distinguish **Event-Driven** from **Command-Driven** interaction;
+- keep unnecessary complexity out of your solution;
+- justify your technical decisions;
+- understand the technologies you use;
+- and explain your work clearly.
+
+---
+
+# What if your group is faster?
+
+Good.
+
+Different groups will progress at different speeds.
+
+If your group finishes an exercise early, do not assume that you have to stop. There are always more difficult things one can try.
+
+You may encounter additional features, modified tracks, new constraints, or completely unnecessary challenges.
+
+And if you ask:
+
+> **“Could we also…?”**
+
+there is a significant chance that our answer will be:
+
+> **“Interesting. Try it.”**
+
+There is only one catch:
+
+> **If you claim it can be done, we may ask you to demonstrate it.**
+
+---
+
+# One Last Warning
+
+The schedule above tells you roughly **what problem we will attack each week**.
+
+It deliberately does **not** tell you every tool, trick, event, feature or architectural possibility that you may encounter along the way.
+
+Discovering that you need something is sometimes part of the exercise.
+
+> **Build it. Test it. Question it. Understand it. Explain it.**
diff --git a/conv.md b/conv.md
index 90cba9e..5c53389 100644
--- a/conv.md
+++ b/conv.md
@@ -193,3 +193,851 @@ Step 0 is waiting whenever you're ready.
- `git mv .claude TUTOR.md`: the file is now `TUTOR.md` (12856 bytes, contents unchanged), and git records it as a rename.
- Updated the memory file `tutor-no-answer-completion` so it refers to `ProcessControl/TUTOR.md` instead of `ProcessControl/.claude`.
- `git commit` with `TUTOR.md` (rename) and `conv.md`. `.setup` stays untracked. **Not pushed.**
+- Result: commit `7b3e0f2` "Rename tutor prompt .claude to TUTOR.md"; `main` is now 1 commit ahead of `origin/main`.
+- Check: `stat .claude/settings.json` and `stat .claude/settings.local.json` now return "No such file or directory" (a missing optional file) instead of ENOTDIR.
+
+## [5] Tutor — reply
+
+Both settings errors had the same cause, and it's fixed.
+
+- **Cause:** Claude Code looks for project settings in a *directory* named `ProcessControl/.claude/`. Yours was a *file* (the tutor prompt), so reading `.claude/settings.json` and `.claude/settings.local.json` failed with ENOTDIR. The settings themselves were fine: you have no project settings, so nothing was lost.
+- **Fix applied:** `git mv .claude TUTOR.md`. Same content, and git records it as a rename, so the history is kept. Nothing was deleted, and your global config and installation weren't touched.
+- **Checked:** both settings paths now report a plain "No such file or directory", which Claude Code treats as "no project settings". You should stop seeing the errors the next time Claude Code starts or reloads settings. I can't see Claude Code's own warning display, so please confirm they're gone.
+- **Git:** committed locally as `7b3e0f2`, **not pushed**. `main` is 1 commit ahead of `origin/main`.
+- **Heads-up:** there's a new empty untracked file `ProcessControl/.setup` (created 2026-09-15 19:44). It isn't related to these errors and I left it alone. I'm just mentioning it so it doesn't end up in a future "commit everything" by surprise.
+- From now on, the tutor instructions live in `TUTOR.md`. I also updated my saved preference to point to the new name.
+
+Back to Step 0: read section **"0. What This Tutorial Is About"** (README lines 47–147), then send me your prediction and the three recurring questions in your own words.
+
+**Progress record**
+- Current step: 0 — What This Tutorial Is About
+- Last observed result: settings errors fixed (commit `7b3e0f2`, local only)
+- Unresolved problem: none (`.setup`: your call)
+- Next action: you read Step 0 and send your prediction and the three questions
+
+---
+
+## [6] Student
+
+> Step 0, the idea is to present what we are going to do: rot13 (the courses files are in java), it also bring the idea of console -> some operation -> console
+
+## [6] Tutor — actions taken
+
+- None (compared the answer with README Step 0, lines 47–147, which I had already read).
+
+## [6] Tutor — reply
+
+**Step 0 — What This Tutorial Is About** (feedback)
+
+**Correct:**
+- The running example is `keyboard → ROT13 → console`: read a line, transform it, print it. Your "console → some operation → console" is exactly that shape.
+- Yes, it's Java, specifically Java 26 with compact source files.
+
+**Missing:** so far you've described *what the program does*. Step 0 spends most of its lines on something else, and that's the part we need before Step 1.
+
+Since you've already read the section, a "prediction" no longer makes sense, so let's skip it. Instead, reread these two short passages:
+
+1. **Lines 67–73.** In one sentence: according to the tutorial, what is the subject of the course, and how does ROT13 relate to it?
+2. **Lines 75–85.** Put the three recurring questions in your own words. Keep them in order, because the order matters.
+
+**Tell me:** your two answers. After that we move to Step 1 and run the first program.
+
+**Progress record**
+- Current step: 0 — What This Tutorial Is About
+- Last observed result: student identified the running example (`keyboard → ROT13 → console`, Java)
+- Unresolved problem: none
+- Next action: student rereads lines 67–85 and states the subject and the three questions
+
+---
+
+## [7] Student
+
+> 1. the idea is to study the architecture of the programm, rot13 is just a pretext to introduce it 2. which part will communicate with which other; for each part, what are its data; which part connect everything together
+
+## [7] Tutor — actions taken
+
+- `grep` in README for how "own/owns/ownership" and "who decides" are used later, so my feedback on question 2 doesn't overstate or invent anything.
+- Read `supplemental-java/01-procedural/ProceduralRot13.java` to prepare for Step 1 (not shown to the student yet).
+
+## [7] Tutor — reply
+
+**Step 0 — feedback**
+
+**1. Subject:** ✅ Right. The tutorial states it bluntly: ROT13 is deliberately uninteresting, and the architecture around it is what we study.
+
+**2. The three questions:** you have the right order and roughly the right spirit. But in two of the three, you swapped the tutorial's key word for a different one. Compare:
+
+| Tutorial (lines 77–85) | You wrote |
+|---|---|
+| Who **knows** whom? | which part **communicates** with which other |
+| Who **owns** what? | for each part, what are **its data** |
+| Who **decides** how the system is wired together? | which part **connects** everything together |
+
+- **Second question:** "its data" is a fair first reading. Just know that the tutorial will later apply "owns" to more than plain data, so keep the word open.
+- **First and third questions:** the verb changed ("knows" → "communicates", "decides" → "connects"). I won't tell you whether that matters. The tutorial makes you find out by building and running the system. Keep both pairs in mind as bookmarks. The first one comes up in Step 1.
+
+Step 0 is complete.
+
+---
+
+**Step 1 — Rock Bottom: Just Call It**
+
+**Goal:** run the simplest possible version of the program, plain procedural code with direct method calls, and use it as the reference point for everything that follows.
+
+**Prerequisite check:** the course files use Java 26 compact source files (`void main()` with no class, `IO.readln()`, `IO.println()`), which need a recent JDK. I can see from my environment that you're on Linux. I haven't checked your Java install, and I'd rather you run the check yourself in your own terminal.
+
+**Do:** run
+
+```bash
+java --version
+```
+
+**Tell me:** the full output. If the command isn't found, say so.
+
+**Progress record**
+- Current step: 1 — Rock Bottom: Just Call It
+- Last observed result: Step 0 done (subject identified; three questions stated, with two verb substitutions bookmarked)
+- Unresolved problem: none
+- Next action: student runs `java --version` and pastes the output
+
+---
+
+## [8] Student
+
+> 1. i'm unnder the 25 sdk system wide, with 17 installed but not in use
+
+then, after being asked to actually run the command:
+
+```
+[matsune@nitro5 ProcessControl]$ java --version
+openjdk 25.0.4.1 2026-08-18
+OpenJDK Runtime Environment (build 25.0.4.1)
+OpenJDK 64-Bit Server VM (build 25.0.4.1, mixed mode, sharing)
+```
+
+> i'm under 25
+
+(Session note: mid-exchange the student ran local `/model` commands and switched the session's model to Sonnet 5; attribution for commits/PRs from here on changes accordingly. Not part of the tutoring content.)
+
+> So i'm running under jdk 25
+
+## [8] Tutor — actions taken
+
+- `archlinux-java status`: `java-25-openjdk` is the system default; `java-17-openjdk` is installed but not selected. Matches the student's own description exactly.
+- `pacman -Qs openjdk` / `pacman -Ss '^jdk[0-9]*-openjdk$'`: JDK 17 and 25 installed; **JDK 26 is available in the `extra` repo but not installed**.
+- Read `supplemental-java/06-mqtt/pom.xml`: `26`. Bookmarked — only matters once we reach the MQTT stage (~Step 56+), not now.
+- `grep` across `supplemental-java` for version-sensitive APIs (`StructuredTaskScope`, `ScopedValue`, `--enable-preview`, etc.): none found. Only `Thread.ofVirtual()` is used, which finalized in JDK 21 — no preview flags needed anywhere in the course code.
+- `WebFetch` on `https://openjdk.org/jeps/512` (Compact Source Files and Instance Main Methods) to check exactly which JDK finalized the compact-source-file feature the tutorial relies on (`void main()`, `IO.readln()`/`IO.println()` without imports). Result: **JEP 512 is Final in JDK 25**, not a preview feature. The `IO` class ships with `print`, `println(Object)`, `println()`, `readln(String)`, `readln()`.
+
+## [8] Tutor — reply
+
+*(Log note, added at [20]: this entry originally contained a garbled draft sentence that differed from the reply actually displayed; it has been aligned with the displayed text below. Two claims in it were later corrected — see [20].)*
+
+Good news: your setup works as-is — nothing to install or switch.
+
+- The README says "Java 26" mainly because that was newest at time of writing, but the specific feature the course depends on — compact source files, instance `main`, `IO.readln()`/`IO.println()` — I checked against **JEP 512** directly, and it's **Final in JDK 25**, not a preview. Your `openjdk 25.0.4.1` is sufficient for every plain `java Something.java` example in this tutorial; no `--enable-preview` flag needed.
+- Virtual threads (`Thread.ofVirtual()`, used from Step 9 onward) finalized back in JDK 21 — also fine on 25.
+- **Bookmark for later, not a problem now:** `supplemental-java/06-mqtt/pom.xml` pins `maven.compiler.release` to `26`. You have JDK 17 and 25 installed, not 26. When we reach the MQTT stage (~Step 56+) and actually build that Maven module, we'll need to either install JDK 26 or adjust the POM. Flagging it now so it's not a surprise; nothing to do about it yet.
+- JDK 17 being installed but unselected doesn't matter here.
+
+Back to Step 1.
+
+---
+
+**Step 1 — Rock Bottom: Just Call It**
+
+**Goal:** run the baseline procedural version and use it to make concrete what "the caller knows" means — our first look at the bookmarked question (*who knows/communicates whom?*).
+
+**Predict:** look at the loop in `ProceduralRot13.java` (specifically `if (text == null) return;`). Before running it: when you send end-of-input (on Linux, `Ctrl+D` on its own line) instead of typing text, what do you expect — does it print something, crash, or just exit quietly?
+
+**Do:**
+```bash
+cd SIN.04028-From-Calling-to-Eventing/supplemental-java/01-procedural
+java ProceduralRot13.java
+```
+Type a line of text, press Enter, look at the output, then send `Ctrl+D` to end input.
+
+**Look for:** the transformed text, and how the program behaves when the input ends.
+
+**Tell me:**
+1. Did your EOF prediction hold?
+2. Open the file and look at `main()` and `rot13()`. Are `ConsoleIn`, `ROT13`, and `ConsoleOut` separate, named things in this code, or is it all one piece? What does that tell you about "who knows whom" at this stage?
+
+**Progress record**
+- Current step: 1 — Rock Bottom: Just Call It
+- Last observed result: Java 25 confirmed sufficient (JEP 512 final in JDK 25); JDK 26/pom.xml release mismatch bookmarked for the MQTT stage
+- Unresolved problem: none
+- Next action: student predicts EOF behavior, runs `ProceduralRot13.java`, and answers the two questions above
+
+---
+
+## [9] Student
+
+> Nothing more after the Crtl + D, once again you autofill my respond field, always let it blank or else i cannot learn. 2. IO.readin() is separated of the rest, but there is a call of rot13 directly as an argument for the output
+
+## [9] Tutor — actions taken
+
+- Updated the persistent memory `tutor-no-answer-completion`: added a rule to never phrase a prediction/comprehension question as multiple choice (my "does it print something, crash, or exit quietly?" did exactly that). Predictions must be asked fully open from now on.
+
+## [9] Tutor — reply
+
+You're right, and that one's on me. My "Predict:" question offered three candidate answers instead of leaving it open — that's still filling in your response, just with a menu instead of a sentence. Fixed going forward: predictions get asked open, no options attached. I've saved this as a standing rule so it also holds in later sessions.
+
+**Step 1 — checking your observations**
+
+1. **EOF behavior:** "Nothing more" after `Ctrl+D` matches the code — `if (text == null) return;` returns from `main()` with nothing printed. Observed and expected agree.
+2. **Code structure:** correct read. `IO.readln()` sits alone on its own line, assigned to `text`. But `rot13(text)` is not its own statement — it's called *inline*, as the argument passed straight into `IO.println(...)`.
+
+That second observation is the important one, so stay with it a moment: **what does it mean, in terms of "who knows whom," that `rot13(text)` is written as an argument to `IO.println` rather than as its own separate step?** Answer in your own words — I won't give you a menu this time.
+
+**Progress record**
+- Current step: 1 — Rock Bottom: Just Call It
+- Last observed result: EOF behavior confirmed (silent return, matches code); code-structure observation confirmed (readln separate, rot13 nested inside println's argument)
+- Unresolved problem: none
+- Next action: student states what the nested `rot13(text)` call implies about "who knows whom" at this stage
+
+---
+
+## [10] Student
+
+> it means that IO.println knows rot13
+
+## [10] Tutor — actions taken
+
+- None (compared the answer against `IO.println`'s role and the README's own framing of "the caller knows", lines 195–220, already read).
+
+## [10] Tutor — reply
+
+Have another look at the direction of that relationship, with one concrete check you can do yourself:
+
+**Does the definition of `IO.println` — a general-purpose method in the JDK — mention `rot13` anywhere?** It doesn't; it just accepts whatever `String` it's handed and prints it. It would print any string, from any source, unchanged.
+
+So if `IO.println` has no idea `rot13` exists, **who did decide that `rot13(text)` should run before printing, and in that specific order?**
+
+**Progress record**
+- Current step: 1 — Rock Bottom: Just Call It
+- Last observed result: student's first answer inverted the direction of "knows" (attributed knowledge to `IO.println`); redirected to check `IO.println`'s own definition
+- Unresolved problem: none
+- Next action: student reconsiders who actually knows about `rot13` and `IO.println`, given that `println` itself doesn't reference `rot13`
+
+---
+
+## [11] Student
+
+> the jdk, at compile/runtime, it knows that rot13 will return a string, knows that IO.println expect one, so at runtime when the function is executed it goes well
+
+## [11] Tutor — actions taken
+
+- Re-checked README lines 195–216 (already read at [1]) to point the student back to the exact passage that names what "the caller knows".
+
+## [11] Tutor — reply
+
+That's a real fact, but it's a different question than the one we're asking. Type-checking (does `rot13` return a `String`, does `println` accept one) is the compiler making sure the *plumbing fits*. It happens after the code is already written a certain way — it doesn't decide *which* pieces get wired together, or in what order.
+
+Set the compiler aside and look at the raw text of the file instead. The README puts it this way (lines 195–208), about the line `String transformed = rot13(text);`:
+
+> The caller knows: that ROT13 exists; how to invoke it; what argument it expects; what result it returns; that ROT13 is available right now; and that execution continues after ROT13 returns.
+
+**"The caller" here means whichever piece of code physically contains that line.** In our compact version, `rot13(text)` and `IO.println(...)` are both typed inside one place. Which function is that? And given the list above, what does *that* function know?
+
+**Progress record**
+- Current step: 1 — Rock Bottom: Just Call It
+- Last observed result: second answer addressed type-checking (a JDK/compiler concern), not the architectural "who knows whom" question; redirected to README's own definition of "the caller knows"
+- Unresolved problem: none
+- Next action: student identifies which function contains both calls and states what that function knows, per the README's list
+
+---
+
+## [12] Student
+
+> the main function
+
+## [12] Tutor — actions taken
+
+- None.
+
+## [12] Tutor — reply
+
+Right, `main()` is the one place both `rot13` and `IO.println` are named. That answers half of what I asked.
+
+The other half is still open: using the README's own list as your checklist —
+
+> exists; how to invoke it; what argument it expects; what result it returns; that it's available right now; that execution continues after it returns
+
+— go through it for `main()` and `rot13`. What, specifically, does `main()` know about `rot13`, item by item?
+
+**Progress record**
+- Current step: 1 — Rock Bottom: Just Call It
+- Last observed result: student correctly identified `main()` as the function containing both calls
+- Unresolved problem: none
+- Next action: student walks through the README's "caller knows" checklist for `main()` and `rot13`
+
+---
+
+## [13] Student
+
+> so, main knows that rot13 and its data (in and out), but does not knows its exact definition, and that it doesn't exit the whole programm
+
+## [13] Tutor — actions taken
+
+- None.
+
+## [13] Tutor — reply
+
+Good — that covers three of the checklist items (argument, result, execution continuing), and the extra point you added yourself is correct too: `main()` knows `rot13`'s *signature*, not its implementation. That's true and worth keeping.
+
+Two items from the list are still untouched: *how to invoke it*, and *that it's available right now*. One sentence each is enough — then we close Step 1 and move on.
+
+**Progress record**
+- Current step: 1 — Rock Bottom: Just Call It
+- Last observed result: student covered argument/result/continuation correctly, plus a correct unprompted point about interface vs. implementation knowledge
+- Unresolved problem: none
+- Next action: student covers the two remaining checklist items ("how to invoke it", "available right now"), then Step 1 closes
+
+---
+
+## [14] Student
+
+> it knows how to invoke because it is in the same class, for external one a path is to be precised (like with IOs one), concerning the last point i must admit that i don't clearly understand with this example how it could not be available right now, i suppose this is a bit for later with process waiting on other and listening to thread?
+
+## [14] Tutor — actions taken
+
+- None new (relied on the already-read README table of contents and JEP 512 findings from earlier turns).
+
+## [14] Tutor — reply
+
+**"How to invoke it":** good, and accepted. One small technical correction, general knowledge rather than tutorial content: this file has *no explicit class*, but under **JEP 512** (which I looked up earlier), a compact source file still compiles to one implicit, unnamed class — `rot13` and `main` end up as instance methods of it. So "same class" is actually correct, just an invisible one rather than a written one. Your broader point stands regardless: a plain call needs no import, no qualification, nothing beyond the bare name, because everything sits in one place.
+
+**"Available right now":** your instinct is correct, and here's the honest answer rather than a hint: yes, this becomes a real, concrete problem later — the README's own table of contents has a step titled **"The First Distributed-Systems Problem: Publication"**, in Part II. I haven't read that section yet, so I won't describe what it says; that's for when we get there. Consider it a bookmark, not a preview of content.
+
+For *this* step specifically, the question is smaller and answerable now: `main()` and `rot13` are two methods of the same class, called on the same thread, in the same running process. Given that, **why is `main()` guaranteed that `rot13` is ready to run the instant it calls it — what would have to be true for that guarantee to fail?**
+
+Answer that one and Step 1 is done; then we move to Step 2.
+
+**Progress record**
+- Current step: 1 — Rock Bottom: Just Call It
+- Last observed result: "how to invoke it" accepted, with a JEP 512 correction (implicit class, not classless); "available right now" correctly flagged by the student as mattering later (bookmarked, not yet read)
+- Unresolved problem: none
+- Next action: student explains why `main()` can be sure `rot13` is ready the instant it's called, in this single-process procedural version; then Step 1 closes
+
+---
+
+## [15] Student
+
+> the moment rot13 is called no other process are running, as the IO.readln is the only process awaiting for something and that it is already ended when rot13 is called there is no issue, a guaranteed fail could have happen i think if rot13 called IO.readln and that an buffer error happen during the reading, sending invalid information to rot13
+
+## [15] Tutor — actions taken
+
+- Read README lines 224–343 (Steps 2 and start of Step 3) to prepare Step 2's guidance.
+
+## [15] Tutor — reply
+
+Two things to untangle, then I'll close this out — you've earned it after several honest attempts.
+
+- **"No other process running" / "readln has already ended":** the sequencing observation is real (`readln()` fully returns before `rot13(text)` is called), but "process" is the wrong word for it. There's only **one** process here — this single JVM — and no other processes exist yet to compete with anything. What actually guarantees availability is narrower than that: `rot13` is compiled into the same (implicit) class, loaded into the same JVM, called on the same thread that's doing the calling. It isn't a separate thing that has to have "started" — it's already there the moment the program is running at all.
+- **The buffer-error scenario:** that's a real category of failure, but it's about *data correctness* (garbled input), not *availability*. Even with corrupted input, `rot13` would still be sitting there, ready to run — it would just receive bad data. So this doesn't actually break the guarantee we're asking about; it's a different guarantee entirely.
+
+So, to close it out plainly: `main()` can be certain `rot13` is ready the instant it's called because they are two methods of one already-loaded class, invoked synchronously on one thread, in one process. There is no startup to wait for, no message to travel anywhere, no listener to be subscribed yet. That guarantee stops being automatic exactly when one of those three things (same class, same thread, same process) stops being true — which is precisely the direction this tutorial is heading, and which you already flagged correctly a moment ago.
+
+**Step 1 is closed.** Full picture of "who knows whom" here: `main()` knows that `rot13` exists, how to invoke it (bare name, same implicit class), its argument and result types, that it's unconditionally available, and that execution resumes after it returns. That is the maximum possible coupling — one function, one place, everything wired by name.
+
+---
+
+**Step 2 — Make Three Egoistic Capabilities**
+
+**Goal:** stop thinking of this as "one function that does three things" and start thinking of `ConsoleIn`, `ROT13`, and `ConsoleOut` as three separate, **egoistic** capabilities — each one only aware of what it itself can do, and what data it accepts/produces.
+
+**Do:** read section **"2. Make Three Egoistic Capabilities"** (README lines 224–267).
+
+**Look for:** the four "I ..." statements that define an "egoistic" component, and the two lines of code the README says an egoistic `ConsoleIn` and `ROT13` should *not* contain.
+
+**Tell me:** once ConsoleIn no longer contains `rot13(...)` and ROT13 no longer contains `consoleOut(...)`, what problem does the README say this immediately creates? Answer in your own words — there's a one-line question posed right there in the text; don't just quote it back, explain what it actually means for the system we had in Step 1.
+
+**Progress record**
+- Current step: 2 — Make Three Egoistic Capabilities
+- Last observed result: Step 1 closed — full "who knows whom" checklist completed for `main()`/`rot13`, with two misconceptions corrected (process vs. thread, availability vs. data correctness)
+- Unresolved problem: none
+- Next action: student reads Step 2 and explains, in their own words, the problem created once the three capabilities stop knowing each other
+
+---
+
+## [16] Student
+
+> nobody knows anyone (in fact a bit wrong there is always the main funciton knowing about the 3), we don't have anymore that IO.println invokes rot13, so we must create a new link between the 2.
+
+## [16] Tutor — actions taken
+
+- None new (compared against README lines 258–267 already read; recalled the Step 7 heading — "Enter the Mediator" — from the table of contents extracted at the very start of the session).
+
+## [16] Tutor — reply
+
+"Nobody knows anybody" is exactly the README's own phrase, and your self-correction is the sharper half of the answer. You're right: *something* still has to know about all three, or nothing ever runs at all — the three capabilities refusing to know each other doesn't remove that knowledge, it just relocates it. That relocation is precisely what the README is fishing for with **"Who makes this into a system?"** You've essentially answered its own next question before it asked it. I can tell you, since it's just a heading, not content: this becomes its own topic soon — **Step 7 is literally titled "Enter the Mediator."** I haven't read it yet, so that's all I'll say.
+
+One small refinement: it's not only "a new link between the 2" — with three egoistic capabilities, both boundaries break (`ConsoleIn ↔ ROT13` and `ROT13 ↔ ConsoleOut`), so two new links are needed, not one.
+
+Step 2 is closed.
+
+---
+
+**Step 3 — Give Every Capability a Mailbox**
+
+**Goal:** introduce the smallest possible mechanism for that "new link" — a `Message` record and a per-capability `BlockingQueue`, addressed by name, inside one JVM.
+
+**Do:** read section **"3. Give Every Capability a Mailbox"** (README lines 270–332).
+
+**Look for:** what the two fields of `Message` are for; what a "mailbox" is built from (`Map>`); and the one sentence that states a hard limitation of `BlockingQueue` when there's more than one reader.
+
+**Tell me:** in your own words, why does the README insist on calling these **mailboxes**, not "topics", at this stage? What would calling them "topics" wrongly imply about how many readers a message can reach?
+
+**Progress record**
+- Current step: 3 — Give Every Capability a Mailbox
+- Last observed result: Step 2 closed — student correctly identified that "who makes this into a system" relocates knowledge rather than removing it, anticipating the mediator concept unprompted
+- Unresolved problem: none
+- Next action: student reads Step 3 and explains why "mailbox" (not "topic") is the right word at this stage
+
+---
+
+## [17] Student
+
+> Before going further, i've added Schedule.md, you'll find inside the course plan schedule with the topic to do each week, at the beginning of each new part we do together, tell me for when i musst do it, do not restrict me on doing thing ahead, but lecture me a bit if something is more than 2 days late
+
+## [17] Tutor — actions taken
+
+- Found and read the new file `ProcessControl/Schedule.md`: the official SIN.04028 autumn 2026 weekly schedule (15 Sep – 15 Dec 2026), with a mission per week, an assessment breakdown, and course policy notes (e.g. "Using an LLM ... is perfectly reasonable, but ... you should still be able to explain what your system is doing and why").
+- `Schedule.md` names **weekly missions**, not README **Parts** — there's no explicit mapping between the two documents. I built one by comparing each week's description against the README's Part titles/content (see table below) and I'm treating it as an inference, not a fact taken from either file.
+- Saved a persistent project memory (`sin04028-schedule-tracking`) recording the requested behavior and my inferred Part→week mapping, so this holds across sessions.
+
+## [17] Tutor — reply
+
+Got it — I'll announce this at the start of each new Part, lecture only if we're more than 2 days past the target, and never block you from going faster.
+
+One caveat first: `Schedule.md` schedules by **week and topic**, not by the README's **Part** names, so there's no explicit mapping given. Here's the one I inferred by matching content — treat it as my best reading, not an official correspondence:
+
+| README Part | Steps | Schedule week | I'll treat as "due by" |
+|---|---|---|---|
+| Part I — Start With What You Already Know | 1–10 | 15 Sep "Getting Ready" | **22 Sep 2026** |
+| Parts II–VIII (process boundary → distributed → rewind → dynamic → vocabulary → merge → filesystem's job done) | 11–53 | 22 Sep "Fighting to the Metal" | **29 Sep 2026** |
+| Part IX — MQTT (+ optional epilogue) | 54–81 | 29 Sep "Something Faster" | **06 Oct 2026** |
+
+(Logic: a week's listed mission is what you *start* that week; I'm using the *next* week's start as the soft deadline to have finished it. Parts II–VIII compress into one week in the schedule text, which is a lot of ground — tell me if that doesn't match what was actually said in class.)
+
+**Right now:** we're inside **Part I**, due by 22 Sep 2026. Today is 17 Sep 2026 — on schedule, no lecture warranted.
+
+---
+
+Back to Step 3: the question is still open — why does the README insist on "mailbox" rather than "topic" here, and what would "topic" wrongly imply about how many readers get a message?
+
+**Progress record**
+- Current step: 3 — Give Every Capability a Mailbox
+- Last observed result: `Schedule.md` read and mapped (inferred) to README Parts; tracking preference saved
+- Unresolved problem: inferred Part→week mapping not officially confirmed (informational only, not blocking)
+- Next action: student explains "mailbox" vs "topic" for Step 3
+
+---
+
+## [18] Student
+
+> i'd say that mailbox implies the idea of getting news from different entity, or multiples one of the same one, but each time with an order, so that if A arrive before B, then A must be managed before B (if no priority flag has been setup), topic implies more the idea of getting news with the latest on top usually, so if publications arrive faster that how they are treat, the oldest one will never be seen
+
+## [18] Tutor — actions taken
+
+- Compared the answer against README lines 316–331 (already read).
+
+## [18] Tutor — reply
+
+That's ordering and freshness — a real distinction elsewhere, but not the one the README is making at line 316. Reread the sentence it actually gives as the reason:
+
+> If two readers call `take()` on the same mailbox, they compete. Each message goes to one of them; it is not copied to both.
+
+That sentence isn't about *order* of arrival. It's about **how many readers get a copy of one message.**
+
+Set your FIFO/freshness framing aside for a moment and answer just from that sentence: if `ConsoleIn` and some second, hypothetical reader both call `take()` on ROT13's mailbox, how many of them receive a given message? What word would describe that, and how would a "topic" (Publish/Subscribe) behave differently on that specific point?
+
+(Small aside, since part of your intuition is real, just misplaced here: "latest message only, oldest never seen" *does* exist in MQTT, as **retained messages** — but that's a distinct, later mechanism, not a general property of topics. It shows up explicitly at Step 71, "Retained State, Non-Retained Events." Bookmarked, not detailed.)
+
+**Progress record**
+- Current step: 3 — Give Every Capability a Mailbox
+- Last observed result: student's answer addressed ordering/freshness, not the README's actual point (one-reader-per-message vs. broadcast-to-all); redirected to the exact quoted sentence
+- Unresolved problem: none
+- Next action: student re-answers using only the "competing readers" sentence — how many readers get each message from a mailbox, vs. a topic
+
+---
+
+## [19] Student
+
+> mail: 1 -> 1, topic: 1 -> many
+
+## [19] Tutor — actions taken
+
+- Read README lines 335–444 (Steps 4, 5, 6 — ConsoleIn/ROT13/ConsoleOut Become Egoistic) to prepare the next round.
+- Confirmed via the stages table (README line 18/22) that the *complete* supplemental source for this whole arc, `02-static-in-jvm/StaticQueueRot13.java`, already contains later material (the mediator, Step 7) — deliberately not opening/showing it yet, since Steps 4–6 haven't reached that point.
+
+## [19] Tutor — reply
+
+Correct. **Mailbox: one message → exactly one reader** (readers compete). **Topic: one message → every subscriber**, independently. That's the real distinction the README draws here. Step 3 closed.
+
+---
+
+**Steps 4–6 — ConsoleIn / ROT13 / ConsoleOut Become Egoistic**
+
+These three are short and mechanically identical, so let's take them together.
+
+**Goal:** apply the mailbox from Step 3 to all three capabilities — each one now only touches its *own* named inbox/outbox, never another capability's name.
+
+**Do:** read README lines 335–441 (sections 4, 5 and 6). Don't open `StaticQueueRot13.java` yet — that supplemental file is the *complete* version for this whole arc and includes material we haven't reached (the mediator, next). We'll open it once we're ready to run something.
+
+**Look for:** the exact mailbox names each capability uses (`consoleIn.outbox`, `rot13.inbox`, `rot13.outbox`, `consoleOut.inbox`), and the one-line summaries the README gives for what each capability "knows".
+
+**Tell me:** the README closes Step 6 by saying we now have three nicely isolated capabilities that "do absolutely nothing together." Looking at the mailbox names involved, what — specifically — is missing for text typed at the keyboard to ever reach the console?
+
+**Progress record**
+- Current step: 4–6 — ConsoleIn / ROT13 / ConsoleOut Become Egoistic
+- Last observed result: Step 3 closed (mailbox = one reader per message, topic = broadcast to all)
+- Unresolved problem: none
+- Next action: student reads Steps 4–6 and names exactly what's missing for the mailboxes to connect
+
+---
+
+## [20] Student
+
+(Session note: the student ran `/model opus` locally and switched the session model back to Opus 5. Not part of the tutoring content.)
+
+> it feels like it missing the link between the different mailbox to fully works, we never tell that ConsoleIn mail must be setn to rot13 inbox and that rot13 mail must be sent to ConsoleOut
+
+## [20] Tutor — actions taken
+
+- Read README lines 444–603 (Step 7 "Enter the Mediator" and Step 8 "Ask Again: Who Knows Whom?") to prepare the next round.
+- Read `supplemental-java/02-static-in-jvm/StaticQueueRot13.java` in full, since Step 7 says "Run it" and points to that file.
+- Re-checked earlier claims against `Schedule.md`: its "Before the course" section asks for "a working installation of **Java 26 or Java 27**". That contradicts my [8] statement "nothing to install or switch". The [8] line about *why* the README says Java 26 was also my own guess, not something either document says.
+- Fixed the [8] log entry: it held a garbled draft sentence that didn't match the reply actually displayed. Added a note there pointing to this correction.
+- (A stray `Read` on a directory path returned a harmless error. Nothing changed.)
+
+## [20] Tutor — reply
+
+Correct, both missing links: `consoleIn.outbox → rot13.inbox` and `rot13.outbox → consoleOut.inbox`. Nothing in any of the three capabilities creates them, and that's intentional. Steps 4–6 are done.
+
+**A correction to something I told you in Step 1.** I said your JDK 25 needed nothing installed or changed, and I guessed at why the README says "Java 26". The guess was mine, not something the material says. More importantly, `Schedule.md` ("Before the course") explicitly asks for **Java 26 or Java 27**.
+- **Observed:** Step 1 ran fine on your JDK 25.
+- **Still true:** the MQTT `pom.xml` needs release 26.
+- **So:** install JDK 26 before the 22 Sep session. It's a course prerequisite, not just a late-tutorial detail. This doesn't block Part I; keep going on 25 for now. JDK 26 is in Arch's `extra` repo (`jdk-openjdk`, 26.0.2.1, seen earlier). Because this changes your system, run it yourself: `sudo pacman -S jdk-openjdk`, then `archlinux-java status` to see the new environment's exact name, then `sudo archlinux-java set `.
+
+---
+
+**Step 7 — Enter the Mediator**
+
+**Goal:** add the missing links without breaking egoism. Neither ConsoleIn nor ROT13 learns about the other. Instead a small, separate piece of code moves messages from one mailbox to another.
+
+**Do:**
+1. Read README lines 444–538.
+2. Open `SIN.04028-From-Calling-to-Eventing/supplemental-java/02-static-in-jvm/StaticQueueRot13.java` and read `main()` (the bottom of the file).
+3. **Before running anything, predict:** in Step 1, `Ctrl+D` ended the program. What do you expect `Ctrl+D` to do this time, and why, based on `main()`?
+4. Then, from `ProcessControl/`:
+ ```bash
+ cd SIN.04028-From-Calling-to-Eventing/supplemental-java/02-static-in-jvm
+ java StaticQueueRot13.java
+ ```
+ Type a line or two, then press `Ctrl+D`.
+
+**Look for:** the output for each line, and what happens after `Ctrl+D`.
+
+**Tell me:** your prediction, what you typed and saw, what `Ctrl+D` actually did, and whether that matched.
+
+**Progress record**
+- Current step: 7 — Enter the Mediator
+- Last observed result: Steps 4–6 done (student named both missing mailbox links)
+- Unresolved problem: JDK 26 not installed yet, though `Schedule.md` requires Java 26/27. Not blocking Part I; recommended before 22 Sep.
+- Next action: student predicts `Ctrl+D` behaviour from `main()`, runs `StaticQueueRot13.java`, reports the result
+
+---
+
+## [21] Student
+
+> jdk26 installed + set as default, as Ctrl + D sent an EOf, text will be null and the thread is gonna loop over the consoleIn
+
+## [21] Tutor — actions taken
+
+- Read-only check: `java --version` → `openjdk 26.0.2.1 2026-08-18`; `archlinux-java status` → `java-26-openjdk (default)`, with `java-17-openjdk` and `java-25-openjdk` also present.
+
+## [21] Tutor — reply
+
+**JDK 26:** confirmed on my side as well: `java --version` reports `openjdk 26.0.2.1`, and `archlinux-java status` shows `java-26-openjdk` as the default. That prerequisite is done.
+
+**Prediction:** recorded as you wrote it. I won't comment on it before you run the program, because comparing it with what actually happens is the point.
+
+**Do:** run it now (from `ProcessControl/`):
+
+```bash
+cd SIN.04028-From-Calling-to-Eventing/supplemental-java/02-static-in-jvm
+java StaticQueueRot13.java
+```
+
+Type a line or two, then press `Ctrl+D`.
+
+**Look for:** the output for each line you type, and what the terminal does after `Ctrl+D`.
+
+**Tell me:** what you typed, what came back, and what happened after `Ctrl+D`. Then say whether it matched your prediction.
+
+**Progress record**
+- Current step: 7 — Enter the Mediator
+- Last observed result: JDK 26.0.2.1 installed and default (verified); student's `Ctrl+D` prediction recorded
+- Unresolved problem: none
+- Next action: student runs `StaticQueueRot13.java` and compares the `Ctrl+D` behaviour with their prediction
+
+---
+
+## [22] Student
+
+> i've runned it and as i was expecting it hadn't stop
+
+## [22] Tutor — actions taken
+
+- None. I compared the report with `StaticQueueRot13.java` as already read (lines 37–51 `runConsoleIn`, lines 74–88 `main`). I did not run the program myself.
+
+## [22] Tutor — reply
+
+**Observed:** after `Ctrl+D` the program kept running. Your predicted *outcome* matches that.
+
+Your predicted *reason* was different: after `text` becomes `null`, "the thread is gonna loop over the consoleIn". A correct outcome doesn't prove a correct reason, so check it against the code:
+
+1. `runConsoleIn()`, lines 42–43: what does the ConsoleIn thread actually do when `text` is `null`?
+2. Depending on your answer to 1, what is keeping the program alive? Look at the last line of `main()` (line 87), and think about what the other four threads are doing at that moment.
+
+**Also, briefly:** you didn't say what came back for the lines you typed. What did you type, and what was printed?
+
+**Progress record**
+- Current step: 7 — Enter the Mediator
+- Last observed result: program did not exit after `Ctrl+D` (student-observed; outcome matched the prediction)
+- Unresolved problem: the predicted reason ("ConsoleIn loops") has not been checked against the code yet; the functional ROT13 output has not been reported
+- Next action: student checks lines 42–43 and line 87 to explain why the program stays alive, and reports the ROT13 output
+
+---
+
+## [23] Student
+
+> ConsoleIn return when text is null but main is nerver return nor exited, the threads continue to run
+
+## [23] Tutor — actions taken
+
+- Read README lines 604–697 (Step 9 "Why Virtual Threads?", Step 10 "Keep the Services Egoistic") to check that the explanation below doesn't jump ahead of the tutorial. Step 9 describes components that "wait indefinitely" but says nothing about daemon threads.
+
+## [23] Tutor — reply
+
+Correct on the two main points: ConsoleIn's thread **returns** (it doesn't loop, so your first reason is now fixed), and `main()` **never returns**.
+
+Two refinements:
+
+- **"The threads continue to run":** they're alive, but not running. ROT13, ConsoleOut and both mediators are each blocked inside `take()` on an empty mailbox. They wait and use no CPU. Hold on to that "waiting forever" picture, because Step 9 builds on it.
+- **What actually keeps the process alive** (general Java knowledge, not from the tutorial): threads created with `Thread.ofVirtual()` are always *daemon* threads, and the JVM doesn't wait for daemon threads before exiting. So the four blocked threads alone wouldn't keep it running. Line 87, `Thread.currentThread().join()`, does: the main thread waits for *itself* to finish, which can never happen.
+
+**To close Step 7:** you still haven't told me what came back for the lines you typed. One line is enough.
+
+---
+
+**Step 8 — Ask Again: Who Knows Whom?**
+
+This is a checkpoint, so answer **before** reading section 8. The README gives its own answers right there.
+
+**Tell me,** based only on `StaticQueueRot13.java`:
+1. Does any of the three capabilities (`runConsoleIn`, `runRot13`, `runConsoleOut`) know about any other one?
+2. In Step 1, the wiring `ConsoleIn → ROT13 → ConsoleOut` lived in `main()`. Where does it live in this file? Name the exact lines.
+
+After you answer, read README lines 542–601 and compare.
+
+**Progress record**
+- Current step: 7 → 8 (Step 7 waiting on the ROT13 output report)
+- Last observed result: student explained why the program stays alive (ConsoleIn returns; `main()` never returns). Refined: other threads are blocked, not running; line 87's self-join is what keeps the JVM alive, because virtual threads are daemon threads.
+- Unresolved problem: ROT13 output from the Step 7 run not reported yet
+- Next action: student reports the ROT13 output, then answers the two Step 8 questions before reading section 8
+
+---
+
+## [24] Student (2026-09-22)
+
+> End step 7: the rot13 version of it, 8.1 I'd say no, as they each just know about the mailbox, not directly the other ones, 8.2 as i open the files in a console directly i don't have the line numbering, but i'd say it is the 2 `Thread.ofVirtual.start(...)`
+
+## [24] Tutor — actions taken
+
+- None new. I compared the answers against `StaticQueueRot13.java` as already read: the mediator starts are at lines 79–81 and 83–85, and `mediate()` is defined at lines 28–35.
+- Schedule check: today is 22 Sep 2026, the inferred due date for Part I. Two short steps remain (9 and 10). Not late, so no lecture.
+
+## [24] Tutor — reply
+
+**Step 7 done.** Each line came back ROT13-transformed, which matches the README's "Functionally: … Again."
+
+**8.1:** ✅ Correct. Each capability knows only its *own* mailbox names. None of them mentions another capability.
+
+**8.2:** ✅ Correct, with one precision: `main()` has five `Thread.ofVirtual().start(...)` calls, and you mean the two that call `mediate(...)`. Those are **lines 79–81 and 83–85**. (Tip for reading files in a console: `cat -n File.java` or `less -N File.java` shows line numbers.)
+
+Before reading section 8, notice something. Those two lines are inside `main()`. In Step 1, the wiring was *also* inside `main()`.
+
+**Do:** read README lines 542–601 and compare with your answers.
+
+**Tell me:** if the wiring is in `main()` in both versions, what actually changed between Step 1 and now? Use the README's "first major result" to help you, but answer in your own words.
+
+*Schedule note:* Part I's target date is today (22 Sep). Two short steps are left after this one, so you're on track.
+
+**Progress record**
+- Current step: 8 — Ask Again: Who Knows Whom?
+- Last observed result: Step 7 run matched (ROT13 output). 8.1 and 8.2 answered correctly (capabilities know only their own mailboxes; wiring is at lines 79–81 / 83–85).
+- Unresolved problem: none
+- Next action: student reads lines 542–601 and explains what changed between Step 1 and now, given that the wiring is in `main()` in both
+
+---
+
+## [25] Student
+
+> We now have a clear separation between each task and their communication ways has changed (from direct to mailbox). The new method is more robust and easier to adapt/change because we only have to change the wiring
+
+## [25] Tutor — actions taken
+
+- None new. I compared the answer against README lines 580–601 ("first major result"), lines 690–693 (Step 10 calls the design "indirect—even a little odd"), and the Part III headings "25. Count What One Keystroke Costs" and "26. Break a Mediator".
+
+## [25] Tutor — reply
+
+**Correct:**
+- Separation: ✅ each capability's code now contains only its own capability.
+- Communication moved from direct calls to mailboxes: ✅
+- "We only have to change the wiring": ✅ this is the key point. In Step 1 the wiring was written *into the capability code itself* (`IO.println(rot13(text))`). Now the capabilities contain no wiring at all, and the wiring is just data (pairs of mailbox names) in lines 79–85. To rewire, you change those lines and don't touch any capability. That's the README's "knowledge moves to where it belongs".
+
+**Not yet supported: "more robust".** Check it against what you've actually seen. The only behavioural difference you've observed so far is that `Ctrl+D` no longer ends the program. The README itself calls this design "indirect—even a little odd" (line 690). So treat "more robust" as a **hypothesis**, not a conclusion. The tutorial tests it directly in Part III ("25. Count What One Keystroke Costs", "26. Break a Mediator"). We'll come back to your claim there.
+
+Step 8 done.
+
+---
+
+**Step 9 — Why Virtual Threads?**
+
+**Goal:** separate a Java *implementation* tool from the *architecture* you just built.
+
+**Do:** read README lines 604–641.
+
+**Tell me:** section 9 says virtual threads and Event-Driven Architecture are "different concepts". Using `StaticQueueRot13.java` as your example, what does each one contribute to this program?
+
+**Progress record**
+- Current step: 9 — Why Virtual Threads?
+- Last observed result: Step 8 done. The student explained the change as capabilities separated and wiring isolated as data. "More robust" is parked as an unverified hypothesis to revisit at Steps 25–26.
+- Unresolved problem: none
+- Next action: student reads section 9 and explains what virtual threads vs. the architecture each contribute in `StaticQueueRot13.java`
+
+---
+
+## [26] Student
+
+> Threads are indefinetly looping part of code running partially indepently, an event-driven architecture is based on event trigger to run some part of the code
+
+## [26] Tutor — actions taken
+
+- None new. I compared the answer against README lines 604–641 (Step 9, already read) and lines 644–694 (Step 10, already read), plus the headings "43. `E` — Event" and "46. Event-Driven Does Not Mean "No Commands"".
+
+## [26] Tutor — reply
+
+**Threads:** "running independently" ✅ is the part that matters. One correction: looping isn't what makes something a thread. A thread is simply an independent path of execution. The `while (true)` loops are this program's code, which happens to run inside threads. `runConsoleIn` returns, and its thread ends with it, as you saw in Step 7.
+
+**Event-Driven Architecture:** my question was partly unfair. I asked what EDA "brings to this program", but the README never says this program is event-driven. Section 9 only warns you not to confuse the two ideas. The tutorial deliberately waits to name "Event" until Step 43 ("`E` — Event"), after you've used the idea. So keep your definition ("events trigger code to run") as a **guess to compare later**, at Steps 43–46.
+
+Here is what section 9 actually says, applied to `StaticQueueRot13.java`. Five loops each wait indefinitely: the keyboard, `rot13.inbox`, `consoleOut.inbox`, and the two mediators' inboxes. Virtual threads are simply the cheap Java way to let five waits happen at once inside one JVM. The *architecture* (who knows whom, and the fact that the wiring lives in lines 79–85) is in the mailbox names, not in the threads. The README's evidence: "The same architecture can later run as separate processes. In step 11, you will do exactly that." There, the same structure survives with no Java threads shared between the parts.
+
+Step 9 done.
+
+---
+
+**Step 10 — Keep the Services Egoistic**
+
+**Goal:** face the obvious shortcut and see why the tutorial refuses it at this stage.
+
+**Before reading section 10, answer this:** the mediator on lines 79–81 moves messages from `consoleIn.outbox` to `rot13.inbox` without changing them. Why not delete that mediator and let `runRot13` call `take()` on `consoleIn.outbox` directly? Use the "who knows whom" lens.
+
+**Then:** read README lines 644–694 and compare.
+
+**Progress record**
+- Current step: 10 — Keep the Services Egoistic (last step of Part I)
+- Last observed result: Step 9 done. Thread definition corrected (an independent path of execution, not a loop). The student's EDA definition is parked as a guess to compare against Steps 43–46.
+- Unresolved problem: none
+- Next action: student explains, before reading section 10, why ROT13 shouldn't read `consoleIn.outbox` directly
+
+---
+
+## [27] Student
+
+> Because we want to keep each service egoistic
+
+## [27] Tutor — actions taken
+
+- None.
+
+## [27] Tutor — reply
+
+True, but that's the section's title rather than a reason. *Why* would reading `consoleIn.outbox` stop ROT13 being egoistic? Let's make it concrete.
+
+Suppose that tomorrow the text comes from a new capability, `FileIn`, which publishes to `fileIn.outbox`, instead of from ConsoleIn.
+
+- **Version A (today's file):** ROT13 reads `rot13.inbox`, and a mediator forwards `consoleIn.outbox → rot13.inbox`.
+- **Version B (the shortcut):** there's no mediator, and `runRot13` does `take()` on `consoleIn.outbox`.
+
+**Tell me:** in each version, which lines or functions would you have to edit to switch the input to `FileIn`? What does the answer for version B tell you about what ROT13 knows?
+
+**Progress record**
+- Current step: 10 — Keep the Services Egoistic
+- Last observed result: first answer restated the section title without a reason
+- Unresolved problem: none
+- Next action: student compares what must be edited in version A vs. B to switch the input to `FileIn`
+
+---
+
+## [28] Student
+
+> the version b, the idea of keeping each service egoistic is that a change of one doesn't need to change the others
+
+## [28] Tutor — actions taken
+
+- Read README lines 697–786 (start of Part II: Step 11 "Separate the Components", Step 12 "A Directory Becomes a Mailbox", start of Step 13) to prepare the Part II opening.
+- Schedule check: today is 22 Sep 2026. Part I finishes today, which is its inferred due date. Part II opens now, and Parts II–VIII are inferred due by 29 Sep 2026. Not late, so no lecture.
+
+## [28] Tutor — reply
+
+✅ That's the principle: in version B, switching the input forces you to edit ROT13, although ROT13's own job (rotating text) hasn't changed at all.
+
+This is the precise version, since you've now worked your way to it twice:
+- **Version A:** you edit one argument, `"consoleIn.outbox"` on line 80, and nothing else. All three capabilities stay untouched.
+- **Version B:** you must edit `runRot13` itself, because it contains the name `consoleIn.outbox`. So ROT13 would *know* that ConsoleIn exists and where it publishes. That is part of the topology. The README says it at lines 676–677: "the topology moves into ROT13 … ROT13 is no longer an egoistic capability."
+
+Read section 10 (lines 644–694) to see it in the README's words. Note that the README openly admits the cost too (lines 690–693): the design "may look indirect—even a little odd", and "later you will find a different way" to keep services egoistic *without* a mediator in every message's path. That's a promise to keep in mind.
+
+**Part I is done.** Summary: `main()` knowing everything → egoistic capabilities with mailboxes → topology held only by the mediators (wired in `main()`).
+
+---
+
+## Part II — Cross the Process Boundary
+
+**Schedule:** by my inferred mapping, Parts II–VIII are due by **29 Sep 2026**. Today is 22 Sep, and today's session ("Fighting to the Metal") matches this part. You're on time, so no lecture. For planning: that's Steps 11–53 in 7 days, about 6 steps a day. You're free to go faster.
+
+**Step 11 — Separate the Components**
+
+**Goal:** move ConsoleIn, ROT13 and ConsoleOut into three separate processes, and see what stops working.
+
+**Before reading, predict:** if each capability runs as its own `java` process, which part of `StaticQueueRot13.java` can no longer work as written, and why?
+
+**Then:** read README lines 697–730.
+
+**Tell me:**
+1. Your prediction, and whether section 11 confirms it.
+2. In your own words: why does the README pick the filesystem as transport here, rather than TCP or MQTT?
+
+**Progress record**
+- Current step: 11 — Separate the Components (Part II)
+- Last observed result: Part I done. Step 10: the student stated the principle (changing one shouldn't force changing another). Precise version given: version B puts the topology into ROT13.
+- Unresolved problem: none
+- Next action: student predicts what breaks across process boundaries, reads section 11, and explains the filesystem choice
+
+---
+
+## [29] Student
+
+> commit everything before moving to step 11
+
+## [29] Tutor — actions taken
+
+- `git status`: `conv.md` modified; `.setup` (empty, 0 bytes) and `Schedule.md` (7528 bytes) untracked; `main` 1 commit ahead of `origin/main` (the unpushed rename commit `7b3e0f2`).
+- Logged this turn in `conv.md` before committing, so the commit includes it.
+- `git add -A` and `git commit`, which includes `conv.md`, `Schedule.md` and the empty `.setup`, as "everything" was requested. Not pushed (not requested).
+