adaptive-director-skill 1.0.0 → 1.1.1

package/README.md

@@ -142,10 +142,11 @@ The repository separates the **npm management/installer layer** from the **self-
 Adaptive-Director-Skill/
 ├── scripts/                      # Management & CLI layer
 │   ├── cli.mjs                   # Main CLI router
-│   ├── setup.mjs                 # Interactive host setup
+│   ├── setup.mjs                 # Interactive host setup & delegate integration
+│   ├── delegate-cli.mjs          # Delegate skills integration CLI
 │   ├── install.mjs               # Idempotent skill copier
 │   ├── refresh.mjs               # Safe config refresher
-│   ├── discover.mjs              # Local agent discovery
+│   ├── discover.mjs              # Local agent & delegate discovery
 │   ├── doctor.mjs                # Installation diagnostics
 │   └── smoke-test.mjs            # Automated test suite
 │
@@ -163,19 +164,25 @@ Adaptive-Director-Skill/
 ## CLI Commands
 
 ```bash
-adaptive-director setup     # Interactive: discover hosts, install Skill, create config
-adaptive-director install   # Re-install/update Skill in host directories
-adaptive-director refresh   # Re-discover hosts & update config (preserves overrides)
-adaptive-director doctor    # Validate installation and health
-adaptive-director help      # Show usage
+adaptive-director setup               # Interactive: discover hosts, install Skill, configure delegate
+adaptive-director setup --with-delegate # Setup and automatically install delegate-skills
+adaptive-director setup --no-delegate   # Setup skipping delegate-skills (native execution)
+adaptive-director delegate install    # Install delegate-skills via official installer
+adaptive-director delegate status     # Check delegate-skills discovery and relay status
+adaptive-director install             # Re-install/update Skill in host directories
+adaptive-director refresh             # Re-discover hosts & update config (preserves overrides)
+adaptive-director doctor              # Validate installation and health
+adaptive-director help                # Show usage
 ```
 
 ---
 
 ## Core Principles
 
-- **Routing Priority:** User overrides → Delegate fleet lanes → Capability registry → Default fallback.
+- **Dynamic Discovery:** Discovers installed host CLIs and inspects locally available models at runtime rather than assuming static pairings.
+- **Routing Priority:** User overrides → Delegate fleet lanes → Dynamic Host Discovery → Capability registry → Default fallback.
 - **Independent Review:** The coder never reviews its own work.
+- **Verification Dimension:** Independent verification requires dedicated verification capabilities (`min_verification: 3`).
 - **Max Reasoning Opt-in:** `max` effort is locked by default; requires `--allow-max`.
 - **Runaway Loop Protection:** Maximum 1 automated fix cycle before alerting the user.
 - **Context Isolation:** Each agent receives only a self-contained brief on disk (`.adaptive-director/runs/`), preventing context window bloat.
@@ -183,6 +190,31 @@ adaptive-director help      # Show usage
 
 ---
 
+## Dynamic Model Discovery & Heuristics
+
+Adaptive Director does **not** rely on rigid, hardcoded host-to-model pairings. Real-world model availability depends on local CLI versions, host configurations, and account subscriptions.
+
+### Routing Pipeline
+
+```text
+Detect Host CLI
+       ↓
+Discover Locally Available Models (cache / config / env)
+       ↓
+Resolve Aliases (e.g. 'astra' → 'gpt-6-astra')
+       ↓
+Intersect with Registry Capabilities & Phase Requirements
+       ↓
+Score Compatible Candidates for Current Phase
+       ↓
+Route to Optimal Candidate (with Graceful Fallback)
+```
+
+> [!NOTE]
+> **Heuristic Calibration Disclaimer:** Capability scores (1–5) in `data/registry.json` represent internal routing heuristics and priors calibrated for phase allocation. They are **not** vendor laboratory benchmarks or absolute leaderboards.
+
+---
+
 ## Configuration (`~/.adaptive-director/config.json`)
 
 ```json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adaptive-director-skill",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Adaptive Director Skill — Skill-first adaptive multi-agent orchestration for AI coding agents",
   "type": "module",
   "bin": {
@@ -19,7 +19,7 @@
     "skills/"
   ],
   "scripts": {
-    "test": "node scripts/smoke-test.mjs",
+    "test": "node scripts/smoke-test.mjs && node scripts/test-setup-delegate.mjs",
     "setup": "node scripts/setup.mjs",
     "discover": "node scripts/discover.mjs",
     "doctor": "node scripts/doctor.mjs"

package/scripts/cli.mjs

@@ -15,20 +15,23 @@ const commands = {
   install: 'install.mjs',
   refresh: 'refresh.mjs',
   doctor: 'doctor.mjs',
+  delegate: 'delegate-cli.mjs',
 };
 
 if (command === 'help' || command === '--help' || command === '-h') {
-  console.log(`Adaptive Director Skill CLI v1.0.0
+  console.log(`Adaptive Director Skill CLI v1.1.1
 
 Usage:
-  adaptive-director <command>
+  adaptive-director <command> [options]
 
 Commands:
-  setup    - Initial interactive setup and installation
-  install  - Install/copy the Skill into supported host skill directories
-  refresh  - Re-run discovery and update config without destroying user overrides
-  doctor   - Validate installation and report health
-  help     - Show this help message
+  setup     - Initial interactive setup and host/delegate configuration
+              Flags: --with-delegate, --no-delegate, --yes
+  install   - Install/copy the Skill into supported host skill directories
+  refresh   - Re-run discovery and update config without destroying user overrides
+  doctor    - Validate installation and report health
+  delegate  - Manage delegate-skills integration (install, status)
+  help      - Show this help message
 `);
   process.exit(0);
 }

package/scripts/delegate-cli.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const args = process.argv.slice(2);
+const subcmd = args[0] || 'help';
+
+function run(script, scriptArgs = []) {
+  try {
+    const out = execFileSync(process.execPath, [script, ...scriptArgs], {
+      encoding: 'utf8',
+      timeout: 15000,
+      cwd: process.cwd(),
+      env: process.env,
+    });
+    return JSON.parse(out.trim());
+  } catch {
+    return null;
+  }
+}
+
+if (subcmd === 'help' || subcmd === '--help' || subcmd === '-h') {
+  console.log(`Adaptive Director — Delegate Skills Management
+
+Usage:
+  adaptive-director delegate <subcommand> [options]
+
+Subcommands:
+  install   Install delegate-skills via official installer and update config
+  status    Display delegate-skills discovery, detected relays, and lanes
+  help      Show this help message
+
+Examples:
+  adaptive-director delegate install
+  adaptive-director delegate status
+`);
+  process.exit(0);
+}
+
+if (subcmd === 'install') {
+  const setupScript = join(__dirname, 'setup.mjs');
+  const forwardArgs = [setupScript, '--with-delegate', '--delegate-only', ...args.slice(1)];
+  const res = spawnSync(process.execPath, forwardArgs, {
+    stdio: 'inherit',
+    env: process.env,
+  });
+  process.exit(res.status ?? 0);
+}
+
+if (subcmd === 'status') {
+  console.log('\nAdaptive Director — Delegate Integration Status\n');
+
+  const configPath = join(homedir(), '.adaptive-director', 'config.json');
+  let config = {};
+  if (existsSync(configPath)) {
+    try {
+      config = JSON.parse(readFileSync(configPath, 'utf8'));
+    } catch {}
+  }
+
+  const discovery = run(join(__dirname, 'discover.mjs'));
+  const ds = discovery?.delegateSkills ?? { installed: false, relays: [], lanes: {} };
+
+  console.log(`  Installed:           ${ds.installed ? 'Yes' : 'No'}`);
+  console.log(`  Config execution:    ${config.execution || 'native'}`);
+  console.log(`  Config enabled:      ${config.delegate?.enabled ?? config.delegateEnabled ?? false}`);
+  if (config.delegate?.lastInstallAttempt) {
+    console.log(`  Last install attempt: ${config.delegate.lastInstallAttempt}`);
+  }
+
+  const skills = ds.skills ?? ds.relays ?? [];
+  const relays = ds.relays ?? [];
+  console.log(`\n  Detected Delegate Skills (${skills.length}):`);
+  if (skills.length > 0) {
+    for (const s of skills) {
+      const isRelay = relays.includes(s);
+      console.log(`    - ${s}${isRelay ? ' (execution relay)' : ''}`);
+    }
+  } else {
+    console.log('    (none detected)');
+  }
+
+  const lanes = ds.lanes ?? {};
+  const laneKeys = Object.keys(lanes);
+  console.log(`\n  Active Execution Lanes (${laneKeys.length}):`);
+  if (laneKeys.length > 0) {
+    for (const k of laneKeys) {
+      const lane = lanes[k];
+      console.log(`    - ${k}: agent=${lane.agent || lane.implementer || 'unknown'}${lane.model ? `, model=${lane.model}` : ''}`);
+    }
+  } else {
+    console.log('    (none configured)');
+  }
+
+  console.log('');
+  process.exit(0);
+}
+
+console.error(`Unknown delegate subcommand: ${subcmd}`);
+console.log(`Run 'adaptive-director delegate help' for usage.`);
+process.exit(1);

package/scripts/discover.mjs

@@ -13,9 +13,10 @@
  */
 
 import { execFileSync, execSync } from 'node:child_process'
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
+import { discoverHostModels } from '../skills/adaptive-director/scripts/discover-models.mjs'
 
 // ─── Known agents ─────────────────────────────────────────────────────────────
 
@@ -88,19 +89,113 @@ function readFleet(path) {
   }
 }
 
+function readJsonConfig(path) {
+  if (!existsSync(path)) return null
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf8'))
+    if (raw.lanes && typeof raw.lanes === 'object') {
+      const result = {}
+      for (const [lane, def] of Object.entries(raw.lanes)) {
+        result[lane] = {
+          agent: def.implementer ?? def.agent,
+          model: def.model ?? null,
+          effort: def.effort ?? def.variant ?? null,
+          implementer: def.implementer ?? def.agent,
+        }
+      }
+      return Object.keys(result).length > 0 ? result : null
+    }
+  } catch {}
+  return null
+}
+
 function discoverDelegate() {
-  const globalPath  = join(homedir(), '.delegate', 'fleet.yaml')
-  const projectPath = join(process.cwd(), '.delegate', 'fleet.yaml')
+  const paths = [
+    join(process.cwd(), '.delegate', 'fleet.yaml'),
+    join(homedir(), '.delegate', 'fleet.yaml'),
+    join(process.cwd(), '.delegate', 'config.json'),
+    join(homedir(), '.config', 'delegate-skills', 'config.json'),
+  ]
+
+  let lanes = {}
+  for (const p of paths) {
+    if (p.endsWith('.json')) {
+      const jsonLanes = readJsonConfig(p)
+      if (jsonLanes) lanes = { ...lanes, ...jsonLanes }
+    } else {
+      const fleetLanes = readFleet(p)
+      if (fleetLanes) lanes = { ...lanes, ...fleetLanes }
+    }
+  }
 
-  const globalLanes  = readFleet(globalPath)
-  const projectLanes = readFleet(projectPath)
+  // Check if delegate-skills is installed on disk
+  const agentsSkillsDir = join(homedir(), '.agents', 'skills')
+  const codexSkillsDir  = join(homedir(), '.codex', 'skills')
+  const hasAgentsSkills = existsSync(join(agentsSkillsDir, 'delegate-setup')) ||
+                          existsSync(join(agentsSkillsDir, 'codex-delegate')) ||
+                          existsSync(join(agentsSkillsDir, 'agy-delegate')) ||
+                          existsSync(join(codexSkillsDir, 'delegate-review-loop'))
+
+  let hasSkillLock = false
+  const skillLockPath = join(homedir(), '.agents', '.skill-lock.json')
+  if (existsSync(skillLockPath)) {
+    try {
+      const lockContent = readFileSync(skillLockPath, 'utf8')
+      if (lockContent.includes('delegate-skills')) hasSkillLock = true
+    } catch {}
+  }
 
-  if (!globalLanes && !projectLanes) {
-    return { installed: false, lanes: {} }
+  // Detect installed delegate relays across candidate directories
+  const relayDirs = [
+    agentsSkillsDir,
+    codexSkillsDir,
+    join(process.cwd(), '.agents', 'skills'),
+    join(process.cwd(), 'delegate-skills', 'skills'),
+    join(homedir(), '.skills', 'amElnagdy', 'delegate-skills', 'skills'),
+  ]
+  const skillsSet = new Set()
+  const relaysSet = new Set()
+  for (const dir of relayDirs) {
+    if (!existsSync(dir)) continue
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true })
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue
+        if (entry.name.endsWith('-delegate') || entry.name === 'delegate-setup' || entry.name.startsWith('delegate-')) {
+          skillsSet.add(entry.name)
+          if (entry.name.endsWith('-delegate')) {
+            relaysSet.add(entry.name)
+          }
+        }
+      }
+    } catch {}
   }
+  const skills = Array.from(skillsSet).sort()
+  const relays = Array.from(relaysSet).sort()
 
-  const merged = { ...(globalLanes ?? {}), ...(projectLanes ?? {}) }
-  return { installed: true, lanes: merged }
+  const installed = Object.keys(lanes).length > 0 || hasAgentsSkills || hasSkillLock || skills.length > 0
+
+  // If installed but no explicit fleet lanes file configured, synthesize lanes from installed delegate skills
+  if (installed && Object.keys(lanes).length === 0 && (hasAgentsSkills || relays.length > 0)) {
+    if (relays.includes('codex-delegate') || existsSync(join(agentsSkillsDir, 'codex-delegate'))) {
+      lanes.feature = { agent: 'codex', implementer: 'codex' }
+      lanes.implement = { agent: 'codex', implementer: 'codex' }
+      lanes.fix = { agent: 'codex', implementer: 'codex' }
+    }
+    if (relays.includes('agy-delegate') || existsSync(join(agentsSkillsDir, 'agy-delegate'))) {
+      lanes.plan = { agent: 'agy', implementer: 'agy' }
+      lanes.review = { agent: 'agy', implementer: 'agy' }
+      lanes.verify = { agent: 'agy', implementer: 'agy' }
+    }
+  }
+
+  return {
+    installed,
+    lanes,
+    skills,
+    relays,
+    source: hasSkillLock ? 'amElnagdy/delegate-skills' : (hasAgentsSkills ? 'local-skills' : (Object.keys(lanes).length > 0 ? 'fleet-config' : (skills.length > 0 ? 'detected-skills' : null)))
+  }
 }
 
 // ─── Main ─────────────────────────────────────────────────────────────────────
@@ -128,11 +223,12 @@ function discover() {
     }
 
     agents[desc.id] = {
-      installed:  true,
-      available:  version !== null,
-      version:    version ?? 'unknown',
-      skillPath:  detectedSkillPath,
-      hasSkill:   detectedSkillPath ? existsSync(join(detectedSkillPath, 'adaptive-director')) || existsSync(join(detectedSkillPath, 'Adaptive-Director')) || existsSync(join(detectedSkillPath, 'adaptive-director-skill')) : false
+      installed:       true,
+      available:       version !== null,
+      version:         version ?? 'unknown',
+      skillPath:       detectedSkillPath,
+      hasSkill:        detectedSkillPath ? existsSync(join(detectedSkillPath, 'adaptive-director')) || existsSync(join(detectedSkillPath, 'Adaptive-Director')) || existsSync(join(detectedSkillPath, 'adaptive-director-skill')) : false,
+      availableModels: discoverHostModels(desc.id),
     }
   }
 

package/scripts/doctor.mjs

@@ -7,11 +7,12 @@ import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-function run(script, args = []) {
+function run(script, args = [], env = process.env) {
   try {
     const out = execFileSync(process.execPath, [script, ...args], {
       encoding: 'utf8', timeout: 15000,
       cwd: process.cwd(),
+      env,
     });
     return JSON.parse(out.trim());
   } catch {
@@ -65,9 +66,10 @@ if (check('Registry exists', existsSync(registryPath))) {
 }
 
 // ── Config ────────────────────────────────────────────────────────────────
+let configObj = null;
 if (check('Config exists', existsSync(configPath), 'adaptive-director setup')) {
   try {
-    JSON.parse(readFileSync(configPath, 'utf8'));
+    configObj = JSON.parse(readFileSync(configPath, 'utf8'));
     check('Config valid', true);
   } catch {
     allGood &= check('Config valid', false, 'rm ~/.adaptive-director/config.json && adaptive-director setup');
@@ -99,7 +101,7 @@ allGood &= check('Resume script exists',    existsSync(join(skillRoot, 'scripts'
 
 // ── Host discovery ────────────────────────────────────────────────────────
 console.log('');
-const discovery = run(join(__dirname, 'discover.mjs'));
+const discovery = run(join(__dirname, 'discover.mjs'), [], process.env);
 if (discovery) {
   let anyHost = false;
   for (const [id, info] of Object.entries(discovery.agents ?? {})) {
@@ -122,11 +124,18 @@ if (discovery) {
   if (!anyHost) warn('No supported hosts detected');
 
   console.log('');
-  const ds = discovery.delegateSkills ?? { installed: false };
+  const ds = discovery.delegateSkills ?? { installed: false, skills: [], relays: [], lanes: {} };
   if (ds.installed) {
-    check(`delegate-skills detected (${Object.keys(ds.lanes ?? {}).length} lane(s))`, true);
+    const skillCount = (ds.skills ?? ds.relays ?? []).length;
+    const laneCount = Object.keys(ds.lanes ?? {}).length;
+    check(`delegate-skills detected (${skillCount} delegate skill(s), ${laneCount} lane(s))`, true);
   } else {
-    warn('delegate-skills not detected (optional)');
+    warn('delegate-skills not detected (optional — native execution active)');
+    if (configObj?.delegate?.lastInstallAttempt === 'failed') {
+      warn('Last delegate-skills install attempt failed (run "adaptive-director delegate install" to retry)');
+    } else if (configObj?.delegate?.lastInstallAttempt === 'unverified') {
+      warn('delegate-skills installation unverified: no relays detected');
+    }
   }
 } else {
   allGood &= check('Discovery script works', false, 'Check Node version or reinstall');

package/scripts/refresh.mjs

@@ -7,11 +7,12 @@ import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-function run(script, args = []) {
+function run(script, args = [], env = process.env) {
   try {
     const out = execFileSync(process.execPath, [script, ...args], {
       encoding: 'utf8', timeout: 15000,
       cwd: process.cwd(),
+      env,
     });
     return JSON.parse(out.trim());
   } catch (e) {
@@ -24,7 +25,7 @@ const configPath = join(configDir, 'config.json');
 
 console.log('Refreshing Adaptive Director config...\n');
 
-const discovery = run(join(__dirname, 'discover.mjs'));
+const discovery = run(join(__dirname, 'discover.mjs'), [], process.env);
 if (!discovery) {
   console.error('✗ Discovery failed.');
   process.exit(1);
@@ -39,11 +40,20 @@ if (existsSync(configPath)) {
   }
 }
 
+const delegateInstalled = Boolean(discovery.delegateSkills?.installed);
+const delegateEnabled = existingConfig.delegate?.enabled ?? existingConfig.delegateEnabled ?? false;
+
 const config = {
   version: 1,
+  execution: existingConfig.execution || 'native',
   defaultBudget: existingConfig.defaultBudget || 'balanced',
   allowMax: existingConfig.allowMax || false,
-  delegateEnabled: existingConfig.delegateEnabled || false,
+  delegateEnabled,
+  delegate: {
+    installed: delegateInstalled,
+    enabled: delegateEnabled,
+    ...(existingConfig.delegate?.lastInstallAttempt ? { lastInstallAttempt: existingConfig.delegate.lastInstallAttempt } : {})
+  },
   hosts: {},
   overrides: existingConfig.overrides || {}
 };
@@ -51,6 +61,7 @@ const config = {
 for (const [id, info] of Object.entries(discovery.agents ?? {})) {
   if (info.installed) {
     config.hosts[id] = {
+      ...existingConfig.hosts?.[id],
       enabled: existingConfig.hosts?.[id]?.enabled ?? true,
       skillPath: info.skillPath
     };