kimal3 0.8.0 → 0.9.0

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",
+  "version": "0.2.0",
+  "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,134 @@
+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)
+  })
+  // 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,58 @@ 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>
+  /** 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 '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(), wartet: null, gespraech: null, abholen: null, nachzuegler: false, wartende: [],
   }
 }
 
@@ -59,6 +101,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 +114,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/meldungen-speicher.js

@@ -40,6 +40,8 @@ export function meldungFehler(m) {
         case "spec":
             if (!istText(m.schluessel) || !istText(m.titel) || !istTextOderNull(m.datei) || !Array.isArray(m.stories))
                 return "meldung";
+            if (m.wartet_auf_lesen !== undefined && typeof m.wartet_auf_lesen !== "boolean")
+                return "meldung";
             return m.stories.every((s) => istObjekt(s) && istText(s.schluessel) && istText(s.titel)) ? null : "meldung";
         case "story":
             if (!istText(m.spec) || !istText(m.story) || typeof m.stand !== "string" || !STAENDE.includes(m.stand))
@@ -50,10 +52,13 @@ export function meldungFehler(m) {
                 return "meldung";
             if (m.befunde !== undefined && !Array.isArray(m.befunde))
                 return "meldung";
+            if (m.pruefen !== undefined && typeof m.pruefen !== "boolean")
+                return "meldung";
             return (m.testen === undefined || istTextOderNull(m.testen)) && (m.grund === undefined || istTextOderNull(m.grund)) ? null : "meldung";
         case "thema": return istText(m.schluessel) && istText(m.text) ? null : "meldung";
         case "uebernommen": return Number.isInteger(m.rueckmeldung) && istText(m.antwort) ? null : "meldung";
         case "eingeordnet": return istText(m.schluessel) && istText(m.text) && istText(m.antwort) ? null : "meldung";
+        case "gespraech": return istTextOderNull(m.spec) && (m.war === undefined || (istText(m.war) && m.spec === null)) ? null : "meldung";
         default: return "art";
     }
 }

package/dist/texte/meldungen.js

@@ -29,7 +29,7 @@ const de = {
   Meldet der Projektseite eine Änderung: liest eine Meldung oder eine Liste
   von Meldungen als JSON von der Eingabe, zum Beispiel
     echo '{"art":"story","spec":"testmonat","story":"US-2","stand":"in_arbeit"}' | kimal3 plan melde
-  Arten: spec, story, thema, uebernommen, eingeordnet.
+  Arten: spec, story, thema, uebernommen, eingeordnet, gespraech.
 
   --ohne-sitzung     Meldet ohne die Nummer der Claude-Sitzung (für das
                      Prüfen von Specs): Auf dem Board leuchtet kein Punkt.
@@ -91,7 +91,7 @@ const en = {
   Reports a change to the project page: reads one report or a list of
   reports as JSON from the input, for example
     echo '{"art":"story","spec":"testmonat","story":"US-2","stand":"in_arbeit"}' | kimal3 plan report
-  Kinds (field "art"): spec, story, thema, uebernommen, eingeordnet.
+  Kinds (field "art"): spec, story, thema, uebernommen, eingeordnet, gespraech.
 
   --no-session       Reports without the Claude session number (for checking
                      specs): no dot lights up on the board.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kimal3",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal. · Log your AI projects where they happen: in the terminal.",
   "type": "module",
   "bin": {

package/skill/commands/k3feierabend.md

@@ -28,7 +28,7 @@ und überspring ihn — kein Leerlauf.
   `~/.claude/skills/kimal3/SKILL.md`):
 
   ```json
-  [ { "art": "story", "spec": "2026-10-24-testmonat", "story": "US-1", "stand": "gebaut",
+  [ { "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 /testmonat.\n2. Klick „Starten“.\n3. Darunter steht „Endet am 30.11.“.\nPasst nicht, wenn: dort ein anderes Datum steht." } ]
   ```
@@ -36,7 +36,7 @@ und überspring ihn — kein Leerlauf.
   Und was unfertig bleibt, getrennt davon, mit dem Schalter:
 
   ```json
-  [ { "art": "story", "spec": "2026-10-24-testmonat", "story": "US-2", "stand": "in_arbeit" } ]
+  [ { "art": "story", "spec": "2026-10-24-testmonat-design", "story": "US-2", "stand": "in_arbeit" } ]
   ```
 
   ```

package/skill/commands/k3plan.md

@@ -43,7 +43,7 @@ Du löschst sie nicht selbst.
 **Was die Ausgabe heißt** (Beispiel, erfundene Werte):
 
 ```
-Spec 2026-09-23-content-planer · Content-Planer als Seite (plan/2026-09-23-content-planer-seite-spec.md)
+Spec 2026-09-23-content-planer · Content-Planer als Seite (plan/2026-09-23-content-planer.md)
   US-1 · gebaut · Runde 1 · Beiträge anlegen
   US-2 · in Arbeit · Runde 1 · Beiträge im Kalender verschieben
 Notiertes Thema T-3: Export als PDF
@@ -130,7 +130,7 @@ Gegenprobe laufen kann.
 
 **Der `testen`-Text** (bei jeder `gebaut`-Story, höchstens 1000 Zeichen) ist eine Anleitung für jemanden ohne Technik. Steht die Story in einer Spec mit der Kiste „So testest du es“, nimmst du ihn von dort, wörtlich; fehlt die Kiste, schreibst du ihn selbst. **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: …“. Im JSON trennst du die Zeilen mit `\n`: Ein echter Zeilenumbruch im Text bricht das JSON, und `kimal3 plan melde` liest die Meldung nicht. Ist der Text länger als 1000 Zeichen, kürze die Schritte — nie mitten im Satz abschneiden, die Zeile „Passt nicht, wenn: …“ muss am Ende stehen bleiben. 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. Fehlt der Text, zeigt die App: „Claude hat nicht aufgeschrieben, wie man das testet".
 
-**Prüfen ist Arbeit.** Bevor du eine Story mit offenen Gegenproben (Spalte „Claude-Test offen“) gegen den Code prüfst, meldest du sie als `in_arbeit` **mit** der Sitzung (also ohne `--ohne-sitzung`): Solange du prüfst, leuchtet der Punkt am Projekt. Nach der Prüfung meldest du das Ergebnis (`gebaut`, oder `in_arbeit` mit Befund). Stories in „Dein Test“ oder „Fertig“ meldest du beim Abgleich **nicht** neu, auch wenn du sie durchsiehst: `in_arbeit` und danach `gebaut` setzt ihr Baudatum auf heute, und jede Meldung zeigt das Etikett „geändert“ und bei zwei Sitzungen das ⚠ „gleichzeitig geändert“. Was am Ende von `/k3plan` unfertig bleibt, meldest du mit `--ohne-sitzung` (Abschnitt 6).
+**Prüfen ist Arbeit.** Bevor du eine Story mit offenen Gegenproben (Spalte „Claude-Test offen“) gegen den Code prüfst, meldest du sie als `in_arbeit` **mit** der Sitzung (also ohne `--ohne-sitzung`) **und mit `"pruefen": true`**: Solange du prüfst, leuchtet der Punkt am Projekt, aber die Karte kommt dadurch nicht ins Gespräch — ohne das Feld wanderte der blaue Rahmen durch jede Spec, die du prüfst. Nach der Prüfung meldest du das Ergebnis (`gebaut`, oder `in_arbeit` mit Befund — jede `in_arbeit`-Meldung aus `/k3plan` trägt `"pruefen": true`). Stories in „Dein Test“ oder „Fertig“ meldest du beim Abgleich **nicht** neu, auch wenn du sie durchsiehst: `in_arbeit` und danach `gebaut` setzt ihr Baudatum auf heute, und jede Meldung zeigt das Etikett „geändert“ und bei zwei Sitzungen das ⚠ „gleichzeitig geändert“. Was am Ende von `/k3plan` unfertig bleibt, meldest du mit `--ohne-sitzung` (Abschnitt 6).
 
 **Wie eine Spec aufgebaut ist.** Findest du beim Prüfen eine Spec, die nicht so gebaut ist, sag es im Bericht — du schreibst sie nicht um. Eine Story steht darin in vier Kisten: **User Story** (der Titel nennt das Ziel des Menschen) · **Akzeptanzkriterium** (mit Gegenprobe) · **So testest du es** (nummerierte Schritte, darunter „Passt nicht, wenn: …“) · **Technische Notiz**.
 
@@ -165,7 +165,7 @@ Die App zeigt sie dem Menschen in genau diesem Wortlaut („So bleibt die Planun
 **Was du danach tust** (jedes Mal eine Meldung, Abschnitt 6):
 
 - **Regel 1 — jedes `passt nicht` aus `kimal3 plan`:** Gibt es die Story noch, melde sie mit dem Satz
-  des Menschen als Befund (`quelle: "mensch"`, `seit: "<heute>"`) und `stand: "in_arbeit"`, und
+  des Menschen als Befund (`quelle: "mensch"`, `seit: "<heute>"`), `stand: "in_arbeit"` und `"pruefen": true`, und
   gleich dahinter in derselben Liste `uebernommen` mit der Nummer: `{ "art": "uebernommen",
   "rueckmeldung": 12, "antwort": "Befund an US-2" }`. Ist sie seitdem schon nachgebessert,
   stattdessen `runde` + 1, `befunde: []` und `stand: "gebaut"` (Abschnitt 4). Gibt es die Story
@@ -207,7 +207,7 @@ Die App zeigt sie dem Menschen in genau diesem Wortlaut („So bleibt die Planun
 
 Jede Meldung ist ein JSON-Objekt, mehrere eine Liste. Sie geht über die Eingabe an
 `kimal3 plan melde`; das Programm setzt die Zeit selbst, das Projekt kommt vom Ordnerzettel
-`plan/projekt.json`. Prüfen ist Arbeit — mit der Sitzung gemeldet leuchtet auf dem Board der Punkt, solange du prüfst.
+`plan/projekt.json`. Prüfen ist Arbeit — mit der Sitzung gemeldet leuchtet auf dem Board der Punkt, solange du prüfst; `"pruefen": true` an jeder `in_arbeit`-Meldung hält die Karte dabei aus dem Gespräch.
 
 ```
 echo '[ … ]' | kimal3 plan melde
@@ -229,17 +229,21 @@ echo '[ … ]' | kimal3 plan melde --ohne-sitzung
 **Eine Spec** — beim Prüfen und wenn Stories dazukommen:
 
 ```json
-{ "art": "spec", "schluessel": "2026-10-24-testmonat", "titel": "Testmonat",
+{ "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" },
                { "schluessel": "US-2", "titel": "Der Testmonat endet" },
                { "schluessel": "US-3", "titel": "Export des Testmonats" } ] }
 ```
 
+Lass dabei `wartet_auf_lesen` weg: Fehlt das Feld, bleibt das Etikett „Wartet auf dein Lesen“, wie es ist. Gesetzt und
+weggenommen wird es, wenn du eine Spec dem Menschen zum Lesen vorlegst und er sie freigibt (Coach, Abschnitt 3.6) — genauso die Meldung
+`gespraech`; `/k3plan` schickt keine.
+
 **Eine Story** — eine Abweichung, ein Eintrag. Gebaut, mit Gegenprobe:
 
 ```json
-{ "art": "story", "spec": "2026-10-24-testmonat", "story": "US-1", "stand": "gebaut",
+{ "art": "story", "spec": "2026-10-24-testmonat-design", "story": "US-1", "stand": "gebaut",
   "kriterien": [ { "text": "Startet Sabine am 1.11., endet der Testmonat 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." }
 ```
@@ -247,14 +251,14 @@ echo '[ … ]' | kimal3 plan melde --ohne-sitzung
 Mit einem offenen Befund (hier von dir; `quelle: "mensch"` nur für den Satz des Menschen):
 
 ```json
-{ "art": "story", "spec": "2026-10-24-testmonat", "story": "US-2", "stand": "in_arbeit",
+{ "art": "story", "spec": "2026-10-24-testmonat-design", "story": "US-2", "stand": "in_arbeit", "pruefen": true,
   "befunde": [ { "text": "Am 30.11. fehlt die Erinnerungsmail, die die Spec verspricht.", "quelle": "claude", "seit": "2026-10-23" } ] }
 ```
 
 Bewusst weggelassen (`grund` ist Pflicht):
 
 ```json
-{ "art": "story", "spec": "2026-10-24-testmonat", "story": "US-3", "stand": "weggelassen", "grund": "Die Spec streicht den Export." }
+{ "art": "story", "spec": "2026-10-24-testmonat-design", "story": "US-3", "stand": "weggelassen", "grund": "Die Spec streicht den Export." }
 ```
 
 **Ein Thema** (Regel 2), **ein Thema von dir einordnen** (Regel 3), **eine Rückmeldung des Menschen
@@ -284,6 +288,8 @@ angemeldet: Sag dem Menschen `kimal3 login`; die Meldung ist gemerkt.
 | `Rückmeldung 12 gibt es in diesem Projekt nicht oder steht zweimal …` | Nur Nummern aus `kimal3 plan`, jede einmal. |
 | `Rückmeldung 12 („…“) ist als übernommen gemeldet, aber US-2 hat keinen Befund von dir …` | Erst die Story mit dem Befund `quelle: "mensch"` melden (Regel 1) — oder `runde` + 1, wenn nachgebessert ist — dann `uebernommen`. |
 | `Der Plan ist nicht lesbar: <Ort> …` | Die genannte Stelle der Meldung berichtigen (Länge, `grund` bei `weggelassen`, doppelter Schlüssel). |
+| `Die Meldung „Im Gespräch“ braucht den Chat, aus dem sie kommt.` | Mit Sitzung noch einmal melden, nicht mit `--ohne-sitzung`. |
+| `Über diese Karte spricht gerade ein anderer Chat.` | Nichts tun: Das Gespräch trägt ein anderer Chat. |
 | `Die Meldung ist angekommen, der Text von <Datei> aber nicht …` | Die Meldung noch einmal schicken — doppelt schadet nicht. Passt der Text nicht mehr (über 300 KB), sag es dem Menschen. |
 | `Die Meldungen sind gespeichert, aber noch nicht ganz vermerkt.` | Noch einmal schicken — doppelt schadet nicht. |
 | `Die gespeicherte Planung in der App ist beschädigt …` | Sag es dem Menschen. `kimal3 plan hoch --ueberschreiben` ersetzt die Planung durch eine ganze Datei `plan/stand.json` — **nur nach seinem ausdrücklichen Ja.** |

package/skill/en/commands/k3plan.md

@@ -41,7 +41,7 @@ not needed any more — the state is in the app. You can delete it." You do not
 **What the output means** (example, made-up values):
 
 ```
-Spec 2026-09-23-content-planner · Content planner as a page (plan/2026-09-23-content-planner-page-spec.md)
+Spec 2026-09-23-content-planner · Content planner as a page (plan/2026-09-23-content-planner.md)
   US-1 · built · round 1 · Create posts
   US-2 · in progress · round 1 · Move posts in the calendar
 Noted topic T-3: Export as PDF
@@ -125,7 +125,7 @@ run.
 
 **The `testen` text** (on every `gebaut` story, at most 1000 characters) is a guide for someone without technical knowledge. If the story sits in a spec with the box "How you test it", you take it from there, word for word; if the box is missing, you write it yourself. **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. If the text is longer than 1000 characters, shorten the steps — never cut off in the middle of a sentence; the line "Doesn't work if: …" must stay at the end. 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. If the text is missing, the app shows: "Claude didn't write down how to test this".
 
-**Checking is work.** Before you check a story with pending counter-checks (column "Claude test pending") against the code, you report it as `in_arbeit` **with** the session (so without `--no-session`): while you check, the dot at the project glows. After the check you report the result (`gebaut`, or `in_arbeit` with a finding). Stories under "Your test" or "Done" you do **not** report again during the reconciliation, even if you look through them: `in_arbeit` followed by `gebaut` sets their build date to today, and every report shows the label "changed" and, with two sessions, the ⚠ "changed at the same time". What stays unfinished at the end of `/k3plan`, you report with `--no-session` (section 6).
+**Checking is work.** Before you check a story with pending counter-checks (column "Claude test pending") against the code, you report it as `in_arbeit` **with** the session (so without `--no-session`) **and with `"pruefen": true`**: while you check, the dot at the project glows, but the card doesn't come into discussion — without the field the blue frame would wander through every spec you check. After the check you report the result (`gebaut`, or `in_arbeit` with a finding — every `in_arbeit` report from `/k3plan` carries `"pruefen": true`). Stories under "Your test" or "Done" you do **not** report again during the reconciliation, even if you look through them: `in_arbeit` followed by `gebaut` sets their build date to today, and every report shows the label "changed" and, with two sessions, the ⚠ "changed at the same time". What stays unfinished at the end of `/k3plan`, you report with `--no-session` (section 6).
 
 **How a spec is built.** If you find a spec while checking that is not built like this, say so in the report — you do not rewrite it. A story in it sits in four boxes: **User story** (the title names the person's goal) · **Acceptance criterion** (with counter-check) · **How you test it** (numbered steps, below them "Doesn't work if: …") · **Technical note**.
 
@@ -160,8 +160,8 @@ The app shows them to the person in exactly this wording ("How planning stays sh
 **What you do with them** (every time a report, section 6):
 
 - **Rule 1 — every `doesn't work` from `kimal3 plan`:** if the story still exists, report it with
-  the person's sentence as a finding (`quelle: "mensch"`, `seit: "<today>"`) and
-  `stand: "in_arbeit"`, and right behind it in the same list `uebernommen` with the number:
+  the person's sentence as a finding (`quelle: "mensch"`, `seit: "<today>"`),
+  `stand: "in_arbeit"` and `"pruefen": true`, and right behind it in the same list `uebernommen` with the number:
   `{ "art": "uebernommen", "rueckmeldung": 12, "antwort": "Finding on US-2" }`. If it has already
   been fixed since, raise `runde` by 1 instead, with `befunde: []` and `stand: "gebaut"`
   (section 4). If the story no longer exists, the `antwort` says why. ⚠️ Without a finding from
@@ -202,7 +202,7 @@ The app shows them to the person in exactly this wording ("How planning stays sh
 
 A report is a JSON object, several are a list. It goes through the input to `kimal3 plan report`;
 the program sets the time itself, and the project comes from the folder note
-`plan/projekt.json`. Checking is work — reported with the session, the dot on the board glows while you check.
+`plan/projekt.json`. Checking is work — reported with the session, the dot on the board glows while you check; `"pruefen": true` on every `in_arbeit` report keeps the card out of discussion meanwhile.
 
 ```
 echo '[ … ]' | kimal3 plan report
@@ -224,17 +224,21 @@ echo '[ … ]' | kimal3 plan report --no-session
 **A spec** — when checking, and when stories are added:
 
 ```json
-{ "art": "spec", "schluessel": "2026-10-24-test-month", "titel": "Test month",
+{ "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" },
                { "schluessel": "US-2", "titel": "The test month ends" },
                { "schluessel": "US-3", "titel": "Export of the test month" } ] }
 ```
 
+Leave out `wartet_auf_lesen` here: if the field is missing, the label "Waiting for you to read" stays as it is. It is set
+and removed when you hand a spec to the person to read and they approve it (coach, section 3.6) — the same goes for the report
+`gespraech`; `/k3plan` sends none.
+
 **A story** — one deviation, one entry. Built, with a counter-check:
 
 ```json
-{ "art": "story", "spec": "2026-10-24-test-month", "story": "US-1", "stand": "gebaut",
+{ "art": "story", "spec": "2026-10-24-test-month-design", "story": "US-1", "stand": "gebaut",
   "kriterien": [ { "text": "If Sabine starts on 1 Nov, the test month 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." }
 ```
@@ -242,14 +246,14 @@ echo '[ … ]' | kimal3 plan report --no-session
 With an open finding (here from you; `quelle: "mensch"` only for the person's sentence):
 
 ```json
-{ "art": "story", "spec": "2026-10-24-test-month", "story": "US-2", "stand": "in_arbeit",
+{ "art": "story", "spec": "2026-10-24-test-month-design", "story": "US-2", "stand": "in_arbeit", "pruefen": true,
   "befunde": [ { "text": "On 30 Nov the reminder mail the spec promises is missing.", "quelle": "claude", "seit": "2026-10-23" } ] }
 ```
 
 Deliberately left out (`grund` is required):
 
 ```json
-{ "art": "story", "spec": "2026-10-24-test-month", "story": "US-3", "stand": "weggelassen", "grund": "The spec drops the export." }
+{ "art": "story", "spec": "2026-10-24-test-month-design", "story": "US-3", "stand": "weggelassen", "grund": "The spec drops the export." }
 ```
 
 **A topic** (rule 2), **sorting a topic of yours** (rule 3), **handing on a response from the
@@ -278,6 +282,8 @@ send it again. `2` — no longer signed in: tell the person `kimal3 login`; the
 | `Response 12 doesn't exist in this project or is listed twice …` | Only numbers from `kimal3 plan`, each once. |
 | `Response 12 ("…") is marked as handled, but US-2 has no finding from you …` | Report the story with the finding `quelle: "mensch"` first (rule 1) — or `runde` + 1 if it has been fixed — then `uebernommen`. |
 | `The plan can't be read: <place> …` | Correct the named place in the report (length, `grund` on `weggelassen`, duplicate key). |
+| `The “in discussion” report needs the chat it comes from.` | Report again with the session, not with `--no-session`. |
+| `Another chat is discussing this card right now.` | Do nothing: another chat carries the discussion. |
 | `The report arrived, but the text of <file> didn't …` | Send the report again — sending twice does no harm. If the text no longer fits (over 300 KB), tell the person. |
 | `The reports are saved, but not fully recorded yet.` | Send again — sending twice does no harm. |
 | `The planning saved in the app is damaged …` | Tell the person. `kimal3 plan upload --overwrite` replaces the planning with a whole file `plan/stand.json` — **only after their explicit yes.** |

package/skill/en/commands/k3wrapup.md

@@ -27,7 +27,7 @@ and skip it — no filler.
   `/k3plan`, section 6; what an exit code means is in `~/.claude/skills/kimal3/SKILL.md`):
 
   ```json
-  [ { "art": "story", "spec": "2026-10-24-test-month", "story": "US-1", "stand": "gebaut",
+  [ { "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. Open /test-month.\n2. Click Start.\n3. Below it says Ends on 30 Nov.\nDoesn't work if: it shows another date." } ]
   ```
@@ -35,7 +35,7 @@ and skip it — no filler.
   And what stays unfinished, separately, with the flag:
 
   ```json
-  [ { "art": "story", "spec": "2026-10-24-test-month", "story": "US-2", "stand": "in_arbeit" } ]
+  [ { "art": "story", "spec": "2026-10-24-test-month-design", "story": "US-2", "stand": "in_arbeit" } ]
   ```
 
   ```