@hybridlabor-api/aos 4.16.0 → 4.18.0

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

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+// UserPromptSubmit hook for the go-gate modes and grants. When the human types,
+// as the whole message (plain form, primary):
+//   gogate grant <scope[,scope...]> <15m|2h|1d|session>
+//   gogate hard|soft|off|status
+// or the slash form /bdb-aos:gogate ... (rarely verifies, the hook says so),
+// it records the request in ~/.aos/gate/<session-key>.json with a pointer to
+// the prompt (transcript, issue time, text hash). Nothing here is trusted on
+// its own: go-gate.mjs re-reads the transcript at use time and honours an
+// entry only if a human-typed (origin-checked) prompt with that hash exists.
+// A loop, peer, bus or agent prompt may reach this hook, but its transcript
+// entry is not human, so what it records never verifies.
+//
+// CLI: node go-grant.mjs --status [--session <id>]   (read-only, prints status)
+
+import { readFileSync, realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import {
+  parseGogate, textHash, sessionKey, readState, writeState, gateLog, effectiveGate,
+  gogateCommandsFor, statusText, listStateKeys, OPENCODE_MAX_GRANT_MS,
+} from "./go-gate.mjs";
+
+const emptyState = (source) => ({ transcript: source, grants: [] });
+
+// Applies a gogate prompt to the store. `source` is the transcript path or
+// "opencode:<sessionID>"; `uuid` the message id when the harness knows it.
+// Returns the text for the model (additionalContext), or null for non-gogate prompts.
+export function applyGogate(prompt, { key, source, uuid = null, now = Date.now(), opencode = false }) {
+  const p = parseGogate(prompt);
+  if (!p) return null;
+  const slashNote = p.form === "slash"
+    ? ` Note: this was a slash command. ${opencode ? "OpenCode accepts only the plain form" : "Claude Code stores slash commands without human-origin data, so the gate will most likely ignore it"}; to make it count, type the plain form as the whole message: \`gogate ${p.cmd === "grant" ? `grant ${p.scopes.join(",")} ${p.session ? "session" : "<duration>"}` : p.cmd || "status"}\`.`
+    : "";
+  if (p.error) return `gogate: ${p.error}. Nothing changed.`;
+  if (!key || !source) return "gogate: no session id in hook input, nothing recorded.";
+  if (process.env.AOS_ACP_CLIENT) return "gogate: an aos-acp worker session cannot set modes or grants.";
+  if (p.cmd === "status") return status(key);
+  if (opencode && p.cmd === "off") return "gogate: `off` is not available on OpenCode (no human-origin signal there). Nothing changed.";
+  let st = readState(key);
+  if (!st || typeof st !== "object" || st.transcript !== source) st = emptyState(source);
+  const src = { transcript: source, uuid, issued_at: new Date(now).toISOString(), text_hash: textHash(prompt) };
+  if (p.cmd === "grant") {
+    const ms = opencode ? Math.min(p.ms, OPENCODE_MAX_GRANT_MS) : p.ms;
+    st.grants = (Array.isArray(st.grants) ? st.grants : []).filter((g) => Date.parse(g?.until) > now);
+    for (const scope of p.scopes) st.grants.push({ scope, until: new Date(now + ms).toISOString(), ...(p.session ? { session_key: key } : {}), source: src });
+  } else {
+    // Append, never overwrite: a later prompt that does not verify must not erase the
+    // store entry of the mode that is still in force.
+    st.modes = [...(Array.isArray(st.modes) ? st.modes : []), { mode: p.cmd, source: src }].slice(-20);
+  }
+  try {
+    writeState(key, st);
+  } catch (e) {
+    return `gogate: could NOT record ${p.cmd}: writing ~/.aos/gate failed (${e.code || e.message}). Nothing changed; the gate stays as it was. Tell the human.`;
+  }
+  gateLog(key, `recorded ${p.form} ${p.cmd}${p.scopes ? ` ${p.scopes.join(",")} ${p.session ? "session" : `${p.ms / 60000}m`}` : ""}`);
+  return [
+    `gogate: recorded ${p.cmd}${p.scopes ? ` for ${p.scopes.join(", ")}` : ""}${p.session ? " (session = this session id, at most 24h, survives --resume)" : ""}${opencode && p.cmd === "grant" && p.ms > OPENCODE_MAX_GRANT_MS ? " (capped at 2h on OpenCode)" : ""}.`,
+    "The gate verifies it against this prompt in the transcript on every use.",
+    slashNote,
+    "Tell the human what was recorded; never try to change modes or grants yourself.",
+  ].filter(Boolean).join(" ");
+}
+
+export function status(key) {
+  const st = readState(key);
+  const eff = st ? effectiveGate(key, { source: st.transcript, cmds: gogateCommandsFor(st.transcript), opencode: String(st.transcript).startsWith("opencode:") }) : { mode: "soft", grants: [], rejected: [] };
+  return statusText(key, eff);
+}
+
+const isMain = () => { try { return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url)); } catch { return false; } };
+
+if (isMain()) {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--status")) {
+    const i = argv.indexOf("--session");
+    const id = i !== -1 ? argv[i + 1] : process.env.AOS_GATE_SESSION || process.env.CLAUDE_SESSION_ID;
+    const keys = id ? [sessionKey(id)] : listStateKeys();
+    console.log(keys.length ? keys.map(status).join("\n\n") : "AOS go-gate: no session state; every session runs in soft mode with no grants (behaves like hard).");
+    process.exit(0);
+  }
+  try {
+    const input = JSON.parse(readFileSync(0, "utf8"));
+    const text = applyGogate(input.prompt, { key: sessionKey(input.session_id), source: input.transcript_path });
+    if (text) console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: text } }));
+  } catch { /* a failing hook must never block the prompt */ }
+  process.exit(0);
+}

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/.claude/settings.json

@@ -123,6 +123,14 @@
           }
         ]
       },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PROJECT_DIR}/.claude/hooks/go-grant.mjs\""
+          }
+        ]
+      },
       {
         "hooks": [
           {

package/.codex-plugin/plugin.json

@@ -1,8 +1,38 @@
 {
-  "name": "bdb-dev-optimized-agent-skills",
-  "version": "2.3.0",
-  "description": "BDB DEV Optimized Agent Skills and MCP pack for Codex CLI, Claude, Cursor and Antigravity",
-  "author": "hybridlabor-api",
-  "skills_dir": "./skills/global_config",
-  "mcp_config": "./.codex-plugin/.mcp.json"
+  "name": "bdb-aos",
+  "version": "4.18.0",
+  "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",
+    "email": "hybridlabor@gmail.com"
+  },
+  "homepage": "https://github.com/hybridlabor-api/aos",
+  "repository": "https://github.com/hybridlabor-api/aos",
+  "license": "Apache-2.0",
+  "keywords": [
+    "skills",
+    "agent-os",
+    "cicd",
+    "multiagent",
+    "startcycle",
+    "bdb"
+  ],
+  "skills": "./plugins/bdb-aos-codex/skills/",
+  "interface": {
+    "displayName": "BDB Agent OS",
+    "shortDescription": "AOS commands for setup, planning and pipelines",
+    "longDescription": "Entry-point skills for the BDB Agent OS suite: invoke $bdb-aos:<command> to run setup, project init, planning and the startcycle pipelines.",
+    "developerName": "Hybridlabor Global LLC",
+    "category": "Developer Tools",
+    "capabilities": [
+      "Interactive",
+      "Read",
+      "Write"
+    ],
+    "websiteURL": "https://github.com/hybridlabor-api/aos",
+    "defaultPrompt": [
+      "$bdb-aos:setup",
+      "$bdb-aos:doctor"
+    ]
+  }
 }

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

@@ -0,0 +1,5 @@
+---
+description: "Brainstorm a topic with the matching skill: bdbrainstorm, bdbmediastorm for event tech, grill-me for a stress test."
+---
+
+Pick by topic: `bdbmediastorm` for live event technology and show control, `grill-me` when the human wants an existing idea stress-tested, `bdbrainstorm` otherwise. Say which one you chose. Topic: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Check the machine and the current project, and print suggested permissions.allow entries without writing any settings."
+---
+
+Run `aos-doctor` (machine check) and report the result. If the current folder is an AOS project, also run the project check `node <aos-project-init skill dir>/scripts/aos-project-doctor.mjs` (it covers `.aos/project.json`, AGENTS.md and the wiki). Print suggested `permissions.allow` entries as text for the human to copy. Never write to settings.json or settings.local.json. Arguments: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Run the startcycle-graph pipeline: durable state, repair loop, quality gate, escalation."
+---
+
+Run the `startcycle-graph` skill; its contract defines the flow. Task: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Set up the current project folder for AOS: slug, wiki, memory, Synapse map, AGENTS.md."
+---
+
+Run the `aos-project-init` skill for the current project folder. This is project setup, not machine setup (that is `/bdb-aos-setup`). Arguments: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Run a prompt repeatedly on an interval, using the harness built-in plus loop templates."
+---
+
+OpenCode has no built-in loop. Use `opencode-loop`, the opt-in package (AOS_OPENCODE_OPTIONAL=loop, see docs/opencode-setup.md); without it, say so and stop. Do not schedule gated commands through its shell loop. Offer a `loop-templates` template when the human has no prompt yet. Safety: a loop prompt never issues a GO, never types or runs `gogate`, never sets a mode or grant, and never merges, pushes or publishes unless a valid grant covers the action. Act on a guarded step only if the human's immediately preceding message is a literal GO or a valid grant covers it; a loop iteration never satisfies the first condition, so it must STOP and report instead of continuing a blocked guarded step. Templates (CI until green, follow a PR to merge, review rounds until no blockers, daily session summary) live in the `loop-templates` skill with run and duration limits and a stop condition each. Arguments: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Supervise other Claude Code sessions on this machine: roster, status requests, GO board, idle notices."
+---
+
+Act as the master session with the `master-session` skill (ACP bridge: `bin/aos-acp.mjs`, see docs/master-session-acp.md). Keep the overview, relay the human's decisions, never decide for the human. Arguments: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Query or store long-term memory with memB."
+---
+
+Use `memb-skill` to search or remember and `memb-ingest` to import material. Never store secrets, tokens or credentials. Arguments: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Coordinate parallel coding agents across repositories through the AO daemon."
+---
+
+Use the `ao-orchestrator` skill. It needs the AO daemon; check that it is running first and stop with a clear message if not. Do not confuse it with `agent-orchestrator`. Arguments: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+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 (`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/.opencode/commands/bdb-aos-playbooks.md

@@ -0,0 +1,5 @@
+---
+description: "List all pb-* playbooks with duration, difficulty and requirements, and start one."
+---
+
+Run `node <bdb-aos skill dir>/scripts/list-playbooks.mjs` and show its output (name, est_time, difficulty, requires of every `pb-*` skill). If the human names a playbook in the arguments or picks one, start that `pb-*` skill; start nothing otherwise. Each playbook keeps its own go-gate points. Arguments: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Bring this machine to a complete, verified AOS installation (skills, MCP servers, gate hooks, memB, OpenWiki, Synapse)."
+---
+
+Run the `aos-setup` skill for this machine. Report what is installed, what was repaired and what is still missing. Arguments: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Pre-ship framing and the technical release gate, with approvals under the go-gate rules."
+---
+
+Use `bdb-shipping-skill` for the pre-flight and `godmode-shipping` for the gate. The playbook `pb-ship` can drive the whole flow. Push, merge and publish need the human's GO under the go-gate rules; never request one on the human's behalf. Arguments: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Start a new composition: project init, brainstorm, then ask whether graph or startcycle follows."
+---
+
+Sequence: 1) `aos-project-init`; 2) `bdbrainstorm`; 3) stop and ask the human whether `/bdb-aos-graph` (startcycle-graph) or `startcycle` follows. Do not start a pipeline on your own. Idea: $ARGUMENTS

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

@@ -0,0 +1,5 @@
+---
+description: "Browse and preview AOS skills, agents and playbooks in the local store UI."
+---
+
+Start the `aos-store` interface. Preview freely, but install nothing until the human says yes for that specific item. Arguments: $ARGUMENTS

package/.opencode/plugins/bdb-aos.js

@@ -23,8 +23,11 @@ import path from 'node:path';
 // so a broken installed hook fails loudly instead of silently falling back.
 const HOOKS = existsSync(new URL('./aos-hooks/go-gate.mjs', import.meta.url)) ? './aos-hooks/' : '../../.claude/hooks/';
 const hook = (f) => import(new URL(HOOKS + f, import.meta.url).href);
-const [{ GUARDED_PATTERNS, tokenGrantsGo }, { issueGoToken }, { checkConventionalCommit }, { envFileReason }, { buildMemoryBlock }, bus] =
-  await Promise.all(['go-gate.mjs', 'go-token.mjs', 'conventional-commits.mjs', 'env-file-protection.mjs', 'memb-inject.mjs', 'aos-bus.mjs'].map(hook));
+// `opencode run "..."` is scriptable by an agent, so it never sets gogate modes or grants
+const OPENCODE_RUN = process.argv.slice(1, 4).includes('run');
+const [gate, { issueGoToken }, { checkConventionalCommit }, { envFileReason }, { buildMemoryBlock }, bus, { applyGogate }] =
+  await Promise.all(['go-gate.mjs', 'go-token.mjs', 'conventional-commits.mjs', 'env-file-protection.mjs', 'memb-inject.mjs', 'aos-bus.mjs', 'go-grant.mjs'].map(hook));
+const { GUARDED_PATTERNS, tokenGrantsGo, isHumanPart, parseGoText, goAllows, isGuardedCommand, gateStoreReason, effectiveGate, opencodeGogateCommands, grantsCover, sessionKey, gateLog } = gate;
 
 // ---------------------------------------------------------------------------
 // Graph gate (W-5, W-6)
@@ -131,9 +134,26 @@ async function ownSessionName(client, sessionID) {
 }
 
 // Only plain text parts are human turns: synthetic = model-only, ignored = display-only,
-// aos_bus = bus delivery (both copies). Each excluded on its own, so safety never hangs on one flag.
-const isHumanText = (p) => p && p.type === 'text' && typeof p.text === 'string' && !p.synthetic && !p.ignored && !p.metadata?.aos_bus;
-const isNonHuman = (p) => p && (p.synthetic || p.ignored || p.metadata?.aos_bus);
+// aos_bus / aos_loop (any loop|aos_ metadata key) = plugin-injected. Each excluded on its own,
+// so safety never hangs on one flag.
+const isHumanText = isHumanPart;
+const isNonHuman = (p) => !!p && !!(p.synthetic || p.ignored || (p.metadata && typeof p.metadata === 'object' && Object.keys(p.metadata).some((k) => /loop|aos_/i.test(k))));
+const ocKey = (id) => sessionKey(`oc-${id}`);
+
+// Root of a session tree (grants live on the root, subagents may use them). null when unknown.
+async function rootSessionId(client, id, parentID) {
+  for (let i = 0; i < 10 && id; i++) {
+    if (parentID === null) return id;
+    try {
+      const res = await client?.session?.get?.({ path: { id } });
+      if (!res?.data) return null;
+      if (!res.data.parentID) return id;
+      id = res.data.parentID;
+      parentID = undefined;
+    } catch { return null; }
+  }
+  return null;
+}
 
 // A plugin reload (SIGUSR2) re-runs init on the cached module in the same process:
 // stop the previous instance's timers and keep its bus names alive. Keyed by directory.
@@ -336,9 +356,10 @@ export default async function bdbAosPlugin(input) {
         if (nudges >= MAX_NUDGES) return;
 
         nudgeState.set(sessionID, { signature: gate.signature, nudges: nudges + 1 });
+        // Synthetic + aos_loop: the nudge is plugin-written and must never count as a human turn (GO, gogate).
         await input.client.session.prompt({
           path: { id: sessionID },
-          body: { parts: [{ type: 'text', text: buildGraphNudge(gate) }] },
+          body: { parts: [{ type: 'text', text: buildGraphNudge(gate), synthetic: true, metadata: { aos_loop: { source: 'graph-gate', nudge: nudges + 1 } } }] },
           query: directory ? { directory } : undefined,
         });
       } catch {
@@ -361,6 +382,12 @@ export default async function bdbAosPlugin(input) {
         if (!s.parentID) issueGoToken(fullText, { session_id: msgInput.sessionID, message_id: msgInput.messageID || msgOutput.message?.id });
       } catch {}
 
+      // plain `gogate ...` message from the human in a root session: record it; the gate verifies it against opencode.db at use.
+      try {
+        const reply = s.parentID || OPENCODE_RUN ? null : applyGogate(fullText, { key: ocKey(msgInput.sessionID), source: `opencode:${msgInput.sessionID}`, uuid: msgInput.messageID || msgOutput.message?.id || null, opencode: true });
+        if (reply) msgOutput.parts.unshift({ id: `gogate-${Date.now()}`, sessionID: msgInput.sessionID, messageID: msgInput.messageID || '', type: 'text', text: reply, synthetic: true });
+      } catch {}
+
       try {
         const event = s.identitySent || s.parentID ? 'UserPromptSubmit' : 'SessionStart';
         s.identitySent = true;
@@ -415,7 +442,9 @@ export default async function bdbAosPlugin(input) {
       // Intercept bash, terminal, or command execution tools
       if (toolName === 'bash' || toolName === 'terminal' || toolName === 'shell' || toolName === 'exec' || toolName === 'run_command') {
         const cmd = toolOutput?.args?.command || toolOutput?.args?.cmd || toolOutput?.args?.script || '';
-        if (typeof cmd === 'string' && GUARDED_PATTERNS.some((re) => re.test(cmd))) {
+        const storeReason = gateStoreReason(cmd);
+        if (storeReason) throw new Error(storeReason);
+        if (typeof cmd === 'string' && (GUARDED_PATTERNS.some((re) => re.test(cmd)) || isGuardedCommand(cmd))) {
           const s = sess(toolInput.sessionID);
           // An unanswered lookup is not proof of a root session: token-only for this call, not cached.
           let tokenOnly = !!s.parentID;
@@ -427,8 +456,9 @@ export default async function bdbAosPlugin(input) {
             } catch { tokenOnly = true; }
             tokenOnly = tokenOnly || !!s.parentID;
           }
-          // Subagent prompts are agent-written, so only a token can open their gate.
-          let authorized = !tokenOnly && s.prompt.toUpperCase() === 'GO';
+          // Subagent prompts are agent-written, so only a token or a grant can open their gate.
+          const goOk = (text) => goAllows(parseGoText(text), cmd);
+          let authorized = !tokenOnly && goOk(s.prompt);
 
           // If this session's cached prompt wasn't GO, query recent session messages via OpenCode client as fallback
           if (!authorized && !tokenOnly && input.client && toolInput.sessionID) {
@@ -440,13 +470,27 @@ export default async function bdbAosPlugin(input) {
                 if ((m.info?.role ?? m.role) === 'user') {
                   const parts = m.parts || [];
                   const text = parts.filter(isHumanText).map((p) => p.text).join('\n').trim();
-                  authorized = text.toUpperCase() === 'GO';
+                  authorized = goOk(text);
                   break;
                 }
               }
             } catch {}
           }
 
+          // Modes and grants of the root session (verified against opencode.db); usable by its subagents.
+          if (!authorized) {
+            const root = await rootSessionId(input.client, toolInput.sessionID, tokenOnly ? undefined : s.parentID);
+            if (root) {
+              const key = ocKey(root);
+              const eff = effectiveGate(key, { source: `opencode:${root}`, cmds: opencodeGogateCommands(root), opencode: true });
+              for (const r of eff.rejected) gateLog(key, `rejected: ${r}`);
+              if (eff.mode === 'soft' && grantsCover(cmd, eff.grants)) { // `off` is never honoured on OpenCode
+                gateLog(key, `grant: allowed ${JSON.stringify(cmd.slice(0, 200))}`);
+                authorized = true;
+              }
+            }
+          }
+
           if (!authorized) {
             authorized = tokenGrantsGo(await ownSessionName(input.client, toolInput.sessionID)).ok;
           }

package/README.md

@@ -110,14 +110,15 @@ What the installer writes for each target. Paths are the defaults; the installer
 | Harness | Skills | Subagents | Hooks | Plugin / rules |
 |---|---|---|---|---|
 | Claude Code / Claude Desktop | `~/.claude/skills` | `~/.claude/agents` | `~/.claude/hooks` + `settings.json` (GO gate, graph gate, env-file protection, Conventional Commits, memB inject, trail relay) | `.claude-plugin/` manifest ships in the repo (see Contributing) |
-| Google Antigravity | `~/.gemini/config/skills` | `~/.gemini/config/agents` | `~/.gemini/config/hooks.json` and `~/.gemini/antigravity-cli/hooks.json` | — |
-| Codex CLI | `~/.codex/skills` | `~/.codex/agents` | `~/.codex/hooks` + `config.toml` | `.codex-plugin/` |
-| OpenCode | `~/.config/opencode/skills` | `~/.opencode/agents` | via plugin | `bdb-aos.js` plugin + `/startcycle-graph` command, registered in `opencode.jsonc`; keeps a `/startcycle-graph` run moving on `session.idle` |
+| Google Antigravity | `~/.gemini/config/skills` | `~/.gemini/config/agents` | `~/.gemini/config/hooks.json` and `~/.gemini/antigravity-cli/hooks.json` | root `plugin.json` / `plugins/bdb-aos/plugin.json`, commands `/bdb-aos:<cmd>`, see [docs/codex-agy-setup.md](docs/codex-agy-setup.md) |
+| Codex CLI | `~/.codex/skills` | `~/.codex/agents` | `~/.codex/hooks` + `config.toml` | `.codex-plugin/` + `.agents/plugins/marketplace.json`, commands `$bdb-aos:<cmd>`, see [docs/codex-agy-setup.md](docs/codex-agy-setup.md) |
+| OpenCode | `~/.config/opencode/skills` | `~/.opencode/agents` | via plugin | `bdb-aos.js` plugin + `/startcycle-graph` command, registered in `opencode.jsonc`; keeps a `/startcycle-graph` run moving on `session.idle`; generated `/bdb-aos-<cmd>` commands; opt-in extras, see [docs/opencode-setup.md](docs/opencode-setup.md) |
 | Cursor | `~/.cursor/skills` | — | — | `.cursor/rules` (project) |
 | Windsurf | `~/.windsurf/bdb-skills` | — | — | `mcp.json` |
 | 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.
 
@@ -431,7 +432,7 @@ aos-uninstall --purge      # also removes ~/.MemBDB, ~/.openwiki, ~/.synapse, ~/
 aos-uninstall --dry-run    # list everything, delete nothing
 ```
 
-The uninstaller works from the install manifest: a file that still matches the hash AOS wrote is removed, a file you edited is backed up instead, a file AOS never wrote is not touched. The same action is in the installer menu.
+The uninstaller works from the install manifest: a file that still matches the hash AOS wrote is removed, a file you edited is backed up instead, a file AOS never wrote is not touched. The same action is in the installer menu. `aos-uninstall --restore-plugin-backup` restores the loose skill copies the installer removed when it registered the plugin; see [docs/plugin-migration.md](docs/plugin-migration.md).
 
 ---