kimal3 0.6.3 → 0.6.5

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

@@ -1,84 +1,111 @@
-import type { Register } from 'claude-code'
-import { appOeffnen } from './app-oeffnen'
-
-// Die Sprache des Kontos. `kimal3 einrichten` setzt diese Zeile beim Ablegen in `~/.kimal3/claude-plugins` und prüft
-// danach, dass sie gesetzt ist (`cli/src/logo-ablegen.ts`).
-const SPRACHE: 'de' | 'en' = 'de'
-
-// Icon: docs/design/kimal3-icon-animated.svg, unverändert bis auf die viewBox:
-// Sie schneidet den leeren Rand um die drei Dreiecke weg (Original: 0 0 80 80).
-const ICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="20 19 40 36" width="24" height="22">
-  <style>
-    /* color-scheme: sonst malt der Browser hinter die Grafik eine eigene Fläche, wenn hell/dunkel nicht zur App passt */
-    :root { background: transparent; color-scheme: light dark; }
-    .icon { opacity: 0.8; }
-    .tri  { fill: none; stroke: hsl(194 100% 51%); stroke-width: 2.8; stroke-linejoin: round; opacity: 0.7; }
-    .t1 { animation: trianglePulse 3s ease-in-out infinite; }
-    .t2 { animation: trianglePulse 3.5s ease-in-out infinite; animation-delay: .4s; }
-    .t3 { animation: trianglePulse 4s ease-in-out infinite; animation-delay: .8s; }
-    @keyframes trianglePulse { 0%,100% { opacity: .5; } 50% { opacity: 1; } }
-  </style>
-  <g class="icon">
-    <polygon class="tri t1" points="33.28,21.6 22.08,41.0 44.48,41.0" />
-    <polygon class="tri t2" points="46.72,21.6 35.52,41.0 57.92,41.0" />
-    <polygon class="tri t3" points="40.00,33.36 28.80,52.76 51.20,52.76" />
-  </g>
-</svg>`
-
-// Das Cyan der Marke (kimal3.de, --brand in der App)
-const MARKEN_CYAN = '#00C3FF'
-// Der Kurs, für alle (Dennis, 15.10.: „mach alle auf den Kurs“). Abgemeldete schickt die App von dort zum Login.
-// Fest auf `/firma` zeigte der Link Kostenlosen ohne Firma eine leere Seite (Spec L-51). Im Terminal: Strg+Klick; Claude Code hängt dort die Adresse
-// grau dahinter, wenn es dem Terminal keine Links zutraut — FORCE_HYPERLINK hilft nicht.
-const APP = 'https://app.kimal3.de/kurs'
-
-// Vor und nach der Wortmarke. Englisch: „AI Workplace“, nie „workspace“ (Spec, Global Constraints).
-const TEXT = {
-  de: { vor: 'Dein ', nach: '-Arbeitsplatz', alt: 'KImal3-Logo' },
-  en: { vor: 'Your ', nach: ' AI Workplace', alt: 'KImal3 logo' },
-}[SPRACHE]
-
-export const register: Register = (on, options) => {
-  // Beim Start die Projektseite in der App öffnen (hooks/app-oeffnen.ts).
-  appOeffnen(on, options)
-
-  on('ui.render', { component: 'AbovePrompt' }, ($, e, next) => {
-    if (e.props.hasSurvey) {
-      return next(e)
-    }
-
-    // Im Terminal gibt es kein Svg: drei Dreiecke als Zeichen, die Wortmarke wie auf kimal3.de
-    // („KI" in Schriftfarbe, „mal3" im Marken-Cyan). Das Cyan steht als Farbwert, nicht als „cyan" —
-    // das Terminal-Cyan ist je nach Farbschema ein anderes, oft ein blasses Türkis.
-    if (e.surface === 'terminal') {
-      const { Box, Link, Text } = $.ui.resolve(e)
-      return (
-        <Box flexDirection="row" gap={1}>
-          <Text color={MARKEN_CYAN} bold>{'▲▲▲'}</Text>
-          <Text bold>
-            {TEXT.vor}
-            <Link href={APP}>
-              {'KI'}
-              <Text color={MARKEN_CYAN}>{'mal3'}</Text>
-              {TEXT.nach}
-            </Link>
-            {'.'}
-          </Text>
-        </Box>
-      )
-    }
-
-    // isInteractive: erst damit spielt die Leiste die CSS-Animation ab, sonst steht das Icon still.
-    const { Box, Link, Svg, Text } = $.ui.resolve(e)
-    return (
-      <Box flexDirection="row" alignItems="center" gap={1}>
-        <Svg source={ICON} alt={TEXT.alt} width={24} height={22} isInteractive />
-        <Text bold>
-          {TEXT.vor}
-          <Link href={APP}>{`KImal3${TEXT.nach}`}</Link>
-          {'.'}
-        </Text>
-      </Box>
-    )
-  })
-}
+import type { Register } from 'claude-code'
+import { KEINE_ABLAGE, type Ablage } from './ablage'
+import { appOeffnen } from './app-oeffnen'
+import { chatBenennen } from './chat-benennen'
+import { updateClaudeFragen, updateInstallieren, updateZustand } from './update'
+import { satzWeicht, TEXTE, type Zustand } from './update-rechnung'
+
+// Die Sprache des Kontos. `kimal3 einrichten` setzt diese Zeile beim Ablegen in `~/.kimal3/claude-plugins` und prüft
+// danach, dass sie gesetzt ist (`cli/src/logo-ablegen.ts`).
+const SPRACHE: 'de' | 'en' = 'de'
+// Fassung und Orte von `kimal3` auf diesem Rechner; beim Ablegen gesetzt wie die Sprache (hooks/ablage.ts).
+const ABLAGE: Ablage = KEINE_ABLAGE
+
+// Icon: docs/design/kimal3-icon-animated.svg, unverändert bis auf die viewBox:
+// Sie schneidet den leeren Rand um die drei Dreiecke weg (Original: 0 0 80 80).
+const ICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="20 19 40 36" width="24" height="22">
+  <style>
+    /* color-scheme: sonst malt der Browser hinter die Grafik eine eigene Fläche, wenn hell/dunkel nicht zur App passt */
+    :root { background: transparent; color-scheme: light dark; }
+    .icon { opacity: 0.8; }
+    .tri  { fill: none; stroke: hsl(194 100% 51%); stroke-width: 2.8; stroke-linejoin: round; opacity: 0.7; }
+    .t1 { animation: trianglePulse 3s ease-in-out infinite; }
+    .t2 { animation: trianglePulse 3.5s ease-in-out infinite; animation-delay: .4s; }
+    .t3 { animation: trianglePulse 4s ease-in-out infinite; animation-delay: .8s; }
+    @keyframes trianglePulse { 0%,100% { opacity: .5; } 50% { opacity: 1; } }
+  </style>
+  <g class="icon">
+    <polygon class="tri t1" points="33.28,21.6 22.08,41.0 44.48,41.0" />
+    <polygon class="tri t2" points="46.72,21.6 35.52,41.0 57.92,41.0" />
+    <polygon class="tri t3" points="40.00,33.36 28.80,52.76 51.20,52.76" />
+  </g>
+</svg>`
+
+// Das Cyan der Marke (kimal3.de, --brand in der App)
+const MARKEN_CYAN = '#00C3FF'
+// Der Kurs, für alle (Dennis, 15.10.: „mach alle auf den Kurs“). Abgemeldete schickt die App von dort zum Login.
+// Fest auf `/firma` zeigte der Link Kostenlosen ohne Firma eine leere Seite (Spec L-51). Im Terminal: Strg+Klick; Claude Code hängt dort die Adresse
+// grau dahinter, wenn es dem Terminal keine Links zutraut — FORCE_HYPERLINK hilft nicht.
+const APP = 'https://app.kimal3.de/kurs'
+
+// Vor und nach der Wortmarke: aus update-rechnung.ts, damit die Breitenrechnung denselben Satz zählt (`satzWeicht`).
+const TEXT = { ...TEXTE[SPRACHE], alt: { de: 'KImal3-Logo', en: 'KImal3 logo' }[SPRACHE] }
+
+export const register: Register = (on, options) => {
+  // Beim Start die Projektseite in der App öffnen (hooks/app-oeffnen.ts).
+  appOeffnen(on, options)
+  // Den Chat nach seinem Thema benennen, sobald es klar ist (hooks/chat-benennen.ts).
+  chatBenennen(on, options)
+
+  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
+    if (e.props.hasSurvey) {
+      return next(e)
+    }
+    // Ohne Ablage (Entwicklung) `null`: keine Fassung, kein Knopf, die Leiste wie früher (U-9).
+    const zustand = await updateZustand($, ABLAGE, e.props.isWorking)
+    const { Button, Text } = $.ui.resolve(e)
+
+    // Hinter dem Satz: die eigene Fassung, gedimmt, und was das Update gerade zu sagen hat (Bauplan 1.4).
+    // Kein Tastenkürzel an den Knöpfen (Spec P-12): eine Ziffer im leeren Eingabefeld darf kein Update anstoßen.
+    const dahinter = (z: Zustand) => [
+      <Text dimColor>{`v${z.fassung}`}</Text>,
+      ...(z.art === 'knopf' ? [<Button key="update" label={TEXT.knopf} onPress={() => void updateInstallieren($, ABLAGE, SPRACHE)} />] : []),
+      ...(z.art === 'laeuft' ? [<Text dimColor>{TEXT.laeuft(z.ziel)}</Text>] : []),
+      ...(z.art === 'geklappt' ? [<Text>{TEXT.geklappt(z.ziel)}</Text>] : []),
+      ...(z.art === 'fehler'
+        ? [<Text>{TEXT.fehler}</Text>, <Button key="fragen" label={TEXT.fragen} onPress={() => void updateClaudeFragen($, SPRACHE)} />]
+        : []),
+      ...(z.art === 'gesperrt' ? [<Text>{TEXT.gesperrt}</Text>] : []),
+    ]
+
+    // Im Terminal gibt es kein Svg: drei Dreiecke als Zeichen, die Wortmarke wie auf kimal3.de
+    // („KI" in Schriftfarbe, „mal3" im Marken-Cyan). Das Cyan steht als Farbwert, nicht als „cyan" —
+    // das Terminal-Cyan ist je nach Farbschema ein anderes, oft ein blasses Türkis.
+    // Ist es zu schmal, weicht der Satz; Fassung, Knopf und Zustand bleiben (U-14).
+    if (e.surface === 'terminal') {
+      const { Box, Link } = $.ui.resolve(e)
+      const weicht = zustand !== null && satzWeicht(zustand, SPRACHE, e.props.bodyColumns)
+      return (
+        <Box flexDirection="row" gap={1}>
+          <Text color={MARKEN_CYAN} bold>{'▲▲▲'}</Text>
+          {weicht ? null : (
+            <Text bold>
+              {TEXT.vor}
+              <Link href={APP}>
+                {'KI'}
+                <Text color={MARKEN_CYAN}>{'mal3'}</Text>
+                {TEXT.nach}
+              </Link>
+              {'.'}
+            </Text>
+          )}
+          {zustand === null ? null : dahinter(zustand)}
+        </Box>
+      )
+    }
+
+    // isInteractive: erst damit spielt die Leiste die CSS-Animation ab, sonst steht das Icon still.
+    const { Box, Link, Svg } = $.ui.resolve(e)
+    return (
+      <Box flexDirection="row" alignItems="center" gap={1}>
+        <Svg source={ICON} alt={TEXT.alt} width={24} height={22} isInteractive />
+        <Text bold>
+          {TEXT.vor}
+          <Link href={APP}>{`KImal3${TEXT.nach}`}</Link>
+          {'.'}
+        </Text>
+        {zustand === null ? null : dahinter(zustand)}
+      </Box>
+    )
+  })
+}

package/claude-plugins/kimal3-logo/hooks/update-rechnung.ts

@@ -0,0 +1,175 @@
+// Die reinen Rechnungen und Texte hinter „Update installieren“ in der Leiste (Bauplan 2026-10-23-update-in-der-leiste.md,
+// Abschnitte 1.2 bis 1.4). Kein `$`, kein Haken: Den Ablauf baut `hooks/update.ts`. Herausgelöst, damit `check:logo`
+// jede Entscheidung gegen von Hand geschriebene Soll-Werte prüft (messen-und-pruefen §17), statt sie nur live zu sehen.
+
+const MINUTE = 60_000
+// Nach einem gescheiterten npm-Anruf (Netz, Firmen-Spiegel) frühestens nach einer Stunde wieder fragen (U-12).
+const FEHLER_PAUSE = 60 * MINUTE
+// Der Lauf dauert höchstens 10 + 2 + 2 Minuten (npm, `--version`, `skill install`); danach gilt eine Sperre als liegen
+// geblieben — etwa weil Claude mittendrin geschlossen wurde und `finally` nie lief (Bauplan 1.3 Punkt 3, A-5).
+const SPERRE_DAUER = 20 * MINUTE
+const FERTIG_DAUER = 24 * 60 * MINUTE
+// Was Claude Code im Terminal womöglich grau hinter den Link hängt: `https://app.kimal3.de/kurs` (Spec P-4, S-22).
+// Der Mod weiß nicht, ob es geschieht, also rechnet er immer damit.
+const KURS_ADRESSE = 26
+
+/** Nur `1.2.3` gilt (Positivliste, Spec 1.4 Punkt 1): keine Vorabfassung, kein `v`, nichts, was in einen Befehl rutscht. */
+export function istFassung(s: unknown): s is string {
+  return typeof s === 'string' && /^\d+\.\d+\.\d+$/.test(s)
+}
+
+/** `a` ist neuer als `b`, Zahl für Zahl — als Text wäre `"0.10.0" < "0.9.0"`. Ungültig auf einer Seite: `false` (kein Knopf). */
+export function istNeuer(a: string, b: string): boolean {
+  if (!istFassung(a) || !istFassung(b)) return false
+  const x = a.split('.').map(Number)
+  const y = b.split('.').map(Number)
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] > y[i]
+  return false
+}
+
+/**
+ * Die drei Befehle in fester Reihenfolge (Bauplan 1.3 Punkt 4), jeder als Wortliste für `$.process.run` ohne Kommandozeile.
+ * Von außen kommt nur `ziel`, und nur als Fassung (§23). `null`, wenn `ziel` keine ist oder ein Pfad fehlt — ein leeres
+ * `npm` heißt „beim Ablegen nicht gefunden“, dann geht der Knopf den Weg über Claude (U-10).
+ */
+export function befehle(ablage: { node: string; npm: string; kimal3: string }, ziel: string): string[][] | null {
+  const { node, npm, kimal3 } = ablage
+  if (!istFassung(ziel) || node === '' || npm === '' || kimal3 === '') return null
+  return [
+    [node, npm, 'install', '-g', `kimal3@${ziel}`],
+    [node, kimal3, '--version'],
+    [node, kimal3, 'skill', 'install'],
+  ]
+}
+
+/**
+ * Was sich der Mod über Sitzungen hinweg merkt (`$.store`), damit npm höchstens einmal am Tag gefragt wird.
+ * `tag`: deutscher Kalendertag der letzten gelungenen Antwort (`2026-10-23`) · `neueste`: was npm da sagte — ein zweites
+ * Fenster am selben Tag zeigt den Knopf daraus, ohne zu fragen · `fehlerAm`: Zeitpunkt (ms) des letzten Fehlschlags.
+ */
+export type Merkzettel = { tag?: string; neueste?: string; fehlerAm?: number }
+
+/** Der Kalendertag in deutscher Zeit, wie `heuteInDeutschland` in der App (`src/app/(erfolgsprofil)/typen.ts`). */
+export function deutscherTag(jetzt: number): string {
+  return new Intl.DateTimeFormat('sv-SE', { timeZone: 'Europe/Berlin' }).format(new Date(jetzt))
+}
+
+/** npm fragen? Einmal je deutschem Kalendertag (U-11), nach einem Fehlschlag höchstens einmal je Stunde (U-12). */
+export function sollFragen(merkzettel: Merkzettel, jetzt: number): boolean {
+  if (merkzettel.tag === deutscherTag(jetzt)) return false
+  return merkzettel.fehlerAm === undefined || jetzt - merkzettel.fehlerAm >= FEHLER_PAUSE
+}
+
+/** Läuft ein Update (`$.store`, auch aus einem anderen Fenster)? `seit` in ms. */
+export type Sperre = { ziel: string; seit: number }
+
+/**
+ * Die Sperre gilt 20 Minuten und nur, solange der Mod selbst noch älter als `ziel` ist: Ein Mod, der die neue Fassung
+ * schon trägt, hat das Update hinter sich, eine übrig gebliebene Sperre darf ihm den Stand nicht verdecken (U-5, U-6b).
+ */
+export function sperreGilt(sperre: Sperre | undefined, jetzt: number, eigeneFassung: string): boolean {
+  return sperre !== undefined && jetzt - sperre.seit < SPERRE_DAUER && istNeuer(sperre.ziel, eigeneFassung)
+}
+
+/** Ein Update hat geklappt (`$.store`), Claude ist noch nicht neu gestartet. `am` in ms. */
+export type Fertig = { ziel: string; am: number }
+
+/**
+ * „✓ installiert – Claude neu starten“ gilt, solange der Mod älter als `ziel` ist (U-6b) — und höchstens 24 Stunden: Hat
+ * ein Tag mit Neustarts den Mod nicht auf `ziel` gebracht, stimmt der Haken offenbar nicht (etwa startet eine andere
+ * Node-Fassung `kimal3`), und die Leiste zeigt wieder, was npm sagt. Ein Wert in anderer Form (bis zum 23.10. ein bloßer
+ * Text) gilt nicht.
+ */
+export function fertigGilt(fertig: unknown, jetzt: number, eigeneFassung: string): fertig is Fertig {
+  const f = (fertig ?? {}) as Record<string, unknown>
+  return istFassung(f.ziel) && typeof f.am === 'number' && jetzt - f.am < FERTIG_DAUER && istNeuer(f.ziel, eigeneFassung)
+}
+
+/**
+ * Hat `kimal3 --version` nach dem Install wirklich die neue Fassung? Die Ausgabe ist mehrzeilig und eingerückt
+ * (`  kimal3 0.6.6` und darunter weitere Zeilen); eine Zeile muss nach `trim` GENAU `kimal3 X` lauten — `kimal3 0.6.66`
+ * zählt nicht für `0.6.6` (Bauplan 1.3 Punkt 4, QA-1).
+ */
+export function versionStimmt(ausgabe: string, ziel: string): boolean {
+  return istFassung(ziel) && ausgabe.split(/\r?\n/).some(zeile => zeile.trim() === `kimal3 ${ziel}`)
+}
+
+// Vor und nach der Wortmarke „KImal3“; register.tsx zeichnet die Wortmarke dazwischen als Link. Englisch: „AI Workplace“,
+// nie „workspace“ (Spec, Global Constraints). Eine Quelle für Leiste und `satzWeicht`, damit die Breite mit dem Satz
+// rechnet, der wirklich dasteht.
+const VOR_NACH = {
+  de: { vor: 'Dein ', nach: '-Arbeitsplatz' },
+  en: { vor: 'Your ', nach: ' AI Workplace' },
+}
+
+// Wortlaute (Bauplan 1.4).
+export const TEXTE = {
+  de: {
+    ...VOR_NACH.de,
+    satz: `${VOR_NACH.de.vor}KImal3${VOR_NACH.de.nach}.`,
+    knopf: 'Update installieren',
+    frage: (von: string, auf: string) =>
+      `Es laufen: npm install -g kimal3@${auf} und kimal3 skill install. Dauert etwa eine Minute, danach Claude neu starten. kimal3 von ${von} auf ${auf} aktualisieren?`,
+    ja: 'Installieren',
+    nein: 'Abbrechen',
+    laeuft: (ziel: string) => `kimal3 ${ziel} wird installiert …`,
+    geklappt: (ziel: string) => `✓ ${ziel} installiert – Claude neu starten`,
+    fehler: 'Update hat nicht geklappt.',
+    fragen: 'Claude fragen',
+    bitteFehler: (ziel: string, meldung: string) =>
+      `Das kimal3-Update auf ${ziel} hat nicht geklappt. Hier die Meldung:\n\n${meldung}\n\nWas ist los, und was kann ich tun?`,
+    bitteOhneNpm: (ziel: string) => `Aktualisiere kimal3 auf ${ziel}: erst npm install -g kimal3@${ziel}, danach kimal3 skill install.`,
+    gesperrt: 'Update hier gesperrt – frag deine IT.',
+  },
+  en: {
+    ...VOR_NACH.en,
+    satz: `${VOR_NACH.en.vor}KImal3${VOR_NACH.en.nach}.`,
+    knopf: 'Install update',
+    frage: (von: string, auf: string) =>
+      `Runs: npm install -g kimal3@${auf} and kimal3 skill install. Takes about a minute, then restart Claude. Update kimal3 from ${von} to ${auf}?`,
+    ja: 'Install',
+    nein: 'Cancel',
+    laeuft: (ziel: string) => `Installing kimal3 ${ziel} …`,
+    geklappt: (ziel: string) => `✓ ${ziel} installed – restart Claude`,
+    fehler: "The update didn't work.",
+    fragen: 'Ask Claude',
+    bitteFehler: (ziel: string, meldung: string) =>
+      `The kimal3 update to ${ziel} didn't work. Here is the message:\n\n${meldung}\n\nWhat's wrong, and what can I do?`,
+    bitteOhneNpm: (ziel: string) => `Update kimal3 to ${ziel}: first npm install -g kimal3@${ziel}, then kimal3 skill install.`,
+    gesperrt: 'Update blocked here – ask your IT.',
+  },
+}
+
+/** Was die Leiste hinter der eigenen Fassung zeigt; `still` = nichts (kein Update, npm stumm, Claude arbeitet). */
+export type Zustand = { fassung: string } & (
+  | { art: 'still' | 'knopf' | 'fehler' | 'gesperrt' }
+  | { art: 'laeuft' | 'geklappt'; ziel: string }
+)
+
+// Ein Knopf im Terminal ist `[ Beschriftung ]` (Typen von Claude Code, `ButtonProps`).
+const knopf = (text: string) => `[ ${text} ]`
+
+/** Die Teile hinter der Fassung, wie das Terminal sie zeichnet. */
+function zustandsteile(zustand: Zustand, sprache: 'de' | 'en'): string[] {
+  const t = TEXTE[sprache]
+  switch (zustand.art) {
+    case 'still': return []
+    case 'knopf': return [knopf(t.knopf)]
+    case 'laeuft': return [t.laeuft(zustand.ziel)]
+    case 'geklappt': return [t.geklappt(zustand.ziel)]
+    case 'fehler': return [t.fehler, knopf(t.fragen)]
+    case 'gesperrt': return [t.gesperrt]
+  }
+}
+
+/**
+ * Muss im Terminal der Satz „Dein KImal3-Arbeitsplatz.“ weichen? Ja, wenn `▲▲▲`, Satz, die womöglich angehängte
+ * Kurs-Adresse, `v0.6.5` und der Zustandsteil nicht in `bodyColumns` passen — Fassung, Knopf und Zustand weichen nie
+ * (Bauplan 1.4, U-14). Zwischen zwei Teilen steht je ein Leerzeichen (`gap={1}` in register.tsx).
+ */
+export function satzWeicht(zustand: Zustand, sprache: 'de' | 'en', bodyColumns: number): boolean {
+  const teile = ['▲▲▲', TEXTE[sprache].satz, `v${zustand.fassung}`, ...zustandsteile(zustand, sprache)]
+  // Zeichen statt UTF-16-Einheiten; ▲, ✓, – und … sind im Terminal je eine Spalte breit.
+  const breite = teile.reduce((summe, teil) => summe + [...teil].length, teile.length - 1) + KURS_ADRESSE
+  return breite > bodyColumns
+}

package/claude-plugins/kimal3-logo/hooks/update.ts

@@ -0,0 +1,244 @@
+import { atom, read, update, type Engine } from 'claude-code'
+import type { Ablage } from './ablage'
+import {
+  befehle, deutscherTag, fertigGilt, istFassung, istNeuer, sollFragen, sperreGilt, TEXTE, versionStimmt,
+  type Fertig, type Merkzettel, type Sperre, type Zustand,
+} from './update-rechnung'
+
+// Der Ablauf hinter „Update installieren“ in der Leiste (Bauplan docs/superpowers/plans/2026-10-23-update-in-der-leiste.md,
+// Abschnitte 1.2 und 1.3, Szenarien U-1 bis U-20). Die Entscheidungen selbst stehen rein in update-rechnung.ts; hier
+// steht, wann was gefragt, gemerkt und ausgeführt wird. Gezeichnet wird in register.tsx.
+
+const MINUTE = 60_000
+const NPM = 'https://registry.npmjs.org/kimal3/latest'
+// `HttpInit` kennt kein Zeitlimit: Was npm nach 5 s nicht beantwortet hat, zählt als Fehlschlag (Bauplan 1.2, A-6).
+const NPM_GEDULD = 5000
+// Was der Mod über Sitzungen und Fenster hinweg weiß (`$.store`, eine Datei je Mod): wann npm gefragt wurde, ob ein
+// Update läuft, und dass eines geklappt hat, aber Claude noch nicht neu gestartet ist.
+const MERKZETTEL = 'updateMerkzettel'
+const SPERRE = 'updateSperre'
+const FERTIG = 'updateFertig'
+// Die zwei Befehle, die der Klick ausführt, so wie Claude sie in seinen Erlaubnis-Regeln sähe (Bauplan 1.3 Punkt 2).
+// Beide Werkzeuge: Eine Firma, die `npm install` nur für PowerShell verbietet, verbietet es trotzdem (A-3).
+const WERKZEUGE = ['Bash', 'PowerShell']
+
+// Was die Leiste neu zeichnen soll, sobald es sich ändert (`$.state`, Vertrag in types/index.d.ts).
+const neueste = atom({ plugin: 'kimal3-logo', key: 'updateNeueste' } as const, '')
+const lauf = atom({ plugin: 'kimal3-logo', key: 'updateLauf' } as const, null)
+
+/**
+ * Die Fehlermeldung für die Bitte an Claude: die letzten 10 Zeilen, höchstens 1500 Zeichen (Bauplan 1.3 Punkt 6).
+ * npm schreibt vorne Fortschritt und hinten den Grund; der Grund ist, was Claude braucht.
+ */
+export function meldungKurz(text: string): string {
+  return text.trim().split(/\r?\n/).slice(-10).join('\n').slice(-1500)
+}
+
+// Was im Store steht, ist Daten von gestern — vielleicht von einer älteren Fassung des Mods. Nur Felder mit dem
+// richtigen Typ zählen; ein `fehlerAm` als Text ergäbe sonst `NaN`, und npm würde nie wieder gefragt.
+function merkzettelAus(roh: unknown): Merkzettel {
+  const m = (roh ?? {}) as Record<string, unknown>
+  return {
+    ...(typeof m.tag === 'string' ? { tag: m.tag } : {}),
+    ...(istFassung(m.neueste) ? { neueste: m.neueste } : {}),
+    ...(typeof m.fehlerAm === 'number' ? { fehlerAm: m.fehlerAm } : {}),
+  }
+}
+
+function versionAus(text: string): string | null {
+  try {
+    const version: unknown = (JSON.parse(text) as { version?: unknown } | null)?.version
+    return istFassung(version) ? version : null
+  } catch {
+    return null
+  }
+}
+
+function sperreAus(roh: unknown): Sperre | undefined {
+  const s = (roh ?? {}) as Record<string, unknown>
+  return istFassung(s.ziel) && typeof s.seit === 'number' ? { ziel: s.ziel, seit: s.seit } : undefined
+}
+
+// Ein Fehlschlag im Hintergrund gehört ins Debug-Protokoll, nie in den Chat (ohne `to: 'debug'` stünde er dort).
+function protokoll($: Engine, text: string): void {
+  $.ui.log(`kimal3-logo: ${text.slice(0, 300)}`, { to: 'debug' })
+}
+
+type Sprache = 'de' | 'en'
+// Gegen einen zweiten Klick, solange die Rückfrage noch offen ist oder der Lauf läuft.
+let beschaeftigt = false
+// Der Blick auf npm startet mit dem ersten Zeichnen der Leiste, einmal je Laden des Mods.
+let angestossen = false
+
+/** Nach dem Laden: Aufräumen, Wache-Schalter, Merkzettel — und npm fragen, wenn es heute noch nicht geschah. */
+async function beimLaden($: Engine, ablage: Ablage): Promise<void> {
+  const fassung = ablage.fassung
+  const jetzt = await $.clock.now()
+  // U-6b: Ein Mod, der die neue Fassung schon trägt, hat das Update hinter sich; nach 24 Stunden gilt der Haken nicht mehr.
+  const fertig = await $.store.get(FERTIG)
+  if (fertig !== undefined && !fertigGilt(fertig, jetzt, fassung)) await $.store.delete(FERTIG)
+  const sperre = sperreAus(await $.store.get(SPERRE))
+  if (sperre !== undefined && !istNeuer(sperre.ziel, fassung)) await $.store.delete(SPERRE)
+
+  if (await wacheAus($, ablage)) return
+  const merkzettel = merkzettelAus(await $.store.get(MERKZETTEL))
+  // Ein zweites Fenster am selben Tag zeigt den Knopf aus dem Merkzettel, ohne zu fragen (U-11).
+  if (merkzettel.tag === deutscherTag(jetzt) && merkzettel.neueste !== undefined) await update($, neueste, () => merkzettel.neueste ?? '')
+  if (sollFragen(merkzettel, jetzt)) await npmFragen($, jetzt)
+}
+
+/** `kimal3 wache aus` schaltet auch den Blick auf npm ab (E-8, U-8). Keine oder kaputte Datei: an. */
+async function wacheAus($: Engine, ablage: Ablage): Promise<boolean> {
+  try {
+    const inhalt: unknown = JSON.parse(await $.fs.read(`${ablage.kimal3Ordner}/wache.json`))
+    return (inhalt as { aus?: unknown } | null)?.aus === true
+  } catch {
+    return false
+  }
+}
+
+async function npmFragen($: Engine, jetzt: number): Promise<void> {
+  // Ein Zeitgeber statt `$.clock.sleep`: Ein `sleep` liefe auf das Zeitbudget des Hakens, aus dem `$` stammt — hier das
+  // Zeichnen der Leiste.
+  let zuEnde: (wert: null) => void = () => {}
+  const zuLangsam = new Promise<null>(aufloesen => { zuEnde = aufloesen })
+  const zeitgeber = $.clock.after(NPM_GEDULD, () => zuEnde(null))
+  const antwort = await Promise.race([$.http.fetch(NPM).catch(() => null), zuLangsam])
+  zeitgeber.cancel()
+  const version = versionAus(antwort?.ok ? antwort.text : '')
+  // Nur `1.2.3` zählt als Antwort; Vorabfassung, Unsinn, Fehler und Schweigen sind ein Fehlschlag (U-2, U-12).
+  if (version === null) {
+    protokoll($, `keine gültige Antwort von npm: ${antwort === null ? 'keine Antwort' : `${antwort.status} ${antwort.text}`}`)
+    await $.store.set(MERKZETTEL, { fehlerAm: jetzt } satisfies Merkzettel)
+    return
+  }
+  await $.store.set(MERKZETTEL, { tag: deutscherTag(jetzt), neueste: version } satisfies Merkzettel)
+  await update($, neueste, () => version)
+}
+
+/** Was die Leiste hinter der Fassung zeigt; `null` ohne Ablage (U-9). Schreibt nichts: Es wird gerade gezeichnet. */
+export async function updateZustand($: Engine, ablage: Ablage, claudeArbeitet: boolean): Promise<Zustand | null> {
+  const fassung = ablage.fassung
+  if (fassung === '') return null
+  // Erst danach, nie in diesem Zeichnen (es soll nicht auf npm warten, und schreiben darf es nicht). Am ersten Zeichnen
+  // statt an `session.start`: Den Start hört schon hooks/app-oeffnen.ts (je Ereignis ein Haken ohne Auswahl), und
+  // ohne Leiste — `claude -p`, Skripte — braucht niemand die Antwort von npm.
+  if (!angestossen) {
+    angestossen = true
+    $.clock.after(0, () => void beimLaden($, ablage).catch(f => protokoll($, `Update-Blick: ${String(f)}`)))
+  }
+  const jetzt = await $.clock.now()
+  const sperre = sperreAus(await $.store.get(SPERRE))
+  const laeuft = sperreGilt(sperre, jetzt, fassung)
+  const hier = await read($, lauf)
+  // „läuft“ aus diesem Fenster nur, solange die Sperre gilt: Sonst ist es liegen geblieben (der Lauf kam nie zu Ende,
+  // etwa weil der Mod mittendrin neu geladen wurde), und die Leiste zeigte für immer „wird installiert“.
+  if (hier !== null && (hier.art !== 'laeuft' || laeuft)) {
+    return hier.art === 'laeuft' || hier.art === 'geklappt' ? { fassung, art: hier.art, ziel: hier.ziel } : { fassung, art: hier.art }
+  }
+  // Aus einem anderen Fenster (oder vor dem Schließen): geklappt, aber noch nicht neu gestartet (U-6b) — oder es läuft (U-5).
+  const fertig = await $.store.get(FERTIG)
+  if (fertigGilt(fertig, jetzt, fassung)) return { fassung, art: 'geklappt', ziel: fertig.ziel }
+  if (sperre !== undefined && laeuft) return { fassung, art: 'laeuft', ziel: sperre.ziel }
+  // Kein Knopf, solange Claude antwortet (U-18): ein Klick mitten in einer Antwort stellte eine Frage quer dazu.
+  return istNeuer(await read($, neueste), fassung) && !claudeArbeitet ? { fassung, art: 'knopf' } : { fassung, art: 'still' }
+}
+
+/** Der Klick auf „Update installieren“ (Bauplan 1.3). */
+export async function updateInstallieren($: Engine, ablage: Ablage, sprache: Sprache): Promise<void> {
+  const t = TEXTE[sprache]
+  const fassung = ablage.fassung
+  const ziel = await read($, neueste)
+  if (beschaeftigt || !istNeuer(ziel, fassung)) return
+  beschaeftigt = true
+  try {
+    // K-4, U-10: Ohne npm-Pfad kein Direktbefehl — Claude bekommt die Bitte und fragt selbst um Erlaubnis.
+    const liste = befehle(ablage, ziel)
+    if (liste === null) {
+      await $.prompt.submit({ text: t.bitteOhneNpm(ziel) })
+      return
+    }
+    // U-3: Abbrechen, „Other“, eine Chat-Nachricht statt einer Antwort und das Wegklicken (Wurf): nichts passiert.
+    const antwort = await $.ui.ask(t.frage(fassung, ziel), [t.ja, t.nein]).catch(() => null)
+    if (antwort !== t.ja) return
+    // U-5: Während der Rückfrage kann ein anderes Fenster angefangen haben — dann zeigt auch dieses „wird installiert“.
+    const sperre = sperreAus(await $.store.get(SPERRE))
+    if (sperre !== undefined && sperreGilt(sperre, await $.clock.now(), fassung)) {
+      await update($, lauf, () => ({ art: 'laeuft', ziel: sperre.ziel, meldung: '' }))
+      return
+    }
+    if (await verboten($, ziel)) {
+      await update($, lauf, () => ({ art: 'gesperrt', ziel, meldung: '' }))
+      return
+    }
+    await ausfuehren($, ablage, liste, ziel)
+  } catch (fehler) {
+    // Etwa `$.store` scheitert (die Sperre lässt sich nicht schreiben): kein Erfolg und kein „gesperrt“, sondern ein Fehler mit Grund.
+    await update($, lauf, () => ({ art: 'fehler', ziel, meldung: meldungKurz(String(fehler)) }))
+  } finally {
+    beschaeftigt = false
+  }
+}
+
+/**
+ * U-4: Verbietet eine Erlaubnis-Regel einen der zwei Befehle in einem der zwei Werkzeuge? `ask` (der Normalfall im
+ * Auto-Modus, M-16) ist kein Verbot. ⚠️ Die Abfrage kennt nur die Regeln, nicht die PreToolUse-Hooks einer Firma und
+ * nicht den Prüfer des Auto-Modus (Typen von `ToolCheckResult.hook`; Bauplan Abschnitt 4).
+ * Gefragt werden nur Werkzeuge, die es hier gibt (ohne PowerShell etwa unter macOS); wirft die Liste, nur `Bash`. Eine
+ * Abfrage, die wirft, ist kein Verbot — nur ein ausgesprochenes `deny` sperrt; sonst hielte ein fehlendes Werkzeug
+ * jedes Update auf.
+ */
+async function verboten($: Engine, ziel: string): Promise<boolean> {
+  const da = await $.tool.list().then(liste => liste.map(w => w.name), () => ['Bash'])
+  for (const tool of WERKZEUGE.filter(w => da.includes(w))) {
+    for (const command of [`npm install -g kimal3@${ziel}`, 'kimal3 skill install']) {
+      const urteil = await $.tool.check({ tool, input: { command } }).catch((fehler: unknown) => {
+        protokoll($, `Regel-Abfrage ${tool}: ${String(fehler)}`)
+        return null
+      })
+      if (urteil?.decision === 'deny') return true
+    }
+  }
+  return false
+}
+
+/**
+ * Die drei Befehle nacheinander, jeder ohne Kommandozeile, im Ordner `~/.kimal3` (nie im Projekt: ein `.npmrc` dort
+ * gälte sonst mit). Scheitert eine Stufe, läuft die nächste nicht (U-6, U-7, U-7b). Die Sperre hält andere Fenster ab
+ * (U-5) und geht in `finally` weg — auch wenn ein Befehl wirft.
+ */
+async function ausfuehren($: Engine, ablage: Ablage, liste: string[][], ziel: string): Promise<void> {
+  await $.store.set(SPERRE, { ziel, seit: await $.clock.now() } satisfies Sperre)
+  await update($, lauf, () => ({ art: 'laeuft', ziel, meldung: '' }))
+  try {
+    const meldung = await stufen($, ablage.kimal3Ordner, liste, ziel).catch((fehler: unknown) => String(fehler))
+    if (meldung === null) {
+      // Bleibt stehen, bis ein Mod mit dieser Fassung lädt oder 24 Stunden um sind (beimLaden, `fertigGilt`): Erst der
+      // Neustart bringt Coach und Befehle.
+      await $.store.set(FERTIG, { ziel, am: await $.clock.now() } satisfies Fertig)
+      await update($, lauf, () => ({ art: 'geklappt', ziel, meldung: '' }))
+    } else {
+      await update($, lauf, () => ({ art: 'fehler', ziel, meldung: meldungKurz(meldung) }))
+    }
+  } finally {
+    await $.store.delete(SPERRE)
+  }
+}
+
+/** `null`: alle drei Stufen geklappt; sonst die Meldung der gescheiterten. */
+async function stufen($: Engine, ordner: string, [npm, version, skill]: string[][], ziel: string): Promise<string | null> {
+  const init = (minuten: number) => ({ cwd: ordner, timeoutMs: minuten * MINUTE })
+  const a = await $.process.run(npm, init(10))
+  if (a.exitCode !== 0) return `${a.stdout}\n${a.stderr}`
+  // Hat das npm dieses Node die Fassung wirklich dorthin gelegt, wo `kimal3` liegt? (Homebrew, Volta, A-8)
+  const b = await $.process.run(version, init(2))
+  if (b.exitCode !== 0 || !versionStimmt(b.stdout, ziel)) return `kimal3 --version:\n${b.stdout}\n${b.stderr}`
+  const c = await $.process.run(skill, init(2))
+  return c.exitCode !== 0 ? `${c.stdout}\n${c.stderr}` : null
+}
+
+/** „Claude fragen“ nach einem Fehlschlag: die Zielfassung und das Ende der Meldung (Bauplan 1.3 Punkt 6). */
+export async function updateClaudeFragen($: Engine, sprache: Sprache): Promise<void> {
+  const stand = await read($, lauf)
+  if (stand?.art === 'fehler') await $.prompt.submit({ text: TEXTE[sprache].bitteFehler(stand.ziel, stand.meldung) })
+}

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

@@ -1,8 +1,16 @@
-declare module 'claude-code' {
-  interface PluginState {
-    'kimal3-logo': {
-      // Die Projektseite wurde in dieser Sitzung schon geöffnet (hooks/app-oeffnen.ts) — übersteht das Neuladen des Mods.
-      appGeoeffnet: boolean
-    }
-  }
-}
+declare module 'claude-code' {
+  interface PluginState {
+    'kimal3-logo': {
+      // Die Projektseite wurde in dieser Sitzung schon geöffnet (hooks/app-oeffnen.ts) — übersteht das Neuladen des Mods.
+      appGeoeffnet: boolean
+      // Der Chat wurde benannt oder es gab schon einen Versuch — danach nie wieder (hooks/chat-benennen.ts, B-3, B-6).
+      chatBenannt: boolean
+      // Wie oft das Modell in dieser Sitzung schon gefragt wurde, ob das Thema klar ist (höchstens 8, B-8).
+      benennenFragen: number
+      // Die neueste Fassung, die npm heute genannt hat ('' = keine bekannt); daraus zeichnet die Leiste den Knopf (hooks/update.ts).
+      updateNeueste: string
+      // Was der Klick in diesem Fenster angestoßen hat; `meldung` = Ende der Fehlermeldung für „Claude fragen“ (hooks/update.ts).
+      updateLauf: { art: 'laeuft' | 'geklappt' | 'fehler' | 'gesperrt'; ziel: string; meldung: string } | null
+    }
+  }
+}