@hybridlabor-api/aos 4.0.2 → 4.2.0-beta.0

package/skills/global_config/plan-canvas/scripts/plan-canvas.js

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Plan Canvas CLI — open plan artifacts in a browser review canvas and block
+ * on human feedback.
+ *
+ *   node scripts/plan-canvas.js open .claude/plans/feature.plan.md
+ *   node scripts/plan-canvas.js await .claude/plans/feature.plan.md
+ *   node scripts/plan-canvas.js await <file> --reply "Updated section 3."
+ *   node scripts/plan-canvas.js end <file>
+ *   node scripts/plan-canvas.js stop
+ *
+ * Agents: `open` returns immediately (the server is a detached process);
+ * `await` long-polls until the human sends feedback, a verdict, or ends the
+ * session, then prints a JSON payload to stdout. Progress notes go to stderr
+ * so stdout stays parseable.
+ *
+ * Source: affaan-m/ECC — MIT, see THIRD_PARTY_NOTICES.md
+ */
+
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const {
+  canonicalizeArtifactPath,
+  createSessionStore,
+  resolveStateDir,
+  sessionKeyFor
+} = require('./lib/plan-canvas/sessions');
+const {
+  DEFAULT_HOST,
+  createPlanCanvasServer,
+  resolveIdleTimeoutMs,
+  resolvePort
+} = require('./lib/plan-canvas/server');
+
+const VERSION = '1.0.0';   // vendored Plan Canvas protocol version; matches SKILL.md metadata.version.
+                           // Bump when the vendored JS changes, to force a stale detached server to restart.
+
+const SAFE_REQUEST_PATHS = new Set([
+  '/',
+  '/health',
+  '/shutdown',
+  '/api/await',
+  '/api/sessions',
+  '/api/end'
+]);
+const SESSION_REPLY_PATH = /^\/api\/session\/[a-f0-9]{12}\/(reply|typing)$/;
+
+function usage() {
+  return [
+    'Plan Canvas - review plans and HTML artifacts in the browser',
+    '',
+    'Usage:',
+    '  aos-plan-canvas                  Show server status and sessions',
+    '  aos-plan-canvas open <file>      Open (or resume) a review session',
+    '  aos-plan-canvas await <file>     Block until the human sends feedback',
+    '  aos-plan-canvas pending          Show feedback queued for no listener',
+    '  aos-plan-canvas typing <file>    Show a thinking/typing indicator in chat',
+    '  aos-plan-canvas end <file>       End a session as the agent',
+    '  aos-plan-canvas stop             Shut down the canvas server',
+    '  aos-plan-canvas server           Run the server in the foreground',
+    '',
+    'Options:',
+    '  open:  --no-open      Do not launch a browser window',
+    '         --reopen       Reopen a session the user ended from the browser',
+    '  await: --reply <msg>  Show an agent reply in the canvas chat before waiting',
+    '         --timeout-ms <n>  Return {status:"waiting"} after n ms (tests/debug only)',
+    '  typing: --state <thinking|typing|idle>  Defaults to typing',
+    '  server: --port <n> --host <h>',
+    '',
+    'Environment: AOS_PLAN_CANVAS_PORT, AOS_PLAN_CANVAS_STATE_DIR, AOS_PLAN_CANVAS_IDLE_MS'
+  ].join('\n');
+}
+
+function valueAfter(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 && index + 1 < args.length ? args[index + 1] : null;
+}
+
+function serverInfoPath(stateDir) {
+  return path.join(stateDir, 'server.json');
+}
+
+function readServerInfo(stateDir) {
+  try {
+    return JSON.parse(fs.readFileSync(serverInfoPath(stateDir), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function validatePort(port) {
+  const value = Number(port);
+  if (!Number.isInteger(value) || value < 0 || value > 65535) {
+    throw new Error(`invalid plan-canvas server port: ${port}`);
+  }
+  return value;
+}
+
+function validateRequestPath(requestPath) {
+  if (typeof requestPath !== 'string' || !requestPath.startsWith('/')) {
+    throw new Error('plan-canvas request path must be root-relative');
+  }
+  const url = new URL(requestPath, `http://${DEFAULT_HOST}`);
+  if (url.hostname !== DEFAULT_HOST) {
+    throw new Error('plan-canvas request path must stay on the loopback server');
+  }
+  if (!SAFE_REQUEST_PATHS.has(url.pathname) && !SESSION_REPLY_PATH.test(url.pathname)) {
+    throw new Error(`unsupported plan-canvas request path: ${url.pathname}`);
+  }
+  return `${url.pathname}${url.search}`;
+}
+
+function requestOptions(port, method, requestPath, headers) {
+  return {
+    host: DEFAULT_HOST,
+    port: validatePort(port),
+    method,
+    path: validateRequestPath(requestPath),
+    agent: false,
+    headers
+  };
+}
+
+function request(port, method, requestPath, body = null) {
+  return new Promise((resolve, reject) => {
+    const payload = body === null ? null : JSON.stringify(body);
+    const req = http.request(
+      requestOptions(
+        port,
+        method,
+        requestPath,
+        payload
+          ? { 'content-type': 'application/json', 'content-length': Buffer.byteLength(payload) }
+          : {}
+      ),
+      res => {
+        let data = '';
+        res.on('data', chunk => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          try {
+            resolve({ statusCode: res.statusCode, body: JSON.parse(data.trim() || '{}') });
+          } catch {
+            resolve({ statusCode: res.statusCode, body: {} });
+          }
+        });
+      }
+    );
+    req.on('error', reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+async function healthCheck(port) {
+  try {
+    const res = await request(port, 'GET', '/health');
+    return res.body && res.body.app === 'aos-plan-canvas' ? res.body : null;
+  } catch {
+    return null;
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Start (or reuse) the detached canvas server and return its port. A version
+// mismatch after this script is updated restarts the server so browser and CLI never
+// disagree about the protocol.
+async function ensureServer({ stateDir, port }) {
+  const health = await healthCheck(port);
+  if (health && health.version === VERSION) return port;
+  if (health) {
+    await request(port, 'POST', '/shutdown').catch(() => {});
+    for (let i = 0; i < 20 && (await healthCheck(port)); i++) await sleep(100);
+  }
+  fs.mkdirSync(stateDir, { recursive: true });
+  const logFd = fs.openSync(path.join(stateDir, 'server.log'), 'a');
+  const child = spawn(process.execPath, [__filename, 'server', '--port', String(port)], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env: { ...process.env, AOS_PLAN_CANVAS_STATE_DIR: stateDir }
+  });
+  child.unref();
+  fs.closeSync(logFd);
+  for (let i = 0; i < 50; i++) {
+    await sleep(100);
+    if (await healthCheck(port)) return port;
+  }
+  throw new Error(`plan-canvas server did not become healthy on port ${port}; check ${path.join(stateDir, 'server.log')}`);
+}
+
+function openBrowser(url) {
+  const platform = process.platform;
+  const [cmd, args] =
+    platform === 'darwin' ? ['open', [url]]
+      : platform === 'win32' ? ['cmd', ['/c', 'start', '', url]]
+        : ['xdg-open', [url]];
+  try {
+    spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function output(payload) {
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+async function cmdStatus({ stateDir, port }) {
+  const health = await healthCheck(port);
+  if (!health) {
+    return { server: 'not running', hint: 'open an artifact to start one', stateDir };
+  }
+  const sessions = await request(port, 'GET', '/api/sessions');
+  return { server: `http://${DEFAULT_HOST}:${port}`, version: health.version, sessions: sessions.body.sessions };
+}
+
+async function cmdOpen(file, args, { stateDir, port }) {
+  if (!file) throw new Error('open requires a file path');
+  if (!fs.existsSync(path.resolve(file))) throw new Error(`artifact not found: ${file}`);
+  await ensureServer({ stateDir, port });
+  const res = await request(port, 'POST', '/api/sessions', {
+    file: path.resolve(file),
+    reopen: args.includes('--reopen')
+  });
+  if (res.statusCode === 409) return res.body;
+  if (res.statusCode !== 200) throw new Error(res.body.error || `open failed (HTTP ${res.statusCode})`);
+  const url = `http://${DEFAULT_HOST}:${port}${res.body.url}`;
+  const launched = args.includes('--no-open') ? false : openBrowser(url);
+  return {
+    status: 'open',
+    url,
+    browser: launched ? 'opened' : 'not opened',
+    next_step:
+      'Run `aos-plan-canvas await <file>` and leave it running; it returns when the human sends feedback, a verdict, or ends the session.'
+  };
+}
+
+function awaitRequest(port, key, timeoutMs) {
+  if (!/^[a-f0-9]{12}$/.test(key)) throw new Error('invalid plan-canvas session key');
+  const params = new URLSearchParams({ key });
+  if (timeoutMs !== null) params.set('timeoutMs', String(timeoutMs));
+  return new Promise((resolve, reject) => {
+    const req = http.request(
+      requestOptions(port, 'GET', `/api/await?${params}`, {}),
+      res => {
+        let data = '';
+        res.on('data', chunk => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data.trim()));
+          } catch {
+            reject(new Error('await response was not JSON (server restarted?) - re-run await; feedback is never lost'));
+          }
+        });
+      }
+    );
+    req.setTimeout(0);
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+async function cmdAwait(file, args, { stateDir, port }) {
+  if (!file) throw new Error('await requires a file path');
+  if (!(await healthCheck(port))) {
+    return { status: 'no-server', hint: 'no canvas server is running; use `open` first', stateDir };
+  }
+  const reply = valueAfter(args, '--reply');
+  if (reply) {
+    const key = sessionKeyFor(canonicalizeArtifactPath(file));
+    await request(port, 'POST', `/api/session/${key}/reply`, { text: reply });
+  }
+  const timeoutRaw = valueAfter(args, '--timeout-ms');
+  const timeoutMs = timeoutRaw === null ? null : Number.parseInt(timeoutRaw, 10) || 0;
+  process.stderr.write('[plan-canvas] waiting for human feedback... leave this running (re-run if interrupted; queued feedback is never lost)\n');
+  const result = await awaitRequest(port, sessionKeyFor(canonicalizeArtifactPath(file)), timeoutMs);
+  if (result.status === 'feedback') {
+    result.next_step = result.sessionEnded
+      ? 'The user sent this feedback and ended the session. Address it and report in chat; do not reopen the canvas uninvited.'
+      : 'Address the feedback, then run `aos-plan-canvas await <file> --reply "<what you changed>"` to answer in the canvas and keep listening.';
+  } else if (result.status === 'ended') {
+    result.next_step =
+      result.endedBy === 'user'
+        ? 'The user ended this review. Stop polling and deliver any remaining updates in chat; do not reopen uninvited.'
+        : 'Session ended. Stop polling.';
+  }
+  return result;
+}
+
+// Show the human an activity indicator in the canvas chat. Cheap and
+// fire-and-forget: a failed signal must never derail the actual work.
+async function cmdTyping(file, args, { port }) {
+  if (!file) throw new Error('typing requires a file path');
+  const state = valueAfter(args, '--state') || 'typing';
+  if (!(await healthCheck(port))) return { status: 'no-server' };
+  const key = sessionKeyFor(canonicalizeArtifactPath(file));
+  const res = await request(port, 'POST', `/api/session/${key}/typing`, { state });
+  if (res.statusCode !== 200) throw new Error(res.body.error || `typing failed (HTTP ${res.statusCode})`);
+  return { status: 'ok', state, presence: res.body.presence };
+}
+
+// Report feedback the human sent that no agent has picked up yet. Reads state
+// directly so it answers even when the server has idled out.
+function cmdPending({ stateDir }) {
+  const store = createSessionStore({ stateDir });
+  const waiting = store
+    .list()
+    .filter(session => session.status !== 'ended' && session.pending > 0)
+    .map(session => ({ file: session.file, pending: session.pending, updatedAt: session.updatedAt }));
+  return {
+    status: waiting.length ? 'pending' : 'clear',
+    sessions: waiting,
+    next_step: waiting.length
+      ? 'Run `aos-plan-canvas await <file>` for each file above to receive the messages.'
+      : 'No canvas feedback is waiting.'
+  };
+}
+
+async function cmdEnd(file, { port }) {
+  if (!file) throw new Error('end requires a file path');
+  if (!(await healthCheck(port))) return { status: 'no-server' };
+  const res = await request(port, 'POST', '/api/end', { file: path.resolve(file) });
+  return res.body;
+}
+
+async function cmdStop({ stateDir, port }) {
+  if (!(await healthCheck(port))) return { status: 'not running' };
+  await request(port, 'POST', '/shutdown').catch(() => {});
+  fs.rmSync(serverInfoPath(stateDir), { force: true });
+  return { status: 'stopping' };
+}
+
+async function cmdServer(args, { stateDir, port }) {
+  const portArg = valueAfter(args, '--port');
+  const hostArg = valueAfter(args, '--host');
+  const listenPort = portArg !== null ? Number.parseInt(portArg, 10) : port;
+  const store = createSessionStore({ stateDir });
+  let shuttingDown = false;
+  const shutdown = async code => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    fs.rmSync(serverInfoPath(stateDir), { force: true });
+    await canvas.close().catch(() => {});
+    process.exit(code);
+  };
+  const canvas = createPlanCanvasServer({
+    store,
+    host: hostArg || DEFAULT_HOST,
+    version: VERSION,
+    idleTimeoutMs: resolveIdleTimeoutMs(),
+    onIdleShutdown: () => shutdown(0),
+    log: line => process.stderr.write(`${line}\n`)
+  });
+  const bound = await canvas.listen(listenPort);
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(
+    serverInfoPath(stateDir),
+    JSON.stringify({ pid: process.pid, port: bound.port, version: VERSION, startedAt: new Date().toISOString() }, null, 2)
+  );
+  // Sessions restored from disk resume their file watchers.
+  for (const session of store.list()) {
+    if (session.status !== 'ended') canvas.watchSession(store.get(session.key));
+  }
+  process.on('SIGINT', () => shutdown(0));
+  process.on('SIGTERM', () => shutdown(0));
+  process.stderr.write(`[plan-canvas] serving on http://${bound.host}:${bound.port}\n`);
+  return new Promise(() => {}); // run until a signal or idle shutdown
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const args = argv.slice();
+  if (args.includes('--help') || args.includes('-h')) {
+    process.stdout.write(`${usage()}\n`);
+    return 0;
+  }
+  const command = args[0] && !args[0].startsWith('--') ? args.shift() : null;
+  const stateDir = resolveStateDir();
+  // A running server may sit on a non-default port; trust its recorded info.
+  const recorded = readServerInfo(stateDir);
+  const context = { stateDir, port: (recorded && recorded.port) || resolvePort() };
+  try {
+    if (command === null) output(await cmdStatus(context));
+    else if (command === 'open') output(await cmdOpen(args[0], args, context));
+    else if (command === 'await') output(await cmdAwait(args[0], args, context));
+    else if (command === 'pending') output(cmdPending(context));
+    else if (command === 'typing') output(await cmdTyping(args[0], args, context));
+    else if (command === 'end') output(await cmdEnd(args[0], context));
+    else if (command === 'stop') output(await cmdStop(context));
+    else if (command === 'server') await cmdServer(args, context);
+    else {
+      process.stderr.write(`Unknown command: ${command}\n\n${usage()}\n`);
+      return 1;
+    }
+    return 0;
+  } catch (error) {
+    output({ error: error.message });
+    return 1;
+  }
+}
+
+if (require.main === module) {
+  main().then(code => {
+    process.exitCode = code;
+  });
+}
+
+module.exports = { main, ensureServer, healthCheck };

package/docs/sessions/AUDIT-HANDOVER-2026-08-28.md

@@ -1,169 +0,0 @@
-# Audit-Handover — Beta Aftercare v3.13.0-nodex.4 (2026-08-28)
-
-Nachfolge-Dokument zu `SESSION-HANDOVER-v3.13.md`. Erstellt durch den
-Aftercare-Audit-Run (Verifikation + Cleanup-Audit, **keine Änderungen**):
-nichts gemergt, geschlossen, gelöscht, gepusht oder published. Alles unten
-ist geprüft und wartet auf Entscheidung/GO.
-
-Repo-Zustand bei Audit: `main` @ `ba49a22` (3.13.0-nodex.4), Working Tree
-clean. Diese Datei ist neu und **untracked** (Commit braucht GO).
-
----
-
-## 1. Verifiziert korrekt
-
-Alle SHAs aus dem Brief existieren exakt in `git log main`:
-
-| Fix | Urteil |
-|---|---|
-| `5c8b634` setup-saas.mjs: Cert-Cleanup + 0600 | korrekt; regex-Replace des Marker-Blocks entfernt sogar alt-gesteckte stale Lines (self-heiling). Restrisiken siehe F9/F10 |
-| `5b2444a` agent-pipeline SKILL.md Rewrite | korrekt (die Datei selbst); aber fiktive Pipeline lebt woanders weiter → F3 |
-| `bb4053d` isNewerVersion im Status-Check | korrekt für den gemeldeten Bug; **unvollständig bei Prereleases** → F1 (wichtigster Befund) |
-| `6425b97` --platforms Flag | korrekt; Kleinigkeiten: Leerzeichen-Form (`--platforms 2`) nicht unterstützt, Duplikate nicht deduped, `0,2` verschweigt das `2` |
-| `f283b7c` MCP-Merge Claude Code/Desktop | korrekt: Read-Modify-Write, fremde Top-Level-Keys (`projects` u. a.) und User-Server bleiben in BEIDEN Dateien erhalten; Namenskollision → BDB gewinnt. Aber: F2 (chmod-Lücke), F8 (env carry-over nur im Mirror) |
-| `e3bea52` excludeList-Rekursion | korrekt; Bug-Klasse existiert genau einmal im Codebase |
-| startcycle-Naming-Fix `2138bd9` | korrekt; ein stale Pointer bleibt → F4 |
-| `.agents/graph.md` Rewrite | korrekt: alle 7 Nodes existieren real (agents.md + .claude/agents + .opencode/agents), alle referenzierten Dateien existieren |
-| go-gate.mjs Transcript-Fix (`51ae49c`) | korrekt: `type`/`message.content`, String- wie Block-Content, Sidechain-Skip, fail-closed. Nuance: `isMeta`-User-Entries werden nicht excluded (konservativ, ok) |
-| Hook-Drift | `~/.claude/hooks/go-gate.mjs` UND `graph-gate.mjs` sind byte-identisch mit den Repo-Kopien (diff geprüft, 2026-08-28) |
-| npm dist-tags | `latest=3.12.0`, `beta=3.13.0-nodex.4` — wie beabsichtigt |
-
-## 2. Befunde (priorisiert)
-
-**P1 — solltest du fixen vor dem nächsten Release:**
-- **F1 `isNewerVersion` versteht keine Prereleases** (installer.js:238-248,
-  Call-Site :1487, `npm view` ohne Tag :1476). Numerischer Dot-Compare:
-  `3.13.0-nodex.4` gilt als NEUER als `3.13.0` (semver: älter). Sobald 3.13.0
-  auf `latest` landet, bekommen nodex.4-User „Up to date" angezeigt, obwohl
-  sie älter sind — dieselbe Fehlerklasse wie der gefixte Bug, nur invertiert.
-  Außerdem sieht die Call-Site nur den `latest`-Dist-Tag: Beta-Bumps unter
-  `beta` sind unsichtbar.
-- **F2 chmod-Lücke beim primären MCP-Merge** (installer.js:1884): der Write
-  für `claude_desktop_config.json` setzt keinen Mode — eine bestehende-0644
-  Datei behält 0644, während API-Keys injiziert werden. Der Mirror-Pfad nach
-  `~/.claude.json` macht 0600+chmod (:1617) — inkonsistent zur eigenen Regel
-  aus `5c8b634`. Zusätzlich: write→chmod-Fenster auch bei
-  `writeMcpConfigSecure` (:223-226) und `catch {}` verschluckt
-  chmod-Fehler still.
-
-**P2 — Konsistenz/Regressionsvektoren:**
-- **F3 Fiktive Pipeline lebt weiter:** `skills/basic/godmode-shipping/SKILL.md:14`
-  empfiehlt `/spec` als echten Befehl; `GEMINI.md:13` und
-  `.codex-plugin/system.md:13` listen `/build`, `/test`; „run `/ship`" steht
-  in 5 aktiven Dateien (`.agents/workflows/startcycle.md:81`,
-  `.codex-plugin/system.md:119`, `.claude/workflows/startcycle-dispatch.mjs:411`,
-  `.agents/state.schema.json:20`, `.agents/graph.md:92+115`), obwohl es
-  `/ship` nirgends als Command gibt (GO-Check passiert stattdessen im
-  go-gate.mjs am Push-Punkt — funktional ok, Benennung inkonsistent).
-- **F4 Stale Path:** `.agents/state.schema.json:76` verweist noch auf
-  `.claude/workflows/startcycle.mjs` (heißt jetzt `startcycle-dispatch.mjs`).
-- **F5 `github-repo` doppelt mit divergiertem Inhalt:**
-  `skills/github-repo/SKILL.md` (neu, BDB-Standard) vs.
-  `skills/global_config/github-repo/SKILL.md` (alt, generisch).
-  Install-Reihenfolge (alphabetisch) überschreibt bei **jedem** Install die
-  neuere Root-Version still mit der älteren.
-
-**P3 — klein:**
-- **F6** `skills/global_config/github-actions-templates/SKILL.md:83,340`
-  referenziert `assets/test-workflow.yml` — existiert nicht.
-- **F7** `/grill-me` wird benutzt von bdbrainstorm, startcycle,
-  bdbmediastorm — ist aber in keinem Repo shipped (undeclared dependency).
-- **F8** Mirror-Path (`~/.claude.json`) hat kein env carry-over bei
-  Namenskollision (primärer Pfad hat es) — User-Env wird ersetzt.
-- **F9** setup-saas: Cert-Existenz-Check ≠ Frische-Check
-  (bin/setup-saas.mjs:139-148): vorhandenes, aber abgelaufenes Cert bleibt
-  verdrahtet, wenn heutiges Bootstrap failt.
-- **F10** Lock-freies Read-Modify-Write auf `~/.claude.json` kann
-  konkurrierende Claude-Code-Updates verlieren (inherent, dokumentieren statt
-  fixen).
-
-## 3. Cleanup-Liste — wartet auf GO / Entscheidung
-
-| # | Aktion | Grund (1 Zeile) |
-|---|---|---|
-| C1 | PR #36 schließen (`gh pr close 36`) | Inhalt seit `54caa5c` in main; einziger Delta = überholter Version-Bump `8eead12` (3.9.5→3.12.0) |
-| C2 | Remote-Branch `feat/agent-skills-v3.13` löschen | vollständig in main gemergt (`merge-base --is-ancestor` bestanden, tip `adc7f47`) |
-| C3 | Lokale Branches `fix/build-profile-hardening` + `fix/v3.13-installer-blockers` löschen | beide 0 unique commits, vollständig gemergt |
-| C4 | `installer_old.js` entfernen (Commit) | 0 Referenzen im ganzen Repo (package.json, installer.js, scripts/, grep) |
-| C5 | `SESSION-HANDOVER-v3.13.md` archivieren/löschen (Commit) | von diesem Handover abgelöst; **`audit-agents.md` BEHALTEN** — wird von `.agents/graph.md:5` als Spec-Referenz zitiert, ist also produktiv |
-| C6 | Tag `v3.13.0-nodex.0`: pushen ODER lokal löschen | npm hat nodex.0, GitHub hat den Tag nicht — Inkonsistenz; entscheide eine Richtung |
-| C7 | 4 `snapshot-*`-Tags: behalten/pushen/löschen | lokale Historie-Anker; nur lokal vorhanden, keine Releases — bewusst entscheiden |
-| C8 | (Beobachtung) `BDB_REMOTEOS_MCP_HANDOVER.md`, `Project-overview.html` im Root | weitere Root-Kandidaten, nicht im Brief — nur angeschaut, nicht bewertet |
-
-**Explizit NICHT tun:** `mcp_config.json` anfassen (live MCP-Template-Quelle);
-`pr-15`/`copilot/worktree-*` suchen — existieren auf dieser Maschine nicht
-mehr (Brief veraltet; `.worktrees/`-Verzeichnis enthält keine Git-Repos).
-
-**Nicht-Cleanup, aber offen:** PR #7 + #8 auf `bdb-saashost-engine`
-(LDAP-Injection, Admin-Group-Authz) sind weiterhin OPEN — brauchen
-Review/Merge-Entscheidung, sitzen seit 2026-08-27.
-
-## 4. Tag-/Release-Anomalien (Inventur, 2026-08-28)
-
-- 45 lokale Tags; 5 lokal-only: 4× `snapshot-*`, `v3.13.0-nodex.0` (→ C6/C7).
-- Kein GitHub-Release für: `v2.4.1`, `v3.9.5` (Tags + npm existieren).
-- `3.0.6`: Tag + Release existieren, aber **nie auf npm publiziert** (E404).
-- `3.3.1`: auf npm, aber kein Tag, kein Release.
-- Betas (3.13.0-beta.nodex, nodex.0–.4): auf npm, keine Git-Tags (außer
-  lokalem nodex.0), keine Releases — konsistent zur Beta-Strategie.
-
-## 5. Design-Abgleich (manuell, teilweise — Subagenten gequotet)
-
-Der unabhängige Screenshot-Vergleich wurde 2× abgebrochen (concurrency limit,
-dann quota limit) und **nicht** durchgeführt. Manuell abgeglichen:
-`~/Downloads/GRAOG/bdb_graph_layer_guide.html` (das distillierte Design-Doku,
-Aug 27, „BDB OS v3.13") gegen `.agents/graph.md` + Implementierung:
-
-| Design (Guide) | Status | Anmerkung |
-|---|---|---|
-| 7-Node State Machine (Architect→TechLead→paralleler Build→Reviewer→Shipping) | MATCH | 1:1 in graph.md + Simulator-Diagramm |
-| „Nodes never call each other", Dispatcher-only Edges | MATCH | Kernregel von graph.md:8-17 |
-| Repair-Loops (TechLead-Reject→Architect, Reviewer→owning node) | MATCH | Edge-Table identisch |
-| No-Progress Guard (gleiche Blocker-ID 2× → needs_human) | MATCH | Implementierung = „same finding IDs"-Eskalation (graph.md:64-75, dokumentierte Adaptation von B3) |
-| Phase 4: „Reply GO → `/ship`" | PARTIAL | `/ship` existiert als Command nicht; GO-Check läuft im go-gate.mjs am Push — F3 |
-| Phase 1: `/bdbrainstorm` & `/grill-me` | PARTIAL | `/grill-me` fehlt (F7) |
-| memB-Dual-Memory (Seed vor Planung, Regression-Match, Ingest nach Ship) | UNKLAR | memb-ingest Skill existiert; ob Architect/Reviewer memB wirklich abfragen, steht nicht im Graph-Contract (ggf. in .agents/agents.md prüfen) |
-| Multi-Harness (Claude dispatcher, Antigravity, OpenCode/Codex, Cursor/Roo-Fallback) | MATCH | Artefakte existieren (.opencode/agents, .roomodes); Guide nennt noch alten Namen `startcycle.mjs` (Guide:889, Design-Doku, nicht Repo) |
-
-**Offen:** die 10 Screenshots (IMG_6186–IMG_6300) wurden einzeln nicht
-ausgewertet. Der Guide referenziert IMG_6186 („4 Primitives") und IMG_6194
-(„Multi-Agent Topology") als die beiden Blueprints — vermutlich deckt der
-Guide deren Inhalt already ab; die übrigen 8 sind wahrscheinlich frühere
-Iterationen. Ein Nachfolge-Agent kann das mit Read auf die Bilddateien
-verifizieren.
-
-## 6. Best-Practices-Check (code.claude.com/docs/en/best-practices, manuell)
-
-- **Verification loops: FOLLOWS** — Stop-Hook-Gates (graph-gate, go-gate),
-  Dispatcher gegen 9+ Szenarien verifiziert (graph.md:117-124),
-  `max_iterations=3` bewusst unter Claude's 8-Block-Override
-  (graph.md:137-141 zitiert die Best-Practices-Doku explizit).
-- **CLAUDE.md-Hygiene: FOLLOWS** — 1.6KB, schlank. **Aber:** 5+ parallele
-  Instruction-Files (CLAUDE/AGENTS/GEMINI/CODEX/.roomodes/.codex-plugin) —
-  der Drift ist schon sichtbar (F3: GEMINI.md + .codex-plugin stale).
-  Empfehlung: single-source + Generierung statt manuell synchronisierter
-  Kopien.
-- **Skills vs CLAUDE.md Split: FOLLOWS.** **Reviewer-Isolation (= adversarial
-  fresh-context review): FOLLOWS** modellhaft (Reviewer sieht nie die Claims
-  der Build-Nodes).
-- 161 Skills: kein Verstoß, aber Redundanz-Cluster existieren (seo×3,
-  prompt×3, tdd×2, debugger×2, postgres×4) — Aufräum-Kandidaten, low
-  priority.
-
-## 7. Sonstiges
-
-- token-saver v2.6.3 aktiv, Lifetime 44.9% Ersparnis (48.3K tokens/162
-  cmds). Auffällig: git-Processor „Mismatches" 28× (~17%) — Config-Stellschraube,
-  unangetastet.
-- `token-saver update` wurde bewusst NICHT ausgeführt (Zustandsänderung).
-- GO-Gate gilt weiter: push/publish/npm version/rekursives rm nur nach
-  wörtlichem „GO" direkt davor.
-
-## 8. Empfohlene Reihenfolge für den Folgende-Agent
-
-1. F1 + F2 fixen (vor dem 3.13.0-latest-Release!) → Beta-Gate.
-2. F3/F4 in einem „stale-references"-Commit.
-3. F5 entscheiden: welche github-repo-Version ist kanonisch, andere löschen
-   + Install-Reihenfolge fixen.
-4. Cleanup C1–C7 einzeln zur Freigabe vorlegen.
-5. PR #7/#8 (bdb-saashost-engine) reviewen.