@jaimevalasek/aioson 1.3.0 → 1.5.1

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-processes.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const path = require('node:path');
+const { getActiveProcesses, stopProcess, stopSquadProcesses } = require('../squad-dashboard/process-monitor');
+
+function formatElapsed(seconds) {
+  if (seconds == null) return '-';
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m${seconds % 60}s`;
+  return `${Math.floor(seconds / 3600)}h${Math.floor((seconds % 3600) / 60)}m`;
+}
+
+async function runSquadProcesses({ args, options, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const squadFilter = options.squad || null;
+
+  // --stop <pid>
+  if (options.stop && options.stop !== true) {
+    const result = await stopProcess(projectDir, options.stop);
+    if (result.ok) {
+      logger.log(`Process ${options.stop} stopped.`);
+    } else {
+      logger.error(`Failed to stop ${options.stop}: ${result.error}`);
+    }
+    return result;
+  }
+
+  // --stop-squad <squad>
+  if (options['stop-squad']) {
+    const slug = options['stop-squad'];
+    const results = await stopSquadProcesses(projectDir, slug);
+    const stopped = results.filter(r => r.ok).length;
+    logger.log(`Stopped ${stopped}/${results.length} processes for squad "${slug}".`);
+    return { ok: true, results };
+  }
+
+  // List
+  const processes = await getActiveProcesses(projectDir, squadFilter);
+  if (processes.length === 0) {
+    logger.log(squadFilter ? `No active processes for squad "${squadFilter}".` : 'No active processes.');
+    return { ok: true, processes: [] };
+  }
+
+  logger.log(`Active processes (${processes.length}):`);
+  for (const proc of processes) {
+    const status = proc.alive ? '[*]' : '[ ]';
+    const elapsed = formatElapsed(proc.elapsedSeconds);
+    const ctx = proc.contextPct != null ? ` ctx:${proc.contextPct}%` : '';
+    const url = proc.url ? `  ${proc.url}` : '';
+    logger.log(`  ${status} [${proc.squadSlug}] ${proc.agentSlug}  pid:${proc.pid}  elapsed:${elapsed}${ctx}${url}`);
+  }
+
+  return { ok: true, processes };
+}
+
+module.exports = { runSquadProcesses };

package/src/commands/squad-recovery.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const path = require('node:path');
+const { generateRecovery, readRecovery } = require('../squad/recovery-context');
+
+/**
+ * aioson squad:recovery <project> --squad <squad> --agent <agent> [--show]
+ *
+ * Generates (or re-generates) the recovery-context.md for an agent.
+ * --show: print the generated content to stdout instead of just confirming.
+ */
+async function runSquadRecovery({ 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:recovery <project> --squad <squad> --agent <agent> [--show]');
+    return { ok: false };
+  }
+
+  const result = await generateRecovery(projectDir, squadSlug, agentSlug);
+
+  if (!result.ok) {
+    logger.error(`Failed to generate recovery context: ${result.error}`);
+    return result;
+  }
+
+  logger.log(`Recovery context generated: ${result.path} (~${result.tokens} tokens)`);
+
+  if (options.show) {
+    const content = await readRecovery(projectDir, squadSlug);
+    if (content) {
+      logger.log('');
+      logger.log(content);
+    }
+  }
+
+  return result;
+}
+
+module.exports = { runSquadRecovery };