kimal3 0.8.0 → 0.9.1

package/claude-plugins/kimal3-plan/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
-{
-  "name": "kimal3-plan",
-  "version": "0.1.1",
-  "description": "Hält das Board der Projektseite in der App aktuell: Punkt solange die Sitzung arbeitet, Spec-Texte, hält Claude vor dem ersten Bau-Schritt an · Keeps the board on the app's project page current: dot while the session works, spec texts, stops Claude before the first build step",
-  "author": { "name": "KImal3", "url": "https://kimal3.de" },
-  "types": "./types/index.d.ts"
-}
+{
+  "name": "kimal3-plan",
+  "version": "0.2.1",
+  "description": "Hält das Board der Projektseite in der App aktuell: Punkt solange die Sitzung arbeitet, ob Claude gerade arbeitet oder wartet, „Besprechen“ an Claude weitergeben, Spec-Texte, hält Claude vor dem ersten Bau-Schritt an · Keeps the board on the app's project page current: dot while the session works, whether Claude is working or waiting, passes ‘Discuss’ on to Claude, spec texts, stops Claude before the first build step",
+  "author": { "name": "KImal3", "url": "https://kimal3.de" },
+  "types": "./types/index.d.ts"
+}

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

@@ -0,0 +1,141 @@
+import { update, type EngineInterface, type On } from 'claude-code'
+import { TEXTE, zugestelltFuer, zustandVon, type Lauf } from './lauf'
+import { naechsteAntwort, sofort } from './lebenszeichen'
+
+/**
+ * „Im Gespräch“ (Spec docs/superpowers/specs/2026-10-26-im-gespraech-design.md, E-4, E-5, E-8, US-2, US-3; Bauplan Task 4,
+ * R-17). Zwei Aufgaben:
+ *
+ * 1. **Ob Claude gerade arbeitet** sieht der Mod selbst, ohne dass Claude etwas meldet (E-4): Jede Runde, die beginnt
+ *    (`turn.start`), kommt in eine Menge, jede, die endet (`turn.complete`, jeder Grund, auch Esc = `aborted`), geht
+ *    wieder hinaus — Hauptrunde UND Subagenten. Gemessen in der Probe (docs/qa/2026-10-26-im-gespraech-probe.md): Die
+ *    Hauptrunde kann VOR einem Subagenten im Hintergrund enden; „arbeitet“ gilt deshalb, solange irgendeine Runde offen
+ *    ist (G-14). „Wartet“ (E-5): ab einer Erlaubnis-Abfrage (`classic.PermissionRequest`, gemessen) oder während Claude mit
+ *    `AskUserQuestion` fragt — bis dieser Werkzeugaufruf endet (`classic.PostToolUse`, `PostToolUseFailure`,
+ *    `PermissionDenied`, gleiches Werkzeug, gleiche Schleife) oder die Runde seiner Schleife (R-34, R-35). Diese Ereignisse
+ *    umschließen nichts; ein `tool.call`-Haken um JEDES Werkzeug läge dagegen um den Start eines Subagenten, und „an agent's
+ *    start skips the hooks its spawn was nested in“ (Typen, `'turn.start'`). Jeder Wechsel löst sofort ein Lebenszeichen aus
+ *    (`sofort`); der Zustand reist ohnehin mit jedem Takt, so heilt der nächste eine verlorene Meldung (G-27).
+ * 2. **Dennis' Klick an Claude weitergeben** (E-8): Beim Abschicken einer Nachricht (`classic.UserPromptSubmit`, gemessen:
+ *    `additionalContext` kommt an) bekommt Claude den Satz „angeklickt“ bzw. „beendet“, wenn die App ihn für diesen Chat
+ *    `abholbar` nennt und die Nummer neu ist. Gewartet wird höchstens 1,5 s auf eine frische Antwort der App, sonst gilt
+ *    die letzte (QA 11: das Abschicken hängt nie 8 s). Die zugestellte Nummer steht in `$.state` und übersteht so ein
+ *    Neuladen des Mods; nach „angeklickt“ geht SOFORT ein Lebenszeichen mit `abgeholt` hinaus (R-17), damit ein zweiter
+ *    Chat den Klick nicht auch zustellt. Für „beendet“ kein `abgeholt` (die App meldet es dem tragenden Chat dauerhaft
+ *    `abholbar`; allein die Nummer in `$.state` verhindert die Wiederholung).
+ */
+
+/** Wie lange das Abschicken einer Nachricht höchstens auf eine frische Antwort der App wartet (US-3, QA 11). */
+const FRISCH_MS = 1_500
+
+// Geschrieben wird hier, gelesen in `zugestelltFuer` (lauf.ts, auch vom Lebenszeichen, R-33): je Projekt eine Nummer.
+const zugestellt = { plugin: 'kimal3-plan', key: 'zugestellt' } as const
+
+/** Ändert `f` den Zustand, erfährt es die App sofort. Kein `await`: Beginn und Ende einer Runde warten auf nichts. */
+function aendere($: EngineInterface, lauf: Lauf, f: () => void): void {
+  const vorher = zustandVon(lauf)
+  f()
+  if (lauf.runden.size === 0) lauf.wartet = null
+  if (zustandVon(lauf) !== vorher) sofort($, lauf)
+}
+
+/** Das Warten auf `werkzeug` in der Schleife `agent` (Hauptrunde: `undefined`) ist vorbei. */
+function wartenVorbei($: EngineInterface, lauf: Lauf, agent: string | undefined, werkzeug: string): void {
+  aendere($, lauf, () => {
+    if (lauf.wartet !== null && lauf.wartet.agent === agent && lauf.wartet.werkzeug === werkzeug) lauf.wartet = null
+  })
+}
+
+export function gespraech(on: On, lauf: Lauf): void {
+  // Nach `/clear` ist es ein neuer Chat: Er hat noch nichts zugestellt.
+  on('classic.SessionStart', { source: 'clear' }, async ($, e, next) => {
+    const ergebnis = await next(e)
+    await update($, zugestellt, () => ({}))
+    return ergebnis
+  })
+  on('turn.start', ($, e, next) => {
+    aendere($, lauf, () => lauf.runden.add(e.turnId))
+    return next(e)
+  })
+  // Jeder Grund schließt die Runde, auch `aborted` (Esc, G-26) und `error`. Eine Runde, deren Beginn der Mod nie hörte
+  // (vor dem Laden begonnen), ändert nichts. Mit ihr endet ein Warten ihrer Schleife (R-34): Endet die Runde, ohne dass
+  // das Werkzeug ein Ende meldete (abgelehnt, abgebrochen), wartet dort niemand mehr — auch wenn ein Subagent weiterläuft.
+  on('turn.complete', ($, e, next) => {
+    aendere($, lauf, () => {
+      lauf.runden.delete(e.turnId)
+      if (lauf.wartet?.agent === e.agentId) lauf.wartet = null
+    })
+    return next(e)
+  })
+  // US-6 (T-12): Beim Stop nennt Claude Code die laufende Hintergrund-Arbeit. Ein Befehl darin hält „arbeitet“, bis ein
+  // späterer Stop (die Runde, die seine Fertig-Meldung verarbeitet) ihn nicht mehr nennt. Subagenten zählen schon über ihre
+  // Runden; Monitore zählen nicht, weil einer ohne Ende laufen kann. Nur die Hauptrunde: Ein Subagent endet mit SubagentStop.
+  on('classic.Stop', ($, e, next) => {
+    aendere($, lauf, () => { lauf.hintergrund = (e.background_tasks ?? []).some(t => t.type === 'shell') })
+    return next(e)
+  })
+  // Nur beobachten: Die Abfrage selbst entscheidet der Mensch, der Haken antwortet nie mit `decision`.
+  on('classic.PermissionRequest', ($, e, next) => {
+    aendere($, lauf, () => {
+      if (lauf.runden.size > 0) lauf.wartet = { agent: e.agent_id, werkzeug: e.tool_name }
+    })
+    return next(e)
+  })
+  // Das Fragefenster: Nur dieser Haken umschließt den Aufruf (`next`), alle anderen Ereignisse hier beobachten nur.
+  on('tool.call', { tool: 'AskUserQuestion' }, async ($, e, next) => {
+    aendere($, lauf, () => {
+      if (lauf.runden.size > 0) lauf.wartet = { agent: e.agentId, werkzeug: e.tool }
+    })
+    try {
+      return await next(e)
+    } finally {
+      wartenVorbei($, lauf, e.agentId, e.tool)
+    }
+  })
+  // Das Werkzeug, auf das gewartet wurde, ist fertig, gescheitert oder abgelehnt (gleiches Werkzeug, gleiche Schleife). Ein
+  // Aufruf eines Subagenten, der nebenher endet, beendet das Warten der Hauptrunde nicht.
+  on('classic.PostToolUse', ($, e, next) => {
+    wartenVorbei($, lauf, e.agent_id, e.tool_name)
+    return next(e)
+  })
+  on('classic.PostToolUseFailure', ($, e, next) => {
+    wartenVorbei($, lauf, e.agent_id, e.tool_name)
+    return next(e)
+  })
+  on('classic.PermissionDenied', ($, e, next) => {
+    wartenVorbei($, lauf, e.agent_id, e.tool_name)
+    return next(e)
+  })
+  // R-36: zugestellt ist der Satz erst, wenn die Nachricht wirklich an Claude geht — nicht bei einer Nachricht, die ein
+  // anderer Haken anhält (`block`, `preventContinuation`), nicht beim Vorab-Durchgang eines Ereignisses (`poll_event`, die
+  // Typen: „before its delivery ack exists“), nicht in einem Subagenten.
+  on('classic.UserPromptSubmit', async ($, e, next) => {
+    const z = e.agent_id === undefined && e.source !== 'poll_event' ? await zustellbar($, lauf) : null
+    const ergebnis = await next(e)
+    if (z === null || ergebnis.block !== undefined || ergebnis.preventContinuation === true) return ergebnis
+    await update($, zugestellt, m => ({ ...m, [z.projekt]: Math.max(m?.[z.projekt] ?? 0, z.nummer) }))
+    if (z.aktiv) {
+      lauf.abholen = { projekt: z.projekt, nummer: z.nummer }
+      sofort($, lauf)
+    }
+    return { ...ergebnis, additionalContext: [...(ergebnis.additionalContext ?? []), z.satz] }
+  })
+}
+
+/** Der Satz, den dieser Chat jetzt zustellen darf, mit Projekt, Nummer und ob es „angeklickt“ ist — oder `null`. */
+async function zustellbar($: EngineInterface, lauf: Lauf): Promise<{ satz: string; projekt: string; nummer: number; aktiv: boolean } | null> {
+  // Ohne laufendes Lebenszeichen (kein Projektordner, kein Zettel, beendet) gibt es nichts abzuholen und nichts zu warten.
+  if (lauf.takt === null) return null
+  await new Promise<void>(fertig => {
+    const frist = $.clock.after(FRISCH_MS, fertig)
+    naechsteAntwort($, lauf).then(() => {
+      frist.cancel()
+      fertig()
+    })
+  })
+  const g = lauf.gespraech
+  if (g === null || !g.abholbar || g.quelle !== 'dennis' || g.nummer <= (await zugestelltFuer($, g.projekt))) return null
+  const texte = TEXTE[lauf.sprache]
+  const satz = g.aktiv ? texte.angeklickt(g.titel, g.datei) : texte.beendet(g.titel)
+  return { satz, projekt: g.projekt, nummer: g.nummer, aktiv: g.aktiv }
+}

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

@@ -37,16 +37,60 @@ export type Lauf = {
   /** Beim naechsten erfolgreichen Lebenszeichen nach gemerkten Meldungen sehen (R-4): beim Start und nach jedem Ausfall. */
   meldungenPruefen: boolean
   fehler: Set<Fehler>
+  /** Die offenen Runden (`turnId`), Hauptrunde und Subagenten: nicht leer = Claude arbeitet (hooks/gespraech.ts, E-4). */
+  runden: Set<string>
+  /** Beim letzten Stop der Hauptrunde lief ein Befehl im Hintergrund: Claude arbeitet weiter, auch ohne offene Runde (US-6, T-12). */
+  hintergrund: boolean
+  /** Worauf Claude gerade wartet (Erlaubnis, Fragefenster) und in welcher Schleife; `null`: auf nichts (E-5). */
+  wartet: { agent: string | undefined; werkzeug: string } | null
+  /** Das Gespräch aus der letzten Antwort der App; `null`: keins, oder eine App ohne „Im Gespräch“ (R-18). */
+  gespraech: (GespraechFuerMod & { projekt: string }) | null
+  /** Diese Nummer („angeklickt“) ist Claude zugestellt, die App weiß es noch nicht: Das nächste Lebenszeichen DIESES Projekts sagt `abgeholt`. */
+  abholen: { projekt: string; nummer: number } | null
+  /** Ein sofortiger Takt fiel aus, weil einer unterwegs war: gleich danach noch einer (der Nachzügler). */
+  nachzuegler: boolean
+  /** Wer auf die Antwort des nächsten Takts wartet (`naechsteAntwort`); ein Takt nimmt beim Start alle mit. */
+  wartende: (() => void)[]
   /** Was gerade in der Statuszeile steht (`undefined`: nichts; `null`: noch nie gesetzt -- die erste Auswertung nach dem
    * Laden ruft `$.ui.status` in jedem Fall und raeumt so eine Zeile ab, die ein frueherer Lauf stehen liess). */
   zeile: string | undefined | null
 }
 
+export type Zustand = 'still' | 'arbeitet' | 'wartet'
+
+/** Was das Lebenszeichen über das Gespräch sagt (`gespraechFuerMod` in `src/lib/planung/gespraech.ts`, Bauplan R-18). */
+export type GespraechFuerMod = { nummer: number; spec: string; titel: string; datei: string | null; aktiv: boolean; quelle: string; abholbar: boolean }
+
+/** Arbeitet Claude, wartet es, oder ist es fertig (hooks/gespraech.ts, E-4, E-5)? */
+export function zustandVon(lauf: Lauf): Zustand {
+  if (lauf.runden.size === 0) return lauf.hintergrund ? 'arbeitet' : 'still'
+  return lauf.wartet === null ? 'arbeitet' : 'wartet'
+}
+
+/** `gespraech` aus der Antwort; fehlt es (alte App, alter Rumpf) oder ist es kaputt: `null` — beides gleich (R-18). */
+export function gespraechAus(o: unknown): GespraechFuerMod | null {
+  const g = o as Partial<Record<keyof GespraechFuerMod, unknown>> | null | undefined
+  if (g === null || typeof g !== 'object') return null
+  const { nummer, spec, titel, datei, aktiv, quelle, abholbar } = g
+  if (!Number.isSafeInteger(nummer) || (nummer as number) < 1 || typeof spec !== 'string' || typeof titel !== 'string') return null
+  if (!(datei === null || typeof datei === 'string') || typeof aktiv !== 'boolean' || typeof quelle !== 'string' || typeof abholbar !== 'boolean') return null
+  return { nummer: nummer as number, spec, titel, datei, aktiv, quelle, abholbar }
+}
+
+/**
+ * Welche Nummer Claude je Projekt schon bekam (R-37): je `projekt_id`, damit ein Chat, der das Projekt wechselt, dort keinen
+ * Satz verschluckt. In `$.state`, damit ein Neuladen des Mods denselben Satz nicht noch einmal zustellt (US-3).
+ */
+export async function zugestelltFuer($: EngineInterface, projekt: string): Promise<number> {
+  const { value } = await $.state.get({ plugin: 'kimal3-plan', key: 'zugestellt' })
+  return value?.[projekt] ?? 0
+}
+
 export function neuerLauf(vorgabe: Sprache): Lauf {
   return {
     vorgabe, sprache: vorgabe, heim: null, basis: APP, lage: { art: 'kein-projektordner' }, inArbeit: null, meldungen: 0, specDateien: [],
     takt: null, startet: false, generation: 0, beendet: false, abgelehnt: null, gemeldetFuer: null, meldungenPruefen: true,
-    fehler: new Set(), zeile: null,
+    fehler: new Set(), zeile: null, runden: new Set(), hintergrund: false, wartet: null, gespraech: null, abholen: null, nachzuegler: false, wartende: [],
   }
 }
 
@@ -59,6 +103,9 @@ export const TEXTE = {
     erinnerung: (titel: string) => `Halt, die Datei ist noch nicht geändert: Du arbeitest im Projekt ${titel}, aber diese Sitzung hat keine Story ‚in Arbeit‘ gemeldet. Melde zuerst die Story, an der du arbeitest, und ändere die Datei danach. Gehört die Änderung zu keiner Story, notiere sie als Thema oder versuch es einfach noch einmal.`,
     anstoss: 'Für diesen Projektordner gibt es noch kein Projekt in der App — leg es mit `kimal3 projekt verbinden` an.',
     gemerkt: 'Gemerkte Meldungen warten — führe `kimal3 plan senden` aus.',
+    // Im Gespräch, E-8 (Wortlaute der Spec ohne Namen: Der Mod kennt den Vornamen des Eigentümers nicht).
+    angeklickt: (titel: string, datei: string | null) => `Auf dem Board wurde ‚${titel}‘${datei === null ? '' : ` (${datei})`} zum Besprechen angeklickt — darüber wird jetzt gesprochen.`,
+    beendet: (titel: string) => `Auf dem Board wurde das Gespräch über ‚${titel}‘ beendet.`,
     fehler: {
       'nicht-erreichbar': 'Die Projektseite ist gerade nicht erreichbar — ich versuche es gleich wieder.',
       'nicht-angemeldet': 'Du bist bei kimal3 nicht mehr angemeldet — `kimal3 login`.',
@@ -69,6 +116,8 @@ export const TEXTE = {
     erinnerung: (titel: string) => `Stop, the file has not been changed: You are working in the project ${titel}, but this session hasn't reported a story as ‘in progress’. Report the story you're working on first, then change the file. If the change belongs to no story, note it as a topic or simply try again.`,
     anstoss: 'There is no project in the app for this project folder yet — create it with `kimal3 project connect`.',
     gemerkt: 'Saved reports are waiting — run `kimal3 plan send`.',
+    angeklickt: (titel: string, datei: string | null) => `'${titel}'${datei === null ? '' : ` (${datei})`} was selected on the board to discuss — that's what this conversation is about now.`,
+    beendet: (titel: string) => `The discussion of '${titel}' was ended on the board.`,
     fehler: {
       'nicht-erreichbar': "The project page can't be reached right now — I'll try again shortly.",
       'nicht-angemeldet': "You're no longer signed in to kimal3 — `kimal3 login`.",

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

@@ -1,7 +1,7 @@
 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 { anApp, gespraechAus, liesAusweis, umgebungLesen, zugestelltFuer, zustandVon, type GespraechFuerMod, type Lauf } from './lauf'
 import { lageJetzt } from './ordner'
 
 /**
@@ -13,6 +13,11 @@ import { lageJetzt } from './ordner'
  *
  * 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.
+ *
+ * „Im Gespraech“ (Spec 2026-10-26-im-gespraech-design.md, US-2, US-3; hooks/gespraech.ts): Jedes Lebenszeichen traegt den
+ * Zustand (`still`/`arbeitet`/`wartet`), `faehig: true` und nach einer Zustellung `abgeholt`; die Antwort `gespraech` merkt
+ * sich der Mod. Ein Wechsel des Zustands loest einen sofortigen Takt aus (`sofort`); ist gerade einer unterwegs, kommt
+ * gleich danach ein Nachzuegler -- sonst fiele die Meldung bis zum naechsten 10-Sekunden-Takt aus.
  */
 const TAKT_MS = 10_000
 const MELDUNG = /\bplan\s+(melde|report|senden|send)\b/
@@ -47,6 +52,7 @@ export function lebenszeichen(on: On, lauf: Lauf): void {
     const ergebnis = await next(e)
     if (e.source === 'clear') {
       Object.assign(lauf, { beendet: false, inArbeit: null, specDateien: [], abgelehnt: null, gemeldetFuer: null, meldungenPruefen: true })
+      Object.assign(lauf, { runden: new Set(), wartet: null, gespraech: null, abholen: null, nachzuegler: false })
       await sitzungNeu($)
       await sitzungFuerProgramm($)
       await starte($, lauf)
@@ -75,6 +81,7 @@ export function lebenszeichen(on: On, lauf: Lauf): void {
     lauf.takt?.cancel()
     lauf.takt = null
     lauf.inArbeit = null
+    Object.assign(lauf, { runden: new Set(), wartet: null, gespraech: null, abholen: 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
@@ -84,6 +91,20 @@ export function lebenszeichen(on: On, lauf: Lauf): void {
   })
 }
 
+/** Ein Lebenszeichen sofort (hooks/gespraech.ts) -- nur, wenn der Zeitgeber laeuft (Projektordner, nicht beendet). */
+export function sofort($: EngineInterface, lauf: Lauf): void {
+  if (lauf.takt !== null) $.clock.after(0, () => void takt($, lauf, true))
+}
+
+/** Erfuellt sich, sobald ein Takt, der ab jetzt beginnt, seine Antwort hat (oder gleich, wenn keiner laeuft). */
+export function naechsteAntwort($: EngineInterface, lauf: Lauf): Promise<void> {
+  if (lauf.takt === null) return Promise.resolve()
+  return new Promise(fertig => {
+    lauf.wartende.push(fertig)
+    sofort($, lauf)
+  })
+}
+
 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).
@@ -106,15 +127,27 @@ async function starte($: EngineInterface, lauf: Lauf): Promise<void> {
 /** 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.
+async function takt($: EngineInterface, lauf: Lauf, sofort = false): Promise<void> {
+  // Ein Takt, dessen Vorgaenger noch auf die App wartet (langsames Netz), faellt aus, statt sich zu stapeln. Ein
+  // sofortiger (Zustand gewechselt, Satz zugestellt) merkt sich, dass gleich danach einer kommen muss -- hoechstens einer.
   const generation = lauf.generation
-  if (lauf.beendet || unterwegs === generation) return
+  if (lauf.beendet) return
+  if (unterwegs === generation) {
+    if (sofort) lauf.nachzuegler = true
+    return
+  }
   unterwegs = generation
+  // Wer jetzt wartet, bekommt die Antwort DIESES Takts; wer erst waehrend des Abrufs dazukommt, die des Nachzueglers.
+  const wartende = lauf.wartende.splice(0)
   try {
     await einTakt($, lauf, generation)
   } finally {
     if (unterwegs === generation) unterwegs = null
+    for (const fertig of wartende) fertig()
+    if (lauf.nachzuegler && !lauf.beendet && lauf.generation === generation) {
+      lauf.nachzuegler = false
+      $.clock.after(0, () => void takt($, lauf, true))
+    }
   }
 }
 
@@ -141,7 +174,11 @@ async function einTakt($: EngineInterface, lauf: Lauf, generation: number): Prom
   // 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 })
+  // Der Zustand im Augenblick des Abschickens; aendert er sich waehrend des Abrufs, kommt der Nachzuegler (`takt`).
+  // `abgeholt` nur an das Projekt, dessen Klick zugestellt wurde (R-37: der Chat kann den Ordner gewechselt haben).
+  const abgeholt = lauf.abholen?.projekt === zettel.projekt_id ? lauf.abholen.nummer : null
+  const rumpf = { projektId: zettel.projekt_id, sitzung, zustand: zustandVon(lauf), faehig: true, ...(abgeholt === null ? {} : { abgeholt }) }
+  const antwort = await anApp($, lauf, '/api/mod/lebenszeichen', ausweis.schluessel, rumpf)
   if (vorbei()) return
 
   if (antwort?.status === 200) {
@@ -150,6 +187,16 @@ async function einTakt($: EngineInterface, lauf: Lauf, generation: number): Prom
     if (gelesen === null) return fehlerSind($, lauf, ['nicht-erreichbar'])
     if (lauf.meldungen === meldungen) lauf.inArbeit = gelesen.inArbeit
     lauf.specDateien = gelesen.specDateien
+    const g = gelesen.gespraech
+    lauf.gespraech = g === null ? null : { ...g, projekt: zettel.projekt_id }
+    if (abgeholt !== null && lauf.abholen?.nummer === abgeholt) lauf.abholen = null
+    // R-33: Nennt die App einen Klick, den dieser Chat schon zugestellt hat, noch `abholbar`, hat das Eintragen nicht
+    // geklappt (oder die Antwort war von davor) -- das naechste Lebenszeichen sagt `abgeholt` noch einmal. Doppeltes
+    // Abholen ist harmlos (wer zuerst kommt, `abholen` in src/lib/planung/gespraech.ts); nie fuer „beendet“ (R-17).
+    if (g !== null && g.aktiv && g.abholbar && g.quelle === 'dennis' && g.nummer === (await zugestelltFuer($, zettel.projekt_id))) {
+      if (vorbei()) return
+      lauf.abholen = { projekt: zettel.projekt_id, nummer: g.nummer }
+    }
     fehlerSind($, lauf, [])
     if (lauf.meldungenPruefen) {
       lauf.meldungenPruefen = false
@@ -163,6 +210,7 @@ async function einTakt($: EngineInterface, lauf: Lauf, generation: number): Prom
   if (antwort?.status === 403) {
     lauf.abgelehnt = zettel.projekt_id
     lauf.inArbeit = null
+    lauf.gespraech = null
     return fehlerSind($, lauf, [])
   }
   // `410`: diese Sitzung ist schon abgemeldet -- nie wiederbeleben, sonst kaeme der Punkt zurueck (Review Focus 5).
@@ -170,19 +218,24 @@ async function einTakt($: EngineInterface, lauf: Lauf, generation: number): Prom
     lauf.takt?.cancel()
     lauf.takt = null
     lauf.inArbeit = null
+    lauf.gespraech = 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 {
+/**
+ * `{ inArbeit, specDateien, gespraech }` aus der Antwort; ohne gueltiges `inArbeit` `null`. Fehlt `specDateien` (aeltere
+ * App): leer. Fehlt `gespraech` oder ist es `null` (App vor „Im Gespraech“): kein Gespraech -- das bricht nichts.
+ */
+function antwortAus(text: string): { inArbeit: boolean; specDateien: string[]; gespraech: GespraechFuerMod | null } | 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') : [] }
+    const gespraech = gespraechAus((o as { gespraech?: unknown }).gespraech)
+    return { inArbeit, specDateien: Array.isArray(dateien) ? dateien.filter((d): d is string => typeof d === 'string') : [], gespraech }
   } catch {
     return null
   }

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

@@ -1,12 +1,14 @@
 import type { Register } from 'claude-code'
 import { erinnerung } from './erinnerung'
+import { gespraech } from './gespraech'
 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 --
+// Projektseite aktuell. Vier Aufgaben, je eine Datei: Punkt am Leben halten (lebenszeichen.ts), Spec-Texte hochladen
+// (spec-text.ts), Claude ans Melden erinnern (erinnerung.ts), „Im Gespraech“ -- ob Claude arbeitet, und Dennis' Klick auf
+// dem Board an Claude weitergeben (gespraech.ts, Spec 2026-10-26-im-gespraech-design.md). 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`.
 
@@ -17,6 +19,7 @@ const SPRACHE: 'de' | 'en' = 'de'
 export const register: Register = on => {
   const lauf = neuerLauf(SPRACHE)
   lebenszeichen(on, lauf)
+  gespraech(on, lauf)
   erinnerung(on, lauf)
   specText(on, lauf)
 }

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

@@ -14,6 +14,10 @@ import { liesDatei, normiert, relativImOrdner } from './ordner'
  *
  * 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).
+ *
+ * „Im Gespraech“ (Spec 2026-10-26-im-gespraech-design.md, E-2 Rang 3, G-8, G-13): Schreibt die HAUPTSITZUNG die Spec,
+ * geht ihre Kennung mit (`sitzung`) -- dann kommt die Spec von selbst ins Gespraech, wenn gerade keins laeuft. Ein Subagent
+ * (`e.agentId`) laedt den Text hoch, aber ohne Kennung: Er setzt nie ein Gespraech.
  */
 export function specText(on: On, lauf: Lauf): void {
   on('tool.call', { tool: ['Write', 'Edit'] }, async ($, e, next) => {
@@ -25,17 +29,18 @@ export function specText(on: On, lauf: Lauf): void {
     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))
+    const sitzung = e.agentId === undefined ? await $.session.id() : null
+    $.clock.after(0, () => void hochladen($, lauf, `${normiert(lage.ordner)}/${pfad}`, pfad, projektId, sitzung))
     return ergebnis
   })
 }
 
-async function hochladen($: EngineInterface, lauf: Lauf, datei: string, pfad: string, projektId: string): Promise<void> {
+async function hochladen($: EngineInterface, lauf: Lauf, datei: string, pfad: string, projektId: string, sitzung: string | null): 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 })
+  const antwort = await anApp($, lauf, '/api/mod/spec-text', ausweis.schluessel, { projektId, pfad, text, ...(sitzung === null ? {} : { sitzung }) })
   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 })

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

@@ -5,6 +5,10 @@ declare module 'claude-code' {
       letzteErinnerung: number | null
       // Der Anstoss „Projekt anlegen“ ging in dieser Sitzung schon an Claude (hooks/erinnerung.ts, US-8).
       anstossGegeben: boolean
+      // Je Projekt (`projekt_id`) die hoechste Nummer eines Gespraechs, deren Satz („angeklickt“/„beendet“) Claude in dieser
+      // Sitzung bekam; fehlt das Projekt: noch keine. In `$.state`, damit ein Neuladen des Mods denselben Satz nicht noch
+      // einmal zustellt (hooks/gespraech.ts, US-3, R-37).
+      zugestellt: Partial<Record<string, number>>
     }
   }
 }

package/coach/de/kimal3-coach.md

@@ -148,20 +148,39 @@ Das Board in der App zeigt nur, was du meldest: Wer nicht meldet, lässt es stun
   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,
+- **Du meldest zu sieben 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
+  1. **Eine Spec entsteht oder ihre Stories ändern sich:** Eine neue Spec meldest du, **sobald der Mensch sagt, dass eine Spec
+     entstehen soll** (oder deinem Vorschlag dazu zustimmt) — vor der ersten Rückfrage, vor dem ersten geschriebenen Satz, auch
+     ohne Stories. Schlüssel ist der Dateiname, den sie bekommt, ohne `.md`. Legst du sie dem Menschen zum Lesen vor (nach deinen
+     eigenen Prüfrunden), meldest du sie mit ihren Stories und `"wartet_auf_lesen":true` — an der Karte steht dann „Wartet auf
+     dein Lesen“. Sagt er „Passt“, meldest du sie mit `"wartet_auf_lesen":false`; sagt er, was nicht passt, bleibt das Etikett,
+     bis du überarbeitet hast und er „Passt“ sagt. Überarbeitest du sie nach „Passt“ so, dass er sie neu lesen muss, setzt du es
+     wieder. 🔑 **Eine Spec ist eine Karte:** keine Nebenkarten wie „Spec schreiben: …“ oder „Bauplan: …“, weder als
+     Spec noch als Thema.
+     `{"art":"spec","schluessel":"2026-10-24-testmonat-design","titel":"Testmonat","datei":"docs/superpowers/specs/2026-10-24-testmonat-design.md","stories":[]}`
+     `{"art":"spec","schluessel":"2026-10-24-testmonat-design","titel":"Testmonat","datei":"docs/superpowers/specs/2026-10-24-testmonat-design.md","stories":[{"schluessel":"US-1","titel":"Der Testmonat startet"}],"wartet_auf_lesen":true}`
+  2. **Das Thema im Chat ist eine Spec** (der Mensch spricht über eine, oder du legst eine an): wann immer das Thema zu einer
+     anderen Spec wechselt, nicht bei jeder Nachricht; im Zweifel melden — doppelt schadet nicht. An der Karte steht dann „Im
+     Gespräch“. Bei einer neuen Spec beides in einer Liste, die Spec zuerst. Sagt der Mensch im Chat, er sei damit fertig,
+     meldest du das Ende mit `"spec":null` und nennst in `"war"` immer die Spec, über die ihr gesprochen habt — hat der Mensch
+     inzwischen eine andere Karte angeklickt, beendet deine Meldung dann nicht deren Gespräch. Immer mit Sitzung, also ohne
+     `--ohne-sitzung`. Sagt die App „Über diese Karte spricht gerade ein anderer Chat.“: nichts tun, das Gespräch trägt ein
+     anderer Chat. Sagt sie „… braucht den Chat, aus dem sie kommt.“: mit Sitzung noch einmal melden, nicht mit
+     `--ohne-sitzung`. Sagt sie „Dieser Chat hat den alten Board-Mod.“: dem Menschen sagen, er soll `/reload-plugins` tippen
+     oder Claude neu starten, danach noch einmal melden. Sagt sie „Dieser Chat ist nicht mehr offen“ (eine gemerkte Meldung kam
+     erst später an): nichts tun — gilt das Thema noch, meldest du es aus dem Chat, in dem ihr gerade sprecht.
+     `{"art":"gespraech","spec":"2026-10-24-testmonat-design"}` · `{"art":"gespraech","spec":null,"war":"2026-10-24-testmonat-design"}`
+  3. **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.
+     `{"art":"story","spec":"2026-10-24-testmonat-design","story":"US-1","stand":"in_arbeit"}`
+  4. **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.
+     `{"art":"story","spec":"2026-10-24-testmonat-design","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."}`
+  5. **Etwas fällt auf, das keine Spec verspricht:** `{"art":"thema","schluessel":"T-4","text":"Der Kalender könnte Feiertage zeigen"}`
+  6. **`/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“, mit `"pruefen":true` — so kommt die Karte dabei nicht ins Gespräch. Stories in „Dein Test“ oder „Fertig“ meldest du beim Abgleich nicht neu.
+  7. **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.
 
@@ -174,7 +193,9 @@ Das Board in der App zeigt nur, was du meldest: Wer nicht meldet, lässt es stun
   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.
+  warten — `kimal3 plan senden`“ · der Mensch hat auf dem Board eine Karte zum Besprechen angeklickt oder das Gespräch beendet
+  (dann sprichst du über diese Spec bzw. nicht mehr; ein `gespraech` meldest du dafür nicht). 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

package/coach/en/kimal3-coach.md

@@ -148,20 +148,38 @@ The board in the app shows only what you report: if you don't, it shows "Open" f
   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,
+- **You report at seven 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
+  1. **A spec comes into being or its stories change:** you report a new spec **as soon as the person says a spec should be
+     written** (or agrees to your suggestion of one) — before the first question back, before the first written sentence, even
+     without stories. The key is the file name it will get, without `.md`. When you hand it to the person to read (after your own
+     review rounds), you report it with its stories and `"wartet_auf_lesen":true` — the card then shows "Waiting for you to
+     read". If they say it works, you report it with `"wartet_auf_lesen":false`; if they say what doesn't work, the label stays
+     until you have revised it and they say it works. If you revise it after "works" so that they have to read it again, you set
+     it again. 🔑 **A spec is one card:** no side cards like "Write spec: …" or "Build plan: …", neither as a spec nor as a topic.
+     `{"art":"spec","schluessel":"2026-10-24-test-month-design","titel":"Test month","datei":"docs/superpowers/specs/2026-10-24-test-month-design.md","stories":[]}`
+     `{"art":"spec","schluessel":"2026-10-24-test-month-design","titel":"Test month","datei":"docs/superpowers/specs/2026-10-24-test-month-design.md","stories":[{"schluessel":"US-1","titel":"The test month starts"}],"wartet_auf_lesen":true}`
+  2. **The topic in the chat is a spec** (the person talks about one, or you are creating one): whenever the topic switches to
+     another spec, not with every message; when in doubt, report — sending twice does no harm. The card then shows "In
+     discussion". For a new spec, both in one list, the spec first. If the person says in the chat that they are done with it,
+     you report the end with `"spec":null` and always name the spec you were discussing in `"war"` — if the person has clicked
+     another card in the meantime, your report then doesn't end that card's discussion. Always with the session, so without
+     `--no-session`. If the app says "Another chat is discussing this card right now.": do nothing, another chat carries the
+     discussion. If it says "… needs the chat it comes from.": report again with the session, not with `--no-session`. If it
+     says "This chat has the old board mod.": tell the person to type `/reload-plugins` or restart Claude, then report again.
+     If it says "This chat is no longer open" (a stored report arrived later): do nothing — if the topic still applies,
+     report it from the chat you are talking in now.
+     `{"art":"gespraech","spec":"2026-10-24-test-month-design"}` · `{"art":"gespraech","spec":null,"war":"2026-10-24-test-month-design"}`
+  3. **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.
+     `{"art":"story","spec":"2026-10-24-test-month-design","story":"US-1","stand":"in_arbeit"}`
+  4. **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.
+     `{"art":"story","spec":"2026-10-24-test-month-design","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."}`
+  5. **Something comes up that no spec promises:** `{"art":"thema","schluessel":"T-4","text":"The calendar could show public holidays"}`
+  6. **`/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, with `"pruefen":true` — so the card doesn't come into discussion meanwhile. Stories under "Your test" or "Done" you do not report again during the reconciliation.
+  7. **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.
 
@@ -174,7 +192,8 @@ The board in the app shows only what you report: if you don't, it shows "Open" f
   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.
+  waiting — `kimal3 plan send`" · the person clicked a card on the board to discuss it, or ended the discussion (then you talk
+  about that spec, or no longer; you don't report a `gespraech` for it). 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

package/dist/anmeldung.js

@@ -49,7 +49,3 @@ export function loescheAnmeldung() {
     }
     catch { /* war schon weg */ }
 }
-/** Nur fuer Meldungen an den Menschen — damit er weiss, wo die Datei liegt. */
-export function anmeldungsPfad() {
-    return DATEI;
-}