kimal3 0.6.5 → 0.7.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

@@ -136,6 +136,39 @@ 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`-Satz. Der Satz ist eine Anleitung für jemanden ohne Technik: wo man es findet, was man tut, was dann zu sehen ist, woran man merkt, dass es nicht stimmt. 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. Ohne Befehl: „Öffne in der App ‚Kennzahlen‘ und klick auf den Beitrag vom 14.10. — dort steht ‚4.210 gesehen‘. Steht dort eine leere Zelle, sag ‚Passt nicht‘.“ Mit Befehl: „Tippe in Claude Code im Projektordner `! node wortzaehler.js beispiel.txt` — es erscheinen fünf Zeilen, oben ‚der (4)‘. Kommt eine Fehlermeldung, sag ‚Passt nicht‘.“
+     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":"Öffne in der App ‚Testmonat‘ und klick „Starten“ — darunter steht ‚Endet am 30.11.‘. Steht dort ein anderes Datum, sag ‚Passt nicht‘."}`
+  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.
+  6. **Feierabend:** den Tag abgleichen — dort steht, wie.
+
+  „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

@@ -136,6 +136,39 @@ 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` sentence. The sentence is a guide for someone without technical knowledge: where to find it, what to do, what must appear, how to notice it is wrong. 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. Without a command: "In the app open 'Metrics' and click the post from 14 Oct - it says '4,210 seen'. If a cell is empty, say 'Doesn't work'." With a command: "In Claude Code in the project folder type `! node wortzaehler.js beispiel.txt` - five lines appear, at the top 'der (4)'. If an error message appears, say 'Doesn't work'."
+     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":"In the app open 'Test month' and click Start - below it says 'Ends on 30 Nov'. If it shows another date, say 'Doesn't work'."}`
+  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.
+  6. **Wrap-up:** reconcile the day — it says how.
+
+  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;
+}