kimal3 0.2.6 → 0.2.8

package/dist/befehle/kontext-hoch.js

@@ -4,6 +4,7 @@ import { FIRMEN_TEXTE, alsMerkzettel, bekannterStandAus, merkzettelNachHoch, } f
 import { traegtFragenVon } from "../fragen-lesen.js";
 import { leseEineDatei, leseMerkzettelDatei, schreibeMerkzettelDatei } from "../kontext-dateien.js";
 import { ERLAUBT, absage, arbeitsplatzOderAbsage, fremdeDateiAbsage } from "./kontext-gemeinsam.js";
+import { hochZeile } from "../kontext-hoch-zeile.js";
 /*
   🪦 **Hier stand `feldSchluessel`, gestrichen mit Ruling K-6 (Task 7).**
 
@@ -185,7 +186,7 @@ export async function kontextHoch(argv) {
       was daneben schiefging. Was hochgeschickt wurde, haengt nicht daran, ob ein
       Merkzettel auf der Platte landet.
     */
-    console.log(`✓ hochgeschickt: ${ergebnis.uebernommen.join(", ")}`);
+    console.log(hochZeile(ergebnis.uebernommen));
     const merkzettelSchreiben = schreibeMerkzettelDatei(ordner, zuSchreiben);
     if (!merkzettelSchreiben.ok) {
         /*
@@ -210,10 +211,17 @@ export async function kontextHoch(argv) {
         */
         console.error("Die Firma hat deine Änderungen gespeichert — nur der lokale Merkzettel ließ sich nicht schreiben:");
         console.error(merkzettelSchreiben.meldung);
-        return 1;
+        // B-d (Dennis, 17.09.): Das ist ein ERFOLG -- die Firma hat gespeichert.
+        // Der Rueckgabewert ist fuer Maschinen da, und fuer die ist "gespeichert"
+        // die Wahrheit; die Warnung steht auf stderr fuer den Menschen. Bis 0.2.7
+        // stand hier `1`, und zwei Anleitungen fuehrten eine Tabelle, nur um diese
+        // Zahl zu uebersetzen.
+        return 0;
     }
-    // US-3: WAS hochgeladen wurde, nicht nur "fertig" -- die Zeile steht seit
-    // Runde 4 oben, vor der Merkzettel-Pruefung (Begruendung dort).
+    // US-3: WAS sich bei der Firma geaendert hat, nicht nur "fertig" -- die
+    // Zeile steht seit Runde 4 oben, vor der Merkzettel-Pruefung (Begruendung
+    // dort). Seit Task 7 (B-e) kommt der Satz aus `hochZeile` und nennt nur
+    // die WIRKLICH geaenderten Dateien -- oder "nichts geaendert".
     //
     // 🔑 Der Erklaersatz darunter ist mit Fund F ersatzlos WEGGEFALLEN. Er
     // benannte eine Ausnahme, die es nicht mehr gibt -- fuenf Texte, zwei

package/dist/befehle/projekt-neu.js

@@ -2,11 +2,16 @@ import { feld, ruf } from "../api.js";
 import { schlussFehler } from "../fehler.js";
 import { BASIS_URL } from "../anmeldung.js";
 import { zerlege } from "../argumente.js";
+import { absage } from "./kontext-gemeinsam.js";
+import { befehlszeileOhneFirma, firmenKoerperAus, ohneFirmaAusArgv } from "../projekt-neu-firma.js";
 const OPTIONEN = [
     "titel", "beschreibung", "symbol", "stunden", "ergebnis", "umsatz",
-    "wirkung", "wirkung-label", "link", "live-seit",
+    "wirkung", "wirkung-label", "link", "live-seit", "firma", "firma-id",
 ];
-const HILFE = `
+// exportiert, damit `check:cli` die HILFE als AUSGABE-Text prueft (§24
+// erlaubt das: nicht die Anleitung, die den Text beschreibt, sondern der
+// Text, der wirklich auf dem Bildschirm des Kunden landet).
+export const HILFE = `
   kimal3 projekt neu --titel "Angebots-Generator" [Optionen]
 
     --titel          Pflicht. 2–80 Zeichen.
@@ -19,6 +24,9 @@ const HILFE = `
     --wirkung-label  Wozu, bis 40 Zeichen, z. B. "Angebotszeit".
     --link           Vollstaendige Adresse mit http:// oder https://.
     --live-seit      Datum als JJJJ-MM-TT.
+    --firma "Name"   Wenn du zu mehreren Firmen gehoerst: welche das Projekt bekommt.
+    --firma-id "…"   Falls zwei deiner Firmen gleich heissen.
+    --ohne-firma     Das Projekt gehoert keiner Firma (steht nur auf deinem Profil).
 `;
 export async function projektNeu(argv) {
     // ⚠️ VOR dem Zerlegen abfragen, nicht danach.
@@ -30,7 +38,12 @@ export async function projektNeu(argv) {
         console.log(HILFE);
         return 0;
     }
-    const z = zerlege(argv, OPTIONEN);
+    // ⚠️ `zerlege` kennt keine Optionen ohne Wert -- `--ohne-firma` wird
+    // deshalb VOR der Zerlegung herausgefiltert, genau wie `--ueberschreiben`
+    // in kontext-hoch.ts. Die Rechnung dahinter steht in projekt-neu-firma.ts,
+    // damit `check:cli` sie pruefen kann (Final-Review F-1).
+    const { rest, ohneFirma } = ohneFirmaAusArgv(argv);
+    const z = zerlege(rest, OPTIONEN);
     if (!z.ok) {
         console.error(z.meldung);
         return 1;
@@ -40,6 +53,15 @@ export async function projektNeu(argv) {
         console.error("Es fehlt --titel.\n" + HILFE);
         return 1;
     }
+    // 🔴 Final-Review F-3: `--ohne-firma` zusammen mit `--firma`/`--firma-id`
+    // liesse die Route den Schalter still gewinnen lassen (`firmenWunschAus` in
+    // route.ts prueft `ohne_firma` zuerst). Hier abweisen, bevor der Wunsch
+    // ueberhaupt losgeschickt wird.
+    const wunsch = firmenKoerperAus(o.firma, o["firma-id"], ohneFirma);
+    if (!wunsch.ok) {
+        console.error(wunsch.meldung);
+        return 1;
+    }
     const antwort = await ruf("/api/cli/projekt", {
         mitAusweis: true,
         koerper: {
@@ -48,6 +70,7 @@ export async function projektNeu(argv) {
             zeitersparnis_std_wo: o.stunden ?? "", ergebnis_monat_eur: o.ergebnis ?? "",
             umsatz_monat_eur: o.umsatz ?? "", link_url: o.link ?? "",
             live_seit: o["live-seit"] ?? "",
+            ...wunsch.koerper,
         },
     });
     if (antwort.status === 201) {
@@ -73,6 +96,13 @@ export async function projektNeu(argv) {
         console.error(`${meldung} Leg es hier an: ${BASIS_URL}/profil`);
         return 1;
     }
+    if (antwort.status === 409) {
+        // Firmen-Absage in der Form von arbeitsplatz/kontext: `absage` druckt die
+        // Meldung und die Firmen als fertige Befehle. Der Befehl in der Zeile
+        // traegt ALLE getippten Optionen mit, nicht nur --titel (Final-Review
+        // F-2) -- sonst verliert der Kunde beim Kopieren --stunden, --ergebnis &co.
+        return absage(antwort, `projekt neu ${befehlszeileOhneFirma(o)}`);
+    }
     // ⚠️ Hier landet auch die `503` "Konto gerade nicht prüfbar" — und sie MUSS
     // hier landen, nicht oben bei der 402. Rueckgabewert 3 heisst "nochmal
     // versuchen kann helfen"; 4 heisst laut SKILL.md ausdruecklich "nicht

package/dist/befehle/wache.js

@@ -107,9 +107,15 @@ function skillIstVeraltet() {
  */
 async function frageServer(schluessel, heute) {
     try {
+        // 🔴 Die Version reist mit, wie bei jedem anderen Befehl (`api.ts`). Bis
+        // 0.2.7 fehlte sie hier -- und der Server konnte nicht wissen, dass diese
+        // Fassung einen Update-Hinweis ohnehin verwirft; der belegte dann den
+        // einen Platz der Antwort, und ein Angebot kam ueber die Wache nie an
+        // (live gemessen 17.09.). Faellt die Version aus, geht der Kopf nicht mit.
+        const version = eigeneVersion();
         const antwort = await fetch(`${BASIS_URL}/api/cli/wache`, {
             method: "POST",
-            headers: { Authorization: `Bearer ${schluessel}` },
+            headers: { Authorization: `Bearer ${schluessel}`, ...(version ? { "X-Kimal3-Version": version } : {}) },
             signal: AbortSignal.timeout(ZEITGRENZE_MS),
         });
         const koerper = await antwort.json().catch(() => null);

package/dist/kimal3.js

@@ -32,6 +32,119 @@ import { projektListe } from "./befehle/projekt-liste.js";
 import { projektNeu } from "./befehle/projekt-neu.js";
 import { skillDatei, skillInstall } from "./befehle/skill-install.js";
 import { wache, wacheSchalten } from "./befehle/wache.js";
+/** Eine Meldung pro Programmlauf -- s. "Einmal-Riegel" im Block darunter. */
+let schonGemeldet = false;
+/**
+ * Die gekappte Leitung macht keinen Laerm mehr (D-27).
+ *
+ * 🔴 WARUM DAS HIER STEHT UND NICHT IN `endeMitHinweis`: Ein Schreibfehler auf
+ * STDOUT/STDERR kommt NICHT als Wurf zurueck, den ein try/catch faengt --
+ * er kommt als `'error'`-EREIGNIS auf dem Kanal selbst. Ohne angemeldeten
+ * Empfaenger behandelt Node ein unbehandeltes `'error'`-Ereignis als
+ * Programmabbruch, egal WELCHE Zeile gerade schreibt. Und geschrieben wird
+ * schon lange vor `endeMitHinweis` -- `haupt()` gibt bei `--version`, `--help`
+ * und jedem Befehl selbst aus. Der Empfaenger muss deshalb angemeldet sein,
+ * BEVOR die erste Zeile faellt: hier, auf Modulebene, noch vor jedem Aufruf.
+ *
+ * Gemessen (`npm run check:cli-live`, Fall a): Leitet ein Kunde
+ * `kimal3 --version | head -1`, schliesst `head` die Leitung, sobald es seine
+ * eine Zeile hat -- der naechste Schreibversuch von kimal3 trifft auf einen
+ * toten Empfaenger. Ohne diesen Empfaenger hier wirft das eine rote
+ * Stapelspur auf den Bildschirm, fuer einen Befehl, der laengst fertig war.
+ *
+ * ⚠️ EPIPE SCHLUCKEN, ABER NICHT ALLES (Technische Notiz der Aufgabe): Eine
+ * gekappte Leitung ist kein Fehler, den man MELDEN koennte -- der Empfaenger
+ * ist weg, niemand liest eine Meldung. Jeder ANDERE Kanalfehler ist einer und
+ * darf nicht stillschweigend verschwinden -- sonst truege ein Fehlerfall
+ * denselben Namen wie ein Erfolgsfall (vgl. die Regel zu `bestaetigungen-
+ * Aktivieren` in der Projekt-CLAUDE.md). Deshalb wird der Rueckgabewert auf 1
+ * gesetzt -- und die Meldung geht, wenn ueberhaupt, auf den FEHLERkanal.
+ *
+ * 🔴 UND DIE MELDUNG GEHT NIE IN DEN DATENKANAL -- die Ungleichheit der zwei
+ * Kanaele IST der Bauplan, keine Ausnahme (Befund W-1a der Gesamt-Durchsicht,
+ * 2026-09-12). Hier stand vorher "sag es auf dem JEWEILS ANDEREN Kanal", und
+ * das war fuer einen der zwei Faelle falsch:
+ *   · Bricht der DATENkanal (stdout), darf auf dem Fehlerkanal gemeldet
+ *     werden -- der ist genau dafuer da.
+ *   · Bricht der FEHLERkanal (stderr), wird NIRGENDS gemeldet. Auf stdout
+ *     liegt die Maschinenform: das JSON von `firma daten` und die JSON-Huelle
+ *     von `wache --hook`, die Claude Code parst. Ein deutscher Satz
+ *     mittendrin macht `JSON.parse` ueber die ganze Ausgabe unmoeglich -- und
+ *     genau das verbietet US-1 ("nie mittendrin") schon fuer den
+ *     Update-Hinweis in `endeMitHinweis`. Dann ist der Rueckgabewert die
+ *     ehrliche Auskunft; der Datenkanal ist keine Protokollzeile wert.
+ * Gemessen vor der Reparatur: `quatschbefehl` mit nur-lesbarem stderr legte
+ * `kimal3: Ausgabekanal-Fehler -- EBADF ...` auf stdout.
+ *
+ * 🔴 UND EIN EINMAL-RIEGEL, DAMIT DAS PROGRAMM UEBERHAUPT ENDET (Befund W-1b,
+ * dieselbe Durchsicht): Solange beide Empfaenger einander anschrieben, erzeugte
+ * jeder Schreibversuch das naechste `'error'`-Ereignis auf dem anderen Kanal --
+ * bei ZWEI kaputten Kanaelen (eine volle Platte genuegt:
+ * `kimal3 firma daten > a.json 2> b.txt` -> ENOSPC auf beiden) endete das
+ * Programm damit NIE. Gemessen: nach 8 Sekunden noch da, musste abgeschossen
+ * werden; dieselbe Lage ohne die Empfaenger endete in 36 ms. Und die
+ * 2-Sekunden-Notbremse half nicht: Sie wird erst IN `endeMitHinweis` gestellt
+ * und vom Ereignis-Pingpong ausgehungert. `schonGemeldet` schneidet das ab --
+ * eine Meldung pro Programmlauf, mehr braucht niemand.
+ *
+ * 🔑 KEIN `process.exit` HIER (Constraint 2): Nur `exitCode` wird gesetzt --
+ * das Programm endet von selbst, sobald kein Ereignis mehr nachkommt, und
+ * genau dafuer sorgt der Einmal-Riegel.
+ *
+ * Registriert wird das genau EINMAL pro Kanal, hier -- nicht an jeder
+ * einzelnen Schreibstelle. `console.log`/`console.error` UND die zwei
+ * direkten `process.stdout.write`/`process.stderr.write`-Aufrufe in
+ * `endeMitHinweis` schreiben alle auf DIESELBEN zwei Stream-Objekte
+ * (`process.stdout`, `process.stderr` sind pro Prozess EINMALIG vorhanden);
+ * ein Empfaenger auf dem Stream selbst deckt deshalb jede Schreibstelle im
+ * ganzen Programm ab, auch die in den einzelnen `befehle/*.ts`-Dateien.
+ */
+/**
+ * @param meldenAuf Wohin die Meldung darf -- oder `null` fuer "nirgends".
+ *   `null` steht fuer den Fehlerkanal selbst: Ist ER kaputt, bleibt nur der
+ *   Rueckgabewert, denn der Datenkanal gehoert der Maschinenform.
+ */
+function gegenUnbehandelteKanalfehlerAbsichern(kanal, meldenAuf) {
+    kanal.on("error", (fehler) => {
+        if (fehler.code === "EPIPE")
+            return;
+        /*
+          🔴 NUR SETZEN, WENN NOCH KEIN FEHLSCHLAG VERMERKT IST (Befund des
+          Koordinators, Fix-Runde 1). Ein Kanalfehler kann auftreten, WAEHREND
+          gerade eine viel genauere Fehlermeldung geschrieben wird -- der
+          `.catch`-Zweig am Dateiende setzt `process.exitCode = 2` ("bitte
+          einloggen") bzw. `3` ("nicht erreichbar") direkt NACH dem
+          `console.error`-Aufruf, der den Kanalfehler ueberhaupt erst ausloest.
+          Ein bedingungsloses `process.exitCode = 1` hier ueberschreibt diese
+          genauere Zahl mit der ungenaueren -- gemessen (Koordinator): Ausweis
+          fehlt, `projekt liste`, Fehlerkanal nur zum Lesen geoeffnet -> `2` geht
+          verloren, es bleibt nur `1`. Das ist derselbe Fehler wie bei
+          `bestaetigungenAktivieren` in der Projekt-CLAUDE.md: Ein Fehlerfall darf
+          nicht in einen anderen zusammenfallen, denn die Seite (hier: Claude)
+          kann nur unterscheiden, was der Rueckgabewert noch unterscheidet.
+    
+          Deshalb: Nur ein UNDEFINIERTER oder ein ERFOLGREICHER (`0`) Stand gilt
+          als "noch kein Fehlschlag vermerkt" -- ausdruecklich BEIDE pruefen,
+          nicht nur auf `0`, denn `process.exitCode` ist am Programmanfang
+          `undefined`, nicht `0`. Jede bereits gesetzte Zahl ungleich `0`
+          (`1`, `2`, `3`, `4`) ist die genauere Auskunft und bleibt stehen.
+        */
+        if (process.exitCode === undefined || process.exitCode === 0)
+            process.exitCode = 1;
+        if (meldenAuf === null || schonGemeldet)
+            return;
+        schonGemeldet = true;
+        try {
+            meldenAuf.write(`kimal3: Ausgabekanal-Fehler -- ${fehler.message}\n`);
+        }
+        catch {
+            // Auch der Fehlerkanal kann kaputt sein -- dann bleibt wenigstens der
+            // Rueckgabewert (oben gesetzt) die ehrliche Auskunft.
+        }
+    });
+}
+gegenUnbehandelteKanalfehlerAbsichern(process.stdout, process.stderr);
+gegenUnbehandelteKanalfehlerAbsichern(process.stderr, null);
 // 📌 Kein handgeschriebener Block mehr (2026-08-18): Die Liste wohnt in
 // `befehle-katalog.ts` und wird von dort AUCH im Pro-Bereich der App angezeigt.
 // Zwei Listen ueber dieselben Befehle driften — die eine bekaeme den naechsten

package/dist/kontext-hoch-zeile.js

@@ -0,0 +1,11 @@
+/**
+ * Die Erfolgszeile von `kimal3 kontext hoch` -- als reine Rechnung, damit
+ * `check:cli` sie prueft. Sie nennt, was sich BEI DER FIRMA geaendert hat,
+ * nicht, was gesendet wurde (B-e, 29.08.: fuenf Dateien genannt, zwei
+ * geaendert, eine davon ohne Zutun des Menschen).
+ */
+export function hochZeile(uebernommen) {
+    if (uebernommen.length === 0)
+        return "✓ nichts geändert — alles war schon so";
+    return `✓ geändert bei der Firma: ${uebernommen.join(", ")}`;
+}

package/dist/projekt-neu-firma.js

@@ -0,0 +1,74 @@
+import { alsBefehlszeile } from "./argumente.js";
+/**
+ * Der Firmenwunsch bei `projekt neu` -- herausgeloest aus `befehle/projekt-neu.ts`,
+ * damit `check:cli` ihn als reine Rechnung pruefen kann (Final-Review F-1).
+ *
+ * 🔴 **Vorher stand hier keine Rechnung, sondern zwei Zeilen QUELLTEXT-Pruefung**
+ * in `check-cli.mts` (`quelle.includes(...)`, ein Regex auf `argv.filter(...)`).
+ * Die wurden rot, wenn jemand die Lambda-Variable umbenannte, und blieben gruen,
+ * wenn die CLI aufhoerte, `ohne_firma` zu senden -- genau das Fehlerbild aus
+ * `docs/regeln/messen-und-pruefen.md`, Abschnitt 24: Eine Wache, die Text gegen
+ * Text haelt, bewacht die Formulierung, nicht das Verhalten.
+ *
+ * Zwei Schritte, weil `--ohne-firma` ein Schalter OHNE Wert ist und `zerlege`
+ * das nicht kennt (Begruendung in argumente.ts) -- er muss deshalb VOR dem
+ * Zerlegen raus. `--firma`/`--firma-id` sind normale Optionen mit Wert und
+ * liegen erst NACH dem Zerlegen vor.
+ */
+/**
+ * Schritt 1, vor `zerlege`: `--ohne-firma` aus der Befehlszeile herausfiltern.
+ * Das ist die Rechnung, die vorher nur als Regex auf ihren eigenen Quelltext
+ * gewacht wurde.
+ */
+export function ohneFirmaAusArgv(argv) {
+    return {
+        rest: argv.filter((a) => a !== "--ohne-firma"),
+        ohneFirma: argv.includes("--ohne-firma"),
+    };
+}
+/**
+ * Schritt 2, nach `zerlege`: aus Firmenname, Firmen-ID und dem Schalter den
+ * Rumpf fuer `/api/cli/projekt` bauen -- oder abweisen (Final-Review F-3).
+ *
+ * 🔴 **Die Route (`firmenWunschAus` in `src/app/api/cli/projekt/route.ts`)
+ * laesst `ohne_firma` GEWINNEN, wenn beides genannt wird** -- `--firma` wird
+ * dort still ignoriert, ohne dass die Firma je zu Wort kommt. Statt die Route
+ * anzufassen (0.2.7-Vertrag, ein `git push` macht sie fuer ALLE sofort neu,
+ * s. CLAUDE.md "Einer CLI-Route eine neue Rueckfrage beibringen"), weist die
+ * CLI die widerspruechliche Eingabe VORHER ab -- wie beim fehlenden `--titel`
+ * daneben.
+ */
+export function firmenKoerperAus(firma, firmaId, ohneFirma) {
+    if (ohneFirma && (firma || firmaId)) {
+        return {
+            ok: false,
+            meldung: 'Entweder --ohne-firma ODER --firma/--firma-id -- nenn nur eines von beiden.',
+        };
+    }
+    return { ok: true, koerper: { firma: firma ?? "", firma_id: firmaId ?? "", ohne_firma: ohneFirma } };
+}
+/**
+ * Die kopierfertige Zeile fuer die Firmen-Absage (`absage` in
+ * `kontext-gemeinsam.ts`) -- ALLE getippten Optionen, nicht nur `--titel`
+ * (Final-Review F-2).
+ *
+ * 🔴 **Vorher fiel jede weitere Option unter den Tisch:** `absage` bekam
+ * immer nur `alsBefehlszeile(["--titel", o.titel])`. Wer `projekt neu --titel
+ * X --stunden 5 --ergebnis 1200` tippte und die 409-Absage bekam, sah einen
+ * Kopierbefehl, der `--stunden` und `--ergebnis` verschluckte -- beim Kopieren
+ * landete ein Projekt ohne Zeitersparnis und ohne Ergebnis.
+ *
+ * `--firma`/`--firma-id` fliegen hier raus, weil `absage` selbst genau diese
+ * Option anhaengt (`kimal3 ${befehl} --firma …`); `--ohne-firma` kommt nie in
+ * `o` an (s. `ohneFirmaAusArgv` oben) und braucht deshalb keinen eigenen
+ * Ausschluss.
+ */
+export function befehlszeileOhneFirma(o) {
+    const teile = [];
+    for (const [name, wert] of Object.entries(o)) {
+        if (name === "firma" || name === "firma-id")
+            continue;
+        teile.push(`--${name}`, wert);
+    }
+    return alsBefehlszeile(teile);
+}

package/dist/zz-kaputt.js

@@ -0,0 +1 @@
+export const x = "das ist keine Zahl";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kimal3",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal.",
   "type": "module",
   "bin": {

package/skill/SKILL.md

@@ -222,11 +222,10 @@ auf dieser einen Zahl (`cli/src/befehle/kontext-hoch.ts`): unbekannte Option ·
 Arbeitsplatz gefunden · eine Datei nicht lesbar · eine Datei ohne Fragen · „jemand anderes hat
 geändert" (Ausweg `--ueberschreiben`) · mehrere Firmen (Ausweg `--firma`) — und die Rolle.
 
-🔴 **Der teuerste davon steht in `kontext-hoch.ts` (Merkzettel-Zweig) und ist ein ERFOLG:** *„Die Firma hat
-deine Änderungen gespeichert — nur der lokale Merkzettel ließ sich nicht schreiben."* Auch das
-gibt `1` zurück. Wer die Zahl als „kein Admin" deutet, sagt einem Menschen, der gerade alle
-Fragen beantwortet und **erfolgreich hochgeschickt** hat, er solle sich an seinen Admin wenden.
-*Ein Erfolg, als Absage vorgelesen — und er tippt danach alles noch einmal.*
+🔴 **Ein Fall in `kontext-hoch.ts` (Merkzettel-Zweig) sieht wie ein Fehler aus und ist ein ERFOLG:**
+*„Die Firma hat deine Änderungen gespeichert — nur der lokale Merkzettel ließ sich nicht schreiben."*
+Ab 0.2.8 gibt dieser Fall **0** zurück — er ist ein Erfolg. Die Warnung auf `stderr` sagt, dass
+nur der lokale Merkzettel fehlt; beim nächsten `kontext runter` fällt das ohnehin auf.
 
 **Also:** Nimm den Satz, den der Befehl geschrieben hat, und sag dem Menschen, was er bedeutet.
 Geht es wirklich um die Rolle, nenne den Admin — lief vorher `kontext runter`, kennt dessen
@@ -251,7 +250,9 @@ jemand anderem geändert wurde. **Nur auf ausdrücklichen Wunsch einsetzen** —
 `kimal3 projekt liste` — steht es schon da, **nicht** noch einmal eintragen.
 
 ## Eintragen
-`kimal3 projekt neu --titel "…" [--stunden 6] [--ergebnis 1200] [--symbol bot]`
+`kimal3 projekt neu --titel "…" [--stunden 6] [--ergebnis 1200] [--symbol bot] [--firma "Name" | --ohne-firma]`
+Wer zu genau einer Firma gehört, braucht `--firma` nicht — das Projekt gehört ihr. Bei zwei
+Firmen nennt die Absage beide als fertige Befehle.
 Alle Optionen: `kimal3 projekt neu --help`
 
 ## 🔑 Zahlen nie erfinden

package/skill/commands/k3kontext.md

@@ -78,12 +78,14 @@ Sammelausgang für mindestens sechs verschiedene Lagen, und sie verlangen Gegens
 | mehrere Firmen / mehrdeutig | Der Ausweg heißt `--firma "…"`. **Du wählst nicht** — leg die Liste vor. |
 | eine Datei ist nicht lesbar oder trägt keine Fragen mehr | `kimal3 kontext runter` holt sie zurück. |
 | **„Du gehörst keiner Firma an."** | 🔴 **Schick ihn NICHT zu einem Admin — es gibt keinen.** Das trifft ausgerechnet den frischen Pro-Käufer: Er bekommt seinen Arbeitsplatz mit allen Fragen offen, beantwortet sie brav, und hier ist niemand, an den sie gehen könnten. Sag ihm, dass seine Antworten **in seinen Dateien stehen und dort bleiben**, und dass sie hochgehen, sobald es eine Firma gibt. Nichts geht verloren. |
-| **„Die Firma hat deine Änderungen gespeichert — nur der lokale Merkzettel …"** | 🔴 **Das ist ein ERFOLG.** Alles ist oben angekommen; nur eine Datei auf der Platte ließ sich nicht schreiben. Sag genau das — **niemals** „das hat nicht geklappt". |
-
-⚠️ **Warum das hier so ausführlich steht:** Die letzte Zeile ist der teuerste Fall. Wer die `1`
-als „kein Admin" deutet, sagt einem Menschen, der gerade alle Fragen beantwortet und
-erfolgreich hochgeschickt hat, er solle sich an seinen Admin wenden. *Ein Erfolg, als Absage
-vorgelesen.*
+| **„Die Firma hat deine Änderungen gespeichert — nur der lokale Merkzettel …"** | 🔴 **Das ist ein ERFOLG.** Alles ist oben angekommen; nur eine Datei auf der Platte ließ sich nicht schreiben. Sag genau das — **niemals** „das hat nicht geklappt". (ab 0.2.8 Rückgabe 0) |
+
+⚠️ **Warum das hier so ausführlich steht:** Die letzte Zeile war bis 0.2.7 der teuerste Fall. Wer
+die `1` als „kein Admin" deutete, sagte einem Menschen, der gerade alle Fragen beantwortet und
+erfolgreich hochgeschickt hatte, er solle sich an seinen Admin wenden. *Ein Erfolg, als Absage
+vorgelesen.* Ab 0.2.8 trennt schon der Rückgabewert (`0` statt `1`) diesen Fall von einer
+echten Absage — bei einer älteren CLI gilt die alte Lesart weiter, deshalb bleibt die Meldung
+der verlässlichere Weg.
 
 **Rückgabewert `4`**: angemeldet, aber kein Pro-Zugang — die Meldung zeigen, den Befehl **nicht**
 wiederholen. Alles Übrige deutest du nach `SKILL.md`, Abschnitt „Rückgabewerte".

package/skill/commands/k3projekt.md

@@ -32,8 +32,10 @@ $ARGUMENTS
 Pro-Bereich kopiert und unverändert abgeschickt. Dann ist **nichts** angegeben: Frag, um welches
 Projekt es geht, statt den Platzhalter als Titel zu nehmen.
 
-Bau daraus `kimal3 projekt neu --titel "…"` mit den passenden Optionen
-(`kimal3 projekt neu --help` nennt alle).
+Bau daraus `kimal3 projekt neu --titel "…" [--firma "Name" | --ohne-firma]` mit den passenden
+Optionen (`kimal3 projekt neu --help` nennt alle). Wer zu genau einer Firma gehört, braucht
+`--firma` nicht — das Projekt gehört ihr. Bei zwei Firmen nennt die Absage beide als fertige
+Befehle.
 
 🔴 **Zeitersparnis, Umsatz und Ergebnis nie schätzen.** Diese Zahlen stehen anschließend
 **öffentlich** auf einer Seite mit dem Namen des Menschen. Wurde eine Zahl nicht genannt: