kimal3 0.6.5 → 0.8.0

package/claude-plugins/kimal3-plan/hooks/ordner.ts

@@ -0,0 +1,141 @@
+import type { EngineInterface } from 'claude-code'
+
+/**
+ * Zu welchem Projekt in der App gehoert der Ordner, in dem Claude laeuft? (Spec 2026-10-23-brett-in-echtzeit-design.md,
+ * 1.4, 1.7, S-27 bis S-31). DIESELBE Regel wie `cli/src/projekt-ordner.ts` -- der Mod kann `cli/src` nicht importieren,
+ * deshalb steht sie hier ein zweites Mal. Den Gleichlauf haelt die gemeinsame Tabelle `scripts/projektordner-faelle.mts`:
+ * `check:cli` prueft die CLI, `check:plan-mod` diesen Mod gegen dieselben Faelle. Aendert sich die Regel, an BEIDEN
+ * Stellen und in der Tabelle.
+ *
+ * Einziger Unterschied: Die Platte fragt der Mod ueber `$.fs`, also asynchron -- `gibt` und `lies` sind hier Promises.
+ */
+
+export type Ordnerzettel = { format: 1; projekt_id: string; titel: string }
+export type Ordnerlage =
+  | { art: 'projekt'; ordner: string; name: string; zettel: Ordnerzettel | null; ausStandJson: boolean }
+  | { art: 'kein-projektordner' }
+type Gibt = (pfad: string) => Promise<boolean>
+type Lies = (pfad: string) => Promise<string | null>
+
+const ZETTEL_PFAD = 'plan/projekt.json'
+const STAND_PFAD = 'plan/stand.json'
+const BEISPIELE: readonly string[] = ['beispiel-rechnungen-erfassen', 'example-capture-invoices']
+const PROJEKTORDNER: readonly string[] = ['projekte', 'projects']
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+export const normiert = (pfad: string) => pfad.replace(/\\/g, '/').replace(/\/+$/, '')
+const nachOben = (pfad: string) => {
+  const teile = normiert(pfad).split('/')
+  return teile.map((_, i) => teile.slice(0, teile.length - i).join('/')).filter(p => p !== '')
+}
+const istWerkbank = (ordner: string) => ordner.startsWith('werkbank-') || ordner.startsWith('workbench-')
+
+/** `werkbank-x/projekte/<name>` irgendwo im Pfad -- der aeusserste Treffer, damit `.claude/worktrees/x` nicht zaehlt. */
+function projektordnerIn(pfad: string): { ordner: string; name: string } | null {
+  const teile = normiert(pfad).split('/')
+  for (let i = 0; i + 2 < teile.length; i++) {
+    if (!istWerkbank(teile[i] ?? '') || !PROJEKTORDNER.includes(teile[i + 1] ?? '')) continue
+    const name = teile[i + 2] ?? ''
+    return name === '' || BEISPIELE.includes(name) ? null : { ordner: teile.slice(0, i + 3).join('/'), name }
+  }
+  return null
+}
+
+function objektAus(text: string | null): Record<string, unknown> | null {
+  if (text === null) return null
+  try {
+    const j: unknown = JSON.parse(text.replace(/^\uFEFF/, ''))
+    return j !== null && typeof j === 'object' && !Array.isArray(j) ? (j as Record<string, unknown>) : null
+  } catch {
+    return null
+  }
+}
+
+/** Der Zettel, wenn er gueltig ist -- sonst `null` (kein JSON, andere Formatnummer, keine Projektnummer, kein Titel). */
+export function zettelAus(text: string | null): Ordnerzettel | null {
+  const o = objektAus(text)
+  if (o === null || o.format !== 1 || typeof o.projekt_id !== 'string' || !UUID.test(o.projekt_id)) return null
+  if (typeof o.titel !== 'string' || o.titel.trim() === '') return null
+  return { format: 1, projekt_id: o.projekt_id, titel: o.titel }
+}
+
+/** Aus einer alten `plan/stand.json` nur die Nummer (und der Titel, falls er dasteht). */
+function zettelAusStand(text: string | null, name: string): Ordnerzettel | null {
+  const o = objektAus(text)
+  if (o === null || typeof o.projekt_id !== 'string' || !UUID.test(o.projekt_id)) return null
+  const titel = typeof o.projekt === 'string' && o.projekt.trim() !== '' ? o.projekt : name
+  return { format: 1, projekt_id: o.projekt_id, titel }
+}
+
+/** `.` und `..` in einem Pfad mit `/` aufloesen, ohne die Platte zu fragen (die Wurzel bleibt stehen). */
+function aufgeloest(pfad: string): string {
+  const teile: string[] = []
+  for (const t of pfad.split('/')) {
+    if (t === '.' || (t === '' && teile.length > 0)) continue
+    if (t === '..' && teile.length > 1) teile.pop()
+    else if (t !== '..') teile.push(t)
+  }
+  return teile.join('/')
+}
+
+async function naechsteGitWurzel(cwd: string, gibt: Gibt): Promise<string | undefined> {
+  for (const o of nachOben(cwd)) if (await gibt(`${o}/.git`)) return o
+  return undefined
+}
+
+/** Der Hauptordner einer Git-Arbeitskopie (die naechste `.git` ueber `cwd` ist eine Datei `gitdir: …/.git/worktrees/x`). */
+export async function hauptordnerFuer(cwd: string, gibt: Gibt, lies: Lies): Promise<string | null> {
+  const wurzel = await naechsteGitWurzel(cwd, gibt)
+  if (wurzel === undefined) return null
+  const text = await lies(`${wurzel}/.git`)
+  const treffer = text === null ? null : /^gitdir:\s*(.+?)[\\/]\.git[\\/]worktrees[\\/][^\\/]+\s*$/.exec(text.trim())
+  if (treffer === null) return null
+  const ziel = normiert(treffer[1] ?? '')
+  return /^([A-Za-z]:)?\//.test(ziel) ? ziel : aufgeloest(`${wurzel}/${ziel}`)
+}
+
+export async function ordnerlage(cwd: string, gibt: Gibt, lies: Lies, hauptordner: string | null): Promise<Ordnerlage> {
+  // In einer Arbeitskopie zaehlt das Projekt des Hauptordners; der Zettel gehoert in ihre eigene Wurzel.
+  const projekt = projektordnerIn(hauptordner ?? cwd)
+  if (projekt === null) return { art: 'kein-projektordner' }
+  const ordner = hauptordner === null ? projekt.ordner : (await naechsteGitWurzel(cwd, gibt)) ?? projekt.ordner
+  const orte = ordner === projekt.ordner ? [ordner] : [ordner, projekt.ordner]
+  for (const o of orte) {
+    const zettel = zettelAus(await lies(`${o}/${ZETTEL_PFAD}`))
+    if (zettel !== null) return { art: 'projekt', ordner, name: projekt.name, zettel, ausStandJson: false }
+  }
+  for (const o of orte) {
+    const zettel = zettelAusStand(await lies(`${o}/${STAND_PFAD}`), projekt.name)
+    if (zettel !== null) return { art: 'projekt', ordner, name: projekt.name, zettel, ausStandJson: true }
+  }
+  return { art: 'projekt', ordner, name: projekt.name, zettel: null, ausStandJson: false }
+}
+
+// ── Platte über `$.fs` ──────────────────────────────────────────────────────────────────────────────────────────────
+
+/** Liest eine Datei; `null`, wenn sie fehlt oder ein Ordner ist (`.git` eines normalen Projekts). */
+export async function liesDatei($: EngineInterface, pfad: string): Promise<string | null> {
+  try {
+    return await $.fs.read(pfad)
+  } catch {
+    return null
+  }
+}
+
+/** Die Lage des Ordners, in dem die Sitzung laeuft. */
+export async function lageJetzt($: EngineInterface): Promise<Ordnerlage> {
+  const cwd = normiert(await $.session.cwd())
+  const gibt: Gibt = p => $.fs.exists(p).catch(() => false)
+  const lies: Lies = p => liesDatei($, p)
+  return ordnerlage(cwd, gibt, lies, await hauptordnerFuer(cwd, gibt, lies))
+}
+
+/**
+ * Der Pfad einer Datei relativ zum Projektordner (`docs/x.md`), oder `null`, wenn sie nicht darin liegt.
+ * Gross- und Kleinschreibung zaehlt nicht (Windows); ein relativer Pfad gilt ab dem Startordner der Sitzung.
+ */
+export function relativImOrdner(datei: string, ordner: string, cwd: string): string | null {
+  const absolut = /^([A-Za-z]:)?[\\/]/.test(datei) ? normiert(datei) : aufgeloest(`${normiert(cwd)}/${normiert(datei)}`)
+  const basis = `${normiert(ordner)}/`
+  return absolut.toLowerCase().startsWith(basis.toLowerCase()) && absolut.length > basis.length ? absolut.slice(basis.length) : null
+}

package/claude-plugins/kimal3-plan/hooks/register.tsx

@@ -0,0 +1,22 @@
+import type { Register } from 'claude-code'
+import { erinnerung } from './erinnerung'
+import { neuerLauf } from './lauf'
+import { lebenszeichen } from './lebenszeichen'
+import { specText } from './spec-text'
+
+// Der Mod `kimal3-plan` (Spec docs/superpowers/specs/2026-10-23-brett-in-echtzeit-design.md, 1.3): haelt das Board der
+// Projektseite aktuell. Drei Aufgaben, je eine Datei: Punkt am Leben halten (lebenszeichen.ts), Spec-Texte hochladen
+// (spec-text.ts), Claude ans Melden erinnern (erinnerung.ts). Dem Menschen sagt er nur etwas, wenn etwas nicht klappt --
+// eine Zeile in der Statuszeile (fehlerzeile.ts). Er startet kein `kimal3` (`$.process` gibt es in der Claude-App nicht)
+// und spricht selbst mit der App, mit dem Geraeteschluessel aus `~/.kimal3/anmeldung.json`.
+
+// Die Sprache, wenn `~/.kimal3/sprache.json` fehlt (S-23). `kimal3 einrichten` setzt diese Zeile beim Ablegen in
+// `~/.kimal3/claude-plugins` (`cli/src/mods-ablegen.ts`, `mitSprache`).
+const SPRACHE: 'de' | 'en' = 'de'
+
+export const register: Register = on => {
+  const lauf = neuerLauf(SPRACHE)
+  lebenszeichen(on, lauf)
+  erinnerung(on, lauf)
+  specText(on, lauf)
+}

package/claude-plugins/kimal3-plan/hooks/spec-text.ts

@@ -0,0 +1,45 @@
+import type { EngineInterface, On } from 'claude-code'
+import { dateiAus } from './erinnerung'
+import { fehlerSetzen } from './fehlerzeile'
+import { anApp, liesAusweis, type Lauf } from './lauf'
+import { liesDatei, normiert, relativImOrdner } from './ordner'
+
+/**
+ * Spec-Texte hochladen (Spec 1.3 Aufgabe 1, S-18): Schreibt oder aendert Claude eine `.md`-Datei im Projektordner, laedt
+ * der Mod ihren Text hoch (`POST /api/mod/spec-text`), damit die Lesefassung in der App stimmt, ohne dass jemand tippt.
+ * 🔑 Hochgeladen wird NUR eine Datei, die die App als Spec des Projekts kennt: Das Lebenszeichen nennt die Liste
+ * (`specDateien`, wie `datei` im Stand). Jede andere `.md` -- Notizen, README, Entwuerfe -- verlaesst den Rechner nicht
+ * (Datensparsamkeit, Ruling der Fixrunde). Eine brandneue Spec kommt mit ihrer Spec-Meldung (`kimal3 plan melde`).
+ * Sagt die App trotzdem `204` (keine Spec), ist das Erfolg ohne Wirkung. Der Pfad geht RELATIV zum Projektordner mit.
+ *
+ * Hochgeladen wird nach dem Werkzeug und ohne Claude darauf warten zu lassen (`$.clock.after(0, …)`). Was per Skript
+ * entsteht (Bash, Python), sieht der Mod nicht; das kommt mit `/k3plan` (S-19).
+ */
+export function specText(on: On, lauf: Lauf): void {
+  on('tool.call', { tool: ['Write', 'Edit'] }, async ($, e, next) => {
+    const ergebnis = await next(e)
+    if (ergebnis.deny !== undefined || ergebnis.isError === true) return ergebnis
+    const datei = dateiAus(e)
+    const lage = lauf.lage
+    if (datei === null || !datei.toLowerCase().endsWith('.md') || lage.art !== 'projekt' || lage.zettel === null) return ergebnis
+    const pfad = relativImOrdner(datei, lage.ordner, await $.session.cwd())
+    if (pfad === null || !lauf.specDateien.includes(pfad)) return ergebnis
+    const projektId = lage.zettel.projekt_id
+    $.clock.after(0, () => void hochladen($, lauf, `${normiert(lage.ordner)}/${pfad}`, pfad, projektId))
+    return ergebnis
+  })
+}
+
+async function hochladen($: EngineInterface, lauf: Lauf, datei: string, pfad: string, projektId: string): Promise<void> {
+  const text = await liesDatei($, datei)
+  const ausweis = await liesAusweis($, lauf)
+  // Ohne Ausweis meldet sich die Statuszeile schon ueber das Lebenszeichen (S-11, S-22).
+  if (text === null || 'fehler' in ausweis) return
+  const antwort = await anApp($, lauf, '/api/mod/spec-text', ausweis.schluessel, { projektId, pfad, text })
+  if (antwort?.status === 200 || antwort?.status === 204) return fehlerSetzen($, lauf, { 'nicht-angemeldet': false, 'nicht-erreichbar': false })
+  if (antwort?.status === 401) return fehlerSetzen($, lauf, { 'nicht-angemeldet': true })
+  if (antwort === null || antwort.status >= 500) return fehlerSetzen($, lauf, { 'nicht-erreichbar': true })
+  // `413` (zu gross), `403`, `400`: Die App war da und hat abgelehnt -- kein Fall fuer die Statuszeile, der Text kommt
+  // mit `/k3plan`. Nur ins Debug-Protokoll.
+  $.ui.log(`kimal3-plan: Spec-Text ${pfad} nicht hochgeladen (${antwort.status})`, { to: 'debug' })
+}

package/claude-plugins/kimal3-plan/types/index.d.ts

@@ -0,0 +1,10 @@
+declare module 'claude-code' {
+  interface PluginState {
+    'kimal3-plan': {
+      // Wann Claude zuletzt ans Melden erinnert wurde (`$.clock.now()`), `null`: noch nie in dieser Sitzung (hooks/erinnerung.ts, S-26).
+      letzteErinnerung: number | null
+      // Der Anstoss „Projekt anlegen“ ging in dieser Sitzung schon an Claude (hooks/erinnerung.ts, US-8).
+      anstossGegeben: boolean
+    }
+  }
+}

package/coach/de/kimal3-coach.md

@@ -88,7 +88,12 @@ nutze sie, statt vorschnell loszulegen.
 
 ### 3.3 Planen, jetzt konkret
 - Was genau gebaut wird, in welchen Schritten, woran jeder Schritt geprüft wird. Bei Größerem schriftlich: eine Spec,
-  also ein Plan mit Nutzergeschichten („Als … will ich … damit …“) und einer Gegenprobe je Kriterium.
+  also ein Plan mit Nutzergeschichten. Jede Story steht in vier Kisten, immer in dieser Reihenfolge:
+  **User Story** („Als … will ich … damit …“; der Titel nennt das Ziel des Menschen, nicht das Ergebnis) ·
+  **Akzeptanzkriterium** (vier Zeilen: *X hat …* · *X tut …* · *Dann muss …* · *Gegenprobe: …* — ein Kriterium, das nicht
+  scheitern kann, ist keins) · **So testest du es** (nummerierte Schritte für jemanden ohne Technik: wo, was tun, was dann
+  zu sehen ist; darunter die Zeile „Passt nicht, wenn: …“; ein Befehl nur mit Ort, in Backticks) · **Technische Notiz**
+  (wo die Sache wohnt, was sie trägt — der Mensch muss sie nicht lesen). Echte Zahlen, echter Text, ein Name statt „der Nutzer“.
 - **Ein abgesegneter Plan rechtfertigt nichts, was frische Messungen widerlegen.** Nie „der Plan sagt, das ist
   hinnehmbar" als Begründung — sondern neu beantworten: *Was ist mit dem, was ich JETZT weiß, das Beste?* Weicht es
   ab: laut sagen, Plan nachziehen.
@@ -136,6 +141,41 @@ nutze sie, statt vorschnell loszulegen.
 - **Sag von selbst, welche Schritte du ausgelassen hast** — auch einen, den ein Skill vorschreibt. Es wird danach
   gefragt, und aufgeflogen wiegt es schwerer als gesagt.
 
+### 3.6 Das Board — wann du der Projektseite meldest
+Gilt in jedem Projektordner (ein Ordner direkt in `werkbank-…/projekte/`). Anderswo meldest du nichts und fragst nichts.
+Das Board in der App zeigt nur, was du meldest: Wer nicht meldet, lässt es stundenlang „Offen“ zeigen, während gebaut wird.
+- **Das Projekt gibt es einmal je Ordner:** `kimal3 projekt verbinden`. Es schweigt (`0`), wenn der Ordner schon verbunden ist.
+  Legt es ein Projekt an, gibst du den **einen** Satz weiter, den es ausgibt („Ich habe das Projekt ‚…‘ in der App angelegt.“).
+  Gibt es zwei gleichnamige Projekte oder wurde es in der App gelöscht, fragt es: Frag den Menschen und wähle nie selbst; `--neu`
+  gibt es nur nach seinem Ja. Fehlt das Erfolgsprofil, sag den Satz einmal, arbeite weiter und melde nichts.
+- **Du meldest zu sechs Zeitpunkten**, jedes Mal mit `kimal3 plan melde` (Eingabe: eine Meldung als JSON oder eine Liste,
+  z. B. `echo '[…]' | kimal3 plan melde`; Zeit und Sitzung setzt das Programm). Die Schlüssel von Spec und Story liest du mit
+  `kimal3 plan` aus der App — erfinde keine.
+  1. **Spec angelegt oder ihre Stories geändert:**
+     `{"art":"spec","schluessel":"2026-10-24-testmonat","titel":"Testmonat","datei":"docs/superpowers/specs/2026-10-24-testmonat-design.md","stories":[{"schluessel":"US-1","titel":"Der Testmonat startet"}]}`
+  2. **Der Bau einer Spec beginnt:** die Stories, die jetzt gebaut werden, auf „in Arbeit“ — **bevor** du den ersten Bau-Schritt oder
+     einen Subagenten losschickst:
+     `{"art":"story","spec":"2026-10-24-testmonat","story":"US-1","stand":"in_arbeit"}`
+  3. **Eine Story ist gebaut und ihre Gegenproben sind gelaufen:** „gebaut“ mit Kriterien und dem `testen`-Text. Den Text nimmst du aus der Kiste „So testest du es“ der Story, wörtlich. Er ist eine Anleitung für jemanden ohne Technik: **eine Zeile je Schritt** (wo man es findet, was man tut, was dann zu sehen ist), **ohne** Kistenüberschrift, und **zuletzt** die Zeile „Passt nicht, wenn: …“. Die Zeilen trennst du im JSON mit `\n` — ein echter Zeilenumbruch im Text bricht das JSON, und `kimal3 plan melde` liest die Meldung nicht. Höchstens 1000 Zeichen: ist er länger, kürze die Schritte, nie mitten im Satz abschneiden. Ein Befehl nur, wenn es keinen anderen Weg gibt — dann sagst du, wo man ihn eingibt (in Claude Code im Projektordner, mit `!` davor), und setzt ihn in Backticks.
+     Beispiel:
+     `{"art":"story","spec":"2026-10-24-testmonat","story":"US-1","stand":"gebaut","kriterien":[{"text":"Startet Sabine am 1.11., endet er am 30.11.","gegenprobe":"bestanden"}],"testen":"1. Öffne in der App ‚Testmonat‘.\n2. Klick „Starten“.\n3. Darunter steht ‚Endet am 30.11.‘.\nPasst nicht, wenn: dort ein anderes Datum steht."}`
+  4. **Etwas fällt auf, das keine Spec verspricht:** `{"art":"thema","schluessel":"T-4","text":"Der Kalender könnte Feiertage zeigen"}`
+  5. **`/k3plan`:** Specs gegen den Code prüfen und jede Abweichung einzeln melden — dort steht, wie. **Prüfen ist Arbeit:** Eine Story mit offenen Gegenproben (Spalte „Claude-Test offen“), die du gegen den Code prüfst, meldest du vorher als „in Arbeit“. Stories in „Dein Test“ oder „Fertig“ meldest du beim Abgleich nicht neu.
+  6. **Feierabend:** den Tag abgleichen — dort steht, wie.
+
+  🔑 **Bleibt eine Story unfertig, wenn du aufhörst** (am Ende von `/k3plan` oder im Feierabend), meldest du sie mit `--ohne-sitzung` (`kimal3 plan melde --ohne-sitzung`): Ihr Plan-Stand bleibt `in_arbeit`, aber der Punkt am Projekt leuchtet nicht weiter, obwohl das Fenster offen bleibt — auf dem Board steht sie dann in „Offen“ als angefangen.
+
+  „Gebaut“ meldest du erst nach einer Gegenprobe, die in dieser Sitzung gelaufen ist, nie aus dem Gedächtnis.
+- **Subagenten melden nie.** Der Mod erinnert nur dich, nicht sie: Du meldest „in Arbeit“ **vor** dem Auftrag an einen Subagenten, der
+  baut, und „gebaut“ **nachdem** du sein Ergebnis geprüft hast.
+- **Bei Erfolg schweigst du.** Der Mensch bekommt keine Zeile darüber, dass du gemeldet hast — ständige Einblendungen stören ihn.
+  Sagen musst du nur den Satz von `projekt verbinden` und Probleme: Rückgabewert `1` heißt, die App hat abgesagt — lies den
+  Satz, behebe es, und gib weiter, was den Menschen betrifft. `3` heißt, die App ist nicht erreichbar: Die Meldung ist gemerkt
+  und geht beim nächsten Befehl mit, schick sie nicht noch einmal. `2` heißt nicht angemeldet: Sag ihm `kimal3 login`.
+- **Sätze, die nur du bekommst** (vom Mod `kimal3-plan`, der Mensch sieht sie nicht): die Erinnerung, eine Story als „in Arbeit“
+  zu melden oder die Änderung als Thema zu notieren · „leg das Projekt mit `kimal3 projekt verbinden` an“ · „gemerkte Meldungen
+  warten — `kimal3 plan senden`“. Handle danach, ohne dem Menschen davon zu erzählen.
+
 ## 4 · Erlaubnis und Sicherheit
 - **Bevor eine Aktion bestätigt werden muss**, erkläre in Alltagssprache: **was** passiert (die Wirkung, nicht der
   Befehl), **warum** jetzt, **was es bedeutet** (umkehrbar? folgenreich?). Ruhig und klar, nicht alarmierend.

package/coach/en/kimal3-coach.md

@@ -88,7 +88,12 @@ use them instead of starting off too quickly.
 
 ### 3.3 Planning, now concretely
 - What exactly is built, in which steps, how each step is checked. For bigger things in writing: a spec,
-  that is a plan with user stories ("As … I want … so that …") and a counter-check per criterion.
+  that is a plan with user stories. Every story sits in four boxes, always in this order:
+  **User story** ("As … I want … so that …"; the title names the person's goal, not the result) ·
+  **Acceptance criterion** (four lines: *X has …* · *X does …* · *Then …must …* · *Counter-check: …* — a criterion that
+  cannot fail is none) · **How you test it** (numbered steps for someone without technical knowledge: where, what to do, what
+  appears; below them the line "Doesn't work if: …"; a command only with its place, in backticks) · **Technical note**
+  (where the thing lives, what carries it — the person need not read it). Real numbers, real text, a name instead of "the user".
 - **An approved plan justifies nothing that fresh measurements refute.** Never "the plan says this is
   acceptable" as a reason — answer anew: *What is the best thing, given what I know NOW?* If it
   differs: say so out loud, update the plan.
@@ -136,6 +141,41 @@ use them instead of starting off too quickly.
 - **Say on your own which steps you skipped** — even one a skill prescribes. They will ask about it,
   and being found out weighs more than saying it.
 
+### 3.6 The board — when you report to the project page
+Applies in every project folder (a folder directly inside `workbench-…/projects/`). Elsewhere you report nothing and ask nothing.
+The board in the app shows only what you report: if you don't, it shows "Open" for hours while you build.
+- **There is one project per folder:** `kimal3 project connect`. It stays silent (`0`) if the folder is already connected.
+  If it creates a project, you pass on the **one** sentence it prints ("I created the project '…' in the app.").
+  If two projects have the same name, or it was deleted in the app, it asks: ask the person and never choose yourself; `--new`
+  only after their yes. If the success profile is missing, say the sentence once, keep working and report nothing.
+- **You report at six moments**, each time with `kimal3 plan report` (input: one report as JSON or a list,
+  e.g. `echo '[…]' | kimal3 plan report`; the program sets time and session). You read the keys of spec and story from the app
+  with `kimal3 plan` — don't invent them.
+  1. **A spec is created or its stories change:**
+     `{"art":"spec","schluessel":"2026-10-24-test-month","titel":"Test month","datei":"docs/superpowers/specs/2026-10-24-test-month-design.md","stories":[{"schluessel":"US-1","titel":"The test month starts"}]}`
+  2. **The build of a spec begins:** the stories being built now go to "in progress" — **before** you take the first build step or
+     send off a subagent:
+     `{"art":"story","spec":"2026-10-24-test-month","story":"US-1","stand":"in_arbeit"}`
+  3. **A story is built and its counter-checks have run:** "built" with criteria and the `testen` text. You take the text from the story's box "How you test it", word for word. It is a guide for someone without technical knowledge: **one line per step** (where to find it, what to do, what must appear), **without** the box heading, and **last** the line "Doesn't work if: …". In the JSON you separate the lines with `\n` — a real line break inside the text breaks the JSON, and `kimal3 plan report` cannot read the report. At most 1000 characters: if it is longer, shorten the steps, never cut off in the middle of a sentence. A command only if there is no other way - then say where to type it (in Claude Code in the project folder, with `!` in front) and put it in backticks.
+     Example:
+     `{"art":"story","spec":"2026-10-24-test-month","story":"US-1","stand":"gebaut","kriterien":[{"text":"If Sabine starts on 1 Nov, it ends on 30 Nov.","gegenprobe":"bestanden"}],"testen":"1. In the app open 'Test month'.\n2. Click Start.\n3. Below it says 'Ends on 30 Nov'.\nDoesn't work if: it shows another date."}`
+  4. **Something comes up that no spec promises:** `{"art":"thema","schluessel":"T-4","text":"The calendar could show public holidays"}`
+  5. **`/k3plan`:** check the specs against the code and report every deviation individually — it says how. **Checking is work:** a story with pending counter-checks (column "Claude test pending") that you check against the code, you report as "in progress" beforehand. Stories under "Your test" or "Done" you do not report again during the reconciliation.
+  6. **Wrap-up:** reconcile the day — it says how.
+
+  🔑 **If a story stays unfinished when you stop** (at the end of `/k3plan` or in the wrap-up), you report it with `--no-session` (`kimal3 plan report --no-session`): its plan state stays `in_arbeit`, but the dot at the project stops glowing although the window stays open — on the board it then sits under "Open" as started.
+
+  You report "built" only after a counter-check that ran in this session, never from memory.
+- **Subagents never report.** The mod reminds only you, not them: you report "in progress" **before** the job to a subagent that
+  builds, and "built" **after** you have checked its result.
+- **On success you stay silent.** The person gets no line saying that you reported — constant pop-ups bother them.
+  You only say the sentence from `project connect` and problems: exit code `1` means the app refused — read the
+  sentence, fix it, and pass on what concerns the person. `3` means the app is not reachable: the report is kept
+  and goes along with the next command, don't send it again. `2` means not signed in: tell them `kimal3 login`.
+- **Sentences only you get** (from the mod `kimal3-plan`; the person doesn't see them): the reminder to report a story as "in
+  progress" or to note the change as a topic · "create the project with `kimal3 project connect`" · "saved reports are
+  waiting — `kimal3 plan send`". Act on them without telling the person.
+
 ## 4 · Permission and safety
 - **Before an action has to be confirmed**, explain in everyday language: **what** happens (the effect, not the
   command), **why** now, **what it means** (reversible? consequential?). Calm and clear, not alarming.

package/dist/argumente.js

@@ -143,3 +143,15 @@ export function schalterOhneWert(argv, deutsch) {
     const namen = [deutsch, ...Object.keys(SCHALTER_EN).filter((e) => SCHALTER_EN[e] === deutsch)].map((n) => `--${n}`);
     return { gesetzt: argv.some((a) => namen.includes(a)), rest: argv.filter((a) => !namen.includes(a)) };
 }
+/**
+ * Was `kimal3 plan melde` / `plan report` hinter dem Befehlswort annimmt: nichts, `--help`/`-h` oder genau
+ * `--ohne-sitzung` (`--no-session`). Alles andere -- auch ein Tippfehler wie `--ohne-sitzungg` -- bleibt „unbekannt"
+ * wie heute (Spec 2026-10-24 E-8). Die Meldung selbst kommt von der Eingabe, nie aus Argumenten.
+ */
+export function planMeldeAngenommen(rest) {
+    if (rest.length === 0)
+        return true;
+    if (rest.length > 1)
+        return false;
+    return rest[0] === "--help" || rest[0] === "-h" || schalterOhneWert(rest, "ohne-sitzung").gesetzt;
+}

package/dist/atomar.js

@@ -0,0 +1,22 @@
+import { randomBytes } from "node:crypto";
+import { renameSync, rmSync, writeFileSync } from "node:fs";
+/**
+ * Schreibt eine Datei so, dass sie nie halb dasteht: erst eine Nebendatei, dann umbenennen (Board in Echtzeit, Task 7,
+ * Fixrunde 1). Ein Absturz oder voller Datentraeger mitten im Schreiben laesst die alte Datei (oder gar keine) zurueck,
+ * nie eine abgeschnittene -- eine abgeschnittene gemerkte Meldung oder ein halber Ordnerzettel waere unlesbar.
+ * Wirft wie `writeFileSync`; die Nebendatei raeumt sie dabei weg.
+ */
+export function schreibeAtomar(pfad, text) {
+    const neben = `${pfad}.${randomBytes(3).toString("hex")}.tmp`; // kein-anzeigetext: Dateiname
+    try {
+        writeFileSync(neben, text, "utf8");
+        renameSync(neben, pfad);
+    }
+    catch (f) {
+        try {
+            rmSync(neben, { force: true });
+        }
+        catch { /* schon weg */ }
+        throw f;
+    }
+}

package/dist/befehle/einrichten.js

@@ -6,7 +6,7 @@ import { leseAnmeldung } from "../anmeldung.js";
 import { alterKursCoachAblage, alterKursCoachPfad, coachDateiLiegt, legeCoachAb, meldeCoach } from "../coach-ablegen.js";
 import { istAlterKursCoach } from "../coach-rechnung.js";
 import { tragePluginsEin } from "../einstellungen-schreiben.js";
-import { logoAblegen } from "../logo-ablegen.js";
+import { modsAblegen } from "../mods-ablegen.js";
 import { pluginStand } from "../plugins-mischen.js";
 import { ruf } from "../api.js";
 import { FIRMEN_OPTIONEN, fehlendeDateienSchreiben, istUnsichererOrdnername, vorlageHolen, werkbankOrdner, } from "../arbeitsplatz-dateien.js";
@@ -310,7 +310,7 @@ async function neuAnlegen(pfad, wunsch, email, gespeichert) {
 function pluginsEinrichten(git) {
     const s = sprache();
     const t = EINRICHTEN_TEXTE[s];
-    const ablage = logoAblegen(s);
+    const ablage = modsAblegen(s);
     // Ohne Logo-Ordner kommt superpowers trotzdem (Durchsicht 2, Fund 1): eine Zeile zum Logo, dann weiter.
     if (!ablage.ok)
         console.log(t.logoNotWritten(ablage.detail));
@@ -328,8 +328,8 @@ function pluginsEinrichten(git) {
         return;
     }
     const stand = pluginStand(eintrag.inhalt);
-    const namen = { superpowers: "superpowers", logo: t.logoName };
-    const mit = (wert) => ["superpowers", "logo"].filter((p) => stand[p] === wert).map((p) => namen[p]);
+    const namen = { superpowers: "superpowers", logo: t.logoName, plan: t.planName };
+    const mit = (wert) => ["superpowers", "logo", "plan"].filter((p) => stand[p] === wert).map((p) => namen[p]);
     console.log(t.pluginsLine(mit("an"), mit("aus"), eintrag.art === "eingetragen"));
     // Auch wenn superpowers schon von früher drinsteht: ohne Git lädt es nicht (Durchsicht 4, Fund 3).
     if (!git && stand.superpowers !== "aus")

package/dist/befehle/login.js

@@ -6,7 +6,7 @@ import { anmeldeAdresse, oeffneImBrowser } from "../browser.js";
 import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
 import { EINRICHTEN_TEXTE } from "../texte/einrichten.js";
 import { frischeCoachAuf } from "../coach-ablegen.js";
-import { frischeLogoAuf } from "../logo-ablegen.js";
+import { frischeModsAuf } from "../mods-ablegen.js";
 import { stelleSkillUm } from "./skill-tausch.js";
 const warte = (ms) => new Promise((f) => setTimeout(f, ms));
 // 🌐 Die Sprache wird bei JEDER Ausgabe neu gelesen: Die Abhol-Antwort nennt die Kontosprache
@@ -36,7 +36,7 @@ export async function login() {
     // 2026-10-18, L-1, L-8): `einrichten` legt es nach der Anmeldung ohnehin selbst ab.
     if (code === 0) {
         frischeCoachAuf(sprache());
-        frischeLogoAuf(sprache());
+        frischeModsAuf(sprache());
     }
     return code;
 }

package/dist/befehle/plan-hoch.js

@@ -50,6 +50,14 @@ export async function planHoch(argv) {
         console.error(zerlegt.meldung);
         return 1;
     }
+    // 🔴 Seit 0.7.0 (Ruling Task 7, Board in Echtzeit 1.1): Claude meldet jede Aenderung einzeln (`plan melde`). Die ganze
+    // Datei geht nur noch mit --ueberschreiben hoch -- fuer eine Planung, die sich anders nicht mehr lesen laesst (die App
+    // nimmt das nur an, wenn seit `basis` keine 0.7-Meldung kam, R-6). Ohne den Schalter wuerde eine alte Datei Meldungen
+    // anderer Sitzungen wegwischen.
+    if (!ueber.gesetzt) {
+        console.error(PLAN_TEXTE[s].uploadNotNeeded);
+        return 1;
+    }
     const datei = planDateiOderAbsage(s);
     if (datei === null)
         return 1;

package/dist/befehle/plan-melde.js

@@ -0,0 +1,105 @@
+import { schalterOhneWert } from "../argumente.js";
+import { sprache } from "../sprache.js";
+import { MELDUNGEN_TEXTE } from "../texte/meldungen.js";
+import { merke, meldungFehler, sitzungFuerMeldung } from "../meldungen-speicher.js";
+import { ladeSpecText, sendeUmschlaege } from "./plan-senden.js";
+import { projektDesOrdners } from "./projekt-verbinden.js";
+/*
+  `kimal3 plan melde` -- Claude meldet der Projektseite EINE Aenderung (oder eine Liste), statt die ganze Datei
+  hochzuladen (Board in Echtzeit, Spec 1.1, 1.2, E-6, S-10, US-1, US-4).
+
+  Das Projekt kommt vom Ordnerzettel, nie aus einer Wahl (S-12). `entstanden` ist JETZT, `sitzung` die Nummer der
+  Claude-Sitzung: Beides setzt das Programm, nicht Claude -- eine von Hand gesetzte Zeit koennte eine fremde,
+  neuere Meldung verdraengen (E-2, E-6).
+
+  Nicht erreichbar -> gemerkt, Rueckgabewert 3; beim naechsten Befehl geht sie mit. Erfolg ist still (US-4).
+*/
+async function leseEingabe() {
+    if (process.stdin.isTTY)
+        return null;
+    const teile = [];
+    for await (const teil of process.stdin)
+        teile.push(Buffer.from(teil));
+    const text = Buffer.concat(teile).toString("utf8").replace(/^/, "");
+    return text.trim() === "" ? null : text;
+}
+export async function planMelde(argv) {
+    const t = MELDUNGEN_TEXTE[sprache()];
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(t.reportHelp);
+        return 0;
+    }
+    const projekt = projektDesOrdners();
+    if (projekt === null)
+        return 1;
+    const text = await leseEingabe();
+    if (text === null) {
+        console.error(t.noInput);
+        return 1;
+    }
+    let roh;
+    try {
+        roh = JSON.parse(text);
+    }
+    catch {
+        console.error(t.inputNoJson);
+        return 1;
+    }
+    const liste = Array.isArray(roh) ? roh : [roh];
+    if (liste.length === 0) {
+        console.error(t.noInput);
+        return 1;
+    }
+    for (const [i, m] of liste.entries()) {
+        const feld = meldungFehler(m);
+        if (feld !== null) {
+            console.error(t.reportUnreadable(i + 1, feld));
+            return 1;
+        }
+    }
+    const entstanden = new Date().toISOString();
+    // Prüfen ist nicht Arbeiten (Spec 2026-10-24 E-8): `--ohne-sitzung` schickt keine Sitzung mit, also leuchtet kein Punkt.
+    const sitzung = schalterOhneWert(argv, "ohne-sitzung").gesetzt ? null : sitzungFuerMeldung(process.env);
+    const umschlaege = liste.map((m) => ({ meldung: m, entstanden, sitzung }));
+    const sendung = await sendeUmschlaege(projekt.projektId, umschlaege);
+    const u = MELDUNGEN_TEXTE[sprache()];
+    // Erst die Absagen (je Satz einmal), dann was mit dem Rest geschieht.
+    for (const satz of new Set(sendung.je.flatMap((e) => (e.art === "abgesagt" ? [e.meldung] : []))))
+        console.error(satz);
+    const offen = umschlaege.filter((_, i) => sendung.je[i].art === "offen");
+    const p = sendung.problem;
+    if (offen.length > 0 && p !== null && p.art !== "absage") {
+        // Jede einzeln merken und zaehlen: Scheitert das Merken mittendrin, muss der Satz sagen, wie viele gemerkt sind.
+        const gemerkt = offen.filter((x) => merke(projekt.projektId, projekt.ordner, x)).length;
+        const satz = gemerkt === offen.length ? (p.art === "anmelden" ? u.storedSignIn : u.stored)
+            : gemerkt > 0 ? u.storedPartly(gemerkt, offen.length)
+                : p.art === "anmelden" ? p.meldung : u.notStored;
+        if (p.art === "anmelden" && gemerkt < offen.length && gemerkt > 0)
+            console.error(p.meldung);
+        console.error(satz);
+        return p.art === "anmelden" ? 2 : 3;
+    }
+    // Ruling Task 7: Eine Spec-Datei, die VOR ihrer Meldung geschrieben wurde, hat die App noch nicht -- jetzt mitnehmen.
+    // Fuer jede ANGENOMMENE Spec-Meldung, auch wenn eine andere der Liste abgesagt wurde.
+    let code = sendung.je.some((e) => e.art === "abgesagt") ? 1 : 0;
+    for (const [i, x] of umschlaege.entries()) {
+        const m = x.meldung;
+        if (sendung.je[i].art !== "angenommen" || m.art !== "spec" || m.datei === null)
+            continue;
+        const text = await ladeSpecText(projekt.projektId, projekt.ordner, m.schluessel, m.datei);
+        if (text === "anmelden") {
+            console.error(u.specTextSignIn(m.datei));
+            return 2;
+        }
+        if (text === "fehler") {
+            console.error(u.specTextFailed(m.datei));
+            code = 3;
+        }
+        else if (text === "zu-gross") {
+            console.error(u.specTextTooBig(m.datei));
+            if (code === 0)
+                code = 1;
+        }
+    }
+    return code;
+}