@jaimevalasek/aioson 1.4.0 → 1.6.0

package/src/commands/squad-worker.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const path = require('node:path');
+const {
+  loadWorkerConfig,
+  listWorkers,
+  runWorker,
+  scaffoldWorker
+} = require('../worker-runner');
+const {
+  openRuntimeDb,
+  insertWorkerRun,
+  listWorkerRuns
+} = require('../runtime-store');
+
+async function handleList(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_worker.squad_required'));
+    return { ok: false };
+  }
+  const workers = await listWorkers(projectDir, squadSlug);
+  if (workers.length === 0) {
+    logger.log(t('squad_worker.no_workers'));
+    return { ok: true, workers: [] };
+  }
+  logger.log(`Workers for squad "${squadSlug}" (${workers.length}):`);
+  for (const w of workers) {
+    logger.log(`  ${w.slug} [${w.type || 'manual'}] - ${w.name || w.slug}`);
+  }
+  return { ok: true, workers };
+}
+
+async function handleRun(projectDir, squadSlug, workerSlug, inputStr, { logger, t }) {
+  if (!squadSlug || !workerSlug) {
+    logger.error(t('squad_worker.run_usage'));
+    return { ok: false };
+  }
+
+  let inputPayload = {};
+  if (inputStr) {
+    try {
+      inputPayload = JSON.parse(inputStr);
+    } catch {
+      logger.error(t('squad_worker.invalid_input'));
+      return { ok: false, error: 'Invalid JSON input' };
+    }
+  }
+
+  logger.log(`Running worker "${workerSlug}" on squad "${squadSlug}"...`);
+  const result = await runWorker(projectDir, squadSlug, workerSlug, inputPayload, { triggerType: 'manual' });
+
+  // Log to runtime store
+  const handle = await openRuntimeDb(projectDir, { mustExist: false });
+  if (handle) {
+    const { db } = handle;
+    try {
+      insertWorkerRun(db, {
+        squadSlug,
+        workerSlug,
+        triggerType: 'manual',
+        inputJson: JSON.stringify(inputPayload),
+        outputJson: result.ok ? JSON.stringify(result.output) : null,
+        status: result.ok ? 'completed' : 'failed',
+        errorMessage: result.ok ? null : result.error,
+        durationMs: result.durationMs || 0,
+        attempt: result.attempt || 1
+      });
+    } finally {
+      db.close();
+    }
+  }
+
+  if (result.ok) {
+    logger.log(t('squad_worker.run_success', { worker: workerSlug }));
+    logger.log(JSON.stringify(result.output, null, 2));
+  } else {
+    logger.error(t('squad_worker.run_failed', { worker: workerSlug, error: result.error }));
+  }
+  return result;
+}
+
+async function handleTest(projectDir, squadSlug, workerSlug, { logger, t }) {
+  if (!squadSlug || !workerSlug) {
+    logger.error(t('squad_worker.test_usage'));
+    return { ok: false };
+  }
+
+  const config = await loadWorkerConfig(projectDir, squadSlug, workerSlug);
+  if (!config) {
+    logger.error(t('squad_worker.not_found', { worker: workerSlug }));
+    return { ok: false };
+  }
+
+  // Build mock input from schema
+  const mockInput = {};
+  for (const [key, spec] of Object.entries(config.inputs || {})) {
+    if (spec.type === 'string') mockInput[key] = `test-${key}`;
+    else if (spec.type === 'number') mockInput[key] = 0;
+    else mockInput[key] = `test-${key}`;
+  }
+
+  logger.log(`Testing worker "${workerSlug}" with mock input:`);
+  logger.log(JSON.stringify(mockInput, null, 2));
+
+  const result = await runWorker(projectDir, squadSlug, workerSlug, mockInput, {
+    triggerType: 'manual',
+    noRetry: true
+  });
+
+  if (result.ok) {
+    logger.log(t('squad_worker.test_passed', { worker: workerSlug }));
+    logger.log(JSON.stringify(result.output, null, 2));
+  } else {
+    logger.error(t('squad_worker.test_failed', { worker: workerSlug, error: result.error }));
+  }
+  return result;
+}
+
+async function handleLogs(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_worker.squad_required'));
+    return { ok: false };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_worker.no_runtime'));
+    return { ok: false };
+  }
+  const { db } = handle;
+  try {
+    const runs = listWorkerRuns(db, squadSlug);
+    if (runs.length === 0) {
+      logger.log(t('squad_worker.no_logs'));
+      return { ok: true, runs: [] };
+    }
+    logger.log(`Worker runs for squad "${squadSlug}" (${runs.length}):`);
+    for (const run of runs) {
+      const icon = run.status === 'completed' ? '[ok]' : run.status === 'failed' ? '[!!]' : '[..]';
+      const duration = run.duration_ms ? `${run.duration_ms}ms` : '-';
+      logger.log(`  ${icon} ${run.worker_slug} (${run.trigger_type}) ${duration} - ${run.created_at}`);
+      if (run.error_message) logger.log(`       Error: ${run.error_message}`);
+    }
+    return { ok: true, runs };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleScaffold(projectDir, squadSlug, workerSlug, options, { logger, t }) {
+  if (!squadSlug || !workerSlug) {
+    logger.error(t('squad_worker.scaffold_usage'));
+    return { ok: false };
+  }
+
+  const result = await scaffoldWorker(projectDir, squadSlug, workerSlug, {
+    name: options.name || workerSlug,
+    triggerType: options.trigger || 'manual',
+    inputs: options.inputs ? options.inputs.split(',') : [],
+    outputs: options.outputs ? options.outputs.split(',') : [],
+    env: options.env ? options.env.split(',') : []
+  });
+
+  logger.log(t('squad_worker.scaffold_created', { worker: workerSlug, path: result.workerDir }));
+  return { ok: true, ...result };
+}
+
+async function runSquadWorker({ args, options, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = options.sub || 'list';
+  const squadSlug = options.squad;
+  const workerSlug = options.worker;
+
+  switch (sub) {
+    case 'list':
+      return handleList(targetDir, squadSlug, { logger, t });
+    case 'run':
+      return handleRun(targetDir, squadSlug, workerSlug, options.input, { logger, t });
+    case 'test':
+      return handleTest(targetDir, squadSlug, workerSlug, { logger, t });
+    case 'logs':
+      return handleLogs(targetDir, squadSlug, { logger, t });
+    case 'scaffold':
+      return handleScaffold(targetDir, squadSlug, workerSlug, options, { logger, t });
+    default:
+      logger.error(t('squad_worker.unknown_sub', { sub }));
+      return { ok: false };
+  }
+}
+
+module.exports = { runSquadWorker };

package/src/commands/squad-worktrees.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const path = require('node:path');
+const { createWorktree, mergeWorktree, cleanupWorktree, listWorktrees } = require('../squad/worktree-manager');
+
+async function runSquadWorktrees({ args, options, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const squadSlug = options.squad || args[1];
+
+  if (!squadSlug) {
+    logger.error('Squad slug required. Use --squad <slug>');
+    return { ok: false };
+  }
+
+  // --cleanup [agent]
+  if (options.cleanup !== undefined) {
+    const agentSlug = typeof options.cleanup === 'string' ? options.cleanup : null;
+    if (agentSlug) {
+      const result = cleanupWorktree(projectDir, squadSlug, agentSlug, true);
+      logger.log(result.ok ? `Worktree for "${agentSlug}" removed.` : `Failed to remove worktree for "${agentSlug}".`);
+      return result;
+    }
+    // cleanup all for squad
+    const worktrees = listWorktrees(projectDir, squadSlug);
+    if (worktrees.length === 0) {
+      logger.log(`No worktrees found for squad "${squadSlug}".`);
+      return { ok: true };
+    }
+    for (const wt of worktrees) {
+      const result = cleanupWorktree(projectDir, squadSlug, wt.agentSlug, false);
+      logger.log(result.ok ? `  Removed: ${wt.agentSlug}` : `  Failed:  ${wt.agentSlug}`);
+    }
+    return { ok: true };
+  }
+
+  // List
+  const worktrees = listWorktrees(projectDir, squadSlug);
+  if (worktrees.length === 0) {
+    logger.log(`No worktrees found for squad "${squadSlug}".`);
+    return { ok: true, worktrees: [] };
+  }
+
+  logger.log(`Worktrees for "${squadSlug}" (${worktrees.length}):`);
+  for (const wt of worktrees) {
+    logger.log(`  ${wt.agentSlug}  branch:${wt.branch}  path:${wt.path}`);
+  }
+  return { ok: true, worktrees };
+}
+
+async function runSquadMerge({ args, options, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const squadSlug = options.squad || args[1];
+  const agentSlug = options.agent || args[2];
+
+  if (!squadSlug || !agentSlug) {
+    logger.error('Usage: aioson squad:merge <project> --squad <squad> --agent <agent>');
+    return { ok: false };
+  }
+
+  const autoMerge = options['no-auto'] !== true;
+  const result = mergeWorktree(projectDir, squadSlug, agentSlug, autoMerge);
+
+  if (result.ok) {
+    logger.log(`Merged branch ${result.branch} successfully.`);
+  } else if (result.reason === 'merge_conflict') {
+    logger.error(`Merge conflict on ${result.branch}. Resolve manually.`);
+    if (result.detail) logger.error(result.detail);
+  } else if (result.reason === 'auto_merge_disabled') {
+    logger.log(`Auto-merge disabled. Branch ready: ${result.branch}`);
+  }
+
+  return result;
+}
+
+module.exports = { runSquadWorktrees, runSquadMerge };

package/src/commands/tool-registry-cmd.js

@@ -0,0 +1,232 @@
+'use strict';
+
+const path = require('node:path');
+const {
+  openRuntimeDb,
+  registerDynamicTool,
+  unregisterDynamicTool,
+  getDynamicTool,
+  listDynamicTools
+} = require('../runtime-store');
+const { executeTool } = require('../tool-executor');
+
+const TOOL_NAME_RE = /^[a-z][a-z0-9_]*$/;
+
+async function runToolRegistry({ args = [], options = {}, logger = console, t = (k) => k } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = options.sub || 'list';
+
+  if (sub === 'register') return handleRegister(projectDir, options, logger);
+  if (sub === 'list') return handleList(projectDir, options, logger);
+  if (sub === 'call') return handleCall(projectDir, options, logger);
+  if (sub === 'unregister') return handleUnregister(projectDir, options, logger);
+  if (sub === 'show') return handleShow(projectDir, options, logger);
+
+  logger.error(`Subcomando desconhecido: ${sub}. Disponíveis: register, list, call, unregister, show`);
+  return { ok: false, error: 'unknown_sub' };
+}
+
+async function handleRegister(projectDir, options, logger) {
+  const name = String(options.name || '').trim();
+  const description = String(options.description || options.desc || '').trim();
+  const handlerType = String(options.type || 'shell').trim();
+  const handlerCode = options.cmd ? String(options.cmd) : null;
+  const handlerPath = options.path ? String(options.path) : null;
+  const squadSlug = options.squad ? String(options.squad) : null;
+  const registeredBy = options.by ? String(options.by) : null;
+
+  if (!name) {
+    logger.error('--name é obrigatório');
+    return { ok: false, error: 'name_required' };
+  }
+  if (!TOOL_NAME_RE.test(name) || name.length > 64) {
+    logger.error(`Nome inválido: "${name}". Use apenas letras minúsculas, números e _ (máx 64 chars, começando com letra)`);
+    return { ok: false, error: 'invalid_name' };
+  }
+  if (!description) {
+    logger.error('--description é obrigatório');
+    return { ok: false, error: 'description_required' };
+  }
+  if (!['shell', 'script'].includes(handlerType)) {
+    logger.error('--type deve ser "shell" ou "script"');
+    return { ok: false, error: 'invalid_type' };
+  }
+  if (handlerType === 'shell' && !handlerCode) {
+    logger.error('--cmd é obrigatório para tools do tipo shell');
+    return { ok: false, error: 'cmd_required' };
+  }
+  if (handlerType === 'script' && !handlerPath) {
+    logger.error('--path é obrigatório para tools do tipo script');
+    return { ok: false, error: 'path_required' };
+  }
+
+  const handle = await openRuntimeDb(projectDir);
+  if (!handle) {
+    logger.error('Runtime store não encontrado. Execute aioson runtime:init primeiro.');
+    return { ok: false, error: 'no_runtime' };
+  }
+  const { db } = handle;
+
+  try {
+    registerDynamicTool(db, {
+      name,
+      description,
+      handlerType,
+      handlerCode,
+      handlerPath,
+      squadSlug,
+      registeredBy
+    });
+    logger.log(`Tool registrada: ${name} (${handlerType})`);
+    return { ok: true, name, handlerType };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleList(projectDir, options, logger) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.log('Nenhum runtime store encontrado.');
+    return { ok: true, tools: [] };
+  }
+  const { db } = handle;
+
+  try {
+    const tools = listDynamicTools(db, options.squad || null);
+    if (tools.length === 0) {
+      logger.log('Nenhuma tool registrada neste projeto.');
+      return { ok: true, tools: [] };
+    }
+
+    logger.log(`Tools registradas (${tools.length}):`);
+    logger.log('');
+    for (const tool of tools) {
+      const scope = tool.squad_slug ? ` [squad:${tool.squad_slug}]` : '';
+      logger.log(`  ${tool.name}${scope}`);
+      logger.log(`    ${tool.description}`);
+      logger.log(`    tipo: ${tool.handler_type} | registrada: ${tool.registered_at.slice(0, 10)}`);
+      logger.log('');
+    }
+    return { ok: true, tools };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleCall(projectDir, options, logger) {
+  const name = String(options.name || '').trim();
+  if (!name) {
+    logger.error('--name é obrigatório');
+    return { ok: false, error: 'name_required' };
+  }
+
+  let input = {};
+  if (options.input) {
+    try {
+      input = JSON.parse(String(options.input));
+    } catch {
+      logger.error('--input deve ser JSON válido');
+      return { ok: false, error: 'invalid_input' };
+    }
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error('Runtime store não encontrado.');
+    return { ok: false, error: 'no_runtime' };
+  }
+  const { db } = handle;
+
+  let tool;
+  try {
+    tool = getDynamicTool(db, name);
+  } finally {
+    db.close();
+  }
+
+  if (!tool) {
+    logger.error(`Tool não encontrada: ${name}`);
+    return { ok: false, error: 'tool_not_found' };
+  }
+
+  const timeoutMs = options.timeout ? Number(options.timeout) * 1000 : undefined;
+  const result = executeTool(tool, input, { projectDir, timeoutMs });
+
+  if (result.stdout) logger.log(result.stdout);
+  if (result.stderr) logger.error(result.stderr);
+
+  if (!result.ok) {
+    logger.error(`Tool falhou (exit ${result.exitCode})${result.error ? `: ${result.error}` : ''}`);
+    return { ok: false, exitCode: result.exitCode, error: result.error };
+  }
+
+  return { ok: true, exitCode: result.exitCode, stdout: result.stdout };
+}
+
+async function handleUnregister(projectDir, options, logger) {
+  const name = String(options.name || '').trim();
+  if (!name) {
+    logger.error('--name é obrigatório');
+    return { ok: false, error: 'name_required' };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error('Runtime store não encontrado.');
+    return { ok: false, error: 'no_runtime' };
+  }
+  const { db } = handle;
+
+  try {
+    const tool = getDynamicTool(db, name);
+    if (!tool) {
+      logger.error(`Tool não encontrada: ${name}`);
+      return { ok: false, error: 'tool_not_found' };
+    }
+
+    unregisterDynamicTool(db, name);
+    logger.log(`Tool removida: ${name}`);
+    return { ok: true, name };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleShow(projectDir, options, logger) {
+  const name = String(options.name || '').trim();
+  if (!name) {
+    logger.error('--name é obrigatório');
+    return { ok: false, error: 'name_required' };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error('Runtime store não encontrado.');
+    return { ok: false, error: 'no_runtime' };
+  }
+  const { db } = handle;
+
+  try {
+    const tool = getDynamicTool(db, name);
+    if (!tool) {
+      logger.error(`Tool não encontrada: ${name}`);
+      return { ok: false, error: 'tool_not_found' };
+    }
+
+    logger.log(`Tool: ${tool.name}`);
+    logger.log(`Descrição: ${tool.description}`);
+    logger.log(`Tipo: ${tool.handler_type}`);
+    if (tool.handler_code) logger.log(`Comando: ${tool.handler_code}`);
+    if (tool.handler_path) logger.log(`Script: ${tool.handler_path}`);
+    if (tool.squad_slug) logger.log(`Squad: ${tool.squad_slug}`);
+    if (tool.registered_by) logger.log(`Registrada por: ${tool.registered_by}`);
+    logger.log(`Registrada em: ${tool.registered_at}`);
+
+    return { ok: true, tool };
+  } finally {
+    db.close();
+  }
+}
+
+module.exports = { runToolRegistry };

package/src/commands/update.js

@@ -28,6 +28,9 @@ async function runUpdate({ args, options, logger, t }) {
       requestedLanguage ||
       (context.parsed && context.data && context.data.conversation_language
         ? context.data.conversation_language
+        : null) ||
+      (result.savedProfile && result.savedProfile.locale
+        ? result.savedProfile.locale
         : 'en');
     localeSync = await applyAgentLocale(targetDir, language, { dryRun });
   }
@@ -35,6 +38,10 @@ async function runUpdate({ args, options, logger, t }) {
   logger.log(t('update.done_at', { targetDir }));
   logger.log(t('update.files_updated', { count: result.copied.length }));
   logger.log(t('update.backups_created', { count: result.backedUp.length }));
+  if (!dryRun) {
+    logger.log('');
+    logger.log(t('update.reconfigure_hint'));
+  }
   if (localeSync) {
     if (dryRun) {
       logger.log(t('locale_apply.dry_run_applied', { locale: localeSync.locale }));

package/src/commands/web-map.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const path = require('node:path');
+const { mapWebsite } = require('../web');
+
+function normalizeBoolean(value, fallback = false) {
+  if (typeof value === 'boolean') return value;
+  if (value === undefined || value === null) return fallback;
+  const text = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(text)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(text)) return false;
+  return fallback;
+}
+
+function parseInteger(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+async function runWebMap({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const url = String(options.url || '').trim();
+  if (!url) {
+    logger.error(t('web_map.url_missing'));
+    process.exitCode = 1;
+    return { ok: false, error: 'url_missing' };
+  }
+
+  const maxDepth = Math.max(0, parseInteger(options.depth, 2));
+  const maxPages = Math.max(1, parseInteger(options['max-pages'], 25));
+  const sameOriginOnly = !normalizeBoolean(options['include-external'], false);
+
+  try {
+    logger.log(t('web_map.starting', { url }));
+    const result = await mapWebsite(url, { maxDepth, maxPages, sameOriginOnly });
+    const output = {
+      ok: true,
+      targetDir,
+      url: result.startUrl,
+      maxDepth,
+      maxPages,
+      sameOriginOnly,
+      pageCount: result.pageCount,
+      urls: result.urls,
+      pages: result.pages
+    };
+
+    if (options.json) return output;
+
+    logger.log(t('web_map.pages_found', { count: result.pageCount }));
+    for (const page of result.pages) {
+      logger.log(t('web_map.page_line', {
+        url: page.url,
+        depth: page.depth,
+        status: page.statusCode,
+        links: page.linkCount
+      }));
+    }
+    logger.log(t('web_map.done'));
+    return output;
+  } catch (error) {
+    logger.error(t('web_map.failed', { error: error.message }));
+    process.exitCode = 1;
+    return { ok: false, error: 'map_failed', detail: error.message };
+  }
+}
+
+module.exports = {
+  runWebMap
+};

package/src/commands/web-scrape.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const path = require('node:path');
+const { scrapePage } = require('../web');
+
+const SUPPORTED_FORMATS = new Set(['markdown', 'text', 'html', 'links']);
+
+async function runWebScrape({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const url = String(options.url || '').trim();
+  const format = String(options.format || 'markdown').trim().toLowerCase();
+
+  if (!url) {
+    logger.error(t('web_scrape.url_missing'));
+    process.exitCode = 1;
+    return { ok: false, error: 'url_missing' };
+  }
+  if (!SUPPORTED_FORMATS.has(format)) {
+    logger.error(t('web_scrape.invalid_format', { format }));
+    process.exitCode = 1;
+    return { ok: false, error: 'invalid_format' };
+  }
+
+  try {
+    logger.log(t('web_scrape.fetching', { url }));
+    const page = await scrapePage(url, { sameOriginOnly: false });
+    const selected = format === 'markdown'
+      ? page.markdown
+      : format === 'text'
+        ? page.text
+        : format === 'html'
+          ? page.html
+          : page.links;
+
+    const output = {
+      ok: true,
+      targetDir,
+      url: page.url,
+      statusCode: page.statusCode,
+      contentType: page.contentType,
+      title: page.title,
+      description: page.description,
+      canonical: page.canonical,
+      format,
+      content: selected,
+      links: page.links,
+      truncated: page.truncated
+    };
+
+    if (options.json) return output;
+
+    logger.log(t('web_scrape.title_line', { title: page.title || '-' }));
+    logger.log(t('web_scrape.status_line', { status: page.statusCode, type: page.contentType || '-' }));
+    logger.log(t('web_scrape.done', { format }));
+    if (Array.isArray(selected)) {
+      for (const link of selected) logger.log(link);
+    } else {
+      logger.log(String(selected || ''));
+    }
+    return output;
+  } catch (error) {
+    logger.error(t('web_scrape.failed', { error: error.message }));
+    process.exitCode = 1;
+    return { ok: false, error: 'scrape_failed', detail: error.message };
+  }
+}
+
+module.exports = {
+  runWebScrape,
+  SUPPORTED_FORMATS
+};

package/src/constants.js

@@ -33,6 +33,7 @@ const MANAGED_FILES = [
   '.aioson/agents/squad.md',
   '.aioson/agents/orache.md',
   '.aioson/agents/genome.md',
+  '.aioson/agents/design-hybrid-forge.md',
   '.aioson/agents/profiler-researcher.md',
   '.aioson/agents/profiler-enricher.md',
   '.aioson/agents/profiler-forge.md',
@@ -304,6 +305,14 @@ const AGENT_DEFINITIONS = [
     dependsOn: ['.aioson/context/discovery.md'],
     output: 'QA report'
   },
+  {
+    id: 'tester',
+    displayName: 'Tester',
+    command: '@tester',
+    path: '.aioson/agents/tester.md',
+    dependsOn: ['.aioson/context/project.context.md'],
+    output: '.aioson/context/test-inventory.md + .aioson/context/test-plan.md'
+  },
   {
     id: 'orchestrator',
     displayName: 'Orchestrator',
@@ -341,6 +350,14 @@ const AGENT_DEFINITIONS = [
     dependsOn: [],
     output: '.aioson/genomes/[slug].md + .aioson/genomes/[slug].meta.json + optional binding in .aioson/squads/{slug}/squad.md or .aioson/squads/{slug}/squad.manifest.json'
   },
+  {
+    id: 'design-hybrid-forge',
+    displayName: 'Design Hybrid Forge',
+    command: '@design-hybrid-forge',
+    path: '.aioson/agents/design-hybrid-forge.md',
+    dependsOn: ['.aioson/context/project.context.md'],
+    output: '.aioson/installed-skills/{hybrid-slug}/SKILL.md + .aioson/installed-skills/{hybrid-slug}/references/ + .aioson/installed-skills/{hybrid-slug}/previews/ + .aioson/installed-skills/{hybrid-slug}/.skill-meta.json'
+  },
   {
     id: 'profiler-researcher',
     displayName: 'Profiler Researcher',