kimal3 0.7.0 → 0.9.0

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

@@ -1,7 +1,7 @@
 {
   "name": "kimal3-plan",
-  "version": "0.1.0",
-  "description": "Hält das Board der Projektseite in der App aktuell: Punkt solange die Sitzung arbeitet, Spec-Texte, Erinnerung an Claude · Keeps the board on the app's project page current: dot while the session works, spec texts, reminder to Claude",
+  "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/erinnerung.ts

@@ -6,11 +6,16 @@ import { relativImOrdner } from './ordner'
  * Die drei Saetze, die NUR Claude bekommt (Spec 1.3 Aufgabe 3, 1.5, 1.7, S-25, S-26, US-6, US-8; Bauplan R-4).
  * Der Mensch sieht keinen davon (gemessen M-3, Claude-App). Zwei Wege, je nachdem, ob der Satz eine Runde starten soll:
  *
- * - **Erinnerung ans Melden** haengt am Aendern einer Datei (`tool.call` mit `context`): keine eigene Runde, Claude liest
- *   ihn direkt nach dem Werkzeug. Nur die Hauptsitzung bekommt ihn: Ein Subagent (`e.agentId`) baut im Auftrag und
- *   meldet nicht; er wuerde die 30-Minuten-Sperre verbrauchen, ohne dass die Hauptsitzung je erinnert wird (Ruling). Hoechstens einmal je 30 Minuten je Sitzung, nur in einem Projektordner mit
+ * - **Sperre vor dem ersten Bau-Schritt** (US-6, Dennis 25.10.: „Ich will das Problem gleich gefixt haben“): Will Claude
+ *   eine Datei aendern, ohne dass diese Sitzung eine Story „in Arbeit“ hat, lehnt der Mod die Aenderung VORHER ab
+ *   (`deny`), und Claude liest den Satz als Grund. Bis zum 25.10. kam der Satz erst NACH der Aenderung als `context` --
+ *   gemessen in einer echten Sitzung: Claude schrieb zuerst die Pruefung und meldete danach. Der zweite Versuch geht
+ *   durch (30-Minuten-Sperre): Eine Aenderung ohne Story (Statuszettel, neue Spec) haengt so nie fest. Nur die
+ *   Hauptsitzung: Ein Subagent (`e.agentId`) baut im Auftrag und meldet nicht. Nur in einem Projektordner mit
  *   Ordnerzettel (S-30), und nur, wenn die App zuletzt „nichts in Arbeit“ gesagt hat -- weiss der Mod es nicht (noch
- *   keine Antwort, App weg), schweigt er.
+ *   keine Antwort, App weg), haelt er nichts an. 🔴 Scheitert der Hook selbst, ueberspringt ihn die Maschine und die
+ *   Aenderung laeuft (`tool.call`, Typen: „A guard that fails is skipped and the tool runs“) -- so gewollt: Ein Fehler
+ *   im Mod darf die Arbeit nie aufhalten.
  * - **Anstoss „Projekt anlegen“** (US-8) und **„gemerkte Meldungen senden“** (R-4) sind eine Zeile im Gespraech
  *   (`$.session.append`): Claude liest sie sofort und handelt.
  */
@@ -30,17 +35,16 @@ export function dateiAus(e: unknown): string | null {
 
 export function erinnerung(on: On, lauf: Lauf): void {
   on('tool.call', { tool: ['Write', 'Edit', 'NotebookEdit'] }, async ($, e, next) => {
-    const ergebnis = await next(e)
-    // Abgelehnt oder gescheitert: Es hat sich nichts geaendert. Ein Subagent: nur die Hauptsitzung wird erinnert.
-    if (ergebnis.deny !== undefined || ergebnis.isError === true || e.agentId !== undefined) return ergebnis
-    const satz = await satzFuer($, lauf, dateiAus(e))
-    return satz === null ? ergebnis : { ...ergebnis, context: [...(ergebnis.context ?? []), satz] }
+    const satz = e.agentId === undefined ? await satzFuer($, lauf, dateiAus(e)) : null
+    return satz === null ? next(e) : { deny: satz }
   })
 }
 
 async function satzFuer($: EngineInterface, lauf: Lauf, datei: string | null): Promise<string | null> {
   const lage = lauf.lage
   if (lauf.inArbeit !== false || lage.art !== 'projekt' || lage.zettel === null || datei === null) return null
+  // Markdown ist Planung (Spec, Bauplan, Statuszettel), kein Bau-Schritt: Eine neue Spec entsteht, bevor es eine Story gibt.
+  if (datei.toLowerCase().endsWith('.md')) return null
   if (relativImOrdner(datei, lage.ordner, await $.session.cwd()) === null) return null
   const jetzt = await $.clock.now()
   const zuletzt = await read($, letzteErinnerung)

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: [],
   }
 }
 
@@ -56,9 +98,12 @@ const APP = 'https://app.kimal3.de'
 // Englische Befehlswoerter wie in `cli/src/befehlswoerter.ts` (`project connect`, `plan send`).
 export const TEXTE = {
   de: {
-    erinnerung: (titel: string) => `Du arbeitest im Projekt ${titel}, aber diese Sitzung hat keine Story ‚in Arbeit‘ gemeldet. Welche ist dran? Gehört die Änderung zu keiner Spec, notiere sie als Thema oder arbeite weiter.`,
+    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`.',
@@ -66,9 +111,11 @@ export const TEXTE = {
     },
   },
   en: {
-    erinnerung: (titel: string) => `You are working in the project ${titel}, but this session hasn't reported a story as ‘in progress’. Which one is it? If the change belongs to no spec, note it as a topic or keep working.`,
+    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

@@ -88,7 +88,12 @@ nutze sie, statt vorschnell loszulegen.
 
 ### 3.3 Planen, jetzt konkret
 - Was genau gebaut wird, in welchen Schritten, woran jeder Schritt geprüft wird. Bei Größerem schriftlich: eine Spec,
-  also ein Plan mit Nutzergeschichten („Als … will ich … damit …“) und einer Gegenprobe je Kriterium.
+  also ein Plan mit Nutzergeschichten. Jede Story steht in vier Kisten, immer in dieser Reihenfolge:
+  **User Story** („Als … will ich … damit …“; der Titel nennt das Ziel des Menschen, nicht das Ergebnis) ·
+  **Akzeptanzkriterium** (vier Zeilen: *X hat …* · *X tut …* · *Dann muss …* · *Gegenprobe: …* — ein Kriterium, das nicht
+  scheitern kann, ist keins) · **So testest du es** (nummerierte Schritte für jemanden ohne Technik: wo, was tun, was dann
+  zu sehen ist; darunter die Zeile „Passt nicht, wenn: …“; ein Befehl nur mit Ort, in Backticks) · **Technische Notiz**
+  (wo die Sache wohnt, was sie trägt — der Mensch muss sie nicht lesen). Echte Zahlen, echter Text, ein Name statt „der Nutzer“.
 - **Ein abgesegneter Plan rechtfertigt nichts, was frische Messungen widerlegen.** Nie „der Plan sagt, das ist
   hinnehmbar" als Begründung — sondern neu beantworten: *Was ist mit dem, was ich JETZT weiß, das Beste?* Weicht es
   ab: laut sagen, Plan nachziehen.
@@ -143,20 +148,41 @@ 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`-Satz. Der Satz ist eine Anleitung für jemanden ohne Technik: wo man es findet, was man tut, was dann zu sehen ist, woran man merkt, dass es nicht stimmt. Ein Befehl nur, wenn es keinen anderen Weg gibt — dann sagst du, wo man ihn eingibt (in Claude Code im Projektordner, mit `!` davor), und setzt ihn in Backticks. Ohne Befehl: „Öffne in der App ‚Kennzahlen‘ und klick auf den Beitrag vom 14.10. — dort steht ‚4.210 gesehen‘. Steht dort eine leere Zelle, sag ‚Passt nicht‘.“ Mit Befehl: „Tippe in Claude Code im Projektordner `! node wortzaehler.js beispiel.txt` — es erscheinen fünf Zeilen, oben ‚der (4)‘. Kommt eine Fehlermeldung, sag ‚Passt nicht‘.“
+     `{"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":"Öffne in der App ‚Testmonat‘ und klick „Starten“ — darunter steht ‚Endet am 30.11.‘. Steht dort ein anderes Datum, sag ‚Passt nicht‘."}`
-  4. **Etwas fällt auf, das keine Spec verspricht:** `{"art":"thema","schluessel":"T-4","text":"Der Kalender könnte Feiertage zeigen"}`
-  5. **`/k3plan`:** Specs gegen den Code prüfen und jede Abweichung einzeln melden — dort steht, wie.
-  6. **Feierabend:** den Tag abgleichen — dort steht, wie.
+     `{"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.
 
   „Gebaut“ meldest du erst nach einer Gegenprobe, die in dieser Sitzung gelaufen ist, nie aus dem Gedächtnis.
 - **Subagenten melden nie.** Der Mod erinnert nur dich, nicht sie: Du meldest „in Arbeit“ **vor** dem Auftrag an einen Subagenten, der
@@ -167,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