amicus 1.0.0

package/src/sidecar/context-builder.js

@@ -0,0 +1,297 @@
+/**
+ * Context Builder Module
+ *
+ * Handles building context from Claude Code sessions for sidecar operations.
+ * Spec Reference: §5 Context Passing
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { resolveSession, getSessionDirectory } = require('../session');
+const { formatContext, readJSONL } = require('../jsonl-parser');
+const { logger } = require('../utils/logger');
+
+/**
+ * Parse duration string (e.g., '2h', '30m', '1d')
+ * @param {string} str - Duration string
+ * @returns {number} Milliseconds
+ */
+function parseDuration(str) {
+  if (!str || typeof str !== 'string') {
+    return 0;
+  }
+  const match = str.match(/^(\d+)(m|h|d)$/);
+  if (!match) {
+    return 0;
+  }
+  const multipliers = { m: 60000, h: 3600000, d: 86400000 };
+  return parseInt(match[1], 10) * multipliers[match[2]];
+}
+
+/**
+ * Resolve session file from session directory
+ * @param {string} sessionDir - Session directory path
+ * @param {string} session - Session ID or 'current'
+ * @returns {{path: string|null, method: string, warning?: string}}
+ */
+function resolveSessionFile(sessionDir, session) {
+  // Use the existing resolveSession function
+  return resolveSession(sessionDir, session);
+}
+
+/**
+ * Apply context filters to messages array
+ * @param {Array} messages - Array of messages
+ * @param {object} options - Filter options
+ * @param {number} [options.contextTurns] - Max number of turns (user messages)
+ * @param {string} [options.contextSince] - Time filter (e.g., '2h')
+ * @param {number} [options._testCutoff] - Test-only: override time cutoff
+ * @returns {Array} Filtered messages
+ */
+function applyContextFilters(messages, options) {
+  if (!messages || messages.length === 0) {
+    return [];
+  }
+
+  const { contextTurns, contextSince, _testCutoff } = options;
+  let filtered = [...messages];
+
+  // Apply time filter if specified (overrides turns)
+  if (contextSince) {
+    const cutoffMs = _testCutoff || (Date.now() - parseDuration(contextSince));
+    filtered = filtered.filter(m => {
+      const ts = m.timestamp ? new Date(m.timestamp).getTime() : 0;
+      return ts >= cutoffMs;
+    });
+  } else if (contextTurns && contextTurns > 0) {
+    // Apply turn filter - count user messages as turns
+    const userIndices = filtered
+      .map((m, i) => m.type === 'user' ? i : -1)
+      .filter(i => i >= 0);
+
+    if (userIndices.length > contextTurns) {
+      const startIdx = userIndices[userIndices.length - contextTurns];
+      filtered = filtered.slice(startIdx);
+    }
+  }
+
+  return filtered;
+}
+
+/**
+ * Get the Cowork local-agent-mode-sessions root for the current platform.
+ * @param {string} [homeDir] - Home directory override (for testing)
+ * @returns {string} Path to local-agent-mode-sessions directory
+ */
+function getCoworkSessionsRoot(homeDir = os.homedir()) {
+  // Cowork stores session data inside Claude Desktop's Application Support:
+  // ~/Library/Application Support/Claude/local-agent-mode-sessions/<org>/<user>/local_<id>/audit.jsonl
+  return path.join(homeDir, 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions');
+}
+
+/**
+ * Find a Cowork session's audit.jsonl by process name or fall back to most recent.
+ * Scans ~/Library/Application Support/Claude/local-agent-mode-sessions/
+ *
+ * When coworkProcess is provided, matches the session metadata JSON file
+ * whose processName matches. This is the reliable path for parallel sessions.
+ * Falls back to most recently modified audit.jsonl when no process name given.
+ *
+ * @param {string} [homeDir] - Home directory override (for testing)
+ * @param {string} [coworkProcess] - Cowork VM process name (e.g., 'modest-laughing-goodall')
+ * @returns {string|null} Path to the matching audit.jsonl, or null
+ */
+function findCoworkSession(homeDir = os.homedir(), coworkProcess = null) {
+  const root = getCoworkSessionsRoot(homeDir);
+  if (!fs.existsSync(root)) {
+    return null;
+  }
+
+  let bestPath = null;
+  let bestMtime = 0;
+
+  // Structure: root/<org-id>/<user-id>/local_<session-id>/audit.jsonl
+  // Metadata: root/<org-id>/<user-id>/local_<session-id>.json (has processName)
+  try {
+    for (const org of fs.readdirSync(root)) {
+      const orgPath = path.join(root, org);
+      try { if (!fs.statSync(orgPath).isDirectory()) { continue; } } catch { continue; }
+
+      for (const user of fs.readdirSync(orgPath)) {
+        const userPath = path.join(orgPath, user);
+        try { if (!fs.statSync(userPath).isDirectory()) { continue; } } catch { continue; }
+
+        for (const session of fs.readdirSync(userPath)) {
+          if (!session.startsWith('local_')) { continue; }
+          const auditPath = path.join(userPath, session, 'audit.jsonl');
+
+          // If matching by process name, check the metadata JSON
+          if (coworkProcess) {
+            const metaPath = path.join(userPath, `${session}.json`);
+            try {
+              const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+              if (meta.processName === coworkProcess) {
+                logger.info('Matched Cowork session by processName', { coworkProcess, session });
+                return fs.existsSync(auditPath) ? auditPath : null;
+              }
+            } catch {
+              continue;
+            }
+            continue; // Skip mtime check when matching by process name
+          }
+
+          // Fallback: track most recent audit.jsonl
+          try {
+            const mtime = fs.statSync(auditPath).mtime.getTime();
+            if (mtime > bestMtime) {
+              bestMtime = mtime;
+              bestPath = auditPath;
+            }
+          } catch {
+            continue;
+          }
+        }
+      }
+    }
+  } catch {
+    return null;
+  }
+
+  return bestPath;
+}
+
+/**
+ * Normalize Cowork audit.jsonl messages to match Claude Code JSONL format.
+ * Maps _audit_timestamp → timestamp and filters to user/assistant messages.
+ *
+ * @param {Array} messages - Raw parsed audit.jsonl entries
+ * @returns {Array} Normalized messages compatible with formatContext/applyContextFilters
+ */
+function normalizeCoworkMessages(messages) {
+  return messages
+    .filter(m => m.type === 'user' || m.type === 'assistant')
+    .map(m => ({
+      ...m,
+      timestamp: m.timestamp || m._audit_timestamp || null
+    }));
+}
+
+/**
+ * Build context from Claude Code session
+ * Spec Reference: §5 Context Passing
+ *
+ * @param {string} project - Project directory
+ * @param {string} session - Session ID or 'current'
+ * @param {object} options - Context options
+ * @param {number} [options.contextTurns=50] - Max conversation turns
+ * @param {string} [options.contextSince] - Time filter (e.g., '2h')
+ * @param {number} [options.contextMaxTokens=80000] - Max context tokens
+ * @param {string} [options.sessionDir] - Explicit session directory override (for code-web, cowork)
+ * @param {string} [options.client] - Client type (code-local, code-web, cowork)
+ * @param {string} [options._homeDir] - Home directory override (testing only)
+ * @returns {string} Formatted context string
+ */
+function buildContext(project, session, options) {
+  const { contextTurns = 50, contextSince, contextMaxTokens = 80000, sessionDir: sessionDirOverride, client, coworkProcess, _homeDir } = options;
+  const homeDir = _homeDir || os.homedir();
+
+  // Determine session directory:
+  // 1. If sessionDir is explicitly provided, use it directly (code-web, cowork)
+  // 2. Otherwise, use the standard getSessionDirectory for code-local
+  const resolvedSessionDir = sessionDirOverride || getSessionDirectory(project, homeDir);
+
+  // For cowork clients: read directly from Cowork's local-agent-mode-sessions
+  // on the host Mac. The Cowork VM can't expose its session path to the MCP server,
+  // so we find the most recently active session's audit.jsonl on the host.
+  if (client === 'cowork' && !sessionDirOverride) {
+    const auditPath = findCoworkSession(homeDir, coworkProcess);
+    if (!auditPath) {
+      logger.warn('No Cowork session found in local-agent-mode-sessions', { project });
+      return '[No Claude Code conversation history found]';
+    }
+
+    logger.info('Using Cowork session', { auditPath });
+
+    let messages;
+    try {
+      messages = readJSONL(auditPath);
+    } catch (err) {
+      logger.error('Error reading Cowork session', { error: err.message });
+      return '[Error reading Claude Code session]';
+    }
+
+    messages = normalizeCoworkMessages(messages);
+    if (messages.length === 0) {
+      return '[Empty Claude Code session]';
+    }
+
+    messages = applyContextFilters(messages, { contextTurns, contextSince });
+    let context = formatContext(messages);
+    const maxChars = contextMaxTokens * 4;
+    if (context.length > maxChars) {
+      context = '[Earlier context truncated...]\n\n' + context.slice(-maxChars);
+    }
+    return context || '[No relevant context found]';
+  }
+
+  if (!fs.existsSync(resolvedSessionDir)) {
+    logger.warn('No Claude Code conversation history found', { project, sessionDir: resolvedSessionDir, client });
+    return '[No Claude Code conversation history found]';
+  }
+
+  // Resolve session file
+  const resolution = resolveSessionFile(resolvedSessionDir, session);
+
+  if (!resolution.path) {
+    logger.warn('No Claude Code session found', { project, session });
+    return '[No Claude Code conversation history found]';
+  }
+
+  if (resolution.warning) {
+    logger.warn('Session resolution warning', { warning: resolution.warning });
+  }
+
+  logger.info('Using session', {
+    session: path.basename(resolution.path),
+    method: resolution.method
+  });
+
+  // Read and parse the session file
+  let messages;
+  try {
+    messages = readJSONL(resolution.path);
+  } catch (err) {
+    logger.error('Error reading session', { error: err.message });
+    return '[Error reading Claude Code session]';
+  }
+
+  if (messages.length === 0) {
+    return '[Empty Claude Code session]';
+  }
+
+  // Apply filters
+  messages = applyContextFilters(messages, { contextTurns, contextSince });
+
+  // Format as context
+  let context = formatContext(messages);
+
+  // Truncate to token limit (~4 chars per token)
+  const maxChars = contextMaxTokens * 4;
+  if (context.length > maxChars) {
+    context = '[Earlier context truncated...]\n\n' + context.slice(-maxChars);
+  }
+
+  return context || '[No relevant context found]';
+}
+
+module.exports = {
+  buildContext,
+  parseDuration,
+  resolveSessionFile,
+  applyContextFilters,
+  findCoworkSession,
+  normalizeCoworkMessages,
+  getCoworkSessionsRoot
+};

package/src/sidecar/continue.js

@@ -0,0 +1,212 @@
+/**
+ * Sidecar Continue Operations - Handles continuing from previous sessions
+ * Spec Reference: §4.4, §8.5
+ */
+
+const fs = require('fs');
+
+const { generateTaskId, runInteractive, buildMcpConfig } = require('./start');
+const {
+  SessionPaths,
+  saveInitialContext,
+  finalizeSession,
+  outputSummary,
+  createHeartbeat
+} = require('./session-utils');
+const { acquireLock, releaseLock } = require('../utils/session-lock');
+const { runHeadless } = require('../headless');
+const { buildPrompts } = require('../prompt-builder');
+const { logger } = require('../utils/logger');
+
+/** Load previous session data (metadata, summary, conversation) */
+function loadPreviousSession(taskId, project) {
+  // Reads an EXISTING session — resolve dual-dir (amicus, then legacy).
+  const sessionDir = SessionPaths.resolveSessionDir(project, taskId);
+
+  if (!fs.existsSync(sessionDir)) {
+    throw new Error(`Session ${taskId} not found`);
+  }
+
+  // Load metadata
+  const metaPath = SessionPaths.metadataFile(sessionDir);
+  const metadata = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+
+  // Load summary if available
+  const summaryPath = SessionPaths.summaryFile(sessionDir);
+  const summary = fs.existsSync(summaryPath) ? fs.readFileSync(summaryPath, 'utf-8') : '';
+
+  // Load and format conversation if available
+  const convPath = SessionPaths.conversationFile(sessionDir);
+  let conversation = '';
+
+  if (fs.existsSync(convPath)) {
+    const lines = fs.readFileSync(convPath, 'utf-8').split('\n').filter(Boolean);
+    const messages = lines.map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+
+    conversation = messages.map(m => {
+      const time = m.timestamp ? new Date(m.timestamp).toLocaleTimeString() : '';
+      return `[${m.role} @ ${time}] ${m.content}`;
+    }).join('\n\n');
+  }
+
+  return { metadata, summary, conversation };
+}
+
+/** Build continuation context from previous session data */
+function buildContinuationContext(metadata, summary, conversation, contextMaxTokens = 80000) {
+  const maxChars = contextMaxTokens * 4;
+
+  const truncatedConversation = conversation.length > maxChars
+    ? conversation.slice(-maxChars)
+    : conversation;
+
+  return `
+## PREVIOUS SIDECAR SESSION
+
+This sidecar continues from a previous session (${metadata.taskId}).
+
+### Previous Task
+${metadata.briefing || 'No briefing recorded'}
+
+### Previous Summary
+${summary || 'No summary available'}
+
+### Previous Conversation Excerpt
+${truncatedConversation || 'No conversation recorded'}
+
+---
+
+## NEW TASK
+
+Build on the previous sidecar's findings. The user wants to continue or extend that work.
+`;
+}
+
+/** Create session metadata for continuation */
+function createContinueSessionMetadata(taskId, project, options, oldTaskId) {
+  const { model, briefing, headless, agent } = options;
+
+  const sessionDir = SessionPaths.sessionDir(project, taskId);
+  fs.mkdirSync(sessionDir, { recursive: true });
+
+  const metadata = {
+    taskId,
+    model,
+    project,
+    briefing,
+    mode: headless ? 'headless' : 'interactive',
+    agent: agent || (headless ? 'build' : 'chat'),
+    status: 'running',
+    createdAt: new Date().toISOString(),
+    continuesFrom: oldTaskId
+  };
+
+  fs.writeFileSync(SessionPaths.metadataFile(sessionDir), JSON.stringify(metadata, null, 2));
+
+  return sessionDir;
+}
+
+/** Continue from a previous sidecar session - Spec Reference: §4.4, §8.5 */
+async function continueSidecar(options) {
+  const {
+    taskId: oldTaskId,
+    briefing,
+    project = process.cwd(),
+    contextMaxTokens = 80000,
+    headless = false,
+    timeout = 15,
+    agent,
+    mcp, mcpConfig, client, noMcp, excludeMcp
+  } = options;
+
+  // Load previous session data
+  const { metadata: oldMetadata, summary: previousSummary, conversation: previousConversation } =
+    loadPreviousSession(oldTaskId, project);
+
+  // Lock the previous (EXISTING) session directory to prevent concurrent
+  // continue operations — resolve dual-dir so a legacy session is locked too.
+  const prevSessionDir = SessionPaths.resolveSessionDir(project, oldTaskId);
+  acquireLock(prevSessionDir, headless ? 'headless' : 'interactive');
+
+  const model = options.model || oldMetadata.model;
+  if (!options.model) {
+    // Inherited model: advisory only (F5) — never block reopening a session.
+    const { warnIfNotInCatalog } = require('../utils/model-validator');
+    await warnIfNotInCatalog(model);
+  }
+  const mcpServers = buildMcpConfig({ mcp, mcpConfig, clientType: client, noMcp, excludeMcp });
+  logger.info('Continuing from session', { oldTaskId, model });
+
+  // Build continuation context
+  const previousContext = buildContinuationContext(
+    oldMetadata, previousSummary, previousConversation, contextMaxTokens
+  );
+  const fullContext = previousContext + '\n\n' + briefing;
+
+  // Inherit agent from previous session if not specified
+  const effectiveAgent = agent || oldMetadata.agent || 'Build';
+
+  // Build system prompt and user message
+  const { system: systemPrompt, userMessage } = buildPrompts(
+    briefing, fullContext, project, headless, effectiveAgent, 'normal', client
+  );
+
+  // Use provided task ID (from MCP server) or generate a new one
+  const newTaskId = options.newTaskId || generateTaskId();
+  logger.info('New continuation task', { newTaskId, oldTaskId });
+
+  const sessionDir = createContinueSessionMetadata(newTaskId, project, {
+    model, briefing, headless, agent: effectiveAgent
+  }, oldTaskId);
+
+  saveInitialContext(sessionDir, systemPrompt, userMessage);
+
+  // Start heartbeat
+  const heartbeat = createHeartbeat();
+
+  let summary;
+
+  try {
+    if (headless) {
+      const result = await runHeadless(
+        model, systemPrompt, userMessage, newTaskId, project,
+        timeout * 60 * 1000, effectiveAgent, { mcp: mcpServers }
+      );
+      summary = result.summary ||
+        '## Sidecar Results: No Output\n\nContinued session completed without summary.';
+
+      if (result.timedOut) { logger.warn('Continuation task timed out', { taskId: newTaskId }); }
+      if (result.error) { logger.error('Continuation task error', { taskId: newTaskId, error: result.error }); }
+    } else {
+      logger.info('Launching interactive continue', { taskId: newTaskId, model });
+      const result = await runInteractive(
+        model, systemPrompt, userMessage, newTaskId, project,
+        { agent: effectiveAgent, mcp: mcpServers }
+      );
+      summary = result.summary || '';
+      if (result.error) { logger.error('Interactive continue error', { taskId: newTaskId, error: result.error }); }
+    }
+  } finally {
+    heartbeat.stop();
+    releaseLock(prevSessionDir);
+  }
+
+  // Output summary
+  outputSummary(summary);
+
+  // Load current metadata for finalization
+  const metaPath = SessionPaths.metadataFile(sessionDir);
+  const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+
+  // Finalize session
+  finalizeSession(sessionDir, summary, project, meta);
+}
+
+module.exports = {
+  loadPreviousSession,
+  buildContinuationContext,
+  createContinueSessionMetadata,
+  continueSidecar
+};

package/src/sidecar/crash-handler.js

@@ -0,0 +1,56 @@
+/**
+ * Crash Handler - Updates metadata to 'error' on uncaught exceptions
+ *
+ * Installed by bin/amicus.js for MCP-spawned processes that have a --task-id.
+ * When the process crashes, the handler marks the session as failed so the
+ * MCP client can detect the error instead of seeing a stuck 'running' status.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { SessionPaths } = require('./session-utils');
+
+/**
+ * Create a crash handler that updates session metadata on error.
+ *
+ * @param {string} taskId - The sidecar task ID
+ * @param {string} project - The project root directory
+ * @returns {function(Error): void} Handler function to call with the error
+ */
+function installCrashHandler(taskId, project) {
+  return function handleCrash(err) {
+    try {
+      // Operates on an EXISTING (possibly legacy) session — resolve dual-dir.
+      const sessionDir = SessionPaths.resolveSessionDir(project, taskId);
+      const metaPath = SessionPaths.metadataFile(sessionDir);
+
+      if (!fs.existsSync(metaPath)) {
+        return;
+      }
+
+      const metadata = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+
+      if (metadata.status !== 'running') {
+        return;
+      }
+
+      metadata.status = 'error';
+      metadata.reason = err.message;
+      metadata.errorAt = new Date().toISOString();
+
+      fs.writeFileSync(metaPath, JSON.stringify(metadata, null, 2), { mode: 0o600 });
+
+      // Delete session lock if it exists
+      const lockPath = path.join(sessionDir, 'session.lock');
+      try {
+        fs.unlinkSync(lockPath);
+      } catch {
+        // Lock may not exist yet
+      }
+    } catch (_ignored) {
+      // Crash handler must never throw - swallow all errors
+    }
+  };
+}
+
+module.exports = { installCrashHandler };

package/src/sidecar/fanout-leg.js

@@ -0,0 +1,107 @@
+// src/sidecar/fanout-leg.js
+'use strict';
+
+/**
+ * @module fanout-leg
+ * Per-leg helpers extracted from fanout.js to keep both files ≤300 lines.
+ * Exports: legStatusFromResult, writeLegPatch, runLeg
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logger } = require('../utils/logger');
+
+/** Map a runHeadless result to a leg metadata status. */
+function legStatusFromResult(result) {
+  const { statusFromResult } = require('../utils/result-schema');
+  return statusFromResult(result);
+}
+
+/** Read-merge-write a leg's metadata.json. Returns the merged object. */
+function writeLegPatch(legDir, patch) {
+  const metaPath = path.join(legDir, 'metadata.json');
+  let meta = {};
+  try { meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8')); } catch { /* fresh */ }
+  const defined = Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== undefined));
+  // A signal/abort marker is authoritative: never demote 'aborted' back to a
+  // softer terminal status (a leg finishing concurrently with Ctrl-C must not
+  // win the write race and report 'complete').
+  if (meta.status === 'aborted' && defined.status && defined.status !== 'aborted') {
+    delete defined.status;
+  }
+  const merged = { ...meta, ...defined };
+  fs.writeFileSync(metaPath, JSON.stringify(merged, null, 2), { mode: 0o600 });
+  return merged;
+}
+
+/**
+ * Run one leg end-to-end: session record → runHeadless (shared server) →
+ * leg finalize. Never throws — always resolves to a run document.
+ */
+async function runLeg({ leg, legId, waveId, project, systemPrompt, userMessage, timeoutMs, agent, client, server, summaryLength, reasoning, quiet }) {
+  const { IdleWatchdog } = require('../utils/idle-watchdog');
+  const { markAborted } = require('../utils/session-abort');
+  const { runHeadless } = require('../headless');
+  const { SessionPaths, saveInitialContext } = require('./session-utils');
+  const { buildRunResult } = require('../utils/result-schema');
+  const { createSessionMetadata } = require('./start');
+
+  const legDir = createSessionMetadata(legId, project, {
+    model: leg.model, prompt: userMessage, noUi: true, agent: agent || 'build',
+  });
+  writeLegPatch(legDir, { parentWave: waveId, modelInput: leg.modelInput });
+  saveInitialContext(legDir, systemPrompt, userMessage);
+
+  // Per-leg watchdog: a BACKSTOP strictly behind runHeadless's own deadline
+  // (timeoutMs + 60s), so it only fires if the poll loop itself wedges. Its
+  // timeout aborts ONLY this leg, and only while the leg is still running.
+  // NEVER server.close()/process.exit() — shared server.
+  const watchdog = new IdleWatchdog({
+    mode: 'headless',
+    timeout: timeoutMs + 60000,
+    onTimeout: () => {
+      let current = {};
+      try { current = JSON.parse(fs.readFileSync(path.join(legDir, 'metadata.json'), 'utf-8')); } catch { /* unreadable */ }
+      if (current.status === 'running') {
+        logger.warn('Leg watchdog backstop fired — aborting leg', { legId });
+        markAborted(legDir, 'leg watchdog backstop');
+      }
+    },
+  }).start();
+
+  let result;
+  try {
+    result = await runHeadless(
+      leg.model, systemPrompt, userMessage, legId, project,
+      timeoutMs, agent || 'build',
+      { client, server, watchdog, summaryLength, reasoning }
+    );
+  } catch (err) {
+    result = { summary: '', completed: false, timedOut: false, aborted: false, error: err.message, taskId: legId };
+  } finally {
+    watchdog.cancel();
+  }
+
+  const status = legStatusFromResult(result);
+  const summary = result.summary || null;
+  if (summary) {
+    fs.writeFileSync(SessionPaths.summaryFile(legDir), summary, { mode: 0o600 });
+  }
+  const finalMeta = writeLegPatch(legDir, {
+    status,
+    reason: result.error || undefined,
+    completedAt: new Date().toISOString(),
+  });
+  const effectiveResult = finalMeta.status === 'aborted'
+    ? { ...result, aborted: true }
+    : result;
+  if (!quiet) {
+    process.stderr.write(`[fanout] leg ${legId} (${leg.modelInput}): ${finalMeta.status}\n`);
+  }
+  return buildRunResult({
+    taskId: legId, metadata: finalMeta, result: effectiveResult, summary,
+    modelInput: leg.modelInput, sessionDir: legDir, waveId,
+  });
+}
+
+module.exports = { legStatusFromResult, writeLegPatch, runLeg };