kimal3 0.6.4 → 0.6.5

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

@@ -1,6 +1,6 @@
 {
   "name": "kimal3-logo",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "KImal3-Logo über dem Eingabefeld, öffnet beim Start das Projekt in der App, benennt den Chat nach seinem Thema · KImal3 logo above the prompt, opens the project in the app on start, names the chat after its topic",
   "author": { "name": "KImal3", "url": "https://kimal3.de" },
   "types": "./types/index.d.ts"

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

@@ -0,0 +1,8 @@
+// Wo `kimal3` auf diesem Rechner liegt und welche Fassung es hat. `kimal3` ersetzt beim Ablegen die Zeile
+// `const ABLAGE: Ablage = KEINE_ABLAGE` in register.tsx durch die echten Werte (`mitAblage` in `cli/src/logo-ablegen.ts`,
+// Bauplan 2026-10-23, Abschnitt 1.1). Hier im Paket bleibt sie leer: Ein Mod ohne Ablage (Entwicklung) zeigt keine
+// Fassung und fragt npm nicht (U-9). Die Felder stehen in `cli/src/logo-ablegen.ts` noch einmal (`Ablage`) -- die CLI
+// kann diese Datei nicht einbinden; `check:cli` hält beide Feldlisten gleich.
+export type Ablage = { fassung: string; node: string; npm: string; kimal3: string; kimal3Ordner: string }
+
+export const KEINE_ABLAGE: Ablage = { fassung: '', node: '', npm: '', kimal3: '', kimal3Ordner: '' }

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

@@ -1,10 +1,15 @@
 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).
@@ -33,11 +38,8 @@ const MARKEN_CYAN = '#00C3FF'
 // 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]
+// 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).
@@ -45,34 +47,55 @@ export const register: Register = (on, options) => {
   // Den Chat nach seinem Thema benennen, sobald es klar ist (hooks/chat-benennen.ts).
   chatBenennen(on, options)
 
-  on('ui.render', { component: 'AbovePrompt' }, ($, e, next) => {
+  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, Text } = $.ui.resolve(e)
+      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>
-          <Text bold>
-            {TEXT.vor}
-            <Link href={APP}>
-              {'KI'}
-              <Text color={MARKEN_CYAN}>{'mal3'}</Text>
-              {TEXT.nach}
-            </Link>
-            {'.'}
-          </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, Text } = $.ui.resolve(e)
+    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 />
@@ -81,6 +104,7 @@ export const register: Register = (on, options) => {
           <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

@@ -7,6 +7,10 @@ declare module 'claude-code' {
       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
     }
   }
 }

package/dist/logo-ablegen.js

@@ -1,11 +1,12 @@
 import { cpSync, existsSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { basename, dirname, join } from "node:path";
+import { homedir, platform } from "node:os";
+import { basename, dirname, join, posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { EINRICHTEN_TEXTE } from "./texte/einrichten.js";
+import { eigeneVersion } from "./version.js";
 /**
  * Legt den Plugin-Katalog mit dem Logo-Mod in `~/.kimal3/claude-plugins` ab und setzt dort die
- * Sprache des Kontos. Claude Code liest den Mod aus genau diesem Ordner (Katalog `kimal3`,
+ * Sprache des Kontos und die Ablage (`mitAblage`). Claude Code liest den Mod aus genau diesem Ordner (Katalog `kimal3`,
  * `plugins-mischen.ts`).
  *
  * 🔑 Warum ein fester Ordner im Benutzerordner und nicht der Ordner im installierten npm-Paket:
@@ -24,10 +25,64 @@ export function mitSprache(quelltext, sprache) {
         return null;
     return quelltext.replace(SPRACH_ZEILE, `const SPRACHE: 'de' | 'en' = '${sprache}'`); // kein-anzeigetext: Quelltext des Mods
 }
+/** Die Zeile im Mod, die beim Ablegen die Ablage bekommt; im Paket steht dort die leere. */
+export const ABLAGE_ZEILE = "const ABLAGE: Ablage = KEINE_ABLAGE"; // kein-anzeigetext: Quelltext des Mods
+/**
+ * Reine Rechnung: der Mod-Text mit der Ablage, oder `null`, wenn die Zeile nicht genau einmal dasteht. Ohne Ablage
+ * (keine eigene Fassung) bleibt die leere Zeile stehen -- der Mod zeigt dann wie bisher nur das Logo (U-9).
+ * 🔴 `split`/`join`, nie `replace(zeile, text)`: Im Ersatz-Text eines `replace` sind `$&` und `$'` Befehle, und ein
+ * Ordnername darf beides enthalten -- dann stünde fremder Quelltext im Mod (messen-und-pruefen §23, U-16). `JSON.stringify`
+ * macht aus jedem Wert ein gültiges Stück Quelltext, auch mit `"` und `\` (Windows-Pfade).
+ */
+export function mitAblage(quelltext, ablage) {
+    const teile = quelltext.split(ABLAGE_ZEILE);
+    if (teile.length !== 2)
+        return null;
+    return ablage === null ? quelltext : teile.join(`const ABLAGE: Ablage = ${JSON.stringify(ablage)}`); // kein-anzeigetext: Quelltext des Mods
+}
+/**
+ * Reine Rechnung hinter `ablageWerte`. Ohne eigene Fassung keine Ablage (`null`).
+ * `npm` ist das `npm-cli.js`, das zu DIESEM Node gehört (Windows daneben, sonst unter `lib/`), und nur dann gesetzt, wenn
+ * es die Datei gibt und `kimal3` global installiert läuft. Sonst `""`: Der Knopf bittet dann Claude (U-10), statt ein
+ * `npm install -g` anzustoßen, nach dem `kimal3 --version` doch die alte Zahl sagte.
+ * 🔑 Global heißt, als Erlaubnisliste (messen-und-pruefen §23): `…/node_modules/kimal3/…` mit genau EINEM `node_modules`,
+ * ohne `_npx` (der Zwischenspeicher von `npx`), und über dem `node_modules` kein `package.json` (sonst ist es der Ordner
+ * eines Projekts). Ein Start aus dem Repo (`cli/dist`) ist damit auch nicht global.
+ */
+export function ablageAus(lage) {
+    if (lage.fassung === null)
+        return null;
+    const p = lage.system === "win32" ? win32 : posix;
+    const npm = lage.system === "win32"
+        ? p.join(p.dirname(lage.node), "node_modules", "npm", "bin", "npm-cli.js") // kein-anzeigetext: Pfad
+        : p.join(p.dirname(p.dirname(lage.node)), "lib", "node_modules", "npm", "bin", "npm-cli.js"); // kein-anzeigetext: Pfad
+    const teile = lage.kimal3.split(/[\\/]/);
+    const i = teile.indexOf("node_modules");
+    const global = i > 0 && teile.lastIndexOf("node_modules") === i && teile[i + 1] === "kimal3" && !teile.includes("_npx")
+        && !lage.gibtEs(p.join(teile.slice(0, i).join(p.sep), "package.json"));
+    return {
+        fassung: lage.fassung,
+        node: lage.node,
+        npm: global && lage.gibtEs(npm) ? npm : "",
+        kimal3: lage.kimal3,
+        kimal3Ordner: p.join(lage.heim, ".kimal3"), // kein-anzeigetext: Ordnername
+    };
+}
+/** Die Ablage dieses Rechners, im laufenden `kimal3` gemessen (Bauplan 2026-10-23, Tabelle in 1.1). */
+export function ablageWerte() {
+    return ablageAus({
+        fassung: eigeneVersion(),
+        node: process.execPath,
+        kimal3: fileURLToPath(new URL("./kimal3.js", import.meta.url)), // kein-anzeigetext: Dateiname
+        heim: homedir(),
+        system: platform(),
+        gibtEs: existsSync,
+    });
+}
 /**
  * 🔴 NIE EIN HALBER ORDNER (Durchsicht-Funde 2 und 9): Claudes Einstellungen zeigen auf `katalogOrdner()`,
  * und eine laufende Claude-Sitzung hat den Mod daraus geladen. Deshalb:
- *   1. Sprache setzen, BEVOR irgendetwas angefasst wird -- fehlt die Zeile, bleibt alles, wie es war.
+ *   1. Sprache und Ablage setzen, BEVOR irgendetwas angefasst wird -- fehlt eine der Zeilen, bleibt alles, wie es war.
  *   2. Steht schon genau das da, was entstehen soll: nichts anfassen (Lage P-8). Das ist auch der Normalfall
  *      eines zweiten Laufs, und so kommt er gar nicht erst in die Nähe der Windows-Sperren unten.
  *   3. Den neuen Ordner daneben fertig bauen (`….neu`), dann tauschen: alten Ordner wegschieben, neuen an
@@ -46,7 +101,8 @@ export function logoAblegen(sprache) {
     const neu = `${ziel}.neu`; // kein-anzeigetext: Ordnername
     const modDatei = (ordner) => join(ordner, "kimal3-logo", "hooks", "register.tsx");
     try {
-        const text = mitSprache(readFileSync(modDatei(quelle), "utf8"), sprache);
+        const mitSpr = mitSprache(readFileSync(modDatei(quelle), "utf8"), sprache);
+        const text = mitSpr === null ? null : mitAblage(mitSpr, ablageWerte());
         if (text === null)
             return { ok: false, detail: modDatei(quelle) };
         if (stehtSchonDa(quelle, ziel, text)) {
@@ -102,7 +158,7 @@ export function frischeLogoAuf(s) {
     else if (ablage.stand === "alt")
         console.log(t.logoNotRefreshed);
 }
-/** Gleiche Dateien, gleicher Inhalt -- der Mod mit der Sprache des Kontos, alles andere wie im Paket. */
+/** Gleiche Dateien, gleicher Inhalt -- der Mod mit Sprache und Ablage, alles andere wie im Paket. */
 function stehtSchonDa(quelle, ziel, modText) {
     if (!existsSync(ziel))
         return false;

package/dist/texte/wache.js

@@ -2,8 +2,8 @@ const de = {
     accessExpired: (login) => "🔴🔴🔴 kimal3: Dein Zugang ist abgelaufen — zum Beispiel nach einem neuen Passwort " +
         `oder einer längeren Pause. Melde dich neu an mit:  ${login}  🔴🔴🔴`,
     messageFromKimal3: (text) => `Nachricht von kimal3: „${text}“`,
-    newVersion: (neu, eigene) => `🟡🟡🟡 kimal3: Es gibt eine neuere Version: ${neu} (du hast ${eigene}). ` +
-        `Holen mit:  ! npm install -g kimal3@${neu}  🟡🟡🟡`,
+    newVersion: (neu, eigene, skill) => `🟡🟡🟡 kimal3: Es gibt eine neuere Version: ${neu} (du hast ${eigene}). ` +
+        `Holen mit:  ! npm install -g kimal3@${neu}  — danach:  ${skill}  🟡🟡🟡`,
     skillsOld: (befehl) => "🟡🟡🟡 kimal3: Deine /k3-Befehle in Claude sind veraltet oder in einer anderen Sprache als dein Konto. " +
         `Auffrischen:  ${befehl}  🟡🟡🟡`,
     instructionToClaude: "Anweisung an Claude: Gib die Zeilen oben dem Menschen als ERSTE Zeilen deiner nächsten " +
@@ -20,8 +20,8 @@ const en = {
     accessExpired: (login) => "🔴🔴🔴 kimal3: Your sign-in has expired, for example after a new password " +
         `or a long break. Sign in again with:  ${login}  🔴🔴🔴`,
     messageFromKimal3: (text) => `Message from kimal3: “${text}”`,
-    newVersion: (neu, eigene) => `🟡🟡🟡 kimal3: A newer version is available: ${neu} (you have ${eigene}). ` +
-        `Install it with:  ! npm install -g kimal3@${neu}  🟡🟡🟡`,
+    newVersion: (neu, eigene, skill) => `🟡🟡🟡 kimal3: A newer version is available: ${neu} (you have ${eigene}). ` +
+        `Install it with:  ! npm install -g kimal3@${neu}  — then:  ${skill}  🟡🟡🟡`,
     skillsOld: (befehl) => "🟡🟡🟡 kimal3: Your /k3 commands in Claude are out of date or in a different language from your account. " +
         `Update them:  ${befehl}  🟡🟡🟡`,
     instructionToClaude: "Instruction to Claude: Show the lines above to the person verbatim, in bold, as the FIRST lines of " +

package/dist/wache-rechnung.js

@@ -49,7 +49,9 @@ export function wacheBefunde(lage, s) {
         istAelter(lage.eigeneVersion, lage.neuesteVersion)) {
         befunde.push({
             art: "version",
-            zeile: T.newVersion(lage.neuesteVersion, lage.eigeneVersion),
+            // Zwei Befehle GETRENNT, nie mit `&&` verbunden: Die Windows-PowerShell 5.1 kennt `&&` nicht, und
+            // ohne `skill install` bleiben Claudes /k3-Befehle auf der alten Fassung (Spec Update in der Leiste, E-4).
+            zeile: T.newVersion(lage.neuesteVersion, lage.eigeneVersion, tippen("skill install", s)), // kein-anzeigetext: Befehlsname
         });
     }
     if (lage.skillVeraltet) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kimal3",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "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": {