@magnusekdahl/parallix 1.0.0

package/lib/core/persistent-data-migration.js

@@ -0,0 +1,201 @@
+const fs = require('fs');
+const path = require('path');
+const storage = require('./storage');
+
+let _stats = null;
+function getStats() {
+  if (!_stats) _stats = require('../commands/stats');
+  return _stats;
+}
+
+function getStatsHeaders() {
+  return getStats().STATS_HEADERS;
+}
+
+const ESSENTIAL_STATS_COLUMNS = ['date', 'mission', 'classification', 'implementer', 'pr_fix_rounds'];
+
+function validateStatsRow(row, rowIndex, filePath) {
+  const missing = ESSENTIAL_STATS_COLUMNS.filter(col => !(col in row) || row[col] === '');
+  if (missing.length > 0) {
+    throw new Error(
+      `Malformed telemetry row ${rowIndex + 1} in ${path.resolve(filePath)}: ` +
+      `missing essential columns: ${missing.join(', ')}`
+    );
+  }
+}
+
+function parseCsvLine(line) {
+  const values = [];
+  let value = '';
+  let quoted = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    if (char === '"') {
+      if (quoted && line[index + 1] === '"') {
+        value += '"';
+        index += 1;
+      } else {
+        quoted = !quoted;
+      }
+    } else if (char === ',' && !quoted) {
+      values.push(value);
+      value = '';
+    } else {
+      value += char;
+    }
+  }
+  values.push(value);
+  return values;
+}
+
+function escapeCsvValue(value) {
+  const text = String(value ?? '');
+  return /[",\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+
+/**
+ * Minimal CSV loader — avoids circular dependency with stats module (which
+ * imports this module at the top). Defined locally so `migrateStats()` can
+ * read any schema without triggering a require-cycle.
+ */
+function loadCsv(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return { headers: [], rows: [] };
+  }
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n').filter(line => line.trim());
+  if (lines.length === 0) {
+    return { headers: [], rows: [] };
+  }
+  const headers = parseCsvLine(lines[0]);
+  const rows = [];
+  for (let i = 1; i < lines.length; i += 1) {
+    const values = parseCsvLine(lines[i]);
+    const row = {};
+    headers.forEach((header, idx) => {
+      row[header] = values[idx] || '';
+    });
+    rows.push(row);
+  }
+  return { headers, rows };
+}
+
+/**
+ * Read a stats CSV file with any schema (legacy 5-col or extended 21-col).
+ * Returns rows as arrays keyed by the 21-column STATS_HEADERS, with missing
+ * columns filled by normalizeStatsRow defaults.
+ */
+function readStatsRows(filePath, options = {}) {
+  if (!filePath || !fs.existsSync(filePath)) return [];
+  const data = loadCsv(filePath);
+  if (data.headers.length === 0) return [];
+  const headers = getStatsHeaders();
+  const validated = data.rows.map((row, idx) => {
+    validateStatsRow(row, idx, filePath);
+    return row;
+  });
+  return validated
+    .map(row => getStats().normalizeStatsRow(row, { repo: options.defaultRepo }))
+    .map(row => headers.map(h => row[h] || ''));
+}
+
+function serializeStatsRows(rows) {
+  const headers = getStatsHeaders();
+  return `${[
+    headers.join(','),
+    ...rows.map(row => row.map(escapeCsvValue).join(','))
+  ].join('\n')}\n`;
+}
+
+function migrateStats(options = {}) {
+  const sourcePaths = options.sourcePaths || [options.sourcePath];
+  const destinationPath = options.destinationPath || storage.resolveStatsPath({ ensureDir: true });
+  const destinationRows = readStatsRows(destinationPath, options);
+  const sourceRows = sourcePaths.flatMap(sourcePath => readStatsRows(sourcePath, options));
+  const rows = [];
+  const seen = new Set();
+
+  for (const row of [...destinationRows, ...sourceRows]) {
+    const key = JSON.stringify(row);
+    if (!seen.has(key)) {
+      seen.add(key);
+      rows.push(row);
+    }
+  }
+
+  const content = serializeStatsRows(rows);
+  const current = fs.existsSync(destinationPath) ? fs.readFileSync(destinationPath, 'utf8') : null;
+  if (current !== content) storage.writeFileAtomic(destinationPath, content);
+  return { destinationPath, imported: rows.length - destinationRows.length, rows: rows.length };
+}
+
+function readBlocklistSource(filePath, warn, hardFailure = false) {
+  if (!filePath || !fs.existsSync(filePath)) return null;
+  try {
+    const payload = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+      throw new Error('expected a JSON object at the file root');
+    }
+    if (
+      payload.blocklist !== undefined &&
+      (!payload.blocklist || typeof payload.blocklist !== 'object' || Array.isArray(payload.blocklist))
+    ) {
+      throw new Error('expected blocklist to be a JSON object');
+    }
+    return { filePath, payload, blocklist: payload.blocklist || {} };
+  } catch (error) {
+    if (hardFailure) throw error;
+    warn(`Skipping malformed legacy agent blocklist ${path.resolve(filePath)}: ${error.message}`);
+    return null;
+  }
+}
+
+function sameValue(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function migrateAgentBlocklists(options = {}) {
+  const warn = options.warn || (() => {});
+  const destinationPath = options.destinationPath || storage.resolveAgentsLocalPath({ ensureDir: true });
+  const sources = (options.sourcePaths || [])
+    .map(filePath => readBlocklistSource(filePath, warn))
+    .filter(Boolean);
+  const destination = readBlocklistSource(destinationPath, warn, true);
+  const selected = {};
+  const selectedFrom = {};
+  const conflicts = [];
+
+  for (const source of [...sources, ...(destination ? [destination] : [])]) {
+    for (const [agent, value] of Object.entries(source.blocklist)) {
+      if (Object.prototype.hasOwnProperty.call(selected, agent) && !sameValue(selected[agent], value)) {
+        const conflict = {
+          agent,
+          previousSource: selectedFrom[agent],
+          previousValue: selected[agent],
+          selectedSource: source.filePath,
+          selectedValue: value
+        };
+        conflicts.push(conflict);
+        warn(
+          `Agent blocklist conflict for "${agent}": ${path.resolve(source.filePath)} takes precedence over ` +
+          `${path.resolve(selectedFrom[agent])}; selected=${JSON.stringify(value)} previous=${JSON.stringify(selected[agent])}`
+        );
+      }
+      selected[agent] = value;
+      selectedFrom[agent] = source.filePath;
+    }
+  }
+
+  const payload = destination ? { ...destination.payload } : {};
+  payload.blocklist = selected;
+  const content = `${JSON.stringify(payload, null, 2)}\n`;
+  const current = fs.existsSync(destinationPath) ? fs.readFileSync(destinationPath, 'utf8') : null;
+  if (current !== content) storage.writeFileAtomic(destinationPath, content);
+  return { destinationPath, blocklist: selected, conflicts };
+}
+
+module.exports = {
+  migrateStats,
+  migrateAgentBlocklists,
+  _internals: { parseCsvLine, readStatsRows, serializeStatsRows }
+};

package/lib/core/product-config.js

@@ -0,0 +1,508 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const REQUIRED_ADAPTER_KEYS = ['tasks', 'missions', 'verification', 'review', 'agents'];
+
+// Code-owned defaults. An absent workflow.config.json yields a working tool;
+// the optional override file overrides only the keys it sets. These defaults
+// are the single source of truth — there is no shipped example config, so there
+// is no second source to drift from (see task-1233 Scope Amendment).
+const DEFAULT_CONFIG = Object.freeze({
+  product: {
+    name: 'Workflow',
+    targetUser: 'Engineering teams using git, task tracking, and code review',
+  },
+  adapters: {
+    tasks: { provider: 'backlog-md', storage: 'backlog', stateMap: 'state-map.json' },
+    missions: {
+      baseDir: 'missions',
+      branchPrefix: 'mission/',
+      worktreePattern: '../<repo>-<slug>',
+    },
+    // No universal cross-repo gate exists, so the default is no validation
+    // (no command). A repository opts into a gate by declaring
+    // adapters.verification.command in workflow.config.json.
+    verification: { defaultArea: 'docs' },
+    stats: { path: 'stats.csv' },
+    // Unset provider currently keeps Forgejo enabled (isForgejoReviewEnabled
+    // treats null as enabled) — a WrGroceries-ism. Flipping review off-by-default
+    // for external repos has a large review-subsystem blast radius and is deferred
+    // to TASK-1244; WrGroceries already declares review.provider in its own config.
+    review: {},
+    agents: {},
+  },
+});
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function deepMerge(base, override) {
+  if (!isPlainObject(override)) return base;
+  const out = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    out[key] = isPlainObject(value) && isPlainObject(out[key])
+      ? deepMerge(out[key], value)
+      : value;
+  }
+  return out;
+}
+
+// A fresh deep clone of the defaults so callers can never mutate the frozen
+// source.
+function defaultConfig() {
+  return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+}
+
+function configCandidates(rootDir = process.cwd()) {
+  return [path.join(rootDir, 'workflow.config.json')];
+}
+
+function findWorkflowConfig(rootDir = process.cwd()) {
+  return configCandidates(rootDir).find(candidate => fs.existsSync(candidate)) || null;
+}
+
+function loadWorkflowConfig(rootDir = process.cwd()) {
+  const configPath = findWorkflowConfig(rootDir);
+  if (!configPath) {
+    return { found: false, configPath: null, config: null };
+  }
+
+  let raw;
+  try {
+    raw = fs.readFileSync(configPath, 'utf8');
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return { found: false, configPath: null, config: null };
+    }
+    throw error;
+  }
+  try {
+    return {
+      found: true,
+      configPath,
+      config: JSON.parse(raw),
+      parseError: null,
+    };
+  } catch (error) {
+    return {
+      found: true,
+      configPath,
+      config: null,
+      parseError: error,
+    };
+  }
+}
+
+// The effective config a command sees: code-owned defaults with any override
+// file merged on top. A missing or malformed override falls back to defaults.
+function loadEffectiveConfig(rootDir = process.cwd()) {
+  const loaded = loadWorkflowConfig(rootDir);
+  if (!loaded.found || loaded.parseError || !isPlainObject(loaded.config)) {
+    return defaultConfig();
+  }
+  // A structurally invalid override (e.g. adapters not an object) falls back to
+  // defaults rather than merging a bad shape into the effective config.
+  if (validateWorkflowConfig(loaded.config).length > 0) {
+    return defaultConfig();
+  }
+  return deepMerge(defaultConfig(), loaded.config);
+}
+
+// The override file is optional and partial: validate only the shape of what it
+// provides. Missing sections are filled by code-owned defaults, so absent
+// sections are not errors (and there are no placeholder sentinels to detect).
+function validateWorkflowConfig(config) {
+  if (!isPlainObject(config)) {
+    return ['top-level JSON object is required'];
+  }
+
+  const issues = [];
+  if ('product' in config && !isPlainObject(config.product)) {
+    issues.push('product must be an object');
+  }
+  if ('adapters' in config) {
+    if (!isPlainObject(config.adapters)) {
+      issues.push('adapters must be an object');
+    } else {
+      for (const [key, value] of Object.entries(config.adapters)) {
+        if (!isPlainObject(value)) {
+          issues.push(`adapters.${key} must be an object`);
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+function detectLegacyRepoLayout(rootDir = process.cwd()) {
+  const backlogDir = path.join(rootDir, 'backlog');
+  const missionDocsDir = path.join(rootDir, 'docs', 'missions');
+  const verifyScript = path.join(rootDir, 'scripts', 'verify-local.sh');
+
+  return fs.existsSync(backlogDir) && fs.existsSync(missionDocsDir) && fs.existsSync(verifyScript);
+}
+
+function isStandaloneWorkflowLayout(rootDir = process.cwd()) {
+  const workflowIndex = path.join(rootDir, 'workflow', 'index.js');
+  const workflowConfig = path.join(rootDir, 'workflow.config.json');
+
+  return fs.existsSync(workflowIndex) && fs.existsSync(workflowConfig);
+}
+
+function hasGitRepository(rootDir = process.cwd()) {
+  return fs.existsSync(path.join(rootDir, '.git'));
+}
+
+function initializeGitRepository(rootDir = process.cwd(), { spawnSyncFn = spawnSync } = {}) {
+  const initMain = spawnSyncFn('git', ['init', '-b', 'main'], {
+    cwd: rootDir,
+    encoding: 'utf8',
+  });
+  if (initMain.status === 0) {
+    return { ok: true, branch: 'main', mode: 'init-main' };
+  }
+
+  const initFallback = spawnSyncFn('git', ['init'], {
+    cwd: rootDir,
+    encoding: 'utf8',
+  });
+  if (initFallback.status !== 0) {
+    return {
+      ok: false,
+      message: (initFallback.stderr || initFallback.stdout || initMain.stderr || initMain.stdout || 'git init failed').trim(),
+    };
+  }
+
+  spawnSyncFn('git', ['symbolic-ref', 'HEAD', 'refs/heads/main'], {
+    cwd: rootDir,
+    encoding: 'utf8',
+  });
+  return { ok: true, branch: 'main', mode: 'init-fallback' };
+}
+
+// Commits the workflow files and any config that exists so the freshly
+// initialized repo has a baseline commit. Without this, mission worktrees
+// created via `git worktree add` would not have workflow/ or
+// workflow.config.json checked out and could not run any workflow command.
+function gitIdentityEnv() {
+  const env = { ...process.env };
+  if (!env.GIT_AUTHOR_NAME) env.GIT_AUTHOR_NAME = 'Workflow Setup';
+  if (!env.GIT_AUTHOR_EMAIL) env.GIT_AUTHOR_EMAIL = 'workflow@example.invalid';
+  if (!env.GIT_COMMITTER_NAME) env.GIT_COMMITTER_NAME = env.GIT_AUTHOR_NAME;
+  if (!env.GIT_COMMITTER_EMAIL) env.GIT_COMMITTER_EMAIL = env.GIT_AUTHOR_EMAIL;
+  return env;
+}
+
+function commitWorkflowBaseline(rootDir, { spawnSyncFn = spawnSync, existsSyncFn = fs.existsSync } = {}) {
+  const candidates = ['workflow', 'workflow.config.json'];
+  const present = candidates.filter(name => existsSyncFn(path.join(rootDir, name)));
+  if (present.length === 0) {
+    return { ok: true, committed: false, reason: 'no-workflow-files' };
+  }
+
+  const addResult = spawnSyncFn('git', ['add', '-A', '.'], {
+    cwd: rootDir,
+    encoding: 'utf8',
+  });
+  if (addResult.status !== 0) {
+    return {
+      ok: false,
+      committed: false,
+      message: (addResult.stderr || addResult.stdout || 'git add failed').trim(),
+    };
+  }
+
+  const commitResult = spawnSyncFn(
+    'git',
+    ['commit', '-m', 'workflow: initial setup'],
+    { cwd: rootDir, encoding: 'utf8', env: gitIdentityEnv() },
+  );
+  if (commitResult.status !== 0) {
+    return {
+      ok: false,
+      committed: false,
+      message: (commitResult.stderr || commitResult.stdout || 'git commit failed').trim(),
+    };
+  }
+
+  return { ok: true, committed: true, files: present };
+}
+
+function ensureStandaloneMissionBaseline(rootDir = process.cwd(), { spawnSyncFn = spawnSync } = {}) {
+  if (!isStandaloneWorkflowLayout(rootDir) || !hasGitRepository(rootDir)) {
+    return { changed: false, committed: false, skipped: true };
+  }
+
+  const statusResult = spawnSyncFn('git', ['status', '--porcelain'], {
+    cwd: rootDir,
+    encoding: 'utf8',
+  });
+  if (statusResult.status !== 0) {
+    return {
+      changed: false,
+      committed: false,
+      failed: true,
+      message: (statusResult.stderr || statusResult.stdout || 'git status failed').trim(),
+    };
+  }
+
+  const dirtyEntries = (statusResult.stdout || '')
+    .split('\n')
+    .map(line => line.trimEnd())
+    .filter(Boolean);
+  const relevantEntries = dirtyEntries.filter(line => {
+    const filePath = line.slice(3).trim();
+    return !filePath.startsWith('.workflow/') && !filePath.startsWith('.sessions/');
+  });
+
+  if (relevantEntries.length === 0) {
+    return { changed: dirtyEntries.length > 0, committed: false, skipped: false };
+  }
+
+  const conflicted = relevantEntries.filter(line => {
+    const state = line.slice(0, 2).trim();
+    return ['DD', 'AU', 'UD', 'UA', 'DU', 'AA', 'UU'].includes(state);
+  });
+  if (conflicted.length > 0) {
+    return {
+      changed: true,
+      committed: false,
+      failed: true,
+      message: `conflicted files block mission baseline commit: ${conflicted.map(line => line.slice(3).trim()).join(', ')}`,
+    };
+  }
+
+  const addResult = spawnSyncFn('git', ['add', '-A', '.'], {
+    cwd: rootDir,
+    encoding: 'utf8',
+  });
+  if (addResult.status !== 0) {
+    return {
+      changed: true,
+      committed: false,
+      failed: true,
+      message: (addResult.stderr || addResult.stdout || 'git add failed').trim(),
+    };
+  }
+
+  const commitResult = spawnSyncFn('git', ['commit', '-m', 'workflow: prepare standalone mission baseline'], {
+    cwd: rootDir,
+    encoding: 'utf8',
+    env: gitIdentityEnv(),
+  });
+  if (commitResult.status !== 0) {
+    return {
+      changed: true,
+      committed: false,
+      failed: true,
+      message: (commitResult.stderr || commitResult.stdout || 'git commit failed').trim(),
+    };
+  }
+
+  return {
+    changed: true,
+    committed: true,
+    entries: relevantEntries.map(line => line.slice(3).trim()),
+  };
+}
+
+function ensureStandaloneGitRepo(rootDir = process.cwd(), options = {}) {
+  const isStandaloneWorkflowLayoutFn = options.isStandaloneWorkflowLayoutFn || isStandaloneWorkflowLayout;
+  const hasGitRepositoryFn = options.hasGitRepositoryFn || hasGitRepository;
+  const initializeGitRepositoryFn = options.initializeGitRepositoryFn || initializeGitRepository;
+  const commitWorkflowBaselineFn = options.commitWorkflowBaselineFn || commitWorkflowBaseline;
+
+  if (!isStandaloneWorkflowLayoutFn(rootDir) || hasGitRepositoryFn(rootDir)) {
+    return { changed: false, initialized: false };
+  }
+
+  const result = initializeGitRepositoryFn(rootDir, options);
+  if (!result.ok) {
+    return {
+      changed: false,
+      initialized: false,
+      failed: true,
+      message: result.message || 'git init failed',
+    };
+  }
+
+  const commit = commitWorkflowBaselineFn(rootDir, options);
+
+  return {
+    changed: true,
+    initialized: true,
+    branch: result.branch || 'main',
+    mode: result.mode || 'init-main',
+    baselineCommit: commit,
+  };
+}
+
+function adapterChecklist() {
+  return [
+    'Workflow runs on built-in defaults; no config file is required to start',
+    'Create workflow.config.json only to override a default (schema: workflow/config/workflow.config.schema.json)',
+    'Run `px config` to print the effective configuration',
+    'Override adapters.tasks for a different task tracker or storage path',
+    'Override adapters.missions for mission document layout and branch/worktree conventions',
+    'Override adapters.verification for your repo gate command',
+    'Override adapters.review to enable a review provider and remote naming',
+  ];
+}
+
+// Returns the override file's adapters object, or {} when there is no override.
+// Each resolver (resolveTaskStorage, resolveVerificationAdapter, …) applies its
+// own code-owned fallback on top of this, so an absent config still yields a
+// fully working tool. loadEffectiveConfig (used by `node parallix config`) is
+// the document-level view; the per-resolver fallbacks remain the runtime source
+// of truth so this change does not shadow them.
+function loadAdapterConfig(rootDir = process.cwd()) {
+  const explicit = loadWorkflowConfig(rootDir);
+  if (!explicit.found || explicit.parseError || !isPlainObject(explicit.config)) {
+    return {};
+  }
+  return isPlainObject(explicit.config.adapters) ? explicit.config.adapters : {};
+}
+
+function resolveTaskStorage(rootDir = process.cwd()) {
+  const fallbackBaseDir = path.join(rootDir, 'backlog');
+  const fallback = {
+    baseDir: fallbackBaseDir,
+    tasksDir: path.join(fallbackBaseDir, 'tasks'),
+    completedDir: path.join(fallbackBaseDir, 'completed'),
+    draftsDir: path.join(fallbackBaseDir, 'drafts'),
+  };
+
+  const storage = loadAdapterConfig(rootDir).tasks && loadAdapterConfig(rootDir).tasks.storage;
+  if (!storage) {
+    return fallback;
+  }
+
+  if (typeof storage === 'string') {
+    const storageDir = path.resolve(rootDir, storage);
+    const storageName = path.basename(storageDir);
+    if (storageName === 'tasks') {
+      const baseDir = path.dirname(storageDir);
+      return {
+        baseDir,
+        tasksDir: storageDir,
+        completedDir: path.join(baseDir, 'completed'),
+        draftsDir: path.join(baseDir, 'drafts'),
+      };
+    }
+
+    return {
+      baseDir: storageDir,
+      tasksDir: path.join(storageDir, 'tasks'),
+      completedDir: path.join(storageDir, 'completed'),
+      draftsDir: path.join(storageDir, 'drafts'),
+    };
+  }
+
+  if (typeof storage === 'object' && !Array.isArray(storage)) {
+    const tasksDir = storage.tasksDir
+      ? path.resolve(rootDir, storage.tasksDir)
+      : fallback.tasksDir;
+    const completedDir = storage.completedDir
+      ? path.resolve(rootDir, storage.completedDir)
+      : path.join(path.dirname(tasksDir), 'completed');
+    const baseDir = path.dirname(tasksDir);
+
+    return {
+      baseDir,
+      tasksDir,
+      completedDir,
+      draftsDir: path.join(baseDir, 'drafts'),
+    };
+  }
+
+  return fallback;
+}
+
+function resolveReviewAdapter(rootDir = process.cwd()) {
+  const review = loadAdapterConfig(rootDir).review || {};
+  return {
+    provider: review.provider || null,
+    remote: review.remote || null,
+    baseUrl: review.baseUrl || null,
+    repo: review.repo || null,
+  };
+}
+
+function isForgejoReviewEnabled(rootDir = process.cwd()) {
+  const review = resolveReviewAdapter(rootDir);
+  if (review.provider === null) return false;
+  return review.provider === 'forgejo';
+}
+
+function resolveAgentAdapter(rootDir = process.cwd()) {
+  return {};
+}
+
+// Returns the configured LLM model string for an agent family, or null when the
+// family is not listed under adapters.agents.models. A null return means the
+// launcher omits the model parameter entirely so the agent uses its own default.
+function resolveAgentModel(agentFamily, rootDir = process.cwd()) {
+  if (!agentFamily || typeof agentFamily !== 'string') return null;
+  const agents = loadEffectiveConfig(rootDir).adapters.agents;
+  if (!isPlainObject(agents) || !isPlainObject(agents.models)) return null;
+  const model = agents.models[agentFamily];
+  return typeof model === 'string' && model.length > 0 ? model : null;
+}
+
+function evaluateRepositoryReadiness(rootDir = process.cwd()) {
+  const explicit = loadWorkflowConfig(rootDir);
+
+  // No override file: the tool runs on code-owned defaults. This is a ready
+  // state, not an "unconfigured" failure — an absent config is valid.
+  if (!explicit.found) {
+    return {
+      mode: 'default',
+      configPath: null,
+      issues: [],
+    };
+  }
+
+  if (explicit.parseError) {
+    return {
+      mode: 'invalid',
+      configPath: explicit.configPath,
+      issues: [`invalid JSON: ${explicit.parseError.message}`],
+    };
+  }
+
+  const issues = validateWorkflowConfig(explicit.config);
+  return {
+    mode: issues.length === 0 ? 'configured' : 'invalid',
+    configPath: explicit.configPath,
+    issues,
+  };
+}
+
+module.exports = {
+  REQUIRED_ADAPTER_KEYS,
+  DEFAULT_CONFIG,
+  defaultConfig,
+  adapterChecklist,
+  commitWorkflowBaseline,
+  configCandidates,
+  deepMerge,
+  detectLegacyRepoLayout,
+  evaluateRepositoryReadiness,
+  findWorkflowConfig,
+  hasGitRepository,
+  initializeGitRepository,
+  isForgejoReviewEnabled,
+  isStandaloneWorkflowLayout,
+  loadWorkflowConfig,
+  loadEffectiveConfig,
+  loadAdapterConfig,
+  resolveAgentAdapter,
+  resolveAgentModel,
+  resolveReviewAdapter,
+  resolveTaskStorage,
+  ensureStandaloneMissionBaseline,
+  ensureStandaloneGitRepo,
+  validateWorkflowConfig,
+};