kimal3 0.6.4 → 0.7.0

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

@@ -0,0 +1,197 @@
+import type { EngineInterface, On } from 'claude-code'
+import { anstossOhneZettel, gemerkteMeldungenAnstossen, sitzungNeu } from './erinnerung'
+import { fehlerSind } from './fehlerzeile'
+import { anApp, liesAusweis, umgebungLesen, type Lauf } from './lauf'
+import { lageJetzt } from './ordner'
+
+/**
+ * Den Punkt am Leben halten (Spec 1.3 Aufgabe 2, E-4, US-2; Bauplan R-5, Review Focus 5). Solange die Sitzung in einem
+ * Projektordner mit Ordnerzettel offen ist, meldet sich der Mod alle 10 Sekunden bei der App (`POST
+ * /api/mod/lebenszeichen`, gemessen M-2: der Zeitgeber laeuft auch, waehrend Claude arbeitet) und merkt sich, ob diese
+ * Sitzung eine Story „in Arbeit“ hat. Beim Ende der Sitzung meldet er sich ab, damit der Punkt in unter 1 Sekunde weg
+ * ist; ein abgeschossener Prozess meldet sich nie ab, dafuer gibt es die 30-Sekunden-Regel der App.
+ *
+ * Jeder Takt liest Ordner, Zettel und Ausweis neu: So kommt ein Zettel, den Claude nach dem Anstoss anlegt (US-8), und ein
+ * `kimal3 login` beim naechsten Takt an, ohne Neustart.
+ */
+const TAKT_MS = 10_000
+const MELDUNG = /\bplan\s+(melde|report|senden|send)\b/
+
+/**
+ * Die Nummer dieser Sitzung fuer `kimal3 plan melde` (Ruling Final, Important 2): Ob `CLAUDE_CODE_SESSION_ID` nach
+ * `/clear` neu ist, ist ungemessen -- der Mod setzt deshalb bei jedem Start, auch nach `/clear`, `KIMAL3_SITZUNG`, und
+ * das Programm nimmt sie vor Claudes eigener Variable (die bleibt unberuehrt). Gemessen am 23.10.: die Variable kommt
+ * bei einem Bash-Aufruf an (docs/qa/2026-10-23-brett-echtzeit-messungen.md, „Final — Sitzungskennung“). Scheitert das
+ * Setzen, laeuft der Mod weiter; das Programm faellt dann auf `CLAUDE_CODE_SESSION_ID` zurueck.
+ */
+async function sitzungFuerProgramm($: EngineInterface): Promise<void> {
+  await $.env.set('KIMAL3_SITZUNG', await $.session.id()).catch(() => undefined)
+}
+
+export function lebenszeichen(on: On, lauf: Lauf): void {
+  on('session.start', async ($, e, next) => {
+    const ergebnis = await next(e)
+    await sitzungFuerProgramm($)
+    await starte($, lauf)
+    return ergebnis
+  })
+  // Haengt sich eine Oberflaeche an, ohne dass es lief (etwa nach einem frueheren Fehlstart): noch einmal versuchen.
+  on('session.attach', async ($, e, next) => {
+    const ergebnis = await next(e)
+    await starte($, lauf)
+    return ergebnis
+  })
+  // `/clear` beendet die Sitzung (abgemeldet unten), der Prozess laeuft unter einer neuen Kennung weiter -- ohne
+  // `session.start`. Die neue Sitzung meldet sich deshalb hier wieder an.
+  on('classic.SessionStart', async ($, e, next) => {
+    const ergebnis = await next(e)
+    if (e.source === 'clear') {
+      Object.assign(lauf, { beendet: false, inArbeit: null, specDateien: [], abgelehnt: null, gemeldetFuer: null, meldungenPruefen: true })
+      await sitzungNeu($)
+      await sitzungFuerProgramm($)
+      await starte($, lauf)
+    }
+    return ergebnis
+  })
+  // Claude hat gerade gemeldet (`kimal3 plan melde`/`plan senden`): Was der Mod ueber „in Arbeit“ weiss, ist ab jetzt
+  // veraltet -- bis zu 10 s lang kaeme sonst die Erinnerung, obwohl die Meldung schon raus ist (Final-Review, Important 1).
+  // Also gilt es als unbekannt (keine Erinnerung), und ein Lebenszeichen holt sofort den neuen Stand. Ein Fehlalarm des
+  // Musters kostet nur ein Lebenszeichen mehr.
+  on('tool.call', { tool: ['Bash', 'PowerShell'] }, async ($, e, next) => {
+    const ergebnis = await next(e)
+    if (!MELDUNG.test(e.command)) return ergebnis
+    lauf.inArbeit = null
+    lauf.meldungen++
+    // Nur, wenn der Zeitgeber laeuft (Projektordner, nicht beendet): kein zweiter Zeitgeber, und `takt` faellt aus, wenn
+    // schon eines unterwegs ist -- dessen Antwort zaehlt dann nicht (`meldungen`), bis der naechste Takt fragt.
+    if (lauf.takt !== null) $.clock.after(0, () => void takt($, lauf))
+    return ergebnis
+  })
+  on('session.end', async ($, e, next) => {
+    // 🔴 ZUERST den Zeitgeber anhalten, DANN abmelden (Review Focus 5): sonst kann ein letzter Takt nach dem Abmelden
+    // ankommen. Die App lehnt ihn zwar ab (`410`), aber `beendet` haelt auch einen Takt an, der schon unterwegs ist.
+    lauf.beendet = true
+    lauf.generation++
+    lauf.takt?.cancel()
+    lauf.takt = null
+    lauf.inArbeit = null
+    // Die ganze Kette von `session.end` hat ~1,5 s (gemessen M-2); der Abruf endet vorher, damit Claude Code nicht
+    // mitten in ihm abschneidet und die Hooks nach uns ihre Zeit behalten.
+    const grenze = next.budget.remainingMs - 100
+    if (lauf.gemeldetFuer !== null) await abmelden($, lauf, lauf.gemeldetFuer, e.sessionId, grenze)
+    lauf.gemeldetFuer = null
+    return next(e)
+  })
+}
+
+async function starte($: EngineInterface, lauf: Lauf): Promise<void> {
+  // 🔴 `startet` steht VOR dem ersten `await`: `session.start` und `session.attach` kommen fast gleichzeitig, und
+  // beide bestanden sonst die Pruefung auf `takt` -- zwei Zeitgeber, einer davon nie angehalten (Befund der Durchsicht).
+  if (lauf.takt !== null || lauf.startet || lauf.beendet) return
+  lauf.startet = true
+  try {
+    await umgebungLesen($, lauf)
+    lauf.lage = await lageJetzt($)
+    // Kein Projektordner (Werkbank, Beispielordner, ausserhalb): der Mod tut nichts (S-30).
+    if (lauf.lage.art !== 'projekt') return
+    await anstossOhneZettel($, lauf)
+    lauf.takt = $.clock.every(TAKT_MS, () => void takt($, lauf))
+    // Das erste Lebenszeichen sofort (Punkt in unter 1 s, E-3), aber ohne den Sitzungsstart darauf warten zu lassen.
+    $.clock.after(0, () => void takt($, lauf))
+  } finally {
+    lauf.startet = false
+  }
+}
+
+/** Die Sitzung (`generation`), fuer die gerade ein Lebenszeichen unterwegs ist -- je Sitzung hoechstens eines. */
+let unterwegs: number | null = null
+
+async function takt($: EngineInterface, lauf: Lauf): Promise<void> {
+  // Ein Takt, dessen Vorgaenger noch auf die App wartet (langsames Netz), faellt aus, statt sich zu stapeln.
+  const generation = lauf.generation
+  if (lauf.beendet || unterwegs === generation) return
+  unterwegs = generation
+  try {
+    await einTakt($, lauf, generation)
+  } finally {
+    if (unterwegs === generation) unterwegs = null
+  }
+}
+
+async function einTakt($: EngineInterface, lauf: Lauf, generation: number): Promise<void> {
+  // Nach jedem `await`: Ist die Sitzung, fuer die dieser Takt lief, inzwischen vorbei (Ende, `/clear`), wirkt er nicht
+  // mehr -- sonst haelt ein spaetes `410` der alten Sitzung den Zeitgeber der neuen an.
+  const vorbei = () => lauf.beendet || lauf.generation !== generation
+  const lage = await lageJetzt($)
+  if (vorbei()) return
+  lauf.lage = lage
+  if (lage.art !== 'projekt') return
+  const ausweis = await liesAusweis($, lauf)
+  if (vorbei()) return
+  if ('fehler' in ausweis) {
+    lauf.inArbeit = null
+    return fehlerSind($, lauf, [ausweis.fehler])
+  }
+  const zettel = lage.zettel
+  // Ohne Zettel gibt es noch kein Projekt (den Anstoss bekam Claude beim Start); nach `403` fragt der Mod nicht mehr.
+  if (zettel === null || zettel.projekt_id === lauf.abgelehnt) return fehlerSind($, lauf, [])
+
+  const sitzung = await $.session.id()
+  if (vorbei()) return
+  // Kam waehrend des Abrufs eine Meldung, ist seine Antwort zu „in Arbeit“ womoeglich von davor: sie zaehlt nicht.
+  const meldungen = lauf.meldungen
+  lauf.gemeldetFuer = zettel.projekt_id
+  const antwort = await anApp($, lauf, '/api/mod/lebenszeichen', ausweis.schluessel, { projektId: zettel.projekt_id, sitzung })
+  if (vorbei()) return
+
+  if (antwort?.status === 200) {
+    const gelesen = antwortAus(antwort.text)
+    // Kann der Mod nicht feststellen, ob es geklappt hat, gilt es als Fehler (US-4).
+    if (gelesen === null) return fehlerSind($, lauf, ['nicht-erreichbar'])
+    if (lauf.meldungen === meldungen) lauf.inArbeit = gelesen.inArbeit
+    lauf.specDateien = gelesen.specDateien
+    fehlerSind($, lauf, [])
+    if (lauf.meldungenPruefen) {
+      lauf.meldungenPruefen = false
+      await gemerkteMeldungenAnstossen($, lauf)
+    }
+    return
+  }
+  if (antwort?.status === 401) return fehlerSind($, lauf, ['nicht-angemeldet'])
+  // `403`: das Projekt gehoert diesem Konto nicht (mehr) -- etwa ein Kollege mit demselben Repo, oder in der App
+  // geloescht (das klaert `kimal3 projekt verbinden`, S-31). Kein Fehler fuer den Menschen, kein weiterer Versuch.
+  if (antwort?.status === 403) {
+    lauf.abgelehnt = zettel.projekt_id
+    lauf.inArbeit = null
+    return fehlerSind($, lauf, [])
+  }
+  // `410`: diese Sitzung ist schon abgemeldet -- nie wiederbeleben, sonst kaeme der Punkt zurueck (Review Focus 5).
+  if (antwort?.status === 410) {
+    lauf.takt?.cancel()
+    lauf.takt = null
+    lauf.inArbeit = null
+    return fehlerSind($, lauf, [])
+  }
+  fehlerSind($, lauf, ['nicht-erreichbar'])
+}
+
+/** `{ inArbeit, specDateien }` aus der Antwort; ohne gueltiges `inArbeit` `null`. Fehlt `specDateien` (aeltere App): leer. */
+function antwortAus(text: string): { inArbeit: boolean; specDateien: string[] } | null {
+  try {
+    const o: unknown = JSON.parse(text)
+    const inArbeit = (o as { inArbeit?: unknown } | null)?.inArbeit
+    const dateien = (o as { specDateien?: unknown } | null)?.specDateien
+    if (typeof inArbeit !== 'boolean') return null
+    return { inArbeit, specDateien: Array.isArray(dateien) ? dateien.filter((d): d is string => typeof d === 'string') : [] }
+  } catch {
+    return null
+  }
+}
+
+async function abmelden($: EngineInterface, lauf: Lauf, projektId: string, sitzung: string, grenzeMs: number): Promise<void> {
+  const ausweis = await liesAusweis($, lauf)
+  if ('fehler' in ausweis) return
+  // Der Abruf brauchte gemessen 4 ms (M-2). Reicht die Zeit nicht, kostet das hoechstens den Punkt fuer 30 Sekunden.
+  const antwort = await anApp($, lauf, '/api/mod/abmelden', ausweis.schluessel, { projektId, sitzung }, grenzeMs)
+  if (antwort?.status !== 204) $.ui.log(`kimal3-plan: abmelden ${antwort === null ? 'nicht erreichbar' : antwort.status}`, { to: 'debug' })
+}

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;