@hybridlabor-api/aos 4.17.0 → 4.18.1

package/.claude/hooks/aos-bus.mjs

@@ -68,17 +68,21 @@ export function touchSession(name, pid = process.pid) {
 
 const alive = (pid) => { try { process.kill(pid, 0); return true; } catch (e) { return e.code === "EPERM"; } };
 
-export function listSessions() {
+// prune: also delete registrations that are dead, stale or corrupt (registration files only, never inboxes).
+export function listSessions({ prune = false } = {}) {
   const dir = join(homedir(), ".aos", "bus", "sessions");
   const out = [];
   let files = [];
   try { files = readdirSync(dir).filter((f) => f.endsWith(".json")); } catch { /* none */ }
   for (const f of files) {
+    const file = join(dir, f);
+    let live = false;
     try {
-      const file = join(dir, f);
       const r = JSON.parse(readFileSync(file, "utf8"));
-      if (Number.isInteger(r.pid) && alive(r.pid) && Date.now() - lstatSync(file).mtimeMs < STALE_MS) out.push(r);
+      live = Number.isInteger(r.pid) && alive(r.pid) && Date.now() - lstatSync(file).mtimeMs < STALE_MS;
+      if (live) out.push(r);
     } catch { /* corrupt entry */ }
+    if (prune && !live) { try { unlinkSync(file); } catch { /* already gone */ } }
   }
   return out;
 }
@@ -134,7 +138,7 @@ if (isMain()) {
     if (cmd === "send" && words.length >= 2) {
       console.log(sendMessage(words[0], words.slice(1).join(" "), opts));
     } else if (cmd === "list") {
-      for (const s of listSessions()) console.log(`${s.name}\tpid ${s.pid}\t${s.cwd}`);
+      for (const s of listSessions({ prune: true })) console.log(`${s.name}\tpid ${s.pid}\t${s.cwd}`);
     } else {
       console.error("usage: aos-bus send <name> <text...> [--from x] [--wake] | aos-bus list");
       process.exit(2);

package/.claude/hooks/go-gate.mjs

@@ -751,7 +751,7 @@ export function statusText(key, eff, now = Date.now()) {
 export const listStateKeys = () => {
   try { return readdirSync(gateDir()).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)); } catch { return []; }
 };
-const TOKEN_TTL_MS = 10 * 60 * 1000;
+export const TOKEN_TTL_MS = 10 * 60 * 1000;
 
 function ownSessionName(transcriptPath) {
   let name = "";

package/.claude/hooks/go-token.mjs

@@ -3,11 +3,11 @@
 // master session, record a single-use token that go-gate.mjs in <session-name>
 // accepts. Writes nothing else and never blocks the prompt.
 
-import { readFileSync, writeFileSync, mkdirSync, realpathSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, realpathSync, readdirSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { slug } from "./go-gate.mjs";
+import { slug, TOKEN_TTL_MS } from "./go-gate.mjs";
 
 function sessionName(transcriptPath) {
   let name = "";
@@ -24,6 +24,20 @@ function sessionName(transcriptPath) {
   return name || process.env.AOS_SESSION_NAME || "";
 }
 
+// Expired or unreadable tokens are never read again by anyone, so a write is the moment to drop them.
+export function pruneExpiredTokens(dir, now = Date.now()) {
+  let files = [];
+  try { files = readdirSync(dir).filter((f) => f.endsWith(".token")); } catch { return 0; }
+  let removed = 0;
+  for (const f of files) {
+    let age = NaN;
+    try { age = now - Date.parse(JSON.parse(readFileSync(join(dir, f), "utf8"))?.issued_at); } catch { /* unreadable: drop */ }
+    if (age >= 0 && age < TOKEN_TTL_MS) continue;
+    try { unlinkSync(join(dir, f)); removed++; } catch { /* already gone */ }
+  }
+  return removed;
+}
+
 // Returns the token path, or null. Never throws. An aos-acp worker is a worker
 // by definition and must not mint a token for itself.
 export function issueGoToken(prompt, { transcript_path, session_id, message_id } = {}) {
@@ -38,6 +52,7 @@ export function issueGoToken(prompt, { transcript_path, session_id, message_id }
     if (!target || !tok) return null;
     const dir = join(homedir(), ".aos", "go");
     mkdirSync(dir, { recursive: true });
+    pruneExpiredTokens(dir);
     const file = join(dir, `${target}.token`);
     writeFileSync(file, JSON.stringify(tok));
     return file;

package/.claude/hooks/memb-inject.mjs

@@ -1,32 +1,41 @@
 #!/usr/bin/env node
-// aos-hook-version: 7
+// aos-hook-version: 8
 /**
  * memB ambient memory hook for Claude Code, Google Antigravity, and OpenAI Codex.
  *
  * Stamped with aos-hook-version for /aos-setup doctor validation.
  * Reads ~/.MemBDB/memb.db directly through node:sqlite and injects relevant
- * project & user memories as ephemeral context in tri-format JSON:
- * - hookSpecificOutput (Claude Code UserPromptSubmit)
+ * project & user memories as ephemeral context, emitting only the key the
+ * calling harness reads:
+ * - hookSpecificOutput.additionalContext (Claude Code, OpenAI Codex)
  * - injectSteps (Google Antigravity PreInvocation)
- * - systemMessage (OpenAI Codex UserPromptSubmit)
+ *
+ * Reads rows of the configured user (MEMB_USER_ID, fallback $USER) plus the
+ * group ids in MEMB_GROUP_IDS (comma list, default bdb_developer). Rows bound
+ * to the current project are injected whatever their category (max 5, 180
+ * chars each); global rows still need category `godmode`.
  *
  * Event-aware: SessionStart injects the persona file, the global godmode
  * identity rows, and the current project's cards once per session; every
  * other prompt (UserPromptSubmit) recalls only FTS keyword hits so 40
  * identity facts are not re-sent on every message. Harnesses without a
  * session hook (e.g. Antigravity PreInvocation) get the full block plus
- * identity on each invocation.
+ * identity on the first invocation of a conversation (cached per
+ * conversationId); later invocations recall FTS hits only.
  *
  * Fails open: any error exits 0 silently.
  */
 
-import { readFileSync, existsSync, realpathSync } from 'node:fs';
+import { readFileSync, existsSync, realpathSync, mkdirSync, writeFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
 
 const COLLECTION = 'bdb_agent_memory';
+const DEFAULT_GROUP_IDS = 'bdb_developer';
+const PROJECT_ROW_CAP = 5;
+const ROW_CHARS = 180;
 const failOpen = () => process.exit(0);
 
 // `deja wip --json` run in the project root, rendered as context lines.
@@ -51,6 +60,14 @@ export function dejaWip(cwd, run = execFileSync) {
   }
 }
 
+// Rows are read for the user plus the configured group ids; nothing is
+// hard-coded beyond the documented default group.
+export function resolveReaderIds({ userId, env = process.env } = {}) {
+  const user = env.MEMB_USER_ID || userId || env.USER || env.LOGNAME || '';
+  const groups = String(env.MEMB_GROUP_IDS ?? DEFAULT_GROUP_IDS).split(',').map((g) => g.trim());
+  return Array.from(new Set([user, ...groups].filter(Boolean)));
+}
+
 // Filler words (German + English) that must never become FTS query terms —
 // they match virtually any document and would inject unrelated projects.
 const STOPWORDS = new Set([
@@ -160,14 +177,7 @@ export async function buildMemoryBlock({ event = '', prompt = '', cwd, userId }
   const projectRoot = findProjectRoot(rawCandidateDir, home);
   const candidateProjectIds = resolveProjectIdentifiers(projectRoot, home);
 
-  // User identification: reconcile active user and bdb_developer baseline
-  const activeUser =
-    process.env.MEMB_USER_ID ||
-    userId ||
-    process.env.USER ||
-    process.env.LOGNAME ||
-    'bdb_developer';
-  const candidateUsers = Array.from(new Set([activeUser, 'bdb_developer'])).filter(Boolean);
+  const candidateUsers = resolveReaderIds({ userId });
 
   const contextItems = [];
 
@@ -259,12 +269,10 @@ export async function buildMemoryBlock({ event = '', prompt = '', cwd, userId }
               OR json_extract(payload, '$.user_id') IN (${uPlaceholders})
               OR json_extract(payload, '$.metadata.user_id') IN (${uPlaceholders})
             )
-            AND (
-              json_extract(payload, '$.category') IN ('project_card','godmode')
-              OR json_extract(payload, '$.metadata.category') IN ('project_card','godmode')
-            )
-          ORDER BY rowid DESC
-          LIMIT 5
+          ORDER BY (COALESCE(json_extract(payload, '$.category'),
+                             json_extract(payload, '$.metadata.category')) = 'project_card') DESC,
+                   rowid DESC
+          LIMIT ${PROJECT_ROW_CAP * 4}
         `;
         const params = [
           COLLECTION,
@@ -276,11 +284,14 @@ export async function buildMemoryBlock({ event = '', prompt = '', cwd, userId }
           ...candidateUsers,
         ];
         const rows = db.prepare(sql).all(...params);
+        let taken = 0;
         for (const r of rows) {
+          if (taken >= PROJECT_ROW_CAP) break;
           const text = textOf(r.payload);
-          if (text.length > 10) {
-            contextItems.push(`- Project [${candidateProjectIds[0]}]: ${text.slice(0, 180)}`);
-          }
+          if (text.length <= 10 || /^\[[^\]|]+\|[^\]|]+\|/.test(text)) continue; // too short / imported file chunk
+          if (contextItems.some((e) => e.includes(text.slice(0, 50)))) continue;
+          contextItems.push(`- Project [${candidateProjectIds[0]}]: ${text.slice(0, ROW_CHARS)}`);
+          taken++;
         }
       } catch { /* project query is best-effort */ }
     }
@@ -316,7 +327,7 @@ export async function buildMemoryBlock({ event = '', prompt = '', cwd, userId }
             const hitProject = projectOf(r.payload);
             if (hitProject && !candidateProjectIds.includes(hitProject)) continue;
             const cat = categoryOf(r.payload);
-            if (cat !== 'project_card' && cat !== 'godmode') continue;
+            if (!hitProject && cat !== 'project_card' && cat !== 'godmode') continue;
             if (!contextItems.some((e) => e.includes(text.slice(0, 50)))) {
               contextItems.push(`- Domain memory: ${text.slice(0, 180)}`);
             }
@@ -338,6 +349,19 @@ export async function buildMemoryBlock({ event = '', prompt = '', cwd, userId }
   }
 }
 
+// Antigravity has no session hook: remember per conversation that identity and
+// project rows were already sent, so later invocations do only the FTS recall
+// and skip `deja wip`. Stamps under ~/.aos/cache are disposable.
+export function agyIdentitySent(conversationId, base = path.join(os.homedir(), '.aos', 'cache')) {
+  const id = String(conversationId || '').replace(/[^\w.-]/g, '_').slice(0, 80);
+  if (!id) return false;
+  const dir = path.join(base, 'memb-agy');
+  const stamp = path.join(dir, id);
+  if (existsSync(stamp)) return true;
+  try { mkdirSync(dir, { recursive: true }); writeFileSync(stamp, ''); } catch {}
+  return false;
+}
+
 // Main logic runs only when the file is executed directly as a hook; importing
 // the module (e.g. from tests) must stay side-effect free.
 async function main() {
@@ -351,26 +375,26 @@ async function main() {
 
     // Discover candidate directory across harnesses:
     // Claude / Codex: eventData.cwd; Antigravity: eventData.workspacePaths[0] or eventData.cwd
+    const isAgy = !eventData.hook_event_name && (Array.isArray(eventData.workspacePaths) || !!eventData.conversationId);
+    const event = isAgy && agyIdentitySent(eventData.conversationId)
+      ? 'UserPromptSubmit'
+      : (eventData.hook_event_name || '');
     const memoryBlock = await buildMemoryBlock({
-      event: eventData.hook_event_name || '',
+      event,
       prompt: eventData.prompt || eventData.userPrompt || '',
       cwd: (Array.isArray(eventData.workspacePaths) && eventData.workspacePaths[0]) || eventData.cwd,
       userId: eventData.user_id || eventData.userId,
     });
 
     if (memoryBlock) {
-      process.stdout.write(JSON.stringify({
-        hookSpecificOutput: {
-          hookEventName: eventData.hook_event_name || 'UserPromptSubmit',
-          additionalContext: memoryBlock,
-        },
-        injectSteps: [
-          {
-            ephemeralMessage: memoryBlock,
-          }
-        ],
-        systemMessage: memoryBlock,
-      }) + '\n');
+      process.stdout.write(JSON.stringify(isAgy
+        ? { injectSteps: [{ ephemeralMessage: memoryBlock }] }
+        : {
+          hookSpecificOutput: {
+            hookEventName: eventData.hook_event_name || 'UserPromptSubmit',
+            additionalContext: memoryBlock,
+          },
+        }) + '\n');
     }
     process.exit(0);
   } catch {

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "bdb-aos",
-  "version": "4.17.0",
+  "version": "4.18.1",
   "description": "Full BDB Agent OS suite for Codex: command entry points ($bdb-aos:setup, $bdb-aos:init, ...) generated from plugin-commands.json.",
   "author": {
     "name": "Tim Rennings / Hybridlabor Global LLC",

package/.opencode/commands/bdb-aos-plan.md

@@ -2,4 +2,4 @@
 description: "Plan end to end: draft, render in plan-canvas or Plan Builder, annotate, await approval, then hand off."
 ---
 
-Run the full planning pipeline: 1) draft the plan with `concise-planning`; 2) always offer the choice between plan-canvas and Plan Builder (`visual-plan`) for rendering; 3) collect annotations and wait for the human's approval; 4) only after approval continue with `writing-plans` or `/bdb-aos-graph`. Topic: $ARGUMENTS
+Run the full planning pipeline: 1) draft the plan with `concise-planning`; 2) always offer the choice between plan-canvas and Plan Builder (`aos-plan-canvas open <dir> --mode bdb-plan-builder`) for rendering; 3) collect annotations and wait for the human's approval; 4) only after approval continue with `writing-plans` or `/bdb-aos-graph`. Topic: $ARGUMENTS

package/README.md

@@ -118,6 +118,7 @@ What the installer writes for each target. Paths are the defaults; the installer
 | Roo Code / Cline | `~/.roo/skills` | — | — | `.roomodes` (project) |
 | Aider | `~/.aider/bdb-skills` | — | — | — |
 | AOS CLI (`pi`) | reads `~/.agents/skills` | `~/.agents/AGENTS.md` as system prompt | — | no MCP; separate install, Node >= 22.19 — see [packages/aos-cli](packages/aos-cli/README.md) |
+| BDB AO Codenotch (macOS app, Windows installer) | macOS `/Applications` or `~/Applications`; Windows per-user NSIS install (`/S`, no admin) | — | — | installed by default on macOS and Windows (never Linux); opt out with `--no-codenotch` or `AOS_CODENOTCH=0`; failures only warn; DMG from the public releases repo created by Tim, SHA-256 verified, ad-hoc signed with quarantine removed, see [docs/codenotch.md](docs/codenotch.md) |
 
 Every install also writes the universal copy to `~/.agents/skills`, which is what the AOS CLI and the `skills` CLI read.
 

package/THIRD_PARTY_NOTICES.md

@@ -309,7 +309,7 @@ dependency.
 
 <https://github.com/BuilderIO/skills> — MIT. Copyright (c) 2026 Builder.io.
 
-Eleven skills are adapted under `skills/global_config/`: `read-the-damn-docs`, `stay-within-limits`, `quick-recap`, `plan-arbiter`, `factory-human-digest`, `factory-collect`, `factory-lookback`, `factory-review-prs`, `visual-plan`, `visual-recap`, and `visual-edit`. The four Factory skills and `plan-arbiter` have `installer-group` dropped and `category`/`source` added; in `factory-collect`, `factory-lookback` and `factory-review-prs` reply, close, approve, merge and publish actions are reduced to drafts or readiness reports that need the user's GO, and all of them carry an "AOS safety rules" section. `plan-arbiter` drops `agents/openai.yaml` and adds an AOS section on double plans. `stay-within-limits` and `quick-recap` are carried over with `category:` and `source:` added; `stay-within-limits` pins `ccusage` to 20.0.26 instead of `@latest`, and `quick-recap` no longer asks the installer to inject a managed `AGENTS.md` / `CLAUDE.md` block. The three visual skills (`visual-plan`, `visual-recap`, `visual-edit`) are optional and drive the Agent-Native Plan/Design services through MCP connectors (`plan` and `design`) that AOS does NOT register; you connect them yourself if needed. Each carries an "AOS notes" section. `read-the-damn-docs` is described below:
+Eight skills are adapted under `skills/global_config/`: `read-the-damn-docs`, `stay-within-limits`, `quick-recap`, `plan-arbiter`, `factory-human-digest`, `factory-collect`, `factory-lookback`, and `factory-review-prs`. The four Factory skills and `plan-arbiter` have `installer-group` dropped and `category`/`source` added; in `factory-collect`, `factory-lookback` and `factory-review-prs` reply, close, approve, merge and publish actions are reduced to drafts or readiness reports that need the user's GO, and all of them carry an "AOS safety rules" section. `plan-arbiter` drops `agents/openai.yaml` and adds an AOS section on double plans. `stay-within-limits` and `quick-recap` are carried over with `category:` and `source:` added; `stay-within-limits` pins `ccusage` to 20.0.26 instead of `@latest`, and `quick-recap` no longer asks the installer to inject a managed `AGENTS.md` / `CLAUDE.md` block. `read-the-damn-docs` is described below:
 the docs-first trigger list, the source hierarchy, the required workflow, the
 must-trigger examples, and the "if docs are unavailable" rule. AOS additionally
 adds a Verification section, a `category:` key (Builder's own validator forbids
@@ -318,7 +318,7 @@ guesswork* rule, and a pointer to the installed `firecrawl-search` /
 `firecrawl-scrape` tools. Prose only — the upstream `agents/openai.yaml` and
 README were not carried over, and no executable from the repo is referenced.
 
-In the three visual skills, five path-like mentions (`/sign-in`, `/live-edit-bridge`, `/read-file`, `/write-file`, `/visualize-repo`) were reworded so the AOS validator does not read them as skill references. The other 13 skills in that repo (as of commit 0dba9ef) are **not** vendored. Three of them
+The other 13 skills in that repo (as of commit 0dba9ef) are **not** vendored. Three of them
 (`an`, `turn-into-app`, `rewind`) plus three others
 are build artefacts synced from a different upstream by
 `scripts/sync-agent-native-skills.mjs`, and the repo's own documentation says

package/bin/aos-acp.mjs

@@ -14,10 +14,11 @@
 import { spawn } from "node:child_process";
 import { appendFileSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline";
 import { GUARDED_PATTERNS, slug, tokenGrantsGo } from "../.claude/hooks/go-gate.mjs";
+import { emitTrail } from "../mcps/mcsc/packages/core/src/trail.js";
 
 export const ADAPTERS = {
   claude: { cmd: ["npx", "-y", "@agentclientprotocol/claude-agent-acp"], consume: false },
@@ -113,6 +114,25 @@ export class AcpClient {
   notify(method, params) { this.write({ jsonrpc: "2.0", method, params }); }
 }
 
+// Same agenttrail protocol as mcsc's adapters (SessionStart/SessionEnd, PreToolUse/PostToolUse),
+// so the GO board reads ACP workers and mcsc runs from one source.
+const cap = (t) => (t ? t.charAt(0).toUpperCase() + t.slice(1) : "Tool");
+
+export function trailToolEvent(u, seen, cwd) {
+  const prev = seen.get(u.toolCallId) || {};
+  const info = { title: u.title ?? prev.title, kind: u.kind ?? prev.kind };
+  seen.set(u.toolCallId, info);
+  const done = u.status === "completed" || u.status === "failed";
+  if (u.sessionUpdate === "tool_call_update" && !done) return null;
+  const tool_input = {};
+  const file = u.locations?.[0]?.path ?? prev.file;
+  if (typeof file === "string" && file) tool_input.file_path = isAbsolute(file) ? file : resolve(cwd, file);
+  info.file = tool_input.file_path;
+  const command = commandOf(u);
+  if (command) tool_input.command = command;
+  return { hook_event_name: done ? "PostToolUse" : "PreToolUse", tool_name: cap(info.kind || info.title), tool_input };
+}
+
 function textOf(block) {
   return block && block.type === "text" ? block.text : "";
 }
@@ -134,6 +154,9 @@ export async function run(opts) {
   const consume = opts.consume ?? adapter?.consume ?? true;
   log("start", { adapter: opts.adapter, cmd: cmd.join(" "), cwd: opts.cwd, allow_default: opts.allowDefault, consume, model: opts.model || "adapter default" });
 
+  const trail = { session_id: `aos-acp-${process.pid}-${Date.now()}`, cwd: opts.cwd, agent: `${opts.adapter}:${opts.name}` };
+  const seenTools = new Map();
+  emitTrail({ ...trail, hook_event_name: "SessionStart" });
   let sessionId;
   const out = opts.stdout || process.stdout;
   const client = new AcpClient(cmd, {
@@ -148,6 +171,8 @@ export async function run(opts) {
         if (t) { out.write(t); log("text", { text: t }); }
       } else if (u.sessionUpdate === "tool_call" || u.sessionUpdate === "tool_call_update") {
         log(u.sessionUpdate, { id: u.toolCallId, title: u.title, kind: u.kind, status: u.status, command: commandOf(u) || undefined });
+        const ev = trailToolEvent(u, seenTools, opts.cwd);
+        if (ev) emitTrail({ ...trail, ...ev });
       } else log("update", { kind: u.sessionUpdate });
     },
     onRequest: (method, p) => {
@@ -182,6 +207,7 @@ export async function run(opts) {
   } finally {
     if (timer) clearTimeout(timer);
     client.child.kill();
+    await emitTrail({ ...trail, hook_event_name: "SessionEnd" });
   }
 }
 

package/bin/aos-doctor.mjs

@@ -169,6 +169,40 @@ function checkAosCore() {
   }
 }
 
+// JSONC to JSON: drops comments (not inside strings) and trailing commas.
+function parseJsonc(text) {
+  let out = '';
+  for (let i = 0, str = false; i < text.length; i++) {
+    const c = text[i];
+    if (str) { out += c; if (c === '\\') out += text[++i] ?? ''; else if (c === '"') str = false; continue; }
+    if (c === '"') { str = true; out += c; continue; }
+    if (c === '/' && text[i + 1] === '/') { while (i < text.length && text[i] !== '\n') i++; out += '\n'; continue; }
+    if (c === '/' && text[i + 1] === '*') { i += 2; while (i < text.length && !(text[i] === '*' && text[i + 1] === '/')) i++; i++; continue; }
+    out += c;
+  }
+  try { return JSON.parse(out.replace(/,(\s*[}\]])/g, '$1')); } catch { return null; }
+}
+
+// Zen gateway limit: a tool name (OpenCode builds it from the MCP server name) is at most 64 characters.
+// Names only, no network: the tool part of the name is not known here.
+const ZEN_TOOL_NAME_MAX = 64;
+
+function checkOpencodeMcpNames() {
+  const dirs = [process.platform === 'win32' ? path.join(process.env.APPDATA || HOME, 'opencode') : h('.config', 'opencode')];
+  const file = firstExisting(dirs.flatMap((d) => ['opencode.jsonc', 'opencode.json'].map((f) => path.join(d, f))));
+  if (!file) return;
+  const conf = parseJsonc(readFileSync(file, 'utf8'));
+  if (!conf) {
+    add('harnesses', 'OpenCode MCP names', false, `${tilde(file)} is not valid JSON(C); names not checked`, 'Fix the OpenCode config syntax.', true);
+    return;
+  }
+  const names = Object.keys(conf.mcp && typeof conf.mcp === 'object' ? conf.mcp : {});
+  const tooLong = names.filter((n) => n.length > ZEN_TOOL_NAME_MAX);
+  add('harnesses', 'OpenCode MCP names', tooLong.length === 0,
+    tooLong.length ? `${tooLong.length} MCP name(s) over ${ZEN_TOOL_NAME_MAX} characters (Zen gateway limit): ${tooLong.join(', ')}` : `${names.length} MCP name(s) in ${tilde(file)}, none over ${ZEN_TOOL_NAME_MAX} characters`,
+    `Rename the MCP server(s) in ${tilde(file)} to a shorter name; tool names are built from them and a name over ${ZEN_TOOL_NAME_MAX} characters is rejected by the Zen gateway. Keeping the MCP set lean also helps.`, true);
+}
+
 // ---------------------------------------------------------------- 3. Harness Placement & Skills Sync
 function checkHarnesses() {
   const harnesses = [
@@ -199,12 +233,13 @@ function checkHarnesses() {
   add('harnesses', 'OpenCode Plugin', !!opencodePlugin,
     opencodePlugin ? tilde(opencodePlugin) : 'bdb-aos.js not installed in OpenCode plugins',
     'Run the AOS installer to wire OpenCode telemetry plugin.', true);
+  checkOpencodeMcpNames();
 }
 
 // ---------------------------------------------------------------- 4. Hooks & Security Gates
 function checkHooks() {
   const claudeHooksDir = h('.claude', 'hooks');
-  const EXPECTED_VERSION = { 'memb-inject.mjs': 7 };
+  const EXPECTED_VERSION = { 'memb-inject.mjs': 8 };
   const versionOf = (text) => {
     const m = /^\/\/\s*aos-hook-version:\s*(\d+)/m.exec(text);
     return m ? Number(m[1]) : null;

package/bin/aos-uninstall.mjs

@@ -25,6 +25,7 @@ import path from 'node:path';
 import { createRequire } from 'node:module';
 
 const pm = createRequire(import.meta.url)('../lib/plugin-migration.js');
+const cn = createRequire(import.meta.url)('../lib/codenotch.js');
 
 const HOME = os.homedir();
 const h = (...p) => path.join(HOME, ...p);
@@ -103,7 +104,9 @@ function plan() {
   const legacy = LEGACY_MARKERS.filter(existsSync);
   const data = PURGE ? DATA_PATHS.filter((d) => existsSync(d.path)) : [];
 
-  return { manifest, ours, edited, gone, agents, modules, legacy, data };
+  const codenotch = cn.planCodenotchUninstall({ stateFile: cn.stateFilePath(HOME) });
+
+  return { manifest, ours, edited, gone, agents, modules, legacy, data, codenotch };
 }
 
 function describe(p) {
@@ -140,6 +143,12 @@ function describe(p) {
     for (const l of legacy) console.log(`    ${tilde(l)}`);
   }
 
+  if (p.codenotch) {
+    const c = p.codenotch;
+    const note = { remove: 'is removed (still the recorded build)', keep: 'is kept (replaced or modified since AOS installed it)', gone: 'is already gone' }[c.action];
+    console.log(`\nBDB AO Codenotch ${tilde(c.state.path || c.state.uninstallPath)} ${note}`);
+  }
+
   console.log('\nBleibt erhalten:');
   if (!PURGE) for (const d of DATA_PATHS.filter((d) => existsSync(d.path))) console.log(`    ${tilde(d.path).padEnd(18)} ${d.what}`);
   console.log('    jede Datei ohne Manifest-Eintrag — eigene Skills, fremde Hooks, alles Selbstgeschriebene');
@@ -169,7 +178,7 @@ function dirSize(p) {
 
 // ------------------------------------------------------------------ execute
 function execute(p) {
-  const { ours, edited, agents, modules, legacy, data } = p;
+  const { ours, edited, agents, modules, legacy, data, codenotch } = p;
   const stamp = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
   let removed = 0, backed = 0;
 
@@ -242,6 +251,11 @@ function execute(p) {
     } catch { console.log(`  ${tilde(codexToml)} nicht lesbar — von Hand prüfen`); }
   }
 
+  if (codenotch) {
+    const r = cn.uninstallCodenotch(codenotch, { stateFile: cn.stateFilePath(HOME) });
+    console.log(`  Codenotch: ${r === 'remove' ? 'removed' : r === 'keep' ? 'kept, not the recorded build' : r === 'error' ? 'uninstaller failed, left in place' : 'already gone'}`);
+  }
+
   for (const l of legacy) { try { rmSync(l); } catch { /* already gone */ } }
   if (legacy.length) console.log(`  ${legacy.length} Installations-Marker entfernt`);
 

package/bin/go-check.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// go-check: one fixed answer to "may this worker run this guarded command?" for callers that
+// are not a harness hook (AO). Installed at ~/.aos/bin/go-check.mjs.
+//
+//   node go-check.mjs --session <Name> --command "<shell string>" [--consume]
+//   node go-check.mjs --write-patterns <file>
+//
+// stdout: {"guarded":bool,"ok":bool,"scope":[...]|null,"reason":"..."}
+// exit 0 allowed (not guarded, or a valid GO token; --consume uses it up), 1 guarded without a
+// valid GO, 2 error (the caller must treat 2 as denied). Only `GO <Name>` tokens count: mode
+// soft grants and mode off belong to the human session and are never read here. Nothing in
+// this file writes a token; the tool is synchronous, offline and reads no stdin.
+
+import { existsSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+async function loadGate() {
+  for (const f of [join(here, "go-gate.mjs"), join(here, "..", ".claude", "hooks", "go-gate.mjs")]) {
+    if (existsSync(f)) return import(pathToFileURL(f).href);
+  }
+  throw new Error("go-gate.mjs not found next to go-check.mjs or in ../.claude/hooks");
+}
+
+export const patternsJson = (gate) => ({
+  version: 1,
+  source: "go-gate.mjs GUARDED_PATTERNS (JavaScript RegExp syntax, lookaheads included; not RE2)",
+  scopes: gate.SCOPES,
+  patterns: gate.GUARDED_PATTERNS.map((r) => ({ source: r.source, flags: r.flags })),
+});
+
+export function check(gate, { session, command, consume = false }) {
+  if (typeof command !== "string" || !command.trim()) return { code: 2, out: { guarded: null, ok: false, scope: null, reason: "--command is empty" } };
+  const storeReason = gate.gateStoreReason(command);
+  if (storeReason) return { code: 1, out: { guarded: true, ok: false, scope: null, reason: storeReason } };
+  if (!gate.isGuardedCommand(command)) return { code: 0, out: { guarded: false, ok: true, scope: [], reason: "" } };
+  const scope = gate.commandScopes(command);
+  if (typeof session !== "string" || !gate.slug(session)) {
+    return { code: 2, out: { guarded: true, ok: false, scope, reason: "--session is missing or has no usable name" } };
+  }
+  const r = gate.tokenGrantsGo(session, { consume });
+  return r.ok
+    ? { code: 0, out: { guarded: true, ok: true, scope, reason: consume ? "GO token consumed" : "GO token valid (not consumed)" } }
+    : { code: 1, out: { guarded: true, ok: false, scope, reason: r.reason } };
+}
+
+export function parseArgs(argv) {
+  const o = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--session") o.session = argv[++i];
+    else if (a === "--command") o.command = argv[++i];
+    else if (a === "--write-patterns") o.writePatterns = argv[++i];
+    else if (a === "--consume") o.consume = true;
+    else throw new Error(`unknown argument ${a}`);
+  }
+  return o;
+}
+
+const done = (code, out) => process.stdout.write(JSON.stringify(out) + "\n", () => process.exit(code));
+
+const invokedAs = (() => { try { return realpathSync(process.argv[1] || ""); } catch { return ""; } })();
+if (invokedAs === fileURLToPath(import.meta.url)) {
+  try {
+    const o = parseArgs(process.argv.slice(2));
+    const gate = await loadGate();
+    if (o.writePatterns) {
+      writeFileSync(o.writePatterns, JSON.stringify(patternsJson(gate), null, 2) + "\n");
+      done(0, { ok: true, reason: `wrote ${o.writePatterns}` });
+    } else {
+      const { code, out } = check(gate, o);
+      done(code, out);
+    }
+  } catch (e) {
+    done(2, { guarded: null, ok: false, scope: null, reason: String(e?.message || e).slice(0, 300) });
+  }
+}