@hybridlabor-api/aos 4.7.0 → 4.7.2

package/mcps/mcsc/packages/core/src/adapters/codex.js

@@ -1,56 +1,179 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
+import { spawn } from 'node:child_process';
 import { emitTrail } from '../trail.js';
 
-const execFileAsync = promisify(execFile);
+const MAX_OUTPUT = 1024 * 1024 * 50; // 50MB, mirrors the old execFile maxBuffer
 
 /**
  * Adapter für die Codex CLI.
  * Implementiert die DelegationRequest Schnittstelle.
- * @param {import('./types.js').DelegationRequest} req 
+ *
+ * Uses `codex exec --json` (confirmed present: `codex exec --help` lists
+ * `--json  Print events to stdout as JSONL`) instead of a blind exec, so a
+ * delegated Codex run gets the same mid-run tool-call visibility on
+ * agenttrail's board as the opencode adapter already has. The envelope shape
+ * below (`thread.started` / `turn.started` / `item.completed` / `turn.failed`,
+ * `item.completed` items carrying `{id, type, ...}`) was confirmed live
+ * against the installed CLI (codex-cli 0.154.0). The exact `item.type` string
+ * for a real tool call (e.g. shell exec, patch apply, the plan/todo tool)
+ * was NOT confirmed live — every probe run in this environment hit a 401
+ * auth error before Codex executed anything. `buildToolInput` below is
+ * therefore deliberately generic/defensive rather than keyed to guessed
+ * field names, and Codex's plan/todo tool is not mapped into a
+ * `PostToolUse` with `tool_name: 'update_plan'` here — doing that from
+ * unverified field names would silently ship a wrong mapping. Re-verify
+ * with authenticated Codex and tighten this once the real item shape for a
+ * tool call (and for its plan/todo tool specifically) is known.
+ *
+ * @param {import('./types.js').DelegationRequest} req
  * @returns {Promise<{ exit: number; output: string }>}
  */
 export async function delegate(req) {
+  const cwd = req.cwd || process.cwd();
   const trailEvent = {
     session_id: `mcsc-codex-${process.pid}-${Date.now()}`,
-    cwd: req.cwd || process.cwd(),
+    cwd,
     agent:
       typeof req.label === 'string' && req.label.length > 0
         ? `codex:${req.label}`
         : 'codex',
   };
   emitTrail({ ...trailEvent, hook_event_name: 'SessionStart' });
-  try {
-    const args = ['exec'];
-    if (req.model) args.push('-m', req.model);
-    args.push(req.prompt);
-
-    // Recursion Guard
-    const env = { ...process.env, MCSC_CALLER: 'codex' };
-
-    const run = execFileAsync(
-      'codex', args,
-      {
-        cwd: req.cwd,
-        encoding: 'utf-8',
-        maxBuffer: 1024 * 1024 * 50, // 50MB Limit
-        env,
-        signal: req.signal
-      }
-    );
-    // An open stdin pipe makes the CLI wait for input forever.
-    run.child.stdin.end();
-    const { stdout, stderr } = await run;
-    
-    emitTrail({ ...trailEvent, hook_event_name: 'SessionEnd' });
-    return { exit: 0, output: stdout || stderr };
-  } catch (e) {
-    emitTrail({ ...trailEvent, hook_event_name: 'SessionEnd' });
-    if (e.name === 'AbortError') {
-      emitTrail({ ...trailEvent, hook_event_name: 'SessionEnd' });
-      return { exit: 1, output: 'Cancelled by orchestrator' };
+
+  const env = { ...process.env, MCSC_CALLER: 'codex' };
+  const args = ['exec', '--json', '--skip-git-repo-check'];
+  if (req.model) args.push('-m', req.model);
+  args.push(req.prompt);
+
+  const child = spawn('codex', args, {
+    cwd,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  return new Promise((resolve) => {
+    let lastAgentMessage = '';
+    let stdoutBuf = '';
+    let stderrBuf = '';
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let overflowed = false;
+    let aborted = false;
+    let settled = false;
+    let turnFailed = false;
+
+    const onAbort = () => {
+      aborted = true;
+      child.kill('SIGKILL');
+    };
+    if (req.signal) {
+      if (req.signal.aborted) onAbort();
+      else req.signal.addEventListener('abort', onAbort, { once: true });
     }
-    emitTrail({ ...trailEvent, hook_event_name: 'SessionEnd' });
-    return { exit: 1, output: (e.stderr || e.message || '').trim() };
-  }
+
+    const finalize = (result) => {
+      if (settled) return;
+      settled = true;
+      if (req.signal) req.signal.removeEventListener('abort', onAbort);
+      emitTrail({ ...trailEvent, hook_event_name: 'SessionEnd' });
+      resolve(result);
+    };
+
+    // Defensive/generic: no confirmed field names for a real tool-call item
+    // (see the doc comment above), so this only forwards what's plausibly
+    // present rather than asserting a specific Codex item shape.
+    const buildToolInput = (item) => {
+      const toolInput = {};
+      if (!item || typeof item !== 'object') return toolInput;
+      const rawCommand = item.command || item.cmd;
+      if (typeof rawCommand === 'string' && rawCommand.length > 0) toolInput.command = rawCommand;
+      else if (Array.isArray(rawCommand)) toolInput.command = rawCommand.join(' ');
+      const rawPath = item.file_path || item.path;
+      if (typeof rawPath === 'string' && rawPath.length > 0) toolInput.file_path = rawPath;
+      return toolInput;
+    };
+
+    const handleLine = (line) => {
+      if (!line) return;
+      let evt;
+      try {
+        evt = JSON.parse(line);
+      } catch {
+        return; // Not valid JSON — ignore.
+      }
+      if (!evt || typeof evt !== 'object') return;
+
+      if (evt.type === 'turn.completed' && typeof evt.last_agent_message === 'string') {
+        lastAgentMessage = evt.last_agent_message;
+        return;
+      }
+      if (evt.type === 'turn.failed') {
+        turnFailed = true;
+        return;
+      }
+      if (evt.type === 'item.completed' && evt.item && typeof evt.item === 'object') {
+        const itemType = evt.item.type;
+        // Informational item types carry no tool call — skip them so the
+        // board doesn't show a fake "tool" for plain error/text output.
+        if (itemType === 'error' || itemType === 'reasoning' || itemType === 'agent_message') return;
+        emitTrail({
+          ...trailEvent,
+          hook_event_name: 'PostToolUse',
+          tool_name: String(itemType || 'codex_item')
+            .replace(/(^|_)([a-z])/g, (_, sep, c) => c.toUpperCase()),
+          tool_input: buildToolInput(evt.item),
+        });
+      }
+    };
+
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      stdoutBytes += Buffer.byteLength(chunk);
+      if (stdoutBytes > MAX_OUTPUT) {
+        if (!overflowed) {
+          overflowed = true;
+          child.kill('SIGKILL');
+        }
+        return;
+      }
+      stdoutBuf += chunk;
+      let idx;
+      while ((idx = stdoutBuf.indexOf('\n')) !== -1) {
+        const line = stdoutBuf.slice(0, idx).trim();
+        stdoutBuf = stdoutBuf.slice(idx + 1);
+        handleLine(line);
+      }
+    });
+
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+      stderrBytes += Buffer.byteLength(chunk);
+      if (stderrBytes > MAX_OUTPUT) return; // cap stderr, never fail on it
+      stderrBuf += chunk;
+    });
+
+    child.on('error', (err) => {
+      finalize({ exit: 1, output: (stderrBuf || err.message || '').trim() });
+    });
+
+    child.on('close', (code) => {
+      const rest = stdoutBuf.trim();
+      if (rest) handleLine(rest); // flush a trailing line without newline
+      if (aborted) {
+        finalize({ exit: 1, output: 'Cancelled by orchestrator' });
+        return;
+      }
+      if (overflowed) {
+        finalize({ exit: 1, output: 'stdout maxBuffer length exceeded' });
+        return;
+      }
+      if (code === 0 && !turnFailed) {
+        finalize({ exit: 0, output: lastAgentMessage || stderrBuf });
+        return;
+      }
+      finalize({ exit: 1, output: (lastAgentMessage || stderrBuf || `codex exited with code ${code}`).trim() });
+    });
+
+    // An open stdin pipe makes the CLI wait for input forever.
+    child.stdin.end();
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hybridlabor-api/aos",
-  "version": "4.7.0",
+  "version": "4.7.2",
   "description": "AOS — A Curated AI AGENT OS. Optimized agent skills and add-ons like memB, OpenWiki, Heimdall Token Saver, and Godmode architectures.",
   "main": "installer.js",
   "engines": {
@@ -16,12 +16,16 @@
     "aos-archify": "skills/global_config/archify/bin/archify.mjs",
     "aos-dashboard": "bin/aos-dashboard.mjs",
     "aos-config": "bin/aos-config.mjs",
+    "aos-store": "bin/aos-store.mjs",
+    "aos-doctor": "bin/aos-doctor.mjs",
     "aos-uninstall": "bin/aos-uninstall.mjs"
   },
   "scripts": {
     "validate": "node scripts/validate-skills.mjs",
     "validate:strict": "node scripts/validate-skills.mjs --strict",
-    "test": "node scripts/validate-skills.mjs --selftest && node scripts/validate-skills.mjs"
+    "store:index": "node scripts/build-ecc-store-index.mjs",
+    "doctor": "node bin/aos-doctor.mjs",
+    "test": "node scripts/validate-skills.mjs --selftest && node scripts/validate-skills.mjs && node tests/aos-store.test.mjs && node tests/aos-doctor.test.mjs"
   },
   "publishConfig": {
     "access": "public"
@@ -48,6 +52,7 @@
     ".codex-plugin/",
     ".opencode/",
     "docs/",
+    "!docs/handover/**",
     "assets/",
     "skills/",
     "mcps/",

package/scripts/build-ecc-store-index.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const MANIFEST_PATH = join(ROOT, '.agents', 'vendor-manifest.json');
+const OUTPUT_PATH = join(ROOT, 'lib', 'ecc-store-index.json');
+const manifest = JSON.parse(readFileSync(MANIFEST_PATH, 'utf8'));
+const entry = manifest.vendors?.['ecc-store'];
+if (!entry?.pinned_commit || !/^[a-f0-9]{40}$/.test(entry.pinned_commit)) {
+  throw new Error('Missing or invalid .agents/vendor-manifest.json ECC store pin');
+}
+
+const checkout = mkdtempSync(join(tmpdir(), 'aos-ecc-store-'));
+
+function runGit(args) {
+  return execFileSync('git', args, { cwd: checkout, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+}
+
+function walk(dir, output = []) {
+  if (!existsSync(dir)) return output;
+  for (const item of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, item.name);
+    if (item.isDirectory()) walk(fullPath, output);
+    else if (item.isFile()) output.push(fullPath);
+  }
+  return output;
+}
+
+function frontmatterValue(text, key) {
+  const match = text.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return '';
+  const lines = match[1].split(/\r?\n/);
+  const start = lines.findIndex((line) => new RegExp(`^${key}:`, 'i').test(line));
+  if (start < 0) return '';
+  const first = lines[start].slice(lines[start].indexOf(':') + 1).trim();
+  if (first && !/^[>|][-+]?$/.test(first)) return first.replace(/^['"]|['"]$/g, '');
+  const values = [];
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line && !/^\s/.test(line)) break;
+    values.push(line.trim());
+  }
+  return values.join(' ').trim();
+}
+
+function categoryFor(name) {
+  const value = name.toLowerCase();
+  if (/(media|video|motion|3d|blender|manim|creative|remotion|comfy)/.test(value)) return 'media-eventtech';
+  if (/(design|frontend|react|vue|angular|next|tailwind|ui-|uiux|brand)/.test(value) || /(^|-)ui($|-)/.test(value)) return 'design-ui-ux';
+  if (/(agent|pipeline|orchestr|autonom|benchmark|eval|security|skill|workflow)/.test(value)) return 'bdb-core';
+  if (/(hardware|pcb|circuit|electronic)/.test(value)) return 'engineering-hardware';
+  if (/(engineering|architecture|database|api|devops|docker|kubernetes|python|pytorch|typescript|rust|golang|java|spring|django|fastapi|react|test|build|resolver|reviewer|performance)/.test(value)) return 'engineering-method';
+  return 'library';
+}
+
+function compatibilityWarnings(text) {
+  const warnings = [];
+  if (/\bBash\b/.test(text)) warnings.push('mentions Bash');
+  if (/\bView\b/.test(text)) warnings.push('mentions View');
+  return warnings;
+}
+
+function localNames() {
+  const names = new Set();
+  for (const file of walk(join(ROOT, 'skills'))) {
+    if (basename(file) === 'SKILL.md') {
+      const text = readFileSync(file, 'utf8');
+      names.add((frontmatterValue(text, 'name') || basename(dirname(file))).trim().toLowerCase());
+    }
+  }
+  for (const root of [join(ROOT, '.claude', 'agents'), join(ROOT, '.agents', 'agents'), join(ROOT, 'agents')]) {
+    if (!existsSync(root)) continue;
+    for (const name of readdirSync(root)) names.add(name.replace(/\.md$/i, '').toLowerCase());
+  }
+  return names;
+}
+
+function hash(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+function itemFromFile(file, type) {
+  const content = readFileSync(file, 'utf8');
+  const name = type === 'skills'
+    ? (frontmatterValue(content, 'name') || basename(dirname(file))).trim()
+    : basename(file, '.md');
+  if (!/^[A-Za-z0-9_-]+$/.test(name)) throw new Error(`Invalid store name: ${name}`);
+  const description = (frontmatterValue(content, 'description') || type).replace(/\s+/g, ' ').trim();
+  const shortDescription = description.length > 32 ? `${description.slice(0, 31)}…` : description;
+  const base = {
+    description: shortDescription,
+    category: categoryFor(name),
+    tier: 'free',
+    origin: 'ecc',
+    requires_auth: false,
+    sha256: hash(content),
+    upstream_path: relative(checkout, file).split(sep).join('/'),
+  };
+  return { name, item: base, warnings: compatibilityWarnings(content) };
+}
+
+try {
+  runGit(['init', '--quiet']);
+  runGit(['remote', 'add', 'origin', entry.upstream]);
+  runGit(['fetch', '--quiet', '--depth=1', 'origin', entry.pinned_commit]);
+  runGit(['checkout', '--quiet', '--detach', 'FETCH_HEAD']);
+  const generatedAt = runGit(['show', '-s', '--format=%cI', 'FETCH_HEAD']);
+  const coreNames = localNames();
+  const skills = {};
+  const subagents = {};
+  let compatibilityWarningCount = 0;
+  const skillFiles = walk(join(checkout, 'skills')).filter((file) => basename(file) === 'SKILL.md');
+  const agentFiles = walk(join(checkout, 'agents')).filter((file) => file.endsWith('.md'));
+  for (const file of skillFiles) {
+    const { name, item, warnings } = itemFromFile(file, 'skills');
+    compatibilityWarningCount += warnings.length;
+    if (coreNames.has(name.toLowerCase())) continue;
+    skills[name] = item;
+  }
+  for (const file of agentFiles) {
+    const { name, item, warnings } = itemFromFile(file, 'subagents');
+    compatibilityWarningCount += warnings.length;
+    if (coreNames.has(name.toLowerCase())) continue;
+    subagents[name] = item;
+  }
+  const index = {
+    version: '1.0.0',
+    generated_at: generatedAt,
+    pinned_commit: entry.pinned_commit,
+    harness_support: ['claude', 'antigravity', 'codex', 'cursor', 'roo'],
+    compatibility_warning_count: compatibilityWarningCount,
+    skills: Object.fromEntries(Object.entries(skills).sort(([a], [b]) => a.localeCompare(b))),
+    subagents: Object.fromEntries(Object.entries(subagents).sort(([a], [b]) => a.localeCompare(b))),
+  };
+  const output = JSON.stringify(index) + '\n';
+  if (Buffer.byteLength(output) >= 100 * 1024) throw new Error(`Store index exceeds 100 KB: ${Buffer.byteLength(output)} bytes`);
+  writeFileSync(OUTPUT_PATH, output);
+  console.log(`Wrote ${OUTPUT_PATH} with ${Object.keys(skills).length} skills and ${Object.keys(subagents).length} subagents (${Buffer.byteLength(output)} bytes).`);
+} finally {
+  rmSync(checkout, { recursive: true, force: true });
+}

package/skills/basic/startcycle-graph/SKILL.md

@@ -118,6 +118,19 @@ the status-mark rules from the `agenttrail` skill: `[~]` before starting,
 `[x]` when done, `[!]` when stuck, with `by: <agent>`, saving the plan file
 immediately.
 
+## Architecture diagram (Archify, native)
+
+Architect authors `production_artifacts/00_architecture.json` (editable truth)
+and delivers `production_artifacts/00_architecture.html` (read-only) via
+`aos-archify validate` / `aos-archify deliver` with `--quality showcase --json`
+at the Architect→TechLead boundary; only a passing showcase receipt (9/9
+checks, 0 errors) sets `state.artifacts.architecture`, and a failed
+validate/deliver preserves the previous HTML and escalates instead of
+proceeding silently. The plan links the diagram with a
+`url: production_artifacts/00_architecture.html` line so the live map opens it
+from the card. Review the HTML in plan-canvas alongside the plan:
+`aos-plan-canvas open production_artifacts/00_architecture.html`.
+
 ## Why this file is a thin router, not a spec
 
 The full contract — state schema, node/edge table, the Stop-hook