@arka-labs/nemesis 1.2.0

package/lib/core/team.js

@@ -0,0 +1,287 @@
+import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, statSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { detectProject } from './project.js';
+import { readRegistry, writeRegistry, addLane, removeLane, getLanes, getPM } from './registry.js';
+import { loadTemplate, mergeTemplate } from './templates.js';
+import { generateMemory, generateOnboardingPrompt, updateClaudeMd, getRepoName } from './generators.js';
+
+/**
+ * Team Add — 9 steps from spec.
+ */
+export async function teamAdd(opts) {
+  const {
+    root = process.cwd(),
+    agentName,
+    role,
+    reportsTo,
+    profileId = null,
+    kairosData = null,
+    odmIds = [],
+    mcpServers = [],
+    environment = null,
+    leader = false,
+  } = opts;
+
+  const results = [];
+
+  // Step 1: Detect project
+  const project = detectProject(root);
+  if (!project) {
+    throw new Error('Aucun projet detecte. Lancez "nemesis init" d\'abord.');
+  }
+  results.push({ step: 1, label: 'Projet detecte', detail: project.id });
+
+  // Step 2: Profile Kairos
+  if (profileId) {
+    results.push({ step: 2, label: 'Profil Kairos', detail: profileId });
+  }
+
+  // Step 3: Agent configured
+  results.push({ step: 3, label: 'Agent configure', detail: `${agentName} — ${role}` });
+
+  // Step 4: Create memory.md
+  const agentDir = join(root, '.nemesis', 'claude', agentName);
+  mkdirSync(agentDir, { recursive: true });
+  const memoryFile = join(agentDir, 'memory.md');
+  if (!existsSync(memoryFile)) {
+    writeFileSync(memoryFile, generateMemory(agentName, role, project), 'utf-8');
+  }
+  results.push({ step: 4, label: 'memory.md cree', detail: `.nemesis/claude/${agentName}/memory.md` });
+
+  // Step 5: Create contributor card
+  const contribId = agentName.replace('Agent_', '').replace(/_/g, '-');
+  const contrib = mergeTemplate(loadTemplate('contributor', root), {
+    contributor_meta: { contributor_id: `CONTRIB-${contribId}`, kind: 'agent', project_id: project.id },
+    contributor_payload: {
+      identity: { display_name: agentName, role, organization: 'Arka Labs' },
+      expertise: { domains: [], description: role },
+      profiles: profileId ? [profileId] : [],
+    },
+  });
+  const contribFile = join(project.hcm_dir, 'contributors', `CONTRIB-${contribId}.json`);
+  writeFileSync(contribFile, JSON.stringify(contrib, null, 2) + '\n', 'utf-8');
+  results.push({ step: 5, label: 'Contributor card creee', detail: contribFile.replace(root + '/', '') });
+
+  // Step 6: Update registry
+  const registry = readRegistry(project.hcm_dir);
+  if (registry) {
+    addLane(registry, {
+      id: agentName, name: agentName, kind: 'agent', role,
+      reports_to: reportsTo || 'PM', reviews: [], executes_from: odmIds,
+      responsibilities: [role], memory_path: `.nemesis/claude/${agentName}/memory.md`,
+      mcp_servers: mcpServers,
+      leader,
+    });
+    writeRegistry(project.hcm_dir, registry);
+    results.push({ step: 6, label: 'Registre mis a jour', detail: `Lane ajoutee : ${agentName}` });
+  }
+
+  // Step 7: Update CLAUDE.md
+  const claudeMdPath = join(homedir(), '.claude', 'CLAUDE.md');
+  if (existsSync(claudeMdPath)) {
+    updateClaudeMd(claudeMdPath, {
+      agentName, repo: getRepoName(root), role,
+      memoryPath: `${getRepoName(root)}/.nemesis/claude/${agentName}/memory.md`,
+    });
+    results.push({ step: 7, label: 'CLAUDE.md mis a jour', detail: 'Tableau + Workflow' });
+  }
+
+  // Step 8: Generate onboarding prompt
+  const onboardingDir = join(root, '.nemesis', 'onboarding');
+  mkdirSync(onboardingDir, { recursive: true });
+  const promptFile = join(onboardingDir, `prompt-${contribId}.md`);
+  // Build environment state for the prompt
+  const envState = environment || {
+    hcm: !!project.hcm_status?.connected,
+    files: [],
+  };
+  // Add files that were just created
+  if (existsSync(memoryFile)) envState.files = [...(envState.files || []), `.nemesis/claude/${agentName}/memory.md`];
+  if (existsSync(contribFile)) envState.files = [...(envState.files || []), contribFile.replace(root + '/', '')];
+
+  writeFileSync(promptFile, generateOnboardingPrompt({ agentName, role, profileId, kairosData, reportsTo, project, odmIds, environment: envState }), 'utf-8');
+  results.push({ step: 8, label: 'Prompt d\'onboarding genere', detail: `.nemesis/onboarding/prompt-${contribId}.md` });
+
+  // Step 9: Launch command
+  const launchCmd = `claude --prompt .nemesis/onboarding/prompt-${contribId}.md`;
+  results.push({ step: 9, label: 'Commande de lancement', detail: launchCmd });
+
+  return { project, agentName, results, launchCmd, promptPath: promptFile };
+}
+
+/**
+ * Team List — build org tree from registry.
+ */
+export function teamList(hcmDir) {
+  const registry = readRegistry(hcmDir);
+  if (!registry) return null;
+
+  const pm = getPM(registry);
+  const lanes = getLanes(registry);
+
+  const tree = {
+    label: `${pm?.name || 'PM'} (${pm?.role || 'PM'})`,
+    meta: pm?.kind || 'human',
+    children: [],
+  };
+
+  const byReportsTo = {};
+  for (const lane of lanes) {
+    const parent = lane.reports_to || 'PM';
+    if (!byReportsTo[parent]) byReportsTo[parent] = [];
+    byReportsTo[parent].push(lane);
+  }
+
+  const topAgents = [
+    ...(byReportsTo['PM'] || []),
+    ...(byReportsTo[pm?.name] || []),
+    ...(byReportsTo[pm?.id] || []),
+  ];
+  const seen = new Set();
+  for (const agent of topAgents) {
+    if (seen.has(agent.id)) continue;
+    seen.add(agent.id);
+    tree.children.push(buildAgentNode(agent, byReportsTo, seen));
+  }
+
+  for (const lane of lanes) {
+    if (!seen.has(lane.id)) {
+      tree.children.push(buildAgentNode(lane, byReportsTo, seen));
+    }
+  }
+
+  return { tree, registry };
+}
+
+function buildAgentNode(agent, byReportsTo, seen) {
+  const node = { label: agent.name || agent.id, meta: agent.role, children: [] };
+  const subordinates = byReportsTo[agent.id] || byReportsTo[agent.name] || [];
+  for (const sub of subordinates) {
+    if (seen.has(sub.id)) continue;
+    seen.add(sub.id);
+    node.children.push(buildAgentNode(sub, byReportsTo, seen));
+  }
+  return node;
+}
+
+/**
+ * Team Inspect — detailed view of an agent.
+ */
+export function teamInspect(agentId, projectRoot) {
+  const { detectProject } = require_detect();
+  const project = detectProject(projectRoot);
+  if (!project) throw new Error('Aucun projet detecte.');
+
+  const registry = readRegistry(project.hcm_dir);
+  if (!registry) throw new Error('Registry introuvable.');
+
+  const lanes = getLanes(registry);
+  const lane = lanes.find(l => l.id === agentId || l.name === agentId);
+  if (!lane) throw new Error(`Agent ${agentId} non trouve dans le registre.`);
+
+  // Memory info
+  let memoryInfo = null;
+  if (lane.memory_path) {
+    const memPath = join(projectRoot, lane.memory_path);
+    if (existsSync(memPath)) {
+      const stat = statSync(memPath);
+      memoryInfo = {
+        path: lane.memory_path,
+        size: (stat.size / 1024).toFixed(1) + ' KB',
+        modified: stat.mtime.toISOString().split('T')[0],
+      };
+    }
+  }
+
+  // Assigned OdMs
+  const odmDir = join(project.hcm_dir, 'odm');
+  let assignedOdms = [];
+  if (existsSync(odmDir)) {
+    assignedOdms = readdirSync(odmDir)
+      .filter(f => f.endsWith('.json') && !f.startsWith('legacy_'))
+      .map(f => {
+        try {
+          const data = JSON.parse(readFileSync(join(odmDir, f), 'utf-8'));
+          return data;
+        } catch (_e) { /* fallback: malformed OdM */ return null; }
+      })
+      .filter(Boolean)
+      .filter(d => {
+        const assignee = d.odm_meta?.assigned_to?.actor_id || '';
+        return assignee === agentId || assignee === lane.name;
+      })
+      .map(d => ({
+        id: d.odm_meta?.odm_id || '?',
+        status: d.odm_meta?.status || '?',
+        title: d.odm_payload?.cadrage?.title || '',
+      }));
+  }
+
+  // Associated CRs
+  const crDir = join(project.hcm_dir, 'cr');
+  let crs = [];
+  if (existsSync(crDir)) {
+    crs = readdirSync(crDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => {
+        try { return JSON.parse(readFileSync(join(crDir, f), 'utf-8')); } catch (_e) { /* fallback: malformed CR */ return null; }
+      })
+      .filter(Boolean)
+      .filter(d => (d.metadata?.executed_by || '').includes(agentId))
+      .map(d => ({
+        id: d.metadata?.odm_id || '?',
+        title: d.title || '',
+        date: d.metadata?.date_execution || '',
+      }));
+  }
+
+  return {
+    agent: lane,
+    memory: memoryInfo,
+    odms: assignedOdms,
+    crs,
+    project: project.id,
+  };
+}
+
+/**
+ * Team Remove — archive agent (no deletion).
+ */
+export function teamRemove(agentId, projectRoot) {
+  const project = detectProject(projectRoot);
+  if (!project) throw new Error('Aucun projet detecte.');
+
+  const registry = readRegistry(project.hcm_dir);
+  if (!registry) throw new Error('Registry introuvable.');
+
+  // Remove from registry
+  removeLane(registry, agentId);
+  writeRegistry(project.hcm_dir, registry);
+
+  // Remove from CLAUDE.md (if present)
+  const claudeMdPath = join(homedir(), '.claude', 'CLAUDE.md');
+  if (existsSync(claudeMdPath)) {
+    let content = readFileSync(claudeMdPath, 'utf-8');
+    // Remove table row
+    const lines = content.split('\n');
+    const filtered = lines.filter(l => !l.includes(`**${agentId}**`));
+    // Remove workflow line
+    const finalLines = filtered.filter(l => !l.includes(`${agentId} :`));
+    writeFileSync(claudeMdPath, finalLines.join('\n'), 'utf-8');
+  }
+
+  // Archive: rename memory.md → memory.md.archived (don't delete)
+  const memoryDir = join(projectRoot, '.nemesis', 'claude', agentId);
+  const memoryFile = join(memoryDir, 'memory.md');
+  if (existsSync(memoryFile)) {
+    renameSync(memoryFile, memoryFile + '.archived');
+  }
+
+  return { agentId, archived: true };
+}
+
+// Lazy import to avoid circular dependency
+function require_detect() {
+  return { detectProject };
+}

package/lib/core/templates.js

@@ -0,0 +1,80 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const EMBEDDED_DIR = join(__dirname, '..', '..', 'templates');
+
+const TEMPLATE_MAP = {
+  'odm': 'template_ODM-NAME-000.json',
+  'cr': 'template_CR-ODM-NAME-000.exemple.json',
+  'mission-contract': 'template_MISSION_CONTRACT.json',
+  'registry': 'template_REGISTRY-PROJECT.json',
+  'decision': 'template_DEC-NAME-000.json',
+  'intervention': 'template_INTV-NAME-000.json',
+  'contributor': 'template_CONTRIB-NAME.json',
+  'transaction': 'template_TXN-NAME-000.json',
+  'project-context': 'project-context.json',
+};
+
+/**
+ * Load a template by type.
+ * Priority: .nemesis/template/ > .owner/template/ (legacy) > embedded templates/
+ */
+export function loadTemplate(type, projectRoot = process.cwd()) {
+  const filename = TEMPLATE_MAP[type];
+  if (!filename) {
+    throw new Error(`Template inconnu : ${type}. Types valides : ${Object.keys(TEMPLATE_MAP).join(', ')}`);
+  }
+
+  // Priority 1: .nemesis/template/
+  const nemesisPath = join(projectRoot, '.nemesis', 'template', filename);
+  if (existsSync(nemesisPath)) {
+    return JSON.parse(readFileSync(nemesisPath, 'utf-8'));
+  }
+
+  // Priority 2: .owner/template/ (legacy fallback)
+  const legacyPath = join(projectRoot, '.owner', 'template', filename);
+  if (existsSync(legacyPath)) {
+    return JSON.parse(readFileSync(legacyPath, 'utf-8'));
+  }
+
+  // Priority 3: embedded templates/
+  const embeddedPath = join(EMBEDDED_DIR, filename);
+  if (existsSync(embeddedPath)) {
+    return JSON.parse(readFileSync(embeddedPath, 'utf-8'));
+  }
+
+  throw new Error(`Template "${type}" introuvable (${filename})`);
+}
+
+/**
+ * Deep merge values into a template.
+ */
+export function mergeTemplate(template, values) {
+  return deepMerge(structuredClone(template), values);
+}
+
+function deepMerge(target, source) {
+  for (const key of Object.keys(source)) {
+    if (
+      source[key] !== null &&
+      typeof source[key] === 'object' &&
+      !Array.isArray(source[key]) &&
+      typeof target[key] === 'object' &&
+      !Array.isArray(target[key])
+    ) {
+      deepMerge(target[key], source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+
+/**
+ * List available template types.
+ */
+export function listTemplateTypes() {
+  return Object.keys(TEMPLATE_MAP);
+}

package/lib/kairos/agent-runner.js

@@ -0,0 +1,261 @@
+/**
+ * Agent Runner — dispatch a prompt to an agent headless (non-interactive).
+ * The agent runs detached; its Stop hook writes the result to dispatch-results/.
+ * No blocking wait — the Leader polls for results via hooks.
+ */
+
+import { spawn } from 'node:child_process';
+import { writeFileSync, mkdirSync, existsSync, readdirSync, readFileSync, unlinkSync, openSync, closeSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../core/logger.js';
+
+const PENDING_DIR = '.nemesis/kairos/pending-dispatch';
+const RESULTS_DIR = '.nemesis/kairos/dispatch-results';
+
+/**
+ * Launch an agent headless with a prompt. Returns immediately.
+ * The agent runs detached; its Stop hook will write the result.
+ * @param {object} agent — lane from registry (must have session_id)
+ * @param {string} prompt — formatted prompt text
+ * @param {object} opts
+ * @param {string} opts.txnId — transaction ID for tracking
+ * @param {string} [opts.odmId] — OdM ID if dispatching an OdM
+ * @param {string} [opts.projectId] — project ID
+ * @param {string} opts.root — project root
+ * @returns {{ pid: number|null, txnId: string }}
+ */
+export async function launchHeadless(agent, prompt, opts = {}) {
+  const { txnId, odmId = '', missionId = '', projectId = '', root = process.cwd() } = opts;
+
+  if (!agent?.session_id) {
+    throw new Error(
+      `Agent ${agent?.name || 'inconnu'} n'a pas de session_id. Lancez d'abord un onboarding.`
+    );
+  }
+
+  if (!txnId) {
+    throw new Error('txnId requis pour le tracking du dispatch.');
+  }
+
+  const launchedAt = new Date().toISOString();
+
+  // Write pending dispatch file — Stop hook will read it
+  createPendingDispatch(root, txnId, {
+    agentName: agent.name || agent.id,
+    agentSessionId: agent.session_id,
+    txnId,
+    odmId,
+    missionId,
+    projectId,
+    launchedAt,
+  });
+
+  // Log file for diagnostics — captures stdout/stderr
+  const logDir = join(root, PENDING_DIR);
+  const logPath = join(logDir, `${txnId}.log`);
+  const logFd = openSync(logPath, 'w');
+
+  // Spawn detached — agent runs independently
+  // stdout/stderr → log file (not /dev/null) for debugging
+  const child = spawn('claude', [
+    '--resume', agent.session_id,
+    '-p', prompt,
+    '--dangerously-skip-permissions',
+  ], {
+    stdio: ['ignore', logFd, logFd],
+    detached: true,
+    env: (() => { const e = { ...process.env }; delete e.CLAUDECODE; return e; })(),
+  });
+
+  child.unref();
+  closeSync(logFd);
+
+  // Patch pending-dispatch file with PID so dashboard can track liveness
+  if (child.pid) {
+    try {
+      const pendingPath = join(root, PENDING_DIR, `${txnId}.json`);
+      const pending = JSON.parse(readFileSync(pendingPath, 'utf-8'));
+      pending.pid = child.pid;
+      writeFileSync(pendingPath, JSON.stringify(pending, null, 2) + '\n', 'utf-8');
+    } catch (e) { debug(`launchHeadless PID patch: ${e.message}`); }
+
+    try {
+      const { registerPid } = await import('./pid-checker.js');
+      registerPid(root, agent.name || agent.id, child.pid, agent.session_id);
+    } catch (e) { debug(`launchHeadless registerPid: ${e.message}`); }
+  }
+
+  return { pid: child.pid ?? null, txnId };
+}
+
+/**
+ * Create a pending dispatch marker for the Stop hook to pick up.
+ * @param {string} root — project root
+ * @param {string} txnId
+ * @param {object} metadata — { agentName, agentSessionId, odmId, projectId, launchedAt }
+ */
+export function createPendingDispatch(root, txnId, metadata) {
+  const dir = join(root, PENDING_DIR);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const filepath = join(dir, `${txnId}.json`);
+  writeFileSync(filepath, JSON.stringify(metadata, null, 2) + '\n', 'utf-8');
+}
+
+/**
+ * Find pending dispatch for a given agent (called by Stop hook).
+ * @param {string} root
+ * @param {string} agentName
+ * @returns {{ txnId: string, metadata: object }|null}
+ */
+export function findPendingDispatch(root, agentName) {
+  const dir = join(root, PENDING_DIR);
+  if (!existsSync(dir)) return null;
+
+  const files = readdirSync(dir).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    try {
+      const data = JSON.parse(readFileSync(join(dir, file), 'utf-8'));
+      if (data.agentName === agentName) {
+        return { txnId: file.replace('.json', ''), metadata: data };
+      }
+    } catch (e) { debug(`findPendingDispatch ${file}: ${e.message}`); }
+  }
+  return null;
+}
+
+/**
+ * Write dispatch result (called by Stop hook when agent finishes).
+ * @param {string} root
+ * @param {string} txnId
+ * @param {object} result — { agentName, odmId, response, exitCode, finishedAt }
+ */
+export function writeDispatchResult(root, txnId, result) {
+  const dir = join(root, RESULTS_DIR);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const filepath = join(dir, `${txnId}.json`);
+  writeFileSync(filepath, JSON.stringify(result, null, 2) + '\n', 'utf-8');
+}
+
+/**
+ * Consume pending dispatch file (cleanup after writing result).
+ * @param {string} root
+ * @param {string} txnId
+ */
+export function consumePendingDispatch(root, txnId) {
+  const filepath = join(root, PENDING_DIR, `${txnId}.json`);
+  try { unlinkSync(filepath); } catch (e) { debug(`consumePendingDispatch: ${e.message}`); }
+}
+
+/**
+ * Read and consume all dispatch results (called by Leader polling).
+ * @param {string} root
+ * @returns {Array<{ txnId: string, result: object }>}
+ */
+export function consumeDispatchResults(root) {
+  const dir = join(root, RESULTS_DIR);
+  if (!existsSync(dir)) return [];
+
+  const files = readdirSync(dir).filter(f => f.endsWith('.json'));
+  const results = [];
+
+  for (const file of files) {
+    const filepath = join(dir, file);
+    try {
+      const data = JSON.parse(readFileSync(filepath, 'utf-8'));
+      results.push({ txnId: file.replace('.json', ''), result: data });
+      unlinkSync(filepath); // consume
+    } catch (e) { debug(`consumeDispatchResults ${file}: ${e.message}`); }
+  }
+
+  return results;
+}
+
+/**
+ * Build a formatted dispatch prompt from an OdM or free document.
+ * @param {object|null} odm — full OdM JSON (null for free document)
+ * @param {object} opts
+ * @param {string} [opts.additionalContext] — extra leader instructions
+ * @param {string} [opts.documentBody] — free text (when odm is null)
+ * @returns {string}
+ */
+export function buildDispatchPrompt(odm, opts = {}) {
+  const { additionalContext = '', documentBody = '' } = opts;
+
+  if (!odm) {
+    const parts = [
+      '# Document a traiter',
+      '',
+      documentBody,
+      '',
+      '## Instructions',
+      'Traite ce document et depose tes livrables dans .nemesis/HCM/.',
+    ];
+    if (additionalContext) parts.push(additionalContext);
+    return parts.join('\n');
+  }
+
+  // Support both flat format (arka.odm.v1) and nested format (odm_meta/odm_payload)
+  const isFlat = !odm.odm_meta && (odm.odm_id || odm.title);
+
+  const odmId = isFlat ? odm.odm_id : (odm.odm_meta?.odm_id);
+  const title = isFlat ? odm.title : (odm.odm_payload?.cadrage?.title);
+  const summary = isFlat ? odm.summary : (odm.odm_payload?.cadrage?.summary);
+  const steps = isFlat ? (odm.steps || []) : (odm.odm_payload?.steps || []);
+  const deliverables = isFlat ? (odm.deliverables || []) : null;
+  const acceptance = isFlat ? (odm.acceptance_criteria || []) : null;
+  const rejection = isFlat
+    ? (odm.rejection_criteria || [])
+    : (odm.odm_payload?.rejection_criteria || '');
+  const objectives = isFlat ? null : (odm.odm_payload?.cadrage?.objectives);
+  const inScope = isFlat ? null : (odm.odm_payload?.cadrage?.in_scope);
+  const outScope = isFlat ? null : (odm.odm_payload?.cadrage?.out_of_scope);
+  const outputs = isFlat ? null : (odm.odm_payload?.outputs_expected);
+
+  const parts = [
+    `# Assignation OdM : ${odmId || 'N/A'}`,
+    '',
+    '## Cadrage',
+    `- Titre : ${title || 'N/A'}`,
+  ];
+
+  if (summary) parts.push(`- Resume : ${summary}`);
+  if (objectives) parts.push(`- Objectifs : ${Array.isArray(objectives) ? objectives.join(', ') : objectives}`);
+  if (inScope) parts.push(`- Scope : ${Array.isArray(inScope) ? inScope.join(', ') : inScope}`);
+  if (outScope) parts.push(`- Hors scope : ${Array.isArray(outScope) ? outScope.join(', ') : outScope}`);
+
+  if (steps.length > 0) {
+    parts.push('', '## Steps');
+    steps.forEach((step, i) => {
+      parts.push(`${i + 1}. ${step.title || ''} — ${step.description || ''}`);
+    });
+  }
+
+  if (deliverables && deliverables.length > 0) {
+    parts.push('', '## Livrables attendus');
+    deliverables.forEach(d => parts.push(`- ${d}`));
+  } else if (outputs?.items) {
+    parts.push('', '## Livrables attendus', Array.isArray(outputs.items) ? outputs.items.map(i => `- ${i}`).join('\n') : outputs.items);
+  }
+
+  if (acceptance && acceptance.length > 0) {
+    parts.push('', '## Criteres d\'acceptation');
+    acceptance.forEach(a => parts.push(`- ${a}`));
+  }
+
+  if (rejection) {
+    parts.push('', '## Criteres de rejet');
+    if (Array.isArray(rejection)) {
+      rejection.forEach(r => parts.push(`- ${r}`));
+    } else {
+      parts.push(rejection);
+    }
+  }
+
+  parts.push('', '## Instructions');
+  parts.push('Execute cet OdM. Depose ton CR dans .nemesis/HCM/cr/ a la fin.');
+  if (additionalContext) parts.push(additionalContext);
+
+  return parts.join('\n');
+}