@jaimevalasek/aioson 1.3.0 → 1.4.0

package/src/commands/squad-pipeline.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const fs = require('node:fs/promises');
 const path = require('node:path');
 const {
   openRuntimeDb,
@@ -9,6 +10,107 @@ const {
   getTopologicalOrder
 } = require('../runtime-store');
 
+/**
+ * Determine node completion status by checking handoffs.
+ * A node is "complete" if all its outgoing edges have consumed handoffs,
+ * or if it has no outgoing edges and has at least one incoming consumed handoff
+ * (or is the first node with no incoming edges and has produced output handoffs).
+ */
+function classifyNodes(db, pipelineSlug, order, edges) {
+  const handoffs = db
+    .prepare('SELECT * FROM squad_handoffs WHERE pipeline_slug = ? ORDER BY created_at DESC')
+    .all(pipelineSlug);
+
+  const outgoing = {};
+  const incoming = {};
+  for (const slug of order) {
+    outgoing[slug] = [];
+    incoming[slug] = [];
+  }
+  for (const edge of edges) {
+    if (outgoing[edge.source_squad]) outgoing[edge.source_squad].push(edge);
+    if (incoming[edge.target_squad]) incoming[edge.target_squad].push(edge);
+  }
+
+  const nodeStatus = {};
+
+  for (const slug of order) {
+    const outEdges = outgoing[slug];
+    const inEdges = incoming[slug];
+
+    // Check if all outgoing handoffs are consumed
+    if (outEdges.length > 0) {
+      const allProduced = outEdges.every(edge =>
+        handoffs.some(h =>
+          h.from_squad === edge.source_squad &&
+          h.from_port === edge.source_port &&
+          (h.status === 'consumed' || h.status === 'pending')
+        )
+      );
+      const allConsumed = outEdges.every(edge =>
+        handoffs.some(h =>
+          h.from_squad === edge.source_squad &&
+          h.from_port === edge.source_port &&
+          h.status === 'consumed'
+        )
+      );
+
+      if (allConsumed) {
+        nodeStatus[slug] = 'completed';
+      } else if (allProduced) {
+        nodeStatus[slug] = 'produced';
+      } else {
+        nodeStatus[slug] = 'pending';
+      }
+    } else {
+      // Terminal node — check if all incoming handoffs are consumed
+      if (inEdges.length === 0) {
+        // Root node with no edges — mark pending
+        nodeStatus[slug] = 'pending';
+      } else {
+        const allInConsumed = inEdges.every(edge =>
+          handoffs.some(h =>
+            h.to_squad === edge.target_squad &&
+            h.to_port === edge.target_port &&
+            h.status === 'consumed'
+          )
+        );
+        nodeStatus[slug] = allInConsumed ? 'completed' : 'pending';
+      }
+    }
+  }
+
+  // First node with no incoming edges: if it has produced outputs, mark completed
+  for (const slug of order) {
+    if (incoming[slug].length === 0 && outgoing[slug].length > 0) {
+      if (nodeStatus[slug] === 'produced' || nodeStatus[slug] === 'completed') {
+        nodeStatus[slug] = 'completed';
+      }
+    }
+  }
+
+  return { nodeStatus, handoffs };
+}
+
+function findNextPendingNode(order, nodeStatus) {
+  // Find first node that is pending and whose dependencies are all completed
+  return order.find(slug => nodeStatus[slug] === 'pending') || null;
+}
+
+function findSquadOrchestratorAgent(projectDir, squadSlug) {
+  // Convention: squad orchestrator is at .aioson/squads/{slug}/agents/{slug}-orchestrator.md
+  // or the first agent in the squad
+  return `@${squadSlug}-orchestrator`;
+}
+
+async function requirePipelineSlug(slugArg, logger) {
+  if (!slugArg) {
+    logger.error('Usage: aioson squad:pipeline [path] --sub=run --pipeline=<slug>');
+    return null;
+  }
+  return slugArg;
+}
+
 async function runSquadPipeline({ args = [], options = {}, logger = console } = {}) {
   const projectDir = path.resolve(process.cwd(), args[0] || '.');
   const subcommand = options.sub || args[1] || 'list';
@@ -87,7 +189,151 @@ async function runSquadPipeline({ args = [], options = {}, logger = console } =
       return { ok: true, pipeline: dag.pipeline, handoffs: { pending, consumed, failed } };
     }
 
-    logger.error(`Unknown subcommand: ${subcommand}. Available: list, show, status`);
+    // --- NEW: run (guided mode) ---
+    if (subcommand === 'run' || subcommand === 'continue') {
+      const slug = await requirePipelineSlug(slugArg, logger);
+      if (!slug) return { ok: false, error: 'missing_slug' };
+
+      const dag = getPipelineDAG(db, slug);
+      if (!dag) {
+        logger.error(`Pipeline not found: ${slug}`);
+        return { ok: false, error: 'not_found' };
+      }
+
+      const order = getTopologicalOrder(db, slug);
+      if (!order) {
+        logger.error('Cycle detected in pipeline — cannot run.');
+        return { ok: false, error: 'cycle_detected' };
+      }
+
+      const { nodeStatus, handoffs } = classifyNodes(db, slug, order, dag.edges);
+
+      // Show pipeline progress
+      logger.log('');
+      logger.log(`Pipeline: ${dag.pipeline.name || dag.pipeline.slug}`);
+      logger.log(`Mode: guided (the system suggests, you execute)`);
+      logger.log('');
+
+      logger.log('Progress:');
+      for (const nodeSlugg of order) {
+        const status = nodeStatus[nodeSlugg];
+        const icon = status === 'completed' ? '[v]'
+          : status === 'produced' ? '[~]'
+          : '[>]';
+        // Only mark the first pending as [>], rest as [ ]
+        const displayIcon = status === 'pending'
+          ? (nodeSlugg === findNextPendingNode(order, nodeStatus) ? '[>]' : '[ ]')
+          : icon;
+        logger.log(`  ${displayIcon} ${nodeSlugg} (${status})`);
+      }
+      logger.log('');
+
+      // Find next node to activate
+      const nextNode = findNextPendingNode(order, nodeStatus);
+
+      if (!nextNode) {
+        // All nodes completed
+        const allCompleted = order.every(s => nodeStatus[s] === 'completed');
+        if (allCompleted) {
+          logger.log('Pipeline completed! All nodes have been executed.');
+          return { ok: true, pipeline: slug, status: 'completed', nextNode: null };
+        }
+        logger.log('No actionable node found. Check pending handoffs.');
+        return { ok: true, pipeline: slug, status: 'blocked', nextNode: null };
+      }
+
+      // Check if next node has pending incoming handoffs to consume
+      const pendingIncoming = handoffs.filter(h =>
+        h.to_squad === nextNode && h.status === 'pending'
+      );
+
+      // Consume pending incoming handoffs for this node
+      if (pendingIncoming.length > 0) {
+        const updateStmt = db.prepare(
+          'UPDATE squad_handoffs SET status = ?, consumed_at = ? WHERE id = ?'
+        );
+        for (const h of pendingIncoming) {
+          updateStmt.run('consumed', new Date().toISOString(), h.id);
+        }
+        logger.log(`Consumed ${pendingIncoming.length} incoming handoff(s) for ${nextNode}.`);
+      }
+
+      const orchestratorAgent = findSquadOrchestratorAgent(projectDir, nextNode);
+      logger.log(`Next: activate squad "${nextNode}"`);
+      logger.log(`  Agent: ${orchestratorAgent}`);
+      logger.log(`  Command: aioson agent ${orchestratorAgent} --tool=claude`);
+      logger.log('');
+      logger.log('After the squad completes its work, run:');
+      logger.log(`  aioson squad:pipeline . --sub=run --pipeline=${slug}`);
+
+      return {
+        ok: true,
+        pipeline: slug,
+        status: 'running',
+        nextNode,
+        orchestratorAgent,
+        nodeStatus
+      };
+    }
+
+    // --- NEW: skip ---
+    if (subcommand === 'skip') {
+      const slug = await requirePipelineSlug(slugArg, logger);
+      if (!slug) return { ok: false, error: 'missing_slug' };
+
+      const dag = getPipelineDAG(db, slug);
+      if (!dag) {
+        logger.error(`Pipeline not found: ${slug}`);
+        return { ok: false, error: 'not_found' };
+      }
+
+      const order = getTopologicalOrder(db, slug);
+      if (!order) {
+        logger.error('Cycle detected — cannot skip.');
+        return { ok: false, error: 'cycle_detected' };
+      }
+
+      const { nodeStatus } = classifyNodes(db, slug, order, dag.edges);
+      const nextNode = findNextPendingNode(order, nodeStatus);
+
+      if (!nextNode) {
+        logger.log('No pending node to skip.');
+        return { ok: true, pipeline: slug, skipped: null };
+      }
+
+      // Create synthetic handoffs for all outgoing edges of the skipped node
+      const outEdges = dag.edges.filter(e => e.source_squad === nextNode);
+      const insertHandoff = db.prepare(`
+        INSERT INTO squad_handoffs (id, pipeline_slug, from_squad, from_port, to_squad, to_port, payload_json, status, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?)
+      `);
+
+      for (const edge of outEdges) {
+        const id = `skip-${nextNode}-${edge.target_squad}-${Date.now()}`;
+        insertHandoff.run(
+          id,
+          slug,
+          edge.source_squad,
+          edge.source_port,
+          edge.target_squad,
+          edge.target_port,
+          JSON.stringify({ skipped: true, reason: 'Node skipped by user' }),
+          new Date().toISOString()
+        );
+      }
+
+      logger.log(`Skipped node: ${nextNode}`);
+      if (outEdges.length > 0) {
+        logger.log(`Created ${outEdges.length} synthetic handoff(s) for downstream nodes.`);
+      }
+      logger.log('');
+      logger.log('Run again to see the next node:');
+      logger.log(`  aioson squad:pipeline . --sub=run --pipeline=${slug}`);
+
+      return { ok: true, pipeline: slug, skipped: nextNode };
+    }
+
+    logger.error(`Unknown subcommand: ${subcommand}. Available: list, show, status, run, continue, skip`);
     return { ok: false, error: 'unknown_subcommand' };
   } finally {
     db.close();

package/src/commands/squad-plan.js

@@ -0,0 +1,329 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const {
+  openRuntimeDb,
+  upsertSquadExecutionPlan,
+  getSquadExecutionPlan,
+  getSquadExecutionPlanBySquad,
+  listSquadExecutionPlans,
+  updateSquadExecutionPlanStatus,
+  upsertSquadPlanRound,
+  updateSquadPlanRoundStatus,
+  getSquadPlanRounds
+} = require('../runtime-store');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Compute hash of squad manifest for staleness detection.
+ */
+async function computeManifestHash(projectDir, squadSlug) {
+  const manifestPath = path.resolve(projectDir, SQUADS_DIR, squadSlug, 'squad.manifest.json');
+  const hash = crypto.createHash('sha256');
+  try {
+    const stat = await fs.stat(manifestPath);
+    hash.update(`manifest:${stat.mtimeMs}`);
+  } catch {
+    hash.update('manifest:missing');
+  }
+  return hash.digest('hex').slice(0, 16);
+}
+
+/**
+ * Parse execution plan frontmatter.
+ */
+function parsePlanFrontmatter(content) {
+  const text = String(content || '');
+  const match = text.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const meta = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length) {
+      meta[key.trim()] = rest.join(':').trim().replace(/^"(.*)"$/, '$1');
+    }
+  }
+  return meta;
+}
+
+/**
+ * Count rounds in an execution plan markdown.
+ */
+function countRounds(content) {
+  const text = String(content || '');
+  const matches = text.match(/^### Round \d+/gm);
+  return matches ? matches.length : 0;
+}
+
+/**
+ * Resolve the execution plan path for a squad.
+ */
+function planPath(projectDir, squadSlug) {
+  return path.resolve(projectDir, SQUADS_DIR, squadSlug, 'docs', 'execution-plan.md');
+}
+
+/**
+ * Subcommand: show <slug>
+ * Shows the execution plan for a squad.
+ */
+async function handleShow(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_plan.slug_required'));
+    return { found: false };
+  }
+
+  const pp = planPath(projectDir, squadSlug);
+  if (!(await pathExists(pp))) {
+    logger.error(t('squad_plan.not_found', { slug: squadSlug }));
+    return { found: false };
+  }
+
+  const content = await fs.readFile(pp, 'utf8');
+  const meta = parsePlanFrontmatter(content);
+  const rounds = countRounds(content);
+
+  logger.log(`Execution Plan: ${squadSlug}`);
+  logger.log(`Status: ${meta.status || 'unknown'}`);
+  logger.log(`Rounds: ${rounds}`);
+  logger.log('');
+  logger.log(content);
+
+  return { found: true, meta, rounds };
+}
+
+/**
+ * Subcommand: status <slug>
+ * Shows progress of the execution plan from SQLite.
+ */
+async function handleStatus(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_plan.slug_required'));
+    return { found: false };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_plan.no_runtime'));
+    return { found: false };
+  }
+  const { db } = handle;
+  try {
+    const plan = getSquadExecutionPlanBySquad(db, squadSlug);
+    if (!plan) {
+      logger.error(t('squad_plan.no_plan', { slug: squadSlug }));
+      return { found: false };
+    }
+
+    const rounds = getSquadPlanRounds(db, plan.plan_slug);
+    logger.log(`Plan: ${plan.plan_slug}`);
+    logger.log(`Squad: ${plan.squad_slug}`);
+    logger.log(`Status: ${plan.status}`);
+    logger.log(`Progress: ${plan.rounds_completed}/${plan.rounds_total}`);
+    logger.log('');
+    for (const rd of rounds) {
+      const icon = rd.status === 'completed' ? '✓' : rd.status === 'in_progress' ? '▸' : '○';
+      logger.log(`  ${icon} Round ${rd.round_number}: ${rd.title} (@${rd.executor_slug}) [${rd.status}]`);
+    }
+    return { found: true, plan, rounds };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: checkpoint <slug> <round-number>
+ * Marks a round as completed.
+ */
+async function handleCheckpoint(projectDir, squadSlug, roundNumber, { logger, t }) {
+  if (!squadSlug || !roundNumber || isNaN(Number(roundNumber))) {
+    logger.error(t('squad_plan.checkpoint_usage'));
+    return { updated: false };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_plan.no_runtime'));
+    return { updated: false };
+  }
+  const { db } = handle;
+  try {
+    const plan = getSquadExecutionPlanBySquad(db, squadSlug);
+    if (!plan) {
+      logger.error(t('squad_plan.no_plan', { slug: squadSlug }));
+      return { updated: false };
+    }
+
+    const updated = updateSquadPlanRoundStatus(db, plan.plan_slug, Number(roundNumber), 'completed');
+    if (updated) {
+      logger.log(t('squad_plan.round_completed', { round: roundNumber }));
+    } else {
+      logger.error(t('squad_plan.round_not_found', { round: roundNumber }));
+    }
+    return { updated };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Subcommand: stale <slug>
+ * Checks if the squad manifest changed after the plan was created.
+ */
+async function handleStale(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_plan.slug_required'));
+    return { found: false, stale: false };
+  }
+
+  const pp = planPath(projectDir, squadSlug);
+  if (!(await pathExists(pp))) {
+    logger.error(t('squad_plan.not_found', { slug: squadSlug }));
+    return { found: false, stale: false };
+  }
+
+  const content = await fs.readFile(pp, 'utf8');
+  const meta = parsePlanFrontmatter(content);
+  if (!meta.created) {
+    logger.log(t('squad_plan.no_created_date'));
+    return { found: true, stale: false };
+  }
+
+  const planDate = new Date(meta.created);
+  const manifestFile = path.resolve(projectDir, SQUADS_DIR, squadSlug, 'squad.manifest.json');
+  let stale = false;
+
+  try {
+    const stat = await fs.stat(manifestFile);
+    if (stat.mtime > planDate) {
+      logger.log('  ⚠ squad.manifest.json modified after plan was created');
+      stale = true;
+    }
+  } catch {
+    // manifest missing — not stale, just broken
+  }
+
+  // Also check blueprint
+  const designsDir = path.resolve(projectDir, SQUADS_DIR, '.designs');
+  try {
+    const files = await fs.readdir(designsDir);
+    const bpFile = files.find(f => f.startsWith(squadSlug) && f.endsWith('.blueprint.json'));
+    if (bpFile) {
+      const bpPath = path.join(designsDir, bpFile);
+      const stat = await fs.stat(bpPath);
+      if (stat.mtime > planDate) {
+        logger.log('  ⚠ blueprint modified after plan was created');
+        stale = true;
+      }
+    }
+  } catch {
+    // designs dir may not exist
+  }
+
+  if (stale) {
+    logger.log(t('squad_plan.is_stale'));
+  } else {
+    logger.log(t('squad_plan.is_fresh'));
+  }
+
+  return { found: true, stale };
+}
+
+/**
+ * Subcommand: register <slug>
+ * Registers an existing execution plan file into the runtime SQLite.
+ */
+async function handleRegister(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_plan.slug_required'));
+    return { registered: false };
+  }
+
+  const pp = planPath(projectDir, squadSlug);
+  if (!(await pathExists(pp))) {
+    logger.error(t('squad_plan.not_found', { slug: squadSlug }));
+    return { registered: false };
+  }
+
+  const content = await fs.readFile(pp, 'utf8');
+  const meta = parsePlanFrontmatter(content);
+  const rounds = countRounds(content);
+  const hash = await computeManifestHash(projectDir, squadSlug);
+
+  const handle = await openRuntimeDb(projectDir);
+  const { db } = handle;
+  try {
+    const planSlug = upsertSquadExecutionPlan(db, {
+      squadSlug,
+      status: meta.status || 'draft',
+      roundsTotal: rounds,
+      roundsCompleted: 0,
+      basedOnBlueprint: meta.based_on_blueprint || null,
+      basedOnInvestigation: meta.based_on_investigation || null,
+      sourceHash: hash
+    });
+    logger.log(t('squad_plan.registered', { planSlug, rounds }));
+    return { registered: true, planSlug };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Main router for squad-plan subcommands.
+ */
+async function run(projectDir, args, context) {
+  const sub = args[0] || 'show';
+  const rest = args.slice(1);
+
+  switch (sub) {
+    case 'show':
+      return handleShow(projectDir, rest[0], context);
+    case 'status':
+      return handleStatus(projectDir, rest[0], context);
+    case 'checkpoint':
+      return handleCheckpoint(projectDir, rest[0], rest[1], context);
+    case 'stale':
+      return handleStale(projectDir, rest[0], context);
+    case 'register':
+      return handleRegister(projectDir, rest[0], context);
+    default:
+      context.logger.error(`Unknown subcommand: ${sub}. Available: show, status, checkpoint, stale, register`);
+      return { error: true };
+  }
+}
+
+/**
+ * Entry point for CLI integration (same signature as other commands).
+ */
+async function runSquadPlan({ args = [], options = {}, logger = console, t = (k) => k } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = options.sub || args[1] || 'show';
+  const slug = options.squad || args[2] || null;
+  const context = { logger, t };
+
+  if (sub === 'show') return handleShow(projectDir, slug, context);
+  if (sub === 'status') return handleStatus(projectDir, slug, context);
+  if (sub === 'checkpoint') {
+    const round = args[3] || options.round;
+    return handleCheckpoint(projectDir, slug, round, context);
+  }
+  if (sub === 'stale') return handleStale(projectDir, slug, context);
+  if (sub === 'register') return handleRegister(projectDir, slug, context);
+
+  logger.error(`Unknown subcommand: ${sub}. Available: show, status, checkpoint, stale, register`);
+  return { error: true };
+}
+
+module.exports = { run, runSquadPlan, handleShow, handleStatus, handleCheckpoint, handleStale, handleRegister };

package/src/commands/squad-status.js

@@ -7,7 +7,7 @@ const { flattenGenomeBindings, mergeGenomeBindings } = require('../genomes/bindi
 const SQUADS_DIR = '.aioson/squads';
 const AGENTS_ROOT = 'agents';
 const OUTPUT_ROOT = 'output';
-const LOGS_ROOT = 'aios-logs';
+const LOGS_ROOT = 'aioson-logs';
 const SKIP_FILES = new Set(['memory.md', '.gitkeep']);
 const SESSION_HTML_RE = /\.html?$/i;
 

package/src/commands/squad-validate.js

@@ -142,7 +142,62 @@ async function validateSemanticDeep(projectDir, slug, manifest) {
     }
   } catch { warnings.push('AGENTS.md not found'); }
 
-  // 5. Readiness não contradiz blockers
+  // 5. Output strategy validation
+  const outputStrategy = manifest.outputStrategy && typeof manifest.outputStrategy === 'object'
+    ? manifest.outputStrategy
+    : null;
+
+  if (outputStrategy) {
+    const validModes = ['files', 'sqlite', 'hybrid'];
+    if (outputStrategy.mode && !validModes.includes(outputStrategy.mode)) {
+      errors.push(`Invalid outputStrategy.mode: "${outputStrategy.mode}" (expected: ${validModes.join(', ')})`);
+    }
+
+    const delivery = outputStrategy.delivery && typeof outputStrategy.delivery === 'object'
+      ? outputStrategy.delivery
+      : null;
+
+    if (delivery) {
+      const webhooks = Array.isArray(delivery.webhooks) ? delivery.webhooks : [];
+      for (const wh of webhooks) {
+        if (!wh.slug) {
+          errors.push('Webhook missing required "slug" field');
+        }
+        if (!wh.trigger) {
+          errors.push(`Webhook "${wh.slug || '?'}" missing required "trigger" field`);
+        }
+        const validTriggers = ['on-publish', 'on-create', 'manual'];
+        if (wh.trigger && !validTriggers.includes(wh.trigger)) {
+          warnings.push(`Webhook "${wh.slug}" has unknown trigger: "${wh.trigger}"`);
+        }
+        if (wh.url && wh.url.includes('{{ENV:')) {
+          const envMatch = wh.url.match(/\{\{ENV:(\w+)\}\}/);
+          if (envMatch && !process.env[envMatch[1]]) {
+            warnings.push(`Webhook "${wh.slug}" references unset env var: ${envMatch[1]}`);
+          }
+        }
+        if (wh.worker) {
+          const workerPath = path.join(projectDir, wh.worker);
+          if (!(await pathExists(workerPath))) {
+            warnings.push(`Webhook "${wh.slug}" worker not found: ${wh.worker}`);
+          }
+        }
+      }
+
+      if (delivery.autoPublish && webhooks.length === 0 && !delivery.cloudPublish) {
+        warnings.push('autoPublish is enabled but no webhooks or cloudPublish configured');
+      }
+    }
+
+    if (outputStrategy.mode === 'files' && outputStrategy.dataOutput && outputStrategy.dataOutput.enabled) {
+      warnings.push('outputStrategy.mode is "files" but dataOutput.enabled is true — consider "hybrid"');
+    }
+    if (outputStrategy.mode === 'sqlite' && outputStrategy.fileOutput && outputStrategy.fileOutput.enabled) {
+      warnings.push('outputStrategy.mode is "sqlite" but fileOutput.enabled is true — consider "hybrid"');
+    }
+  }
+
+  // 6. Readiness não contradiz blockers
   if (manifest.readiness) {
     for (const [dim, val] of Object.entries(manifest.readiness)) {
       if (val && val.status === 'ready' && val.blocker) {
@@ -207,6 +262,7 @@ async function runSquadValidate({ args = [], options = {}, logger = console } =
   logger.log(`  Structure:      ${structure.errors.length === 0 ? '\u2705 PASS' : '\u274c FAIL'}`);
   logger.log(`  Semantics:      ${semantics.errors.length === 0 ? (semantics.warnings.length > 0 ? '\u26a0\ufe0f  WARNINGS' : '\u2705 PASS') : '\u274c FAIL'}`);
   logger.log(`  Semantic deep:  ${semanticDeep.errors.length === 0 ? (semanticDeep.warnings.length > 0 ? '\u26a0\ufe0f  WARNINGS' : '\u2705 PASS') : '\u274c FAIL'}`);
+  logger.log(`  Output strategy: ${manifest.outputStrategy ? `${manifest.outputStrategy.mode || 'unknown'} mode` : 'not configured'}`);
 
   if (allErrors.length > 0) {
     logger.log('');

package/src/commands/test-agents.js

@@ -14,7 +14,7 @@ const AGENTS = [
   'qa',
   'orchestrator',
   'squad',
-  'genoma',
+  'genome',
   'profiler-researcher',
   'profiler-enricher',
   'profiler-forge'
@@ -167,6 +167,11 @@ async function runTestAgents({ options, logger }) {
     addCheck(`skill: ${skill}`, content !== null && content.length > 100);
   }
 
+  const packagedDesignSkill = await readFile(
+    path.join(TEMPLATE_DIR, '.aioson', 'skills', 'design', 'cognitive-ui', 'SKILL.md')
+  );
+  addCheck('skill package: cognitive-ui', packagedDesignSkill !== null && packagedDesignSkill.length > 100);
+
   // ── Summary ──────────────────────────────────────────────────────────────
   log('');
   const total = passed + failed;