@wix/agent-skills 1.36.0 → 1.36.1

package/skills/wix-replatform/lib/discovered-census.js

@@ -1,231 +0,0 @@
-'use strict';
-
-// Deterministic metadata-only discovered-set census. Raw records are never read.
-const fs = require('node:fs/promises');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const coverage = require('./source-coverage.js');
-const CENSUS_FILE = 'discovery/census.json';
-const hash = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
-async function readJson(projectDir, file) {
-  try {
-    return JSON.parse(await fs.readFile(path.join(projectDir, file), 'utf8'));
-  } catch (error) {
-    if (error.code === 'ENOENT') return null;
-    throw error;
-  }
-}
-async function fileDigest(projectDir, file) {
-  try {
-    return hash(await fs.readFile(path.join(projectDir, file)));
-  } catch (error) {
-    if (error.code === 'ENOENT') return null;
-    throw error;
-  }
-}
-function sorted(value) {
-  if (Array.isArray(value)) return value.map(sorted);
-  if (value && typeof value === 'object') return Object.fromEntries(Object.keys(value).sort().map(key => [key, sorted(value[key])]));
-  return value;
-}
-const digestJson = value => hash(JSON.stringify(sorted(value)));
-const slugOf = value => String(value || '').split('/')[0];
-const countOf = value => typeof value === 'number' && Number.isFinite(value) ? value : null;
-function entityEntries(schema) {
-  const entities = schema && schema.entities;
-  if (Array.isArray(entities)) return entities.map(row => [row.name || row.entityName || row.sourceEntity, row]);
-  return Object.entries(entities || {});
-}
-function fieldNames(fields) {
-  if (Array.isArray(fields)) return fields.map(field => typeof field === 'string' ? field : field && (field.name || field.path || field.field)).filter(Boolean);
-  return Object.keys(fields || {});
-}
-async function registryPath(projectDir, options = {}) {
-  if (Object.prototype.hasOwnProperty.call(options, 'subPartRegistryPath')) return options.subPartRegistryPath;
-  const schema = await readJson(projectDir, 'source-schema.json');
-  const decisions = await readJson(projectDir, 'orchestration/decisions.json');
-  const adapter = schema && (schema.platform || schema.sourcePlatform) || decisions && decisions.sourcePlatform && decisions.sourcePlatform.value;
-  if (!adapter || !/^[a-z0-9-]+$/i.test(adapter)) return null;
-  return path.join(__dirname, '..', 'resources', `rp-source-${adapter}`, 'sub-parts.json');
-}
-async function censusInputs(projectDir, options = {}) {
-  const registry = await registryPath(projectDir, options);
-  const contract = await coverage.readCoverageContract(projectDir);
-  return {
-    sourceSchema: await fileDigest(projectDir, 'source-schema.json'),
-    pluginCoverage: await fileDigest(projectDir, 'discovery/plugin-coverage.json'),
-    sourceCoverage: contract.stamped ? await fileDigest(projectDir, coverage.SOURCE_COVERAGE_FILE) : null,
-    subPartRegistry: registry ? await fileDigest('', registry) : null
-  };
-}
-function validateRegistry(registry) {
-  for (const [entity, subtypes] of Object.entries(registry || {})) {
-    const fields = new Set();
-    for (const [subtype, entry] of Object.entries(subtypes)) {
-      if (!entry || !Array.isArray(entry.evidenceFields) || !entry.evidenceFields.length) throw new Error(`invalid_sub_part_registry: ${entity}/${subtype}`);
-      for (const field of entry.evidenceFields) {
-        if (typeof field !== 'string' || fields.has(field)) throw new Error(`duplicate_sub_part_field: ${entity}/${field}`);
-        fields.add(field);
-      }
-    }
-  }
-}
-async function buildCensus(projectDir, options = {}) {
-  const schema = await readJson(projectDir, 'source-schema.json');
-  if (!schema || !schema.entities || typeof schema.entities !== 'object') throw new Error('source_schema_missing');
-  const plugins = await readJson(projectDir, 'discovery/plugin-coverage.json');
-  const regPath = await registryPath(projectDir, options);
-  const registry = regPath ? await readJson('', regPath) : null;
-  validateRegistry(registry);
-  const rows = [];
-  for (const [entity, value] of entityEntries(schema)) {
-    if (!entity || !value || typeof value !== 'object') throw new Error('source_entity_invalid');
-    rows.push({
-      censusId: `entity:${entity}`,
-      kind: 'entity',
-      decisionRow: true,
-      entity,
-      subtype: 'all',
-      recordCount: countOf(value.recordCount),
-      inUse: value.inUse == null ? null : value.inUse
-    });
-    const fields = new Set(fieldNames(value.fields));
-    for (const [subtype, entry] of Object.entries(registry && registry[entity] || {})) {
-      if (!entry.evidenceFields.some(field => fields.has(field))) continue;
-      rows.push({
-        censusId: `entity:${entity}/${subtype}`,
-        kind: 'sub-part',
-        decisionRow: true,
-        entity,
-        subtype,
-        recordCount: null,
-        evidenceFields: entry.evidenceFields,
-        label: entry.label || subtype
-      });
-    }
-  }
-  const capabilities = new Map();
-  for (const row of plugins && plugins.capabilities || []) {
-    if (!row || typeof row.capability !== 'string' || !row.capability) throw new Error('capability_invalid');
-    if (!capabilities.has(row.capability)) capabilities.set(row.capability, []);
-    capabilities.get(row.capability).push(row);
-  }
-  for (const [capability, sources] of capabilities) {
-    const selected = sources.find(row => row.recognized === true) || sources[0];
-    const union = key => [...new Map(sources.flatMap(row => row[key] || []).map(value => [JSON.stringify(sorted(value)), value])).values()];
-    rows.push({
-      censusId: `capability:${capability}`,
-      kind: 'capability',
-      decisionRow: true,
-      capability,
-      coverageStatus: selected.status,
-      plugins: union('plugins'),
-      sourceEntities: union('sourceEntities'),
-      blocked: union('blocked'),
-      recordCounts: selected.recordCounts || {},
-      basis: selected.basis || null,
-      rationale: selected.rationale || null
-    });
-  }
-  for (const plugin of plugins && plugins.perPlugin || []) {
-    const slug = slugOf(plugin.plugin);
-    if (!slug) throw new Error('plugin_invalid');
-    const linkedCapabilities = [...capabilities.keys()].filter(capability => (plugin.capabilities || []).includes(capability) || capabilities.get(capability).some(row => (row.plugins || []).some(p => slugOf(p) === slug))).map(key => `capability:${key}`).sort();
-    rows.push({
-      censusId: `plugin:${slug}`,
-      kind: 'plugin',
-      decisionRow: linkedCapabilities.length === 0,
-      pluginStatus: plugin.status,
-      linkedCapabilities
-    });
-  }
-  const contract = await coverage.readCoverageContract(projectDir);
-  if (contract.stamped) {
-    const inputs = await coverage.loadCoverageInputs(projectDir);
-    const validation = coverage.validateCoverageFile(inputs.coverage);
-    for (const row of validation.rows) rows.push({
-      censusId: `coverage:${row.coverageId}`,
-      kind: 'source-coverage',
-      decisionRow: false,
-      coverageId: row.coverageId,
-      capability: row.capability,
-      sourceEntity: row.sourceEntity,
-      reason: row.reason
-    });
-  }
-  rows.sort((a, b) => a.censusId.localeCompare(b.censusId));
-  if (new Set(rows.map(row => row.censusId)).size !== rows.length) throw new Error('duplicate_census_id');
-  const result = {
-    schemaVersion: 1,
-    inputs: await censusInputs(projectDir, options),
-    rows
-  };
-  if (options.write !== false) await coverage.writeJsonAtomic(path.join(projectDir, CENSUS_FILE), result);
-  return result;
-}
-async function readCensus(projectDir) {
-  return readJson(projectDir, CENSUS_FILE);
-}
-async function censusFreshness(projectDir, census, options = {}) {
-  if (!census) return {
-    ok: false,
-    staleInputs: ['census']
-  };
-  try {
-    const current = await censusInputs(projectDir, options);
-    const staleInputs = Object.keys(current).filter(key => !census.inputs || current[key] !== census.inputs[key]);
-    // A malformed or hand-edited projection is not accepted merely because input hashes match.
-    const rebuilt = await buildCensus(projectDir, {
-      ...options,
-      write: false
-    });
-    if (digestJson(census.rows) !== digestJson(rebuilt.rows) || census.schemaVersion !== 1) staleInputs.push('rows');
-    return {
-      ok: staleInputs.length === 0,
-      staleInputs
-    };
-  } catch {
-    return {
-      ok: false,
-      staleInputs: ['census']
-    };
-  }
-}
-async function rolloutScan(root, options = {}) {
-  const classify = options.classifyFinalizedRun || require('./migration-completion.js').classifyFinalizedRun;
-  const result = {
-    reviewOnly: [],
-    held: []
-  };
-  for (const entry of await fs.readdir(root, {
-    withFileTypes: true
-  })) {
-    if (!entry.isDirectory()) continue;
-    const projectDir = path.join(root, entry.name);
-    const classification = await classify(projectDir, {
-      decisions: (await readJson(projectDir, 'orchestration/decisions.json')) || {}
-    });
-    if (classification.kind === 'valid-v1') result.reviewOnly.push({
-      projectDir,
-      reason: 'mapping_approval_missing_census'
-    });
-    if (classification.kind === 'unverified-v1') result.held.push({
-      projectDir,
-      reason: classification.reason || 'finalized_receipt_unverified',
-      errors: classification.errors || []
-    });
-  }
-  return result;
-}
-module.exports = {
-  CENSUS_FILE,
-  buildCensus,
-  readCensus,
-  censusFreshness,
-  censusInputs,
-  rolloutScan,
-  readJson,
-  fileDigest,
-  digestJson,
-  sorted
-};

package/skills/wix-replatform/lib/discovered-set-status.js

@@ -1,255 +0,0 @@
-'use strict';
-
-const fs = require('node:fs/promises');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const {
-  writeJsonAtomic
-} = require('./orchestration-state.js');
-const STATUS_FILE = 'execution/discovered-set-status.json';
-const STATUS_MARKDOWN = 'execution/review/discovered-set-status.md';
-const RESOLUTIONS_FILE = 'execution/discovered-set-resolutions.ndjson';
-const RECONCILIATION_FILE = 'mapping/review/census-reconciliation.json';
-const REPORT_FILE = 'execution/completion-report.json';
-const OUTCOME_ORDER = ['failed', 'unresolved', 'deferred', 'partial', 'no-outcome-recorded', 'not-decided', 'unsupported', 'excluded', 'manual-open', 'manual-done', 'imported', 'reference-only', 'no-data'];
-const CLOSED = new Set(['imported', 'manual-done', 'reference-only', 'no-data']);
-const COVERAGE_OPEN = {
-  recovered: false,
-  'gated-exclusion': false,
-  'ungated-exclusion': true,
-  'accepted-loss': true,
-  unresolved: true
-};
-function digest(value) {
-  return crypto.createHash('sha256').update(value).digest('hex');
-}
-function sorted(value) {
-  return Array.isArray(value) ? value.map(sorted) : value && typeof value === 'object' ? Object.fromEntries(Object.keys(value).sort().map(key => [key, sorted(value[key])])) : value;
-}
-async function raw(projectDir, file) {
-  try {
-    return await fs.readFile(path.join(projectDir, file), 'utf8');
-  } catch (e) {
-    if (e.code === 'ENOENT') return null;
-    throw e;
-  }
-}
-async function json(projectDir, file) {
-  const value = await raw(projectDir, file);
-  return value === null ? null : JSON.parse(value);
-}
-function refusal(code, detail = {}) {
-  return Object.assign(new Error(code), {
-    code,
-    ...detail
-  });
-}
-async function resolutionInputs(projectDir) {
-  const text = await raw(projectDir, RESOLUTIONS_FILE);
-  const lines = text === null ? [] : text.split('\n').filter(Boolean);
-  // The journal has one canonical newline per entry; reject malformed or partial entries.
-  for (const line of lines) JSON.parse(line);
-  return {
-    text,
-    lines,
-    sha256: text === null ? null : digest(text)
-  };
-}
-async function inputDigests(projectDir) {
-  const [report, reconciliation, approvals, resolutions] = await Promise.all([raw(projectDir, REPORT_FILE), raw(projectDir, RECONCILIATION_FILE), json(projectDir, 'orchestration/approvals.json'), resolutionInputs(projectDir)]);
-  return {
-    completionReport: report === null ? null : digest(report),
-    reconciliation: reconciliation === null ? null : digest(reconciliation),
-    approvalsMapping: digest(JSON.stringify(sorted(approvals?.mapping ?? null))),
-    resolutions: {
-      sha256: resolutions.sha256,
-      lines: resolutions.lines.length
-    }
-  };
-}
-async function discoveredSetStatusFreshness(projectDir, status) {
-  const current = await inputDigests(projectDir);
-  const staleInputs = Object.keys(current).filter(key => JSON.stringify(current[key]) !== JSON.stringify(status?.inputs?.[key]));
-  const reconciliation = await json(projectDir, RECONCILIATION_FILE);
-  const {
-    censusReconciliationFreshness
-  } = require('./census-reconciliation.js');
-  if (!reconciliation || !(await censusReconciliationFreshness(projectDir, reconciliation)).ok) {
-    if (!staleInputs.includes('reconciliation')) staleInputs.push('reconciliation');
-  }
-  return {
-    ok: staleInputs.length === 0,
-    staleInputs
-  };
-}
-function deriveFinalStatus(backendStatus, statusReport) {
-  return backendStatus === 'complete' && statusReport?.openCount > 0 ? 'complete_with_warnings' : backendStatus;
-}
-function labelFor(row) {
-  return row.label || (row.entity ? `${row.entity}${row.subtype && row.subtype !== 'all' ? `/${row.subtype}` : ''}` : row.capability || row.censusId);
-}
-function actionFor(projectDir, row, outcome, count) {
-  if (CLOSED.has(outcome) || (outcome === 'excluded' || outcome === 'unsupported') && row.ownerApproved) return null;
-  if (outcome === 'manual-open') return {
-    owner: 'Cutover Operator',
-    action: 'Complete the recorded manual steps, then record resolution evidence',
-    timing: 'before-dns',
-    consequence: 'The discovered capability still needs manual setup',
-    affectedCount: count,
-    resolvedWhen: 'A merchant or Cutover Operator records completion evidence',
-    importOperatorPrompt: null
-  };
-  const label = labelFor(row);
-  let instruction;
-  if (outcome === 'not-decided' && row.reasonCode === 'import-after-finalization') instruction = 'was discovered after this migration finalized, and the owner wants it imported. Importing into the finalized site needs a separate human decision. Do not import it. Raise that decision with the migration owner and record the answer.';else if (outcome === 'not-decided') instruction = `is pending: ${row.question || 'Ask the owner how to handle this discovered scope'}. Ask the owner, record the answer as a closed state with rp-mapper, rebuild the census reconciliation, record the mapping approval, then rebuild the discovered-set status report and the post-execution handoff.`;else if (outcome === 'excluded' || outcome === 'unsupported') instruction = `is ${outcome} without the owner's approval. Present the mapping review to the owner for approval, or reverse the exclusion with rp-mapper, then rebuild the status report and handoff.`;else instruction = `has outcome ${outcome}. Recover it through the existing import recovery path, then rebuild the completion report, the discovered-set status report and the post-execution handoff.`;
-  return {
-    owner: 'Import Operator',
-    action: outcome === 'not-decided' ? 'Ask the migration owner and record the decision' : ['excluded', 'unsupported'].includes(outcome) ? 'Obtain owner approval or reverse the exclusion' : 'Recover through the import recovery path',
-    timing: 'before-dns',
-    consequence: `Discovered scope ${row.censusId} is ${outcome}`,
-    affectedCount: count,
-    resolvedWhen: outcome === 'not-decided' ? 'A fresh approved reconciliation records a closed decision' : ['excluded', 'unsupported'].includes(outcome) ? 'A current user approval covers this exact reconciliation' : 'A fresh completion report gives this row imported',
-    importOperatorPrompt: `Open the RePlatform migration project at ${path.resolve(projectDir)} in the original migration environment. Census row ${row.censusId} (${label}) ${instruction} Do not paste or log record values.`
-  };
-}
-function leastFavorable(rows) {
-  return rows.reduce((worst, row) => !worst || OUTCOME_ORDER.indexOf(row.outcome) < OUTCOME_ORDER.indexOf(worst.outcome) ? row : worst, null);
-}
-function deriveRows(projectDir, reconciliation, report, approvedIds, resolutions) {
-  const resolvedIds = new Set(resolutions.map(row => row.censusId));
-  const censusRows = reconciliation.rows || [];
-  const rows = censusRows.map(source => {
-    const row = {
-      ...source,
-      ownerApproved: ['excluded', 'unsupported'].includes(source.state) ? approvedIds.has(source.censusId) : null
-    };
-    let outcome = source.state;
-    if (source.kind === 'source-coverage') {
-      outcome = (report.sourceCoverage || []).find(entry => entry.coverageId === source.coverageId)?.treatment || 'recovered';
-      if (!(outcome in COVERAGE_OPEN)) throw refusal('source_coverage_treatment_unknown', {
-        coverageId: source.coverageId
-      });
-    } else if (source.state === 'manual') outcome = resolvedIds.has(source.censusId) ? 'manual-done' : 'manual-open';else if (source.state === 'pending') outcome = 'not-decided';else if (source.state === 'planned' && ['entity', 'sub-part'].includes(source.kind)) {
-      const completeness = (report.entityCompleteness || []).find(entry => entry.entity === source.entity && (entry.subtype || 'all') === (source.subtype || 'all'));
-      const dropped = (report.droppedFields || []).some(field => {
-        if (field.entity !== source.entity) return false;
-        if (field.subtype) return field.subtype === (source.subtype || 'all');
-        const subparts = censusRows.filter(entry => entry.kind === 'sub-part' && entry.entity === field.entity && (entry.evidenceFields || []).includes(field.field));
-        return subparts.length ? subparts.some(entry => entry.censusId === source.censusId) : (source.subtype || 'all') === 'all';
-      });
-      outcome = !completeness ? 'no-outcome-recorded' : completeness.failed > 0 ? 'failed' : completeness.unresolved > 0 ? 'unresolved' : completeness.deferred > 0 ? 'deferred' : completeness.imported + completeness.alreadyPresentByCrosswalk < completeness.inScope || dropped ? 'partial' : 'imported';
-    }
-    if (source.state === 'planned' && source.kind === 'plugin' && !(source.linkedCapabilities || []).length) outcome = 'no-outcome-recorded';
-    return {
-      censusId: source.censusId,
-      kind: source.kind,
-      state: source.state,
-      outcome,
-      ownerApproved: row.ownerApproved,
-      count: Object.prototype.hasOwnProperty.call(source, 'count') ? typeof source.count === 'number' ? source.count : null : typeof source.recordCount === 'number' ? source.recordCount : null,
-      open: source.kind === 'source-coverage' ? COVERAGE_OPEN[outcome] : !CLOSED.has(outcome) && !(['excluded', 'unsupported'].includes(outcome) && row.ownerApproved),
-      action: null,
-      ...(source.kind === 'source-coverage' ? {
-        actionSource: 'completion-report'
-      } : {})
-    };
-  });
-  // Capabilities are based on actual plan links, never guessed from source entity names.
-  for (const row of rows.filter(entry => entry.kind === 'capability' && entry.state === 'planned')) {
-    const source = censusRows.find(entry => entry.censusId === row.censusId);
-    const children = (source.relatedEntityIds || []).map(id => rows.find(entry => entry.censusId === id)).filter(Boolean);
-    const worst = leastFavorable(children);
-    row.outcome = worst?.outcome || 'no-outcome-recorded';
-    row.open = children.length ? children.some(entry => entry.open) : true;
-  }
-  for (const row of rows.filter(entry => entry.kind === 'plugin')) {
-    const source = censusRows.find(entry => entry.censusId === row.censusId);
-    if (!(source.linkedCapabilities || []).length) continue;
-    const children = source.linkedCapabilities.map(id => rows.find(entry => entry.censusId === id)).filter(Boolean);
-    const worst = leastFavorable(children);
-    row.outcome = worst?.outcome || 'no-outcome-recorded';
-    row.open = children.length ? children.some(entry => entry.open) : true;
-    row.ownerApproved = ['excluded', 'unsupported'].includes(row.outcome) ? children.every(entry => !entry.open) : null;
-  }
-  for (const row of rows) if (row.open && row.kind !== 'source-coverage') row.action = actionFor(projectDir, {
-    ...censusRows.find(entry => entry.censusId === row.censusId),
-    ownerApproved: row.ownerApproved
-  }, row.outcome, row.count);
-  return rows;
-}
-function renderStatus(status) {
-  return ['# Discovered set status', '', '| Census ID | State | Outcome | Count | Open |', '| --- | --- | --- | --- | --- |', ...status.rows.map(row => `| ${row.censusId} | ${row.state || 'derived'} | ${row.outcome} | ${row.count === null ? 'unknown' : row.count} | ${row.open ? 'yes' : 'no'} |`), '', `Open discovered-set rows: ${status.openCount}`, ''].join('\n');
-}
-async function buildDiscoveredSetStatus(projectDir) {
-  const {
-    censusReconciliationFreshness,
-    mappingApprovalBound,
-    ownerApprovedCensusIds
-  } = require('./census-reconciliation.js');
-  const reconciliation = await json(projectDir, RECONCILIATION_FILE);
-  if (!reconciliation) throw refusal('census_reconciliation_missing');
-  const fresh = await censusReconciliationFreshness(projectDir, reconciliation);
-  if (!fresh.ok) throw refusal('census_reconciliation_stale', fresh);
-  if (reconciliation.errors?.length) throw refusal('census_reconciliation_blocking', {
-    errors: reconciliation.errors
-  });
-  const approval = (await json(projectDir, 'orchestration/approvals.json'))?.mapping;
-  const ref = approval?.artifactRefs?.find(ref => ref && typeof ref === 'object' && ref.kind === 'census-reconciliation' && ref.path === RECONCILIATION_FILE && /^[0-9a-f]{64}$/i.test(ref.sha256));
-  if (!ref) throw refusal('approval_missing_census_reference');
-  if (!(await mappingApprovalBound(projectDir, approval))) throw refusal('mapping_approval_stale_census');
-  const report = await json(projectDir, REPORT_FILE);
-  if (!report) throw refusal('completion_report_missing');
-  const resolutions = await resolutionInputs(projectDir);
-  const rows = deriveRows(projectDir, reconciliation, report, await ownerApprovedCensusIds(projectDir), resolutions.lines.map(JSON.parse));
-  const status = {
-    schemaVersion: 1,
-    generatedAt: new Date().toISOString(),
-    inputs: await inputDigests(projectDir),
-    rows,
-    openCount: rows.filter(row => row.open && row.kind !== 'source-coverage').length
-  };
-  await writeJsonAtomic(path.join(projectDir, STATUS_FILE), status);
-  await fs.mkdir(path.dirname(path.join(projectDir, STATUS_MARKDOWN)), {
-    recursive: true
-  });
-  await fs.writeFile(path.join(projectDir, STATUS_MARKDOWN), renderStatus(status));
-  return status;
-}
-async function resolveDiscoveredSet(projectDir, {
-  censusId,
-  by,
-  evidence
-}) {
-  if (!['merchant', 'cutover-operator'].includes(by) || typeof evidence !== 'string' || !evidence.trim() || evidence.length > 500 || /[\r\n\x00]/.test(evidence) || /[\w.+-]+@[\w-]+\.[\w.-]+/.test(evidence)) throw refusal('resolution_invalid');
-  // Recompute from trusted inputs before appending; callers cannot resolve a forged status row.
-  const status = await buildDiscoveredSetStatus(projectDir);
-  if (!status.rows.some(row => row.censusId === censusId && row.outcome === 'manual-open')) throw refusal('resolution_not_manual_open');
-  const entry = {
-    censusId,
-    by,
-    evidence: evidence.trim(),
-    recordedAt: new Date().toISOString()
-  };
-  await fs.appendFile(path.join(projectDir, RESOLUTIONS_FILE), `${JSON.stringify(entry)}\n`);
-  return buildDiscoveredSetStatus(projectDir);
-}
-async function checkResolutionPrefix(projectDir, recorded) {
-  const current = await resolutionInputs(projectDir);
-  if (current.lines.length < recorded.lines) return false;
-  if (!recorded.lines) return recorded.sha256 === null || recorded.sha256 === digest('');
-  return digest(`${current.lines.slice(0, recorded.lines).join('\n')}\n`) === recorded.sha256;
-}
-module.exports = {
-  STATUS_FILE,
-  STATUS_MARKDOWN,
-  RESOLUTIONS_FILE,
-  RECONCILIATION_FILE,
-  inputDigests,
-  discoveredSetStatusFreshness,
-  deriveFinalStatus,
-  deriveRows,
-  buildDiscoveredSetStatus,
-  resolveDiscoveredSet,
-  checkResolutionPrefix,
-  renderStatus
-};