@hybridlabor-api/aos 4.5.1 → 4.6.0

package/installer.js

@@ -2919,17 +2919,83 @@ function yamlQuote(str) {
     return `"${str.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, ' ')}"`;
 }
 
+// Canonical model tiers mapped to verified provider-specific model IDs for each harness.
+// Protects against vendor model churn and provides seamless cross-harness defaults.
+const CANONICAL_TIERS = {
+    reasoning_max: {
+        claude: 'opus',
+        antigravity: 'gemini-3.1-pro-high',
+        opencode: 'opencode/muse-spark-1.3-contributor-free',
+        codex: 'o3-mini'
+    },
+    standard_fast: {
+        claude: 'sonnet',
+        antigravity: 'gemini-3.8-flash-high',
+        opencode: 'opencode/muse-spark-1.3-contributor-free',
+        codex: 'gpt-4o'
+    },
+    trivial_low: {
+        claude: 'haiku',
+        antigravity: 'gemini-3.8-flash-low',
+        opencode: 'opencode/muse-spark-1.3-contributor-free',
+        codex: 'gpt-4o-mini'
+    }
+};
+
+// Loads .aos/pipeline.json or .aos/project.json containing role-to-model/harness mappings.
+function loadPipelineConfig(projectDir = currentDir) {
+    const candidates = [
+        path.join(projectDir, '.aos', 'pipeline.json'),
+        path.join(projectDir, '.aos', 'project.json'),
+        path.join(homeDir, '.aos', 'pipeline.json')
+    ];
+    for (const p of candidates) {
+        if (fs.existsSync(p)) {
+            try {
+                const data = JSON.parse(fs.readFileSync(p, 'utf8'));
+                if (data && data.pipeline) return data.pipeline;
+            } catch {}
+        }
+    }
+    return null;
+}
+
+// Resolves model ID, tier, and enabled status for a given agent role and target harness.
+function resolveAgentConfig(agentSlug, harness, pipelineConfig = null) {
+    const normSlug = agentSlug.toLowerCase().replace(/-/g, '_');
+    const roleCfg = pipelineConfig ? (pipelineConfig[normSlug] || pipelineConfig[agentSlug]) : null;
+    if (roleCfg) {
+        if (roleCfg.model) {
+            return {
+                model: roleCfg.model,
+                tier: roleCfg.tier || 'custom',
+                enabled: roleCfg.enabled !== false,
+                harness: roleCfg.harness || harness
+            };
+        }
+        if (roleCfg.tier && CANONICAL_TIERS[roleCfg.tier] && CANONICAL_TIERS[roleCfg.tier][harness]) {
+            return {
+                model: CANONICAL_TIERS[roleCfg.tier][harness],
+                tier: roleCfg.tier,
+                enabled: roleCfg.enabled !== false,
+                harness: roleCfg.harness || harness
+            };
+        }
+    }
+    const defaultTier = (normSlug === 'architect' || normSlug === 'reviewer') ? 'reasoning_max' : 'standard_fast';
+    const fallbackModel = (CANONICAL_TIERS[defaultTier] && CANONICAL_TIERS[defaultTier][harness]) || 'inherit';
+    return { model: fallbackModel, tier: defaultTier, enabled: true, harness };
+}
+
 // Generates .claude/agents/<name>.md — Claude Code's native subagent format.
 // Only frontmatter fields confirmed against code.claude.com/docs/en/sub-agents
-// are emitted (name, description, model). `tools:`/`permission`-style
-// allowlists are deliberately omitted rather than guessed from the MCP-server
-// list -- an unverified mapping there would silently over- or under-scope a
-// subagent's tool access, which is worse than inheriting the default set.
-function compileClaudeAgents(agents, targetDir) {
+// are emitted (name, description, model).
+function compileClaudeAgents(agents, targetDir, pipelineConfig = null) {
     fs.mkdirSync(targetDir, { recursive: true });
     for (const a of agents) {
         const slug = a.name.toLowerCase().replace(/_/g, '-');
-        const model = a.model ? a.model.toLowerCase() : 'inherit';
+        const resolved = resolveAgentConfig(slug, 'claude', pipelineConfig);
+        const model = (resolved && resolved.model) ? resolved.model.toLowerCase() : (a.model ? a.model.toLowerCase() : 'inherit');
         const body = [
             a.role,
             a.skills.length ? `**Primary skills:** ${a.skills.join(', ')}` : null,
@@ -2950,18 +3016,13 @@ function compileClaudeAgents(agents, targetDir) {
     }
 }
 
-// Generates .opencode/agents/<name>.md. Only `description` and `mode` are
-// emitted -- confirmed fields per opencode.ai/docs/agents. `model` and
-// `permission` are left unset: OpenCode's model-id format and its mapping
-// from an MCP-server list to `permission` keys are not verified against its
-// docs, so guessing either would risk emitting a value OpenCode silently
-// can't resolve. `mode: subagent` is used for every generated agent, since
-// none of these five is meant to be a primary/default agent a user talks to
-// directly.
-function compileOpenCodeAgents(agents, targetDir) {
+// Generates .opencode/agents/<name>.md. Emits description, mode: subagent, and model.
+function compileOpenCodeAgents(agents, targetDir, pipelineConfig = null) {
     fs.mkdirSync(targetDir, { recursive: true });
     for (const a of agents) {
         const slug = a.name.toLowerCase().replace(/_/g, '-');
+        const resolved = resolveAgentConfig(slug, 'opencode', pipelineConfig);
+        const model = resolved && resolved.model ? resolved.model : null;
         const body = [
             a.role,
             a.skills.length ? `**Primary skills:** ${a.skills.join(', ')}` : null,
@@ -2969,18 +3030,54 @@ function compileOpenCodeAgents(agents, targetDir) {
             a.output ? `**Output artifact(s):** ${a.output}` : null,
         ].filter(Boolean).join('\n\n');
 
-        const frontmatter = [
+        const frontmatterLines = [
             '---',
             `description: ${yamlQuote(a.role)}`,
             'mode: subagent',
-            '---',
-            '',
+        ];
+        if (model) {
+            frontmatterLines.push(`model: ${model}`);
+        }
+        frontmatterLines.push('---', '');
+
+        fs.writeFileSync(path.join(targetDir, `${slug}.md`), frontmatterLines.join('\n') + body + '\n');
+    }
+}
+
+// Generates .codex/agents/<name>.toml and .codex/agents/<name>.md for ChatGPT Codex CLI.
+function compileCodexAgents(agents, targetDir, pipelineConfig = null) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    for (const a of agents) {
+        const slug = a.name.toLowerCase().replace(/_/g, '-');
+        const resolved = resolveAgentConfig(slug, 'codex', pipelineConfig);
+        const model = resolved && resolved.model ? resolved.model : 'o3-mini';
+
+        const tomlContent = [
+            `# Codex subagent configuration for ${slug}`,
+            `name = "${slug}"`,
+            `description = ${JSON.stringify(a.role)}`,
+            `model = "${model}"`,
+            `tier = "${resolved.tier || 'standard_fast'}"`,
+            `enabled = ${resolved.enabled !== false}`,
+            `prompt_file = "${slug}.md"`
         ].join('\n');
+        fs.writeFileSync(path.join(targetDir, `${slug}.toml`), tomlContent + '\n');
 
-        fs.writeFileSync(path.join(targetDir, `${slug}.md`), frontmatter + body + '\n');
+        const body = [
+            `# Role: ${a.name}`,
+            a.role,
+            a.skills.length ? `**Primary skills:** ${a.skills.join(', ')}` : null,
+            a.mcpServers.length ? `**MCP servers used:** ${a.mcpServers.join(', ')}` : null,
+            a.output ? `**Output artifact(s):** ${a.output}` : null,
+            '',
+            '## Instructions',
+            a.systemPrompt
+        ].filter(Boolean).join('\n\n');
+        fs.writeFileSync(path.join(targetDir, `${slug}.md`), body + '\n');
     }
 }
 
+
 function injectHarnessRules() {
     const geminiMdSrc = path.join(srcDir, 'GEMINI.md');
     const agentsMdSrc = path.join(srcDir, '.agents', 'agents.md');
@@ -3034,11 +3131,16 @@ function injectHarnessRules() {
                     const agyAgentsDir = path.join(geminiDir, 'config', 'agents');
                     if (!fs.existsSync(agyAgentsDir)) fs.mkdirSync(agyAgentsDir, { recursive: true });
 
+                    const pipelineConfig = loadPipelineConfig();
                     const agents = parseAgentsMd(agentsMdContent);
                     for (const a of agents) {
+                        const slug = a.name.toLowerCase().replace(/_/g, '-');
+                        const resolved = resolveAgentConfig(slug, 'antigravity', pipelineConfig);
                         const agentConfig = {
                             name: a.name,
                             description: a.role,
+                            model: resolved.model,
+                            model_tier: resolved.tier,
                             enable_write_tools: true,
                             enable_subagent_tools: true,
                             enable_mcp_tools: true,
@@ -3053,22 +3155,34 @@ function injectHarnessRules() {
 
             installStep('compile Claude Code subagents', () => {
                 if (agentsMdContent) {
+                    const pipelineConfig = loadPipelineConfig();
                     const agents = parseAgentsMd(agentsMdContent);
                     const claudeAgentsDir = path.join(homeDir, '.claude', 'agents');
-                    compileClaudeAgents(agents, claudeAgentsDir);
+                    compileClaudeAgents(agents, claudeAgentsDir, pipelineConfig);
                     log.step(`Compiled AGENTS.md to Claude Code subagents in ${claudeAgentsDir}`);
                 }
             }, 'Claude Code agents unchanged');
 
             installStep('compile OpenCode subagents', () => {
                 if (agentsMdContent) {
+                    const pipelineConfig = loadPipelineConfig();
                     const agents = parseAgentsMd(agentsMdContent);
                     const opencodeAgentsDir = path.join(homeDir, '.opencode', 'agents');
-                    compileOpenCodeAgents(agents, opencodeAgentsDir);
+                    compileOpenCodeAgents(agents, opencodeAgentsDir, pipelineConfig);
                     log.step(`Compiled AGENTS.md to OpenCode subagents in ${opencodeAgentsDir}`);
                 }
             }, 'OpenCode agents unchanged');
 
+            installStep('compile Codex subagents', () => {
+                if (agentsMdContent) {
+                    const pipelineConfig = loadPipelineConfig();
+                    const agents = parseAgentsMd(agentsMdContent);
+                    const codexAgentsDir = path.join(homeDir, '.codex', 'agents');
+                    compileCodexAgents(agents, codexAgentsDir, pipelineConfig);
+                    log.step(`Compiled AGENTS.md to Codex subagents in ${codexAgentsDir}`);
+                }
+            }, 'Codex agents unchanged');
+
             const claudeMdPath = path.join(currentDir, 'CLAUDE.md');
             installStep(`sync ${claudeMdPath}`, () => {
                 let claudeContent = fs.existsSync(claudeMdPath) ? fs.readFileSync(claudeMdPath, 'utf8') : '';
@@ -3213,6 +3327,24 @@ function installGlobalHooks() {
         copyDirRecursiveSync(workflowsSrc, codexWorkflowsDir);
     }
     mergeCodexTomlHooks(path.join(homeDir, '.codex', 'config.toml'));
+
+    // 4. OpenCode CLI
+    const opencodeDir = process.platform === 'win32'
+        ? path.join(process.env.APPDATA || homeDir, 'opencode')
+        : path.join(homeDir, '.config', 'opencode');
+    const opencodePluginSrc = path.join(srcDir, '.opencode', 'plugins', 'bdb-aos.js');
+    if (fs.existsSync(opencodePluginSrc)) {
+        const opencodePluginsDir = path.join(opencodeDir, 'plugins');
+        const opencodePluginDest = path.join(opencodePluginsDir, 'bdb-aos.js');
+        try {
+            fs.mkdirSync(opencodePluginsDir, { recursive: true });
+            fs.copyFileSync(opencodePluginSrc, opencodePluginDest);
+            try { fs.chmodSync(opencodePluginDest, 0o644); } catch (e) { logDebug(e, 'chmod opencode plugin'); }
+            log.step(`Installed OpenCode plugin to ${opencodePluginDest}`);
+        } catch (e) {
+            log.warn(`Could not install OpenCode plugin: ${e.message}`);
+        }
+    }
 }
 
 // Merge the BDB hooks -- the two gates plus the memB ambient-memory hook --
@@ -3495,10 +3627,20 @@ function installProjectHarness() {
     }, 'go-gate / graph-gate enforcement stays inactive in this project.');
 
     installStep('copy agent definitions into project', () => {
-        const agentsSrc = path.join(srcDir, '.claude', 'agents');
-        if (fs.existsSync(agentsSrc)) {
-            copyDirRecursiveSync(agentsSrc, path.join(projectClaudeDir, 'agents'));
-            log.step(`Copied agent definitions to ${path.join(projectClaudeDir, 'agents')}`);
+        const agentsMdSrc = path.join(srcDir, '.agents', 'agents.md');
+        const pipelineConfig = loadPipelineConfig(currentDir);
+        if (fs.existsSync(agentsMdSrc)) {
+            const agents = parseAgentsMd(fs.readFileSync(agentsMdSrc, 'utf8'));
+            compileClaudeAgents(agents, path.join(projectClaudeDir, 'agents'), pipelineConfig);
+            compileOpenCodeAgents(agents, path.join(currentDir, '.opencode', 'agents'), pipelineConfig);
+            compileCodexAgents(agents, path.join(projectCodexDir, 'agents'), pipelineConfig);
+            log.step(`Compiled project agent definitions for Claude, OpenCode, and Codex`);
+        } else {
+            const agentsSrc = path.join(srcDir, '.claude', 'agents');
+            if (fs.existsSync(agentsSrc)) {
+                copyDirRecursiveSync(agentsSrc, path.join(projectClaudeDir, 'agents'));
+                log.step(`Copied agent definitions to ${path.join(projectClaudeDir, 'agents')}`);
+            }
         }
     }, 'The dispatcher runs, but its agent-file pointers resolve to nothing.');
 
@@ -4022,17 +4164,98 @@ async function universalHarnessSync(primaryMcpConfigPath) {
             const existing = readJsoncFile(targetPath);
             const data = existing && existing.mcp ? existing : Object.assign({}, existing || {}, { mcp: {} });
             if (masterMcpData.mcpServers) {
+                // OpenCode provider APIs (e.g. OpenAI-compatible, Console) enforce tool name length limits
+                // (e.g. max 64 chars) and context limits. Loading 20+ MCPs causes provider errors (e.g. 73-char tool names).
+                // OpenCode uses a slim profile: only core servers (memb_mcp, zavora_computer_use) are enabled by default.
+                const OPENCODE_DEFAULT_SLIM = new Set(['memb_mcp', 'zavora_computer_use']);
+                const existingMcp = existing && existing.mcp ? existing.mcp : {};
+                const hasExistingKeys = Object.keys(existingMcp).length > 0;
+
                 for (const [key, val] of Object.entries(masterMcpData.mcpServers)) {
-                    const cmd = Array.isArray(val.command) ? val.command : [val.command];
-                    const args = Array.isArray(val.args) ? val.args : [];
+                    const rawCmd = Array.isArray(val.command) ? val.command : [val.command];
+                    const rawArgs = Array.isArray(val.args) ? val.args : [];
+                    const fullCmd = [...rawCmd, ...rawArgs].map(c => {
+                        if (c === '__PYTHON_BIN__') {
+                            return process.platform === 'win32'
+                                ? path.join(homeDir, '.gemini', 'config', 'mcps', 'memb-mcp', '.venv', 'Scripts', 'python.exe')
+                                : path.join(homeDir, '.gemini', 'config', 'mcps', 'memb-mcp', '.venv', 'bin', 'python');
+                        }
+                        return c;
+                    });
+
+                    const existingEntry = existingMcp[key];
+
+                    // If existing config is intentionally slimmed (has keys, but omitted this one), don't resurrect unless in slim set
+                    if (hasExistingKeys && !existingEntry && !OPENCODE_DEFAULT_SLIM.has(key)) {
+                        continue;
+                    }
+
+                    // Preserve user's explicit enabled/disabled setting; otherwise default to true only for slim set
+                    const isEnabled = existingEntry && typeof existingEntry.enabled === 'boolean'
+                        ? existingEntry.enabled
+                        : OPENCODE_DEFAULT_SLIM.has(key);
+
+                    let envObj = val.environment || val.env;
+                    if (envObj) {
+                        envObj = Object.assign({}, envObj);
+                        for (const [eKey, eVal] of Object.entries(envObj)) {
+                            if (eVal === '__GEMINI_API_KEY__') {
+                                envObj[eKey] = '${GEMINI_API_KEY}';
+                            }
+                        }
+                    }
+
                     data.mcp[key] = {
                         type: "local",
-                        command: [...cmd, ...args],
-                        enabled: true,
-                        ...(val.environment || val.env ? { environment: val.environment || val.env } : {})
+                        command: fullCmd,
+                        enabled: isEnabled,
+                        ...(envObj ? { environment: envObj } : {})
                     };
                 }
             }
+
+            // Wire BDB AOS Plugin for OpenCode
+            const opencodeDir = path.dirname(targetPath);
+            const pluginsDir = path.join(opencodeDir, 'plugins');
+            const pluginFile = path.join(pluginsDir, 'bdb-aos.js');
+            const pluginSrc = path.join(srcDir, '.opencode', 'plugins', 'bdb-aos.js');
+
+            try {
+                if (fs.existsSync(pluginSrc)) {
+                    fs.mkdirSync(pluginsDir, { recursive: true });
+                    fs.copyFileSync(pluginSrc, pluginFile);
+                    try { fs.chmodSync(pluginFile, 0o644); } catch (e) { logDebug(e, 'chmod pluginFile'); }
+                }
+            } catch (pluginErr) {
+                log.warn(`Could not install OpenCode plugin: ${pluginErr.message}`);
+            }
+
+            // Register plugin in opencode.jsonc if plugin file exists
+            if (fs.existsSync(pluginFile)) {
+                if (!Array.isArray(data.plugin)) {
+                    data.plugin = [];
+                }
+                const pluginPathNormalized = pluginFile.replace(/\\/g, '/');
+                const alreadyRegistered = data.plugin.some(p => {
+                    const str = typeof p === 'string' ? p : (Array.isArray(p) ? p[0] : '');
+                    return str.includes('bdb-aos');
+                });
+                if (!alreadyRegistered) {
+                    data.plugin.push(pluginPathNormalized);
+                }
+            }
+
+            // Register skills paths for OpenCode
+            if (!data.skills || typeof data.skills !== 'object') {
+                data.skills = { paths: [".agents/skills"] };
+            } else if (Array.isArray(data.skills.paths)) {
+                if (!data.skills.paths.includes(".agents/skills")) {
+                    data.skills.paths.push(".agents/skills");
+                }
+            } else {
+                data.skills.paths = [".agents/skills"];
+            }
+
             fs.mkdirSync(path.dirname(targetPath), { recursive: true });
             fs.writeFileSync(targetPath, JSON.stringify(data, null, 2), { mode: 0o600 });
             try { fs.chmodSync(targetPath, 0o600); } catch (e) { logDebug(e, 'chmod targetPath'); }
@@ -4616,4 +4839,12 @@ module.exports = {
     flushSessionManifest,
     copyDirRecursiveSync,
     INSTALL_MANIFEST_PATH,
+    // Agent compilers & pipeline helpers
+    parseAgentsMd,
+    compileClaudeAgents,
+    compileOpenCodeAgents,
+    compileCodexAgents,
+    loadPipelineConfig,
+    resolveAgentConfig,
+    CANONICAL_TIERS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hybridlabor-api/aos",
-  "version": "4.5.1",
+  "version": "4.6.0",
   "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": {

package/skills/global_config/aos-project-init/SKILL.md

@@ -77,6 +77,8 @@ your head. Ask; do not default it on.
 holds content, merge it into `AGENTS.md` first and only then replace it with a
 symlink. Never silently overwrite it.
 
+**Subagents & Multi-Harness Pipeline.** Offer to initialize `.aos/pipeline.json` using canonical tiers (or custom roles via `/subagent-setup`). Ensures subagents are automatically compiled across Claude Code, Antigravity, OpenCode, and Codex CLI.
+
 **With a GitHub remote, two more.** Skip both entirely without a remote — a
 local-only repo has nowhere to put them, and a skipped question is clearer than
 one answered "no".

package/skills/global_config/subagent-setup/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: subagent-setup
+description: Configure and synchronize multi-harness subagents (Claude Code, Google Antigravity, OpenCode, ChatGPT Codex CLI) with canonical model tiers and single source of truth in .aos/pipeline.json.
+category: bdb-core
+risk: low
+source: bdb
+date_added: "2026-09-20"
+---
+
+# Skill: subagent-setup — Multi-Harness Subagent Configuration
+
+Manages and synchronizes autonomous subagent roles across all four supported execution harnesses:
+1. **Claude Code** (`.claude/agents/*.md`)
+2. **Google Antigravity** (`~/.gemini/config/agents/*.json`)
+3. **OpenCode** (`.opencode/agents/*.md`)
+4. **ChatGPT Codex CLI** (`.codex/agents/*.toml` & `.codex/agents/*.md`)
+
+Single Source of Truth: **`.aos/pipeline.json`** (compatible with AO Orchestrator Pipeline Wizard).
+
+---
+
+## 1. Canonical Model Tiers (Resilience against Model Churn)
+
+To prevent breaking configurations when providers update model names, roles map to canonical tiers:
+
+| Tier | Description | Claude Code | Antigravity | OpenCode | Codex CLI |
+|---|---|---|---|---|---|
+| `reasoning_max` | Deep reasoning, planning, adversarial review | `opus` | `gemini-3.1-pro-high` | `opencode/muse-spark-1.3-contributor-free` | `o3-mini` |
+| `standard_fast` | Fast coding, frontend/backend engineering | `sonnet` | `gemini-3.8-flash-high` | `opencode/muse-spark-1.3-contributor-free` | `gpt-4o` |
+| `trivial_low` | Mechanical tasks, summaries | `haiku` | `gemini-3.8-flash-low` | `opencode/muse-spark-1.3-contributor-free` | `gpt-4o-mini` |
+
+*Note:* Custom model IDs can also be set directly per role and harness.
+
+---
+
+## 2. CLI Usage
+
+### View Current Pipeline Status
+```bash
+node skills/global_config/subagent-setup/scripts/setup-subagents.mjs --show
+```
+
+### Initialize Default Pipeline Configuration
+```bash
+node skills/global_config/subagent-setup/scripts/setup-subagents.mjs --init-default
+```
+
+### Update a Specific Role
+```bash
+# Example: Set Reviewer to Codex with o3-mini
+node skills/global_config/subagent-setup/scripts/setup-subagents.mjs \
+  --set-role reviewer --harness codex --model o3-mini --tier reasoning_max
+
+# Example: Set Shipping to OpenCode with Free Tier
+node skills/global_config/subagent-setup/scripts/setup-subagents.mjs \
+  --set-role shipping --harness opencode --model opencode/muse-spark-1.3-contributor-free
+
+# Example: Enable or Disable a Role
+node skills/global_config/subagent-setup/scripts/setup-subagents.mjs --set-role media_eventtech --enable
+```
+
+### Synchronize to All Harnesses
+```bash
+node skills/global_config/subagent-setup/scripts/setup-subagents.mjs --sync
+```
+
+---
+
+## 3. Integration with `aos-project-init` & AO Orchestrator
+- **AO Orchestrator (Port 3101)**: The Pipeline Wizard (Schritt 3 von 4: Agenten & Rollen) directly reads and writes `.aos/pipeline.json`.
+- **`aos-project-init`**: Offers subagent configuration during project interview, defaulting to the canonical tier matrix.

package/skills/global_config/subagent-setup/scripts/setup-subagents.mjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+/**
+ * skills/global_config/subagent-setup/scripts/setup-subagents.mjs
+ *
+ * Interactive & CLI tool to configure subagent roles and model tiers across:
+ * - Claude Code (.claude/agents/*.md)
+ * - Google Antigravity (~/.gemini/config/agents/*.json)
+ * - OpenCode (.opencode/agents/*.md)
+ * - ChatGPT Codex CLI (.codex/agents/*.toml & *.md)
+ *
+ * Single Source of Truth: .aos/pipeline.json (or .aos/project.json)
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const installer = require('../../../../installer.js');
+
+const {
+    CANONICAL_TIERS,
+    loadPipelineConfig,
+    resolveAgentConfig,
+    parseAgentsMd,
+    compileClaudeAgents,
+    compileOpenCodeAgents,
+    compileCodexAgents
+} = installer;
+
+const ROLES = [
+    { key: 'architect', label: 'Architect', defaultTier: 'reasoning_max', defaultHarness: 'claude' },
+    { key: 'techlead', label: 'TechLead', defaultTier: 'standard_fast', defaultHarness: 'antigravity' },
+    { key: 'ui_ux', label: 'Godmode_UI_UX', defaultTier: 'standard_fast', defaultHarness: 'claude' },
+    { key: 'engineering', label: 'Godmode_Engineering', defaultTier: 'standard_fast', defaultHarness: 'claude' },
+    { key: 'media_eventtech', label: 'Godmode_Media_EventTech', defaultTier: 'standard_fast', defaultHarness: 'antigravity', defaultEnabled: false },
+    { key: 'reviewer', label: 'Reviewer', defaultTier: 'reasoning_max', defaultHarness: 'codex' },
+    { key: 'shipping', label: 'Godmode_Shipping', defaultTier: 'standard_fast', defaultHarness: 'opencode' }
+];
+
+function printPipeline(pipeline) {
+    console.log('\n=== AOS Multi-Harness Subagent Pipeline ===\n');
+    console.log(
+        'Role'.padEnd(20) +
+        'Status'.padEnd(10) +
+        'Harness'.padEnd(15) +
+        'Tier'.padEnd(18) +
+        'Model'
+    );
+    console.log('-'.repeat(80));
+
+    for (const r of ROLES) {
+        const cfg = pipeline[r.key] || {};
+        const enabled = cfg.enabled !== false;
+        const harness = cfg.harness || r.defaultHarness;
+        const tier = cfg.tier || r.defaultTier;
+        const model = cfg.model || (CANONICAL_TIERS[tier] ? CANONICAL_TIERS[tier][harness] : 'inherit');
+
+        console.log(
+            r.label.padEnd(20) +
+            (enabled ? '✔ ON' : '✖ OFF').padEnd(10) +
+            harness.padEnd(15) +
+            tier.padEnd(18) +
+            model
+        );
+    }
+    console.log('\nConfig file: .aos/pipeline.json\n');
+}
+
+function getDefaultPipeline() {
+    const pipeline = {};
+    for (const r of ROLES) {
+        const harness = r.defaultHarness;
+        const tier = r.defaultTier;
+        const model = CANONICAL_TIERS[tier] ? CANONICAL_TIERS[tier][harness] : 'inherit';
+        pipeline[r.key] = {
+            enabled: r.defaultEnabled !== false,
+            harness,
+            tier,
+            model
+        };
+    }
+    return pipeline;
+}
+
+function syncAllHarnesses(projectDir, pipeline) {
+    const agentsMdSrc = path.join(projectDir, '.agents', 'agents.md');
+    if (!fs.existsSync(agentsMdSrc)) {
+        console.error(`Error: .agents/agents.md not found at ${agentsMdSrc}`);
+        return false;
+    }
+
+    const content = fs.readFileSync(agentsMdSrc, 'utf8');
+    const agents = parseAgentsMd(content);
+
+    // 1. Claude
+    const claudeDir = path.join(projectDir, '.claude', 'agents');
+    compileClaudeAgents(agents, claudeDir, pipeline);
+    console.log(`  ✓ Synced Claude Code agents to ${claudeDir}`);
+
+    // 2. OpenCode
+    const opencodeDir = path.join(projectDir, '.opencode', 'agents');
+    compileOpenCodeAgents(agents, opencodeDir, pipeline);
+    console.log(`  ✓ Synced OpenCode agents to ${opencodeDir}`);
+
+    // 3. Codex
+    const codexDir = path.join(projectDir, '.codex', 'agents');
+    compileCodexAgents(agents, codexDir, pipeline);
+    console.log(`  ✓ Synced Codex CLI agents to ${codexDir}`);
+
+    return true;
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+    const cwd = process.cwd();
+    const aosDir = path.join(cwd, '.aos');
+    const pipelinePath = path.join(aosDir, 'pipeline.json');
+
+    let pipeline = loadPipelineConfig(cwd) || getDefaultPipeline();
+
+    if (args.includes('--show')) {
+        printPipeline(pipeline);
+        process.exit(0);
+    }
+
+    if (args.includes('--init-default')) {
+        fs.mkdirSync(aosDir, { recursive: true });
+        fs.writeFileSync(pipelinePath, JSON.stringify({ version: 1, pipeline: getDefaultPipeline() }, null, 2));
+        console.log(`Initialized default pipeline at ${pipelinePath}`);
+        printPipeline(getDefaultPipeline());
+        syncAllHarnesses(cwd, getDefaultPipeline());
+        process.exit(0);
+    }
+
+    if (args.includes('--sync')) {
+        console.log('Syncing all harnesses from .aos/pipeline.json...');
+        syncAllHarnesses(cwd, pipeline);
+        console.log('✓ All subagents synchronized.');
+        process.exit(0);
+    }
+
+    const setRoleIdx = args.indexOf('--set-role');
+    if (setRoleIdx !== -1 && args[setRoleIdx + 1]) {
+        const role = args[setRoleIdx + 1].toLowerCase().replace(/-/g, '_');
+        const harnessIdx = args.indexOf('--harness');
+        const modelIdx = args.indexOf('--model');
+        const tierIdx = args.indexOf('--tier');
+        const disableFlag = args.includes('--disable');
+        const enableFlag = args.includes('--enable');
+
+        if (!pipeline[role]) {
+            pipeline[role] = {};
+        }
+
+        if (harnessIdx !== -1 && args[harnessIdx + 1]) pipeline[role].harness = args[harnessIdx + 1];
+        if (modelIdx !== -1 && args[modelIdx + 1]) pipeline[role].model = args[modelIdx + 1];
+        if (tierIdx !== -1 && args[tierIdx + 1]) pipeline[role].tier = args[tierIdx + 1];
+        if (disableFlag) pipeline[role].enabled = false;
+        if (enableFlag) pipeline[role].enabled = true;
+
+        fs.mkdirSync(aosDir, { recursive: true });
+        fs.writeFileSync(pipelinePath, JSON.stringify({ version: 1, pipeline }, null, 2));
+        console.log(`Updated role "${role}" in ${pipelinePath}`);
+        printPipeline(pipeline);
+        syncAllHarnesses(cwd, pipeline);
+        process.exit(0);
+    }
+
+    // Default: Show pipeline and usage
+    printPipeline(pipeline);
+    console.log('Commands:');
+    console.log('  node setup-subagents.mjs --show');
+    console.log('  node setup-subagents.mjs --init-default');
+    console.log('  node setup-subagents.mjs --sync');
+    console.log('  node setup-subagents.mjs --set-role <role> --harness <claude|antigravity|opencode|codex> --model <model> [--tier <tier>]');
+}
+
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});