@polymorphism-tech/morph-spec 4.21.0 → 5.0.1

package/src/lib/agents/agents-manager.js

@@ -1,349 +0,0 @@
-/**
- * agents-manager.js — Core logic for agent CRUD operations
- *
- * Pure functions that accept agentsData object. File I/O only in
- * loadAgentsFile / saveAgentsFile. All other functions are testable
- * with fixture data.
- *
- * @module agents-manager
- */
-
-import { existsSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
-import { mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-
-// ── Constants ──────────────────────────────────────────────────────────────────
-
-/** Known valid phases for active_phases validation */
-export const KNOWN_PHASES = [
-  'proposal', 'uiux', 'design',
-  'plan', 'tasks', 'implement', 'sync',
-];
-
-/** Tier labels for display and validation */
-export const TIER_LABELS = {
-  1: 'orchestrator',
-  2: 'leader',
-  3: 'specialist',
-  4: 'validator',
-};
-
-/** Tier metadata key names in agents.json */
-export const TIER_KEYS = {
-  1: 'tier_1_orchestrators',
-  2: 'tier_2_leaders',
-  3: 'tier_3_specialists',
-  4: 'tier_4_validators',
-};
-
-/** Agent ID pattern: kebab-case starting with a letter */
-export const AGENT_ID_PATTERN = /^[a-z][a-z0-9-]*$/;
-
-// ── Validation ─────────────────────────────────────────────────────────────────
-
-/**
- * Validate agent fields.
- * @param {string} id
- * @param {object} fields
- * @param {string[]} existingIds - IDs already in agents.json (for uniqueness check)
- * @param {string[]} [knownGroups] - Known group names (for warnings)
- * @param {object} [allAgents] - Full agents map (for circular reports_to check)
- * @returns {{ valid: boolean, errors: string[], warnings: string[] }}
- */
-export function validateAgent(id, fields, existingIds = [], knownGroups = [], allAgents = {}) {
-  const errors = [];
-  const warnings = [];
-
-  // ID validation
-  if (!AGENT_ID_PATTERN.test(id)) {
-    errors.push('Agent ID must be kebab-case (lowercase letters, numbers, hyphens) and start with a letter');
-  }
-  if (existingIds.includes(id)) {
-    errors.push(`Agent ID '${id}' is not unique — already exists in agents.json`);
-  }
-
-  // Tier
-  const tier = fields.tier;
-  if (tier == null || !Number.isInteger(tier) || tier < 1 || tier > 4) {
-    errors.push('Tier must be 1 (orchestrator), 2 (leader), 3 (specialist), or 4 (validator)');
-  }
-
-  // Title
-  if (!fields.title || typeof fields.title !== 'string' || fields.title.trim() === '') {
-    errors.push('Title is required');
-  }
-
-  // Group
-  if (!fields.group || typeof fields.group !== 'string' || fields.group.trim() === '') {
-    errors.push('Group is required');
-  } else if (knownGroups.length > 0 && !knownGroups.includes(fields.group)) {
-    warnings.push(`Unknown group '${fields.group}' — known groups: ${knownGroups.join(', ')}`);
-  }
-
-  // Active phases
-  if (fields.active_phases) {
-    const phases = fields.active_phases;
-    if (!Array.isArray(phases)) {
-      errors.push('active_phases must be an array');
-    } else if (phases.length === 1 && phases[0] === '*') {
-      // wildcard — valid
-    } else {
-      for (const p of phases) {
-        if (!KNOWN_PHASES.includes(p)) {
-          errors.push(`Invalid phase '${p}' — valid: ${KNOWN_PHASES.join(', ')}`);
-        }
-      }
-    }
-  }
-
-  // reports_to — circular check
-  if (fields.reports_to) {
-    if (fields.reports_to === id) {
-      errors.push('Agent cannot report to itself');
-    } else if (fields.reports_to !== 'user' && allAgents && Object.keys(allAgents).length > 0) {
-      // Walk the chain to detect cycles
-      const visited = new Set([id]);
-      let current = fields.reports_to;
-      while (current && current !== 'user') {
-        if (visited.has(current)) {
-          errors.push(`Circular reports_to chain detected: ${[...visited, current].join(' \u2192 ')}`);
-          break;
-        }
-        visited.add(current);
-        current = allAgents[current]?.reports_to;
-      }
-    }
-  }
-
-  // spawn_prompt required for tier >= 3
-  if (Number.isInteger(tier) && tier >= 3) {
-    const hasPrompt = fields.teammate?.spawn_prompt ||
-      (typeof fields.spawn_prompt === 'string' && fields.spawn_prompt.trim());
-    if (!hasPrompt) {
-      errors.push('spawn_prompt is required for tier 3+ agents');
-    }
-  }
-
-  return { valid: errors.length === 0, errors, warnings };
-}
-
-// ── Metadata Sync ──────────────────────────────────────────────────────────────
-
-/**
- * Recalculate total_agents and tier counts.
- * @param {object} agentsData - Full agents.json data
- * @returns {object} Updated agentsData (mutated in place + returned)
- */
-export function syncMetadata(agentsData) {
-  const agents = agentsData.agents || {};
-  const entries = Object.values(agents);
-
-  agentsData.total_agents = entries.length;
-  agentsData.tiers = {
-    tier_1_orchestrators: entries.filter(a => a.tier === 1).length,
-    tier_2_leaders: entries.filter(a => a.tier === 2).length,
-    tier_3_specialists: entries.filter(a => a.tier === 3).length,
-    tier_4_validators: entries.filter(a => a.tier === 4).length,
-  };
-
-  return agentsData;
-}
-
-// ── List + Show ────────────────────────────────────────────────────────────────
-
-/**
- * List agents with optional filters.
- * @param {object} agentsData
- * @param {{ group?: string, tier?: number }} [filters]
- * @returns {{ agents: Array, groupCounts: Record<string, number>, total: number }}
- */
-export function listAgents(agentsData, filters = {}) {
-  const agents = agentsData.agents || {};
-  let entries = Object.entries(agents).map(([id, data]) => ({ id, ...data }));
-
-  if (filters.group) {
-    entries = entries.filter(a => a.group === filters.group);
-  }
-  if (filters.tier != null) {
-    entries = entries.filter(a => a.tier === filters.tier);
-  }
-
-  entries.sort((a, b) => a.tier - b.tier || a.id.localeCompare(b.id));
-
-  // groupCounts over ALL agents (not filtered)
-  const groupCounts = {};
-  for (const a of Object.values(agents)) {
-    groupCounts[a.group] = (groupCounts[a.group] || 0) + 1;
-  }
-
-  return {
-    agents: entries.map(a => ({
-      id: a.id,
-      tier: a.tier,
-      title: a.title,
-      group: a.group,
-      phases: Array.isArray(a.active_phases) ? a.active_phases.join(',') : '*',
-      keywords: (a.keywords || []).join(', ') || '\u2014',
-    })),
-    groupCounts,
-    total: entries.length,
-  };
-}
-
-/**
- * Show detailed info for a single agent.
- * @param {object} agentsData
- * @param {string} id
- * @returns {object|null}
- */
-export function showAgent(agentsData, id) {
-  return agentsData.agents?.[id] ?? null;
-}
-
-// ── Mutations ──────────────────────────────────────────────────────────────────
-
-/**
- * Add a new agent.
- * @param {object} agentsData
- * @param {string} id
- * @param {object} fields
- * @returns {{ success: boolean, data?: object, changes?: string[], errors?: string[], warnings?: string[] }}
- */
-export function addAgent(agentsData, id, fields) {
-  const existingIds = Object.keys(agentsData.agents || {});
-  const knownGroups = [...new Set(Object.values(agentsData.agents || {}).map(a => a.group))];
-  const validation = validateAgent(id, fields, existingIds, knownGroups, agentsData.agents);
-
-  if (!validation.valid) {
-    return { success: false, errors: validation.errors, warnings: validation.warnings };
-  }
-
-  const entry = {
-    tier: fields.tier,
-    title: fields.title,
-    group: fields.group,
-    active_phases: fields.active_phases || ['implement'],
-    reports_to: fields.reports_to || 'user',
-    domains: fields.domains || [],
-    keywords: fields.keywords || [],
-    validators: fields.validators || [],
-    standards: fields.standards || [],
-  };
-
-  if (fields.stacks) entry.stacks = fields.stacks;
-  if (fields.teammate) entry.teammate = fields.teammate;
-
-  agentsData.agents[id] = entry;
-  syncMetadata(agentsData);
-
-  return {
-    success: true,
-    data: agentsData,
-    changes: [`Added agent '${id}' (tier ${fields.tier}, group '${fields.group}')`],
-    warnings: validation.warnings,
-  };
-}
-
-/**
- * Edit existing agent fields.
- * @param {object} agentsData
- * @param {string} id
- * @param {object} changes
- * @returns {{ success: boolean, data?: object, changes?: string[], errors?: string[] }}
- */
-export function editAgent(agentsData, id, changes) {
-  const agent = agentsData.agents?.[id];
-  if (!agent) {
-    return { success: false, errors: [`Agent '${id}' not found`] };
-  }
-
-  const changedFields = [];
-
-  // Handle spawn_prompt shortcut -> nested teammate
-  if (changes.spawn_prompt) {
-    if (!agent.teammate) {
-      agent.teammate = { role: 'specialist', icon: '\u{1F527}', spawn_prompt: changes.spawn_prompt };
-    } else {
-      agent.teammate.spawn_prompt = changes.spawn_prompt;
-    }
-    changedFields.push('teammate.spawn_prompt');
-    delete changes.spawn_prompt;
-  }
-
-  // Apply direct field changes
-  for (const [key, value] of Object.entries(changes)) {
-    if (value !== undefined && agent[key] !== value) {
-      changedFields.push(key);
-      agent[key] = value;
-    }
-  }
-
-  if (changedFields.length === 0) {
-    return { success: true, data: agentsData, changes: ['No changes detected'] };
-  }
-
-  syncMetadata(agentsData);
-  return { success: true, data: agentsData, changes: changedFields.map(f => `${f} updated`) };
-}
-
-/**
- * Remove an agent.
- * @param {object} agentsData
- * @param {string} id
- * @returns {{ success: boolean, data?: object, dependents?: string[], errors?: string[] }}
- */
-export function removeAgent(agentsData, id) {
-  if (!agentsData.agents?.[id]) {
-    return { success: false, errors: [`Agent '${id}' not found`] };
-  }
-
-  // Find dependents
-  const dependents = Object.entries(agentsData.agents)
-    .filter(([aid, a]) => aid !== id && a.reports_to === id)
-    .map(([aid]) => aid);
-
-  delete agentsData.agents[id];
-  syncMetadata(agentsData);
-
-  return { success: true, data: agentsData, dependents };
-}
-
-// ── File I/O ───────────────────────────────────────────────────────────────────
-
-/**
- * Load and parse agents.json.
- * @param {string} filePath
- * @returns {object}
- * @throws {Error} If file not found or invalid JSON
- */
-export function loadAgentsFile(filePath) {
-  if (!existsSync(filePath)) {
-    throw new Error(`agents.json not found at ${filePath}. Run 'morph-spec doctor' to diagnose.`);
-  }
-
-  try {
-    const content = readFileSync(filePath, 'utf8');
-    return JSON.parse(content);
-  } catch (err) {
-    if (err instanceof SyntaxError) {
-      throw new Error(`Failed to parse agents.json: ${err.message}. Run 'morph-spec doctor' to diagnose.`);
-    }
-    throw err;
-  }
-}
-
-/**
- * Write agents.json atomically (write to .tmp, then rename).
- * @param {string} filePath
- * @param {object} agentsData
- */
-export function saveAgentsFile(filePath, agentsData) {
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-
-  const tmpPath = `${filePath}.tmp.${process.pid}`;
-  writeFileSync(tmpPath, JSON.stringify(agentsData, null, 2) + '\n', 'utf8');
-  renameSync(tmpPath, filePath);
-}

package/src/lib/build/build-runner.js

@@ -1,99 +0,0 @@
-/**
- * Build Runner — Resolves and executes the project's build command.
- *
- * Resolution order for build command:
- *   1. .morph/config/config.json → project.buildCommand
- *   2. Stack profile → profile.buildCommand
- *   3. package.json → scripts.build → "npm run build"
- *   4. tsconfig.json at root → "npx tsc --noEmit"
- *   5. null (no build command detected)
- */
-
-import { execSync } from 'child_process';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { getStackProfile } from '../stack/stack-profile.js';
-
-/**
- * Resolve the build command for a project.
- *
- * @param {string} [projectPath] - Project root directory (defaults to '.')
- * @returns {string | null} The build command to run, or null if none found
- */
-export function resolveBuildCommand(projectPath = '.') {
-  // 1. Explicit override from .morph/config/config.json
-  const configPath = join(projectPath, '.morph', 'config', 'config.json');
-  if (existsSync(configPath)) {
-    try {
-      const config = JSON.parse(readFileSync(configPath, 'utf8'));
-      const cmd = config?.project?.buildCommand;
-      if (cmd && typeof cmd === 'string') {
-        return cmd;
-      }
-    } catch {
-      // Malformed config — fall through to detection
-    }
-  }
-
-  // 2. Stack profile default (only when an actual stack is configured)
-  const profile = getStackProfile(projectPath);
-  if (profile.stack !== 'unknown' && profile.buildCommand) {
-    return profile.buildCommand;
-  }
-
-  // 3. package.json with a build script
-  const packageJsonPath = join(projectPath, 'package.json');
-  if (existsSync(packageJsonPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-      if (pkg?.scripts?.build) {
-        return 'npm run build';
-      }
-    } catch {
-      // Malformed package.json — fall through
-    }
-  }
-
-  // 4. tsconfig.json at root → generic type-check
-  if (existsSync(join(projectPath, 'tsconfig.json'))) {
-    return 'npx tsc --noEmit';
-  }
-
-  // 5. Nothing found
-  return null;
-}
-
-/**
- * Run the project's build check.
- *
- * @param {string} [projectPath] - Project root directory (defaults to '.')
- * @param {object} [opts] - Optional overrides for testing
- * @param {Function} [opts._execSync] - Override execSync for unit testing
- * @returns {{ passed?: boolean, output?: string, exitCode?: number, command?: string, skipped?: boolean, reason?: string }}
- */
-export function runBuildCheck(projectPath = '.', opts = {}) {
-  const cmd = resolveBuildCommand(projectPath);
-
-  if (!cmd) {
-    return { skipped: true, reason: 'No buildCommand configured and no known project file detected' };
-  }
-
-  const exec = opts._execSync ?? execSync;
-
-  try {
-    const output = exec(cmd, {
-      cwd: projectPath,
-      timeout: 120_000,
-      encoding: 'utf8',
-      stdio: 'pipe'
-    });
-    return { passed: true, output: output ?? '', exitCode: 0, command: cmd };
-  } catch (err) {
-    return {
-      passed: false,
-      output: (err.stdout || '') + (err.stderr || ''),
-      exitCode: err.status ?? 1,
-      command: cmd
-    };
-  }
-}

package/src/lib/checkpoints/checkpoint-hooks.js

@@ -1,111 +0,0 @@
-/**
- * Checkpoint Hooks — Orchestrates validation, build, and test phases at checkpoints.
- *
- * This is the module that task-manager.js imports at:
- *   import('../src/lib/checkpoints/checkpoint-hooks.js')
- *
- * All three phases run independently (failures don't short-circuit) so the user
- * gets a complete picture of all issues in a single checkpoint report.
- */
-
-import chalk from 'chalk';
-import { runValidation } from '../validators/validation-runner.js';
-import { runBuildCheck } from '../build/build-runner.js';
-import { runTestSuite } from '../tasks/test-runner.js';
-import { persistCheckpointValidation } from '../validators/checkpoint-persistence.js';
-
-/**
- * Determine whether a checkpoint should run based on task count and frequency.
- *
- * @param {number} tasksCompleted - Number of tasks completed so far
- * @param {number} frequency - Run every N tasks (default: 3)
- * @returns {boolean}
- */
-export function shouldRunCheckpoint(tasksCompleted, frequency = 3) {
-  return tasksCompleted > 0 && tasksCompleted % frequency === 0;
-}
-
-/**
- * Run all checkpoint hooks: static validation, build check, and test suite.
- *
- * @param {string} featureName - The feature being worked on
- * @param {number} checkpointNum - Checkpoint sequence number
- * @param {object} [opts] - Options
- * @param {string} [opts.projectPath] - Project root (defaults to cwd)
- * @returns {Promise<{ passed: boolean, summary: { errors: number, warnings: number }, results: object }>}
- */
-export async function runCheckpointHooks(featureName, checkpointNum, opts = {}) {
-  const projectPath = opts.projectPath ?? process.cwd();
-  const results = {};
-  let totalErrors = 0;
-  let totalWarnings = 0;
-
-  // Phase 1: Static validators
-  console.log(chalk.gray('\n  Phase 1/3: Running static validators...'));
-  try {
-    const valResult = await runValidation(projectPath, featureName, { verbose: false, mode: 'full' });
-    results.validators = {
-      passed: valResult.passed,
-      errors: valResult.errors,
-      warnings: valResult.warnings,
-      details: valResult.results,
-      scores: valResult.scores || null
-    };
-    totalErrors += valResult.errors;
-    totalWarnings += valResult.warnings;
-  } catch (err) {
-    results.validators = { passed: false, errors: 1, warnings: 0, details: {}, error: err.message };
-    totalErrors += 1;
-  }
-
-  // Phase 2: Build check
-  console.log(chalk.gray('  Phase 2/3: Running build check...'));
-  const buildResult = runBuildCheck(projectPath);
-  results.build = buildResult;
-  if (buildResult.skipped) {
-    console.log(chalk.gray(`    Skipped: ${buildResult.reason}`));
-  } else if (buildResult.passed) {
-    console.log(chalk.green(`    ✓ Build passed (${buildResult.command})`));
-  } else {
-    console.log(chalk.red(`    ✗ Build failed (${buildResult.command})`));
-    totalErrors += 1;
-  }
-
-  // Phase 3: Test suite
-  console.log(chalk.gray('  Phase 3/3: Running test suite...'));
-  const testResult = runTestSuite(projectPath);
-  results.tests = testResult;
-  if (testResult.skipped) {
-    console.log(chalk.gray(`    Skipped: ${testResult.reason}`));
-  } else if (testResult.passed) {
-    console.log(chalk.green('    ✓ Tests passed'));
-  } else {
-    console.log(chalk.red('    ✗ Tests failed'));
-    totalErrors += 1;
-  }
-
-  // Persist results
-  const summaryText = [
-    `Validators: ${results.validators?.errors || 0} errors, ${results.validators?.warnings || 0} warnings`,
-    buildResult.skipped ? 'Build: skipped' : `Build: ${buildResult.passed ? 'passed' : 'FAILED'}`,
-    testResult.skipped ? 'Tests: skipped' : `Tests: ${testResult.passed ? 'passed' : 'FAILED'}`
-  ].join(' | ');
-
-  try {
-    persistCheckpointValidation(projectPath, featureName, {
-      checkpointNum,
-      timestamp: new Date().toISOString(),
-      passed: totalErrors === 0,
-      validators: results,
-      summary: summaryText
-    });
-  } catch {
-    // Non-blocking — persistence failure shouldn't break the checkpoint
-  }
-
-  return {
-    passed: totalErrors === 0,
-    summary: { errors: totalErrors, warnings: totalWarnings },
-    results
-  };
-}

package/src/lib/contracts/sprint-contract-generator.js

@@ -1,137 +0,0 @@
-/**
- * Sprint Contract Generator
- *
- * Generates sprint contracts from tasks.md + spec.md for the evaluator.
- * Contracts define objective "definition of done" criteria.
- */
-
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
-import { join } from 'path';
-import { getBuildCommand } from '../../../framework/hooks/shared/build-check.js';
-
-/**
- * Parse a task entry from tasks.md markdown.
- *
- * Expected format: ## T001: Task Title [FR001, FR003]
- *
- * @param {string} content - tasks.md content
- * @param {string} taskId - Task ID (e.g., 'T001')
- * @returns {{ id: string, title: string, frs: string[], description: string }|null}
- */
-export function parseTaskFromMarkdown(content, taskId) {
-  const pattern = new RegExp(
-    `##\\s+${taskId}:\\s+(.+?)(?:\\s+\\[([^\\]]+)\\])?\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`,
-    'i'
-  );
-  const match = content.match(pattern);
-  if (!match) return null;
-
-  const title = match[1].trim();
-  const frString = match[2] || '';
-  const description = match[3].trim();
-
-  const frs = frString
-    ? frString.split(',').map(fr => fr.trim()).filter(Boolean)
-    : [];
-
-  return { id: taskId, title, frs, description };
-}
-
-/**
- * Generate a sprint contract for a task.
- *
- * @param {string} projectPath - Project root
- * @param {string} featureName - Feature name
- * @param {string} taskId - Task ID
- * @returns {Object|null} Contract object or null if unable to generate
- */
-export function generateSprintContract(projectPath, featureName, taskId) {
-  const featureDir = join(projectPath, '.morph/features', featureName);
-  const tasksPath = join(featureDir, '4-tasks/tasks.md');
-
-  if (!existsSync(tasksPath)) return null;
-
-  const tasksContent = readFileSync(tasksPath, 'utf-8');
-  const task = parseTaskFromMarkdown(tasksContent, taskId);
-  if (!task) return null;
-
-  // Read spec for FR-based criteria
-  const specPath = join(featureDir, '2-design/spec.md');
-  let definitionOfDone = [];
-  if (task.frs.length > 0 && existsSync(specPath)) {
-    const specContent = readFileSync(specPath, 'utf-8');
-    for (const fr of task.frs) {
-      const frPattern = new RegExp(`##\\s+${fr}[:\\s]([\\s\\S]*?)(?=\\n##\\s|$)`, 'i');
-      const frMatch = specContent.match(frPattern);
-      if (frMatch) {
-        const bullets = frMatch[1].match(/^[\s]*[-*]\s+(.+)/gm);
-        if (bullets) {
-          definitionOfDone.push(...bullets.map(b => b.replace(/^[\s]*[-*]\s+/, '').trim()));
-        }
-      }
-    }
-  }
-
-  if (definitionOfDone.length === 0) {
-    definitionOfDone = [task.description || `Complete ${task.title}`];
-  }
-
-  // Read stack for build commands
-  let stack = '';
-  try {
-    const configPath = join(projectPath, '.morph/config/config.json');
-    if (existsSync(configPath)) {
-      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-      stack = config?.project?.stack || '';
-    }
-  } catch { /* ignore */ }
-
-  const hasTsConfig = existsSync(join(projectPath, 'tsconfig.json'));
-  const buildCmd = getBuildCommand(stack, hasTsConfig);
-
-  const contract = {
-    task: taskId,
-    title: task.title,
-    functionalRequirements: task.frs,
-    definitionOfDone,
-    verification: {
-      build: buildCmd || 'echo "No build command configured"',
-      test: stack.includes('dotnet') ? `dotnet test --filter ${task.title.replace(/\s+/g, '')}` : 'npm test',
-      e2e: null
-    },
-    maxAttempts: 3,
-    generatedAt: new Date().toISOString()
-  };
-
-  // Write contract to disk
-  const contractsDir = join(featureDir, '5-implement/contracts');
-  mkdirSync(contractsDir, { recursive: true });
-  const yamlContent = contractToYaml(contract);
-  writeFileSync(join(contractsDir, `${taskId}-contract.yaml`), yamlContent, 'utf-8');
-
-  return contract;
-}
-
-/**
- * Simple YAML serializer for contracts (no dependency needed).
- *
- * @param {Object} contract - Contract object
- * @returns {string} YAML string
- */
-function contractToYaml(contract) {
-  const lines = [
-    `task: ${contract.task}`,
-    `title: "${contract.title}"`,
-    `functionalRequirements:`,
-    ...contract.functionalRequirements.map(fr => `  - ${fr}`),
-    `definitionOfDone:`,
-    ...contract.definitionOfDone.map(d => `  - "${d}"`),
-    `verification:`,
-    `  build: "${contract.verification.build}"`,
-    `  test: "${contract.verification.test}"`,
-    `  e2e: ${contract.verification.e2e ? `"${contract.verification.e2e}"` : 'null'}`,
-    `maxAttempts: ${contract.maxAttempts}`,
-    `generatedAt: "${contract.generatedAt}"`,
-  ];
-  return lines.join('\n') + '\n';
-}