DogFatherGit/dogfather-universe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Entwicklung: aus einer Beobachtung wird ein Schritt

Browse Source 
Filipe: "ich will die noch viel besser, perfektionniert, viel geiler
und krasser. es soll so einfach wie moeglich sein fuer jeden."

Die Karte konnte bisher genau eines: festhalten, dass etwas hakt --
mit Anlass, das war schon richtig. Danach passierte nichts. Beim
naechsten Oeffnen stand dieselbe Beobachtung da, nur aelter.

Die Quellen zur laufenden Entwicklungsbegleitung sagen zweierlei: weg
von der Bewertung, hin zum Gespraech -- und ein Entwicklungsplan wirkt
dann, wenn er an einer ECHTEN Aufgabe haengt. Nicht "daran arbeiten
wir", sondern etwas mit Verantwortlichem und Frist.

Also: An einem Punkt, der hakt, steht ein Knopf. Er legt eine Aufgabe
auf dem Brett an -- Titel = der Punkt, der Anlass wandert in die
Beschreibung (ohne ihn waere es ein Vorwurf), verantwortlich ist der
Mensch selbst, Frist in 14 Tagen. Die Karte zeigt danach, dass ein
Schritt laeuft, und verweist auf ihn.

UND DANN SCHLIESST SICH DER KREIS: Ist der Schritt erledigt, sagt die
Karte das und bittet, noch einmal hinzusehen. Das ist der Rhythmus,
den die Quellen meinen -- keine Bewertung einmal im Jahr, sondern eine
Runde, die zu Ende geht. Danach geht derselbe Punkt wieder.

Die Riegel: nur aus dem EIGENEN "da hakt es" (aus dem eines anderen
hiesse, in seinem Namen zu handeln), nur ein offener Schritt je Punkt,
nur Leitung, und ein Punkt aus Block 5 sieht von aussen aus wie ein
erfundener. Im Protokoll steht, DASS -- nie der Anlass.

NEBENBEFUND, beim Uebernehmen der Schreibweise gefunden: aufgaben.html
#a<nummer> stand an DREI Stellen im Haus (bereich.js, report.js, jetzt
die Entwicklungskarte) und wurde von keiner gelesen -- das Brett kannte
nur ?zeigen=, und eine Karte mit ihrer Nummer als Anker gab es nicht.
Wer draufdrueckte, landete auf dem Brett und suchte von Hand. Jetzt
tragen die Karten ihre Nummer, und das Brett hebt genau die eine
hervor. Alle drei Verweise funktionieren damit.

Und was die Pruefung an sich selbst gefunden hat: Ich habe die rechte
Hand ueber die Adresse von DogFather gerufen. Sie bekam 401 -- und WEIL
sie nichts setzen konnte, ging ein zweiter Test aus dem falschen Grund
durch. Ein gruener Haken ueber einer Leere.

  server/pruef-schritt.mjs    46 Pruefungen, 0 Fehler (Port 4421)
  pruef-uebergang 61, pruef-nachwuchs 123, pruef-entwicklung 43,
  pruef-uebernahme 39, pruef-aufgabenbrett, pruef-css-klassen -- 0 Fehler

Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
DogFatherGit
2026-09-15 14:03:03 +02:00
co-authored by Claude Opus 5
parent b85740dc20
commit c615eab236
36 changed files with 1016 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/pruef-schritt.mjs
+388
View File
@@ -0,0 +1,388 @@
/* =====================================================================
Aus einer Beobachtung wird ein Schritt (15.09.2026)
Filipe: „ich will dass du die 2 kategorien perfektionnierst […] es
soll so einfach wie möglich sein für jeden."
---------------------------------------------------------------------
WAS GEFEHLT HAT
Die Entwicklungskarte konnte genau eines: festhalten, dass etwas
hakt — mit Anlass, das war schon richtig. Danach passierte nichts.
Beim nächsten Öffnen stand dieselbe Beobachtung da, nur älter.
Ein Entwicklungsplan wirkt dann, wenn er an einer ECHTEN Aufgabe
hängt. Also wird aus „da hakt es" eine Aufgabe auf dem Brett — und
wenn sie erledigt ist, fragt die Karte dieselbe Frage noch einmal.
---------------------------------------------------------------------
UND GENAU DA SIND DIE RIEGEL
Aus „läuft" einen Schritt machen? (darf nicht)
Aus der Beobachtung eines anderen? (darf nicht)
Zweimal zum selben Punkt? (darf nicht)
Ein Modi für sich selbst? (darf nicht)
Steht der Anlass hinterher im Protokoll? (darf nicht)
Aufrufen mit: node server/pruef-schritt.mjs
===================================================================== */
import { mkdtempSync, rmSync, readFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { request as httpAnfrage } from "node:http";
import { portMussFreiSein } from "./helfer-port.mjs";
const PORT = await portMussFreiSein(4421, "pruef-schritt");
const ordner = mkdtempSync(join(tmpdir(), "ws-schritt-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = String(PORT);
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
await import("./index.js");
notbremse(240_000, "pruef-schritt");
await new Promise((r) => setTimeout(r, 700));
process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });
let fehler = 0, geprueft = 0;
const melde = (t) => console.log(t);
const ok = (b, t) => { geprueft++; console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
const CREW = "crew.dogfather-universe.com";
const HAUS = "workspace.dogfather-universe.com";
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const kat = await import("./workspace-entwicklungs-punkte.js");
const ent = await import("./workspace-entwicklung.js");
const oeffne = () => new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
let idDogi, idHand, idFrida;
{
const d = oeffne();
const s = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
+ " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
.run("code_kennung_schluessel", s, jetzt);
const anlegen = (name, rolle, code) => {
const salt = randomBytes(16).toString("hex");
const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, code_kennung, aktiv, erstellt)"
+ " VALUES (?,?,?,?,?,?,1,?)")
.run(name, rolle, hash, salt, 32768, createHmac("sha256", s).update(code).digest("hex"), jetzt);
return d.prepare("SELECT last_insert_rowid() AS id").get().id;
};
idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
idHand = anlegen("Rieke", "hand", "CODE-HAND-0001");
idFrida = anlegen("Frida", "modi", "CODE-MODI-0001");
d.close();
}
function ruf(pfad, host, methode, kopf = {}, koerper = null) {
return new Promise((fertig, schief) => {
const a = httpAnfrage({ host: "127.0.0.1", port: PORT, path: pfad, method: methode,
headers: { Host: host, ...(koerper ? { "Content-Type": "application/json" } : {}), ...kopf } },
(antwort) => {
let text = "";
antwort.on("data", (s) => { text += s; });
antwort.on("end", () => fertig({ code: antwort.statusCode, text, kopf: antwort.headers }));
});
a.on("error", schief);
if (koerper) a.write(JSON.stringify(koerper));
a.end();
});
}
const json = (a) => { try { return JSON.parse(a.text); } catch { return {}; } };
async function anmelden(rolle, code, host) {
const r = await ruf("/workspace/api/anmelden", host, "POST", {}, { rolle, code });
return [].concat(r.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");
}
const kDogi = await anmelden("admin", "CODE-DOGI-0001", HAUS);
const kHand = await anmelden("hand", "CODE-HAND-0001", CREW);
const kFrida = await anmelden("modi", "CODE-MODI-0001", CREW);
ok(!!kDogi && !!kHand && !!kFrida, "DogFather, die rechte Hand und ein Modi sind angemeldet");
/* Zwei Punkte, die andere setzen dürfen. */
const P1 = kat.ENTWICKLUNG_FREMD[0].schluessel;
const P2 = kat.ENTWICKLUNG_FREMD[1].schluessel;
const SELBST = kat.ENTWICKLUNG_SELBST[0].schluessel;
/* DIE ADRESSE GEHÖRT ZUM KEKS.
Ein Zugang ist an das Haus gebunden, über das er angemeldet wurde --
die rechte Hand arbeitet auf crew., DogFather auf workspace. Mein
erster Entwurf schickte beide über dieselbe Adresse; die rechte Hand
bekam daraufhin 401, und WEIL sie nichts setzen konnte, ging ein
zweiter Test ("aus der Beobachtung eines anderen wird kein Schritt")
aus dem falschen Grund durch. Ein grüner Haken über einer Leere. */
const wo = (keks) => (keks === kDogi ? HAUS : CREW);
const setzen = (keks, punkt, stufe, anlass) =>
ruf(`/workspace/api/entwicklung/person/${idFrida}/${punkt}`, wo(keks),
"PUT", { cookie: keks }, { stufe, anlass });
const schritt = (keks, punkt, person = idFrida) =>
ruf(`/workspace/api/entwicklung/person/${person}/${punkt}/schritt`, wo(keks),
"POST", { cookie: keks }, {});
const karte = async (keks = kDogi) => json(await ruf(
`/workspace/api/entwicklung/person/${idFrida}`, wo(keks), "GET", { cookie: keks }));
const punktVon = (k, s) => k.bloecke?.flatMap((b) => b.punkte).find((p) => p.schluessel === s);
/* =======================================================================
1. EIN SCHRITT ENTSTEHT NUR AUS EINEM „DA HAKT ES"
======================================================================= */
melde("");
melde("=== 1. Nur aus „Da hakt es“ ===");
{
const l = await setzen(kDogi, P1, "laeuft");
ok(l.code === 200, `„Läuft“ ist gesetzt (${l.code})`);
const ohne = await schritt(kDogi, P1);
ok(ohne.code === 400 && json(ohne).fehler === "kein_hakt",
`daraus wird kein Schritt (${ohne.code}, ${json(ohne).fehler})`);
/* Gar nichts gesetzt: auch nicht. */
const nichts = await schritt(kDogi, P2);
ok(nichts.code === 400 && json(nichts).fehler === "kein_hakt",
"und aus gar nichts erst recht nicht");
const h = await setzen(kDogi, P1, "hakt", "Am Dienstag zweimal hintereinander gesehen.");
ok(h.code === 200, `mit „Da hakt es“ und Anlass geht es (${h.code})`);
const ja = await schritt(kDogi, P1);
ok(ja.code === 201, `und daraus wird ein Schritt (${ja.code})`);
ok(json(ja).titel === kat.ENTWICKLUNG_FREMD[0].titel,
`er heißt wie der Punkt: „${json(ja).titel}“`);
ok(/^\d{4}-\d{2}-\d{2}$/.test(json(ja).frist || ""),
`mit einer Frist in ${ent.SCHRITT_TAGE} Tagen (${json(ja).frist})`);
}
/* =======================================================================
2. ES IST EINE ECHTE AUFGABE — keine Notiz
======================================================================= */
melde("");
melde("=== 2. Eine echte Aufgabe ===");
{
const d = oeffne();
const a = d.prepare("SELECT * FROM aufgaben WHERE aus_punkt = ?").get(P1);
d.close();
ok(!!a, "sie steht in der Aufgabentabelle, nicht in einer eigenen Liste");
ok(a.verantwortlich_id === idFrida, "Frida ist verantwortlich, nicht DogFather");
ok(a.erstellt_von === idDogi, "und DogFather hat sie angelegt");
ok(a.status === "offen", `sie ist offen (${a.status})`);
/* DER ANLASS WANDERT MIT -- ohne ihn stuende auf dem Brett ein Satz
ohne Grund, und die Aufgabe waere ein Vorwurf. */
ok(/Am Dienstag zweimal/.test(a.beschreibung || ""),
"der Anlass steht in der Beschreibung");
/* UND SIE STEHT WIRKLICH AUF DEM BRETT, nicht nur in der Tabelle. */
const brett = json(await ruf("/workspace/api/aufgaben", HAUS, "GET", { cookie: kDogi }));
const drauf = (brett.aufgaben || []).find((x) => x.id === a.id);
ok(!!drauf, "und sie taucht auf dem Aufgabenbrett auf");
/* AUCH FRIDA SIEHT SIE -- eine Aufgabe, die nur die Leitung sieht,
waere wieder eine Notiz. */
const ihres = json(await ruf("/workspace/api/aufgaben", CREW, "GET", { cookie: kFrida }));
ok((ihres.aufgaben || []).some((x) => x.id === a.id),
"Frida sieht sie ebenfalls — sonst wäre sie keine Aufgabe");
}
/* =======================================================================
3. DIE KARTE ZEIGT IHN
======================================================================= */
melde("");
melde("=== 3. Die Karte zeigt ihn ===");
{
const k = await karte();
const p = punktVon(k, P1);
ok(!!p?.schritt, "an dem Punkt hängt der Schritt");
ok(p.schritt.status === "offen", `er läuft (${p.schritt.status})`);
ok(punktVon(k, P2)?.schritt === null, "an einem Punkt ohne Schritt hängt nichts");
/* ZWEIMAL ZUM SELBEN PUNKT WAERE ZWEIMAL DIESELBE ERINNERUNG -- und
die zweite macht die erste wertlos. */
const nochmal = await schritt(kDogi, P1);
ok(nochmal.code === 400 && json(nochmal).fehler === "schon_da",
`ein zweiter Schritt zum selben Punkt: abgelehnt (${json(nochmal).fehler})`);
ok(json(nochmal).aufgabe_id === p.schritt.id,
"und die Absage nennt den, der schon läuft");
}
/* =======================================================================
4. WER DARF — UND WER NICHT
======================================================================= */
melde("");
melde("=== 4. Wer darf ===");
{
/* DIE RECHTE HAND FÜHRT DAS TEAM MIT -- sie darf. */
await setzen(kHand, P2, "hakt", "Ist mir im Stream am Freitag aufgefallen.");
const hand = await schritt(kHand, P2);
ok(hand.code === 201, `die rechte Hand darf auch (${hand.code})`);
/* EIN MODI NICHT -- nicht für sich und nicht für andere. */
const modi = await ruf(`/workspace/api/entwicklung/person/${idFrida}/${P1}/schritt`,
CREW, "POST", { cookie: kFrida }, {});
ok(json(modi).fehler === "nicht_gefunden", "mit der Auskunft „gibt es nicht“");
ok(modi.code === 404, `ein Modi bekommt 404 — nicht „verboten“ (${modi.code})`);
/* AUS DER BEOBACHTUNG EINES ANDEREN wird kein Schritt: DogFather hat
bei P2 nichts gesetzt, die rechte Hand schon. */
const fremd = await schritt(kDogi, P2);
ok(fremd.code === 400 && json(fremd).fehler === "kein_hakt",
"und aus der Beobachtung eines anderen auch nicht");
/* EIN PUNKT AUS BLOCK 5 SIEHT VON AUSSEN AUS WIE EIN ERFUNDENER. */
const geheim = await schritt(kDogi, SELBST);
ok(geheim.code === 404, `ein Punkt aus „Wie geht's dir?“ gibt 404 (${geheim.code})`);
const quatsch = await schritt(kDogi, "e-gibt-es-nicht");
ok(quatsch.code === 404, "ein erfundener Punkt ebenfalls");
}
/* =======================================================================
5. IM PROTOKOLL STEHT, DASS — NICHT WORAN
======================================================================= */
melde("");
melde("=== 5. Das Protokoll ===");
{
const d = oeffne();
const zeilen = d.prepare(
"SELECT detail FROM protokoll WHERE aktion = 'entwicklung_schritt'").all();
d.close();
ok(zeilen.length === 2, `${zeilen.length} Schritte stehen im Protokoll`);
ok(zeilen.every((z) => /Frida/.test(z.detail || "")),
"mit Punkt und Name — das ist der Vorgang");
/* WORAN JEMAND ETWAS GEMERKT HAT, GEHÖRT NICHT INS PROTOKOLL. Es
liest sich anders, wenn es zwischen Anmeldungen steht. */
ok(!zeilen.some((z) => /Dienstag|Freitag/.test(z.detail || "")),
"aber ohne den Anlass");
}
/* =======================================================================
6. UND DANN SCHLIESST SICH DER KREIS
======================================================================= */
melde("");
melde("=== 6. Der Kreis ===");
{
const d = oeffne();
const a = d.prepare("SELECT id FROM aufgaben WHERE aus_punkt = ?").get(P1);
d.close();
const fertig = await ruf(`/workspace/api/aufgaben/${a.id}`, HAUS, "PATCH",
{ cookie: kDogi }, { status: "erledigt" });
ok(fertig.code === 200, `die Aufgabe wird erledigt (${fertig.code})`);
const k = await karte();
const p = punktVon(k, P1);
ok(p.schritt?.status === "erledigt", `die Karte sieht das (${p.schritt?.status})`);
ok(!!p.schritt?.erledigt_am, "mit Datum");
/* UND DANACH GEHT ES WIEDER -- der Kreis ist ein Kreis, keine
Einbahnstrasse. Waere das gesperrt, koennte man denselben Punkt
nie wieder angehen. */
const zweite = await schritt(kDogi, P1);
ok(zweite.code === 201, `zum selben Punkt geht danach ein neuer Schritt (${zweite.code})`);
const k2 = await karte();
ok(punktVon(k2, P1).schritt?.id === json(zweite).id,
"und die Karte zeigt den NEUEN, nicht den alten");
}
/* =======================================================================
7. DER VERWEIS AUFS BRETT FÜHRT WIRKLICH HIN
======================================================================= */
melde("");
melde("=== 7. Der Verweis ===");
{
/* `aufgaben.html#a12` stand an drei Stellen im Haus und wurde von
keiner gelesen -- das Brett kannte nur `?zeigen=`. Wer draufdrueckte,
landete auf dem Brett und suchte von Hand. */
const brett = readFileSync(new URL("../workspace/assets/js/aufgaben.js", import.meta.url), "utf8");
ok(/data-id=/.test(brett), "die Karten auf dem Brett tragen ihre Nummer");
ok(/\^#a/.test(brett), "und das Brett liest `#a<nummer>` aus der Adresse");
const e = readFileSync(new URL("../workspace/assets/js/entwicklung.js", import.meta.url), "utf8");
ok(/aufgaben\.html#a/.test(e), "die Entwicklungskarte verweist in dieser Schreibweise");
const b = readFileSync(new URL("../workspace/assets/js/bereich.js", import.meta.url), "utf8");
const r = readFileSync(new URL("../workspace/assets/js/report.js", import.meta.url), "utf8");
ok(/aufgaben\.html#a/.test(b) && /aufgaben\.html#a/.test(r),
"die beiden anderen Stellen auch — sie funktionieren jetzt mit");
}
/* =======================================================================
8. IM BROWSER
======================================================================= */
melde("");
melde("=== 8. Im Browser ===");
{
const { chromium } = await import(
"file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await chromium.launch();
const kontext = await browser.newContext({ viewport: { width: 1280, height: 1100 } });
await kontext.addCookies(kDogi.split("; ").filter(Boolean).map((teil) => {
const i = teil.indexOf("=");
return { name: teil.slice(0, i), value: teil.slice(i + 1), domain: "127.0.0.1", path: "/" };
}));
const seite = await kontext.newPage();
const konsole = [];
seite.on("console", (m) => { if (m.type() === "error" && !/favicon|ERR_/i.test(m.text())) konsole.push(m.text()); });
seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));
await seite.goto(`http://127.0.0.1:${PORT}/workspace/entwicklung.html`, { waitUntil: "networkidle" });
await seite.waitForTimeout(800);
/* Erst die Person öffnen -- ohne Karte gibt es keine Punkte. */
/* FRIDAS KARTE, nicht die erste in der Liste. Die steht dort nach
der Hierarchie des Hauses -- also die rechte Hand -- und die hat
keinen Schritt. Mein erster Entwurf klickte blind auf die erste
und maß danach eine leere Karte. */
await seite.click('.e-person:has-text("Frida")');
await seite.waitForTimeout(900);
const stand = await seite.evaluate(() => ({
punkte: document.querySelectorAll(".e-punkt").length,
laeuft: document.querySelectorAll('.e-schritt[data-lage="laeuft"]').length,
knoepfe: document.querySelectorAll(".e-schritt__knopf").length,
leere: document.querySelectorAll(".e-schritt:not([data-lage])").length,
verweis: document.querySelector(".e-schritt__hin")?.getAttribute("href") || "",
}));
ok(stand.punkte > 20, `${stand.punkte} Punkte stehen auf der Karte`);
ok(stand.laeuft >= 1, `${stand.laeuft} Schritt läuft sichtbar`);
ok(/aufgaben\.html#a\d+/.test(stand.verweis),
`und verweist auf die Aufgabe (${stand.verweis})`);
/* KEIN KNOPF, WO ER NICHTS TUN KANN. Bei über zwanzig Punkten wären
zwanzig Knöpfe, die fast alle „geht nicht" antworten, schlimmer
als keiner. */
ok(stand.knoepfe === 0,
"an den übrigen Punkten steht kein Knopf — dort hakt nichts");
ok(stand.leere > 20, `und dort steht auch kein leerer Kasten (${stand.leere})`);
/* DER SPRUNG: die Adresse mit der Nummer, und das Brett zeigt genau
die eine Aufgabe. */
const d = oeffne();
const a = d.prepare("SELECT id FROM aufgaben WHERE aus_punkt IS NOT NULL ORDER BY id DESC").get();
d.close();
await seite.goto(`http://127.0.0.1:${PORT}/workspace/aufgaben.html#a${a.id}`,
{ waitUntil: "networkidle" });
await seite.waitForTimeout(1100);
const sprung = await seite.evaluate(() => ({
leiste: document.querySelector(".ziel-leiste__text")?.textContent || "",
marke: document.querySelector(".ziel-leiste__marke")?.textContent || "",
}));
ok(/Diese eine Aufgabe/.test(sprung.leiste),
`das Brett sagt, was es zeigt: „${sprung.leiste}“`);
ok(sprung.marke === "1", `und es ist genau eine (${sprung.marke})`);
ok(konsole.length === 0,
konsole.length ? "Fehler im Browser: " + konsole[0].slice(0, 90) : "keine Fehler im Browser");
await browser.close();
}
/* ------------------------------------------------------------------- */
melde("");
melde(`${geprueft} Pruefungen, ${fehler} Fehler`);
melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Aufraeumrest */ }
process.exit(fehler ? 1 : 0);
server/workspace-entwicklung.js
+123
View File
@@ -326,6 +326,7 @@ entwicklungRouter.get("/workspace/api/entwicklung/person/:id", nurLeitung, (req,
WHERE s.person_id = ? AND s.von_id <> ?`).all(id, req.person.id);
const grenze = Date.now() - VERBLASST_NACH_TAGEN * TAG;
const schritte = schritteVon(p.id);
const bloecke = katalogFuer(req.person, false).map((b) => ({
...b,
punkte: b.punkte.map((pt) => {
@@ -344,6 +345,10 @@ entwicklungRouter.get("/workspace/api/entwicklung/person/:id", nurLeitung, (req,
nicht" dasselbe Bild, und das erste ist eine Auskunft,
das zweite eine Taeuschung. */
andere_offen: m ? 0 : fremde.filter((f) => f.schluessel === pt.schluessel).length,
/* DER SCHRITT ZU DIESEM PUNKT. Er steht an der Karte und
nicht auf einer eigenen Liste: Wer die Beobachtung sieht,
soll im selben Blick sehen, ob daraus etwas geworden ist. */
schritt: schritte.get(pt.schluessel) || null,
};
}),
}));
@@ -381,6 +386,124 @@ entwicklungRouter.get("/workspace/api/entwicklung/person/:id", nurLeitung, (req,
}
});
/* =====================================================================
AUS EINER BEOBACHTUNG WIRD EIN SCHRITT (15.09.2026)
Filipe: „ich will die noch viel besser, perfektionniert […] so
einfach wie möglich für jeden."
---------------------------------------------------------------------
WAS GEFEHLT HAT
Die Karte konnte bisher genau eines: festhalten, dass etwas hakt --
mit Anlass, das war schon richtig. Danach passierte nichts. Beim
nächsten Öffnen stand dieselbe Beobachtung da, nur älter.
Die Quellen zur laufenden Entwicklungsbegleitung sagen übereinstimmend
zweierlei: weg von der Bewertung, hin zum Gespräch -- und ein
Entwicklungsplan wirkt dann, wenn er an einer ECHTEN Aufgabe hängt.
Nicht „daran arbeiten wir", sondern etwas, das auf dem Aufgabenbrett
steht, einen Verantwortlichen hat und irgendwann erledigt ist.
Genau dieses Muster gibt es im Haus schon: Aus einer Idee auf einem
Brett wird eine Aufgabe. Hier ist es dasselbe, nur mit einem anderen
Ausgangspunkt -- und deshalb sieht es auch gleich aus.
---------------------------------------------------------------------
UND DANN SCHLIESST SICH DER KREIS
Ist der Schritt erledigt, sagt die Karte das und fragt dieselbe Frage
noch einmal. Das ist der Rhythmus, den die Quellen meinen: nicht
einmal im Jahr eine Bewertung, sondern eine Runde, die zu Ende geht.
Quellen:
https://www.quantumworkplace.com/future-of-work/continuous-performance-management
https://www.aihr.com/blog/continuous-performance-management/
https://www.deel.com/blog/implement-continuous-performance-management-system/
===================================================================== */
/** Wie lange ein Schritt Zeit bekommt. Vorschlag, kein Gesetz --
* auf dem Aufgabenbrett lässt sich die Frist ändern wie bei jeder
* anderen Aufgabe auch. Zwei Wochen sind nah genug, dass man sich
* erinnert, und weit genug, dass sich etwas ändern kann. */
export const SCHRITT_TAGE = 14;
/** Die Schritte zu den Punkten einer Person — einer je Punkt.
*
* ES IST IMMER DER JÜNGSTE. Wer denselben Punkt ein zweites Mal
* angeht, soll den neuen Schritt sehen und nicht den von vor einem
* halben Jahr. */
function schritteVon(personId) {
const zeilen = db().prepare(
`SELECT id, titel, status, frist, erledigt_am, aus_punkt, erstellt
FROM aufgaben
WHERE verantwortlich_id = ? AND aus_punkt IS NOT NULL
ORDER BY id DESC`).all(personId);
const nach = new Map();
for (const z of zeilen) if (!nach.has(z.aus_punkt)) nach.set(z.aus_punkt, z);
return nach;
}
entwicklungRouter.post("/workspace/api/entwicklung/person/:id/:schluessel/schritt",
gleicheHerkunft, nurLeitung, express.json({ limit: "8kb" }), (req, res) => {
try {
const id = nummer(req.params.id);
const schluessel = String(req.params.schluessel || "");
const p = id && db().prepare("SELECT id, name, rolle FROM personen WHERE id = ?").get(id);
if (!p || !KARTEN_ROLLEN.includes(p.rolle)) {
return res.status(404).json({ fehler: "nicht_gefunden" });
}
const punkt = ENTWICKLUNG_FREMD.find((x) => x.schluessel === schluessel);
if (!punkt) return res.status(404).json({ fehler: "nicht_gefunden" });
/* NUR AUS EINEM „DA HAKT ES" WIRD EIN SCHRITT -- und nur aus dem
EIGENEN. Aus „läuft" einen Schritt zu machen hieße, jemandem
Arbeit zu geben für etwas, das gut läuft; aus der Beobachtung
eines anderen hieße, in seinem Namen zu handeln. */
const stand = db().prepare(
`SELECT stufe, anlass FROM entwicklung_stand
WHERE person_id = ? AND schluessel = ? AND von_id = ?`)
.get(id, schluessel, req.person.id);
if (!stand || stand.stufe !== "hakt") {
return res.status(400).json({ fehler: "kein_hakt" });
}
/* EIN OFFENER SCHRITT REICHT. Zwei Aufgaben zum selben Punkt
wären zwei Erinnerungen an dieselbe Sache -- und die zweite
macht die erste wertlos. */
const offen = db().prepare(
`SELECT id FROM aufgaben
WHERE verantwortlich_id = ? AND aus_punkt = ?
AND status NOT IN ('erledigt','abgebrochen')`).get(id, schluessel);
if (offen) return res.status(400).json({ fehler: "schon_da", aufgabe_id: offen.id });
const frist = new Date(Date.now() + SCHRITT_TAGE * 86400000).toISOString().slice(0, 10);
const jetztIso = jetzt();
db().prepare(`INSERT INTO aufgaben
(titel, beschreibung, status, prioritaet, verantwortlich_id,
frist, erstellt, erstellt_von, aus_punkt)
VALUES (?,?,'offen','mittel',?,?,?,?,?)`)
.run(
punkt.titel,
/* DER ANLASS WANDERT MIT. Ohne ihn stünde auf dem Brett ein
Satz ohne Anlass, und die Aufgabe wäre ein Vorwurf. */
`${punkt.text}\n\nWoran es aufgefallen ist: ${stand.anlass || "–"}`,
id, frist, jetztIso, req.person.id, schluessel);
const neu = db().prepare("SELECT last_insert_rowid() AS id").get().id;
protokolliere("entwicklung_schritt", {
personId: req.person.id, ip: echteIp(req),
/* KEIN ANLASS IM PROTOKOLL. Dass ein Schritt entstanden ist,
gehört hinein; woran jemand etwas gemerkt hat, nicht. */
detail: `${punkt.titel} für ${p.name}`.slice(0, 120),
});
res.status(201).json({ id: neu, titel: punkt.titel, frist });
} catch (f) {
console.error("[entwicklung] Schritt:", f?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
const STUFEN_SATZ = new Set(ENTWICKLUNG_STUFEN.map((s) => s.schluessel));
entwicklungRouter.put("/workspace/api/entwicklung/person/:id/:schluessel",
server/workspace.js
+16
View File
@@ -2125,6 +2125,22 @@ function umstellungen(d) {
im Projekt schon dreimal Spalten verlorengegangen sind. Geprueft
wird beim Schreiben, an der Stelle, die die Liste kennt. */
["aufgaben", "aufwand", "TEXT"],
/* AUS WELCHER BEOBACHTUNG DIESE AUFGABE ENTSTANDEN IST (15.09.2026).
Der Schluessel aus dem Entwicklungskatalog, nichts weiter. Zusammen
mit `verantwortlich_id` ergibt er das Paar, um das es geht: DIESER
Punkt bei DIESEM Menschen.
WARUM ÜBERHAUPT: Eine Beobachtung, die nur auf einer Karte steht,
ist eine Notiz. Die Quellen zur laufenden Entwicklungsbegleitung
sagen dasselbe in einem Satz -- ein Entwicklungsplan wirkt dann,
wenn er an einer echten Aufgabe haengt, und sonst nicht.
KEIN FREMDSCHLUESSEL: Die Punkte stehen in einer Datei, nicht in
einer Tabelle. Ein REFERENCES darauf gaebe es nicht; geprueft wird
beim Schreiben, an der Stelle, die den Katalog kennt. */
["aufgaben", "aus_punkt", "TEXT"],
]) {
try {
const vorhanden = d.prepare(`PRAGMA table_info(${tabelle})`).all().map((s) => s.name);