@work-graph/cli 0.2.0

package/vendor/src/codeGapAnalyzer.mjs

@@ -0,0 +1,308 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+export const CODE_GAP_REPORT_SCHEMA = 'code-gap.report.v1';
+
+const SKIP_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'coverage',
+  'out',
+  'build',
+  '.vite',
+  'vendor',
+]);
+
+const STEP_BLOCK_PATTERN = /^#([^\n<]+)<\[\n([\s\S]*?)\n\]>/gmu;
+const LINK_MODE_RE = /(?:^|\n)\s*(?:compiler\.mode|mode):\s*link\s*(?:\n|$)/iu;
+const GUID_LABEL_RE = /(?:^|\n)\s*guid:\s*([a-fA-F0-9-]{8}-[a-fA-F0-9-]{4}-[a-fA-F0-9-]{4}-[a-fA-F0-9-]{4}-[a-fA-F0-9-]{12})/iu;
+const TUR_ID_LABEL_RE = /(?:^|\n)\s*tur_id:\s*([A-Za-z0-9_.-]+)/iu;
+const EXPORT_PATTERN = /^\s*export\s+(?:async\s+)?(?:function|class|const|let|var)\s+([A-Za-z_$][\w$]*)/gmu;
+
+function posixRel(root, absPath) {
+  return relative(root, absPath).replace(/\\/g, '/');
+}
+
+function walkFiles(absDir, predicate, out = []) {
+  if (!existsSync(absDir)) {
+    return out;
+  }
+
+  for (const entry of readdirSync(absDir, { withFileTypes: true })) {
+    const entryPath = join(absDir, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) {
+        continue;
+      }
+      walkFiles(entryPath, predicate, out);
+      continue;
+    }
+
+    if (entry.isFile() && predicate(entry.name)) {
+      out.push(entryPath);
+    }
+  }
+
+  return out;
+}
+
+export function collectStepFilePaths(repoRoot, relDirs) {
+  const out = [];
+  for (const relDir of relDirs) {
+    walkFiles(join(repoRoot, relDir), (name) => name.endsWith('.bvc'), out);
+  }
+
+  return out.sort();
+}
+
+export function collectCodeFilePaths(repoRoot, relDirs) {
+  const out = [];
+  for (const relDir of relDirs) {
+    walkFiles(
+      join(repoRoot, relDir),
+      (name) => /\.(mjs|cjs|js|ts|mts)$/u.test(name) && !/\.(test|spec)\.[cm]?[jt]s$/iu.test(name),
+      out,
+    );
+  }
+
+  return out.sort();
+}
+
+function extractStepBlocks(text) {
+  return [...text.matchAll(STEP_BLOCK_PATTERN)].map((match) => ({
+    name: match[1].trim(),
+    body: match[2],
+  }));
+}
+
+function parseLinkSteps(stepAbsPaths, repoRoot) {
+  const linkSteps = [];
+
+  for (const absPath of stepAbsPaths) {
+    let text;
+    try {
+      text = readFileSync(absPath, 'utf8');
+    } catch {
+      continue;
+    }
+
+    for (const block of extractStepBlocks(text)) {
+      if (!LINK_MODE_RE.test(block.body)) {
+        continue;
+      }
+
+      linkSteps.push({
+        stepName: block.name,
+        stepGuid: block.body.match(GUID_LABEL_RE)?.[1] ?? '',
+        stepFile: posixRel(repoRoot, absPath),
+        stepTurId: block.body.match(TUR_ID_LABEL_RE)?.[1] ?? block.name,
+      });
+    }
+  }
+
+  return linkSteps;
+}
+
+function collectStepNames(stepAbsPaths) {
+  const names = new Set();
+  for (const absPath of stepAbsPaths) {
+    try {
+      for (const block of extractStepBlocks(readFileSync(absPath, 'utf8'))) {
+        names.add(block.name);
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return names;
+}
+
+function scanTurImplementations(codeAbsPaths, repoRoot) {
+  const implementations = [];
+
+  for (const absPath of codeAbsPaths) {
+    let text;
+    try {
+      text = readFileSync(absPath, 'utf8');
+    } catch {
+      continue;
+    }
+
+    const lines = text.split(/\r?\n/u);
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+      const turMatch = lines[lineIndex].match(/@iohasc-tur:\s*([A-Za-z0-9_.-]+)/u);
+      if (!turMatch) {
+        continue;
+      }
+
+      const stepGuidMatch = lines.slice(lineIndex, lineIndex + 6).join('\n').match(
+        /@iohasc-step:\s*([a-fA-F0-9-]{8}-[a-fA-F0-9-]{4}-[a-fA-F0-9-]{4}-[a-fA-F0-9-]{4}-[a-fA-F0-9-]{12})/iu,
+      );
+
+      const fnMatch = lines.slice(lineIndex, lineIndex + 4).join('\n').match(/(?:function|const)\s+([A-Za-z_$][\w$]*)/u);
+
+      implementations.push({
+        turId: turMatch[1],
+        stepGuid: stepGuidMatch?.[1] ?? '',
+        filePath: posixRel(repoRoot, absPath),
+        lineNumber: lineIndex + 1,
+        functionName: fnMatch?.[1] ?? turMatch[1],
+      });
+    }
+  }
+
+  return implementations;
+}
+
+function listExportedSymbols(text) {
+  const symbols = new Set();
+  for (const match of text.matchAll(EXPORT_PATTERN)) {
+    symbols.add(match[1]);
+  }
+
+  return [...symbols];
+}
+
+function shouldSkipUntrackedSymbol(name) {
+  return !name || name.startsWith('_');
+}
+
+export function analyzeCodeGaps(options = {}) {
+  const repoRoot = String(options.repoRoot ?? process.cwd()).replace(/\\/g, '/').replace(/\/+$/, '');
+  const codeRelDirs = options.codeRelDirs?.length ? options.codeRelDirs : ['src'];
+  const stepRelDirs = options.stepSearchRelDirs?.length
+    ? options.stepSearchRelDirs
+    : ['steps', 'charter', 'protocols', 'intent'];
+
+  const stepFiles = collectStepFilePaths(repoRoot, stepRelDirs);
+  const codeFiles = collectCodeFilePaths(repoRoot, codeRelDirs);
+  const linkSteps = parseLinkSteps(stepFiles, repoRoot);
+  const stepNames = collectStepNames(stepFiles);
+  const implementations = scanTurImplementations(codeFiles, repoRoot);
+
+  const implByGuid = new Map(
+    implementations
+      .filter((entry) => entry.stepGuid)
+      .map((entry) => [entry.stepGuid, entry]),
+  );
+  const implTurIds = new Set(implementations.map((entry) => entry.turId));
+  const implFunctionNames = new Set(implementations.map((entry) => entry.functionName));
+
+  const entries = [];
+
+  for (const linkStep of linkSteps) {
+    if (!implByGuid.has(linkStep.stepGuid)) {
+      entries.push({
+        kind: 'missing_implementation',
+        filePath: linkStep.stepFile,
+        stepGuid: linkStep.stepGuid,
+        reason: `Link step «${linkStep.stepName}» without @iohasc-tur implementation (guid ${linkStep.stepGuid}).`,
+      });
+    }
+  }
+
+  for (const impl of implementations) {
+    const linked = linkSteps.some((step) => step.stepGuid === impl.stepGuid);
+    if (!linked) {
+      entries.push({
+        kind: 'orphaned_tur',
+        filePath: impl.filePath,
+        symbol: impl.functionName,
+        line: impl.lineNumber,
+        turId: impl.turId,
+        stepGuid: impl.stepGuid,
+        reason: `@iohasc-tur «${impl.turId}» is not linked to a link-mode .bvc block.`,
+      });
+    }
+
+    const linkedStep = linkSteps.find((step) => step.stepGuid === impl.stepGuid);
+    if (linkedStep && linkedStep.stepTurId && linkedStep.stepTurId !== impl.turId) {
+      entries.push({
+        kind: 'tur_id_mismatch',
+        filePath: impl.filePath,
+        symbol: impl.functionName,
+        line: impl.lineNumber,
+        turId: impl.turId,
+        stepGuid: impl.stepGuid,
+        reason: `tur_id «${linkedStep.stepTurId}» in step ≠ @iohasc-tur «${impl.turId}».`,
+      });
+    }
+  }
+
+  for (const absPath of codeFiles) {
+    let text;
+    try {
+      text = readFileSync(absPath, 'utf8');
+    } catch {
+      continue;
+    }
+
+    const rel = posixRel(repoRoot, absPath);
+    for (const symbol of listExportedSymbols(text)) {
+      if (shouldSkipUntrackedSymbol(symbol)) {
+        continue;
+      }
+
+      if (stepNames.has(symbol) || implTurIds.has(symbol) || implFunctionNames.has(symbol)) {
+        continue;
+      }
+
+      entries.push({
+        kind: 'untracked_export',
+        filePath: rel,
+        symbol,
+        reason: 'Export is not covered by step block name or known @iohasc-tur marker.',
+      });
+    }
+  }
+
+  entries.sort((left, right) => {
+    const kind = left.kind.localeCompare(right.kind);
+    if (kind !== 0) {
+      return kind;
+    }
+
+    return `${left.filePath}:${left.symbol ?? ''}`.localeCompare(`${right.filePath}:${right.symbol ?? ''}`);
+  });
+
+  const summary = {
+    total: entries.length,
+    untrackedExports: entries.filter((entry) => entry.kind === 'untracked_export').length,
+    missingImplementation: entries.filter((entry) => entry.kind === 'missing_implementation').length,
+    orphanedTur: entries.filter((entry) => entry.kind === 'orphaned_tur').length,
+    turIdMismatch: entries.filter((entry) => entry.kind === 'tur_id_mismatch').length,
+  };
+
+  return {
+    schema: CODE_GAP_REPORT_SCHEMA,
+    summary,
+    entries,
+    tur: {
+      linkStepCount: linkSteps.length,
+      implementationCount: implementations.length,
+    },
+  };
+}
+
+export function formatCodeGapReportMarkdown(report) {
+  const lines = [
+    '## Code gap',
+    '',
+    `- missing_implementation: **${report.summary.missingImplementation}**`,
+    `- orphaned_tur: **${report.summary.orphanedTur}**`,
+    `- tur_id_mismatch: **${report.summary.turIdMismatch}**`,
+    `- untracked_export: **${report.summary.untrackedExports}**`,
+    `- **total entries:** ${report.summary.total}`,
+    '',
+  ];
+
+  for (const entry of report.entries) {
+    const location = entry.line != null ? `${entry.filePath}:${entry.line}` : entry.filePath;
+    const symbol = entry.symbol ? ` \`${entry.symbol}\`` : '';
+    lines.push(`- **${entry.kind}**${symbol} — ${location}: ${entry.reason}`);
+  }
+
+  return lines.join('\n');
+}

package/vendor/src/codeGapBacklogFeeder.mjs

@@ -0,0 +1,82 @@
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+function slugify(value) {
+  return String(value ?? '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/gu, '-')
+    .replace(/^-+|-+$/gu, '')
+    .slice(0, 48) || 'gap-item';
+}
+
+function confidenceForGapKind(kind) {
+  if (kind === 'missing_implementation') {
+    return 'high';
+  }
+
+  if (kind === 'untracked_export') {
+    return 'medium';
+  }
+
+  return 'low';
+}
+
+function titleForGapEntry(entry) {
+  if (entry.kind === 'untracked_export') {
+    return `покрыть step для экспорта ${entry.symbol ?? entry.filePath}`;
+  }
+
+  if (entry.kind === 'missing_implementation') {
+    return `реализовать TUR/link для ${entry.stepGuid ?? entry.filePath}`;
+  }
+
+  if (entry.kind === 'orphaned_tur') {
+    return `сопоставить orphaned TUR ${entry.turId ?? entry.symbol ?? ''}`.trim();
+  }
+
+  return `устранить code-gap: ${entry.kind}`;
+}
+
+export function mapGapEntryToWorkItemDraft(entry, options = {}) {
+  const prefix = options.idPrefix ?? 'gap';
+  const baseId = entry.symbol ? `${prefix}-${slugify(entry.symbol)}` : `${prefix}-${slugify(entry.filePath)}`;
+
+  return {
+    schema: 'workitem.draft.v1',
+    suggestedWorkId: baseId,
+    title: titleForGapEntry(entry),
+    status: 'backlog',
+    targetFiles: [entry.filePath].filter(Boolean),
+    confidence: confidenceForGapKind(entry.kind),
+    gapKind: entry.kind,
+    reason: entry.reason,
+    provenance: {
+      source: 'code-gap-analyzer',
+      repo: options.sourceRepo ?? '../project',
+      gapKind: entry.kind,
+      symbol: entry.symbol ?? '',
+      turId: entry.turId ?? '',
+      stepGuid: entry.stepGuid ?? '',
+    },
+    reviewRequired: true,
+  };
+}
+
+export function buildCodeGapBacklogFeed(report, options = {}) {
+  if (report === undefined || report === null) {
+    throw new TypeError('report is required');
+  }
+
+  const entries = Array.isArray(report.entries) ? report.entries : [];
+  const suggestions = entries
+    .map((entry) => mapGapEntryToWorkItemDraft(entry, options))
+    .sort((left, right) => compareText(left.suggestedWorkId, right.suggestedWorkId));
+
+  return {
+    schema: 'code-gap.backlog-feed.v1',
+    sourceReport: report.summary ?? {},
+    suggestionCount: suggestions.length,
+    suggestions,
+    promotionProtocol: 'protocols/workgraph-draft-intake.bvc',
+    reviewRequired: true,
+  };
+}

package/vendor/src/codeGapDraftIntakeApi.mjs

@@ -0,0 +1,307 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import {
+  appendWorkItemAtomToBacklogText,
+  findWorkItemAtomSpan,
+  writeBacklogTextAtomically,
+} from './workGraphBacklogPersist.mjs';
+import {
+  appendWorkItemAtomToIntentTree,
+  readWorkItemAtomFromRepo,
+} from './intentTreeWorkItems.mjs';
+import { formatStepAtomDraft, validateStepAtomDraft } from './stepAtomFormatter.mjs';
+import {
+  evaluateDraftIntakePromotion,
+  partitionDraftIntakeCandidates,
+} from './draftIntakePromotionRules.mjs';
+import { DEFAULT_CODE_GAP_REPORT_PATH } from './codeGapOperatorProjection.mjs';
+
+export const CODE_GAP_DRAFT_PROPOSAL_SCHEMA = 'code-gap.draft-intake.proposal.v1';
+export const CODE_GAP_DRAFT_APPLY_SCHEMA = 'code-gap.draft-intake.apply.response.v1';
+export const CODE_GAP_DRAFT_SCHEMA = 'code-gap.draft-intake.draft.v1';
+
+function atomNameFromWorkId(workId) {
+  const safe = String(workId ?? '').trim().replace(/-/g, '_');
+  return `Задача_${safe}`;
+}
+
+function priorityForConfidence(confidence) {
+  if (confidence === 'high') {
+    return 'high';
+  }
+
+  if (confidence === 'low') {
+    return 'low';
+  }
+
+  return 'medium';
+}
+
+export function buildWorkItemDraftFromCodeGapSuggestion(suggestion, options = {}) {
+  if (!suggestion || typeof suggestion !== 'object') {
+    throw new TypeError('suggestion is required');
+  }
+
+  const workId = String(suggestion.suggestedWorkId ?? '').trim();
+  if (workId === '') {
+    throw new TypeError('suggestion.suggestedWorkId is required');
+  }
+
+  const title = String(suggestion.title ?? workId).trim();
+  const targetFiles = [...(suggestion.targetFiles ?? [])];
+  const provenance = suggestion.provenance ?? {};
+  const sourceReportPath = String(
+    options.sourceReportPath ?? options.intakeSourcePath ?? DEFAULT_CODE_GAP_REPORT_PATH,
+  ).trim();
+
+  const draft = {
+    name: atomNameFromWorkId(workId),
+    profile: 'work_item',
+    basis: [
+      `Code-gap analyzer обнаружил ${suggestion.gapKind ?? 'gap'}: ${suggestion.reason ?? title}.`,
+      provenance.symbol ? `Symbol: ${provenance.symbol}.` : '',
+      provenance.stepGuid ? `Step GUID: ${provenance.stepGuid}.` : '',
+    ].filter(Boolean),
+    vector: [
+      'Оформить WorkItem из code-gap suggestion через reviewed draft intake.',
+      'Связать задачу с target files и закрыть gap после verification.',
+    ],
+    goal: [title],
+    checks: [
+      'draft проходит StepAtomDraft validation',
+      'operator подтвердил explicit apply в backlog',
+      'duplicate work.id отсутствует',
+    ],
+    labels: {
+      'atom.profile': 'work_item',
+      'work.id': workId,
+      'work.title': title,
+      'work.status': 'backlog',
+      'work.owner_role': options.ownerRole ?? 'integration_architect',
+      'work.department': options.department ?? 'memory',
+      'work.priority': priorityForConfidence(suggestion.confidence),
+      'work.risk': 'medium',
+      'work.next_action': options.nextAction ?? 'review draft и promote в ready',
+      'work.target_files': targetFiles.join(', '),
+      'intake.source_kind': 'code-gap-analyzer',
+      'intake.review_status': 'pending',
+      'intake.source_path': sourceReportPath,
+      'intake.promoted_work.id': workId,
+      'trace.status': 'pending',
+      'migration.strategy': 'rebuild',
+    },
+  };
+
+  return {
+    schema: CODE_GAP_DRAFT_SCHEMA,
+    suggestedWorkId: workId,
+    reviewRequired: suggestion.reviewRequired !== false,
+    gapKind: suggestion.gapKind ?? '',
+    confidence: suggestion.confidence ?? 'medium',
+    targetFiles,
+    provenance,
+    draft,
+  };
+}
+
+export function buildCodeGapDraftProposal(body, options = {}) {
+  const suggestion = body?.suggestion;
+
+  if (!suggestion || typeof suggestion !== 'object') {
+    const emptyProposal = {
+      ok: false,
+      error: 'suggestion_required',
+      validationErrors: ['suggestion is required'],
+      codeGapDraft: null,
+    };
+
+    return {
+      schema: CODE_GAP_DRAFT_PROPOSAL_SCHEMA,
+      ...emptyProposal,
+      reviewRequired: true,
+      promotionProtocol: 'protocols/workgraph-draft-intake.bvc',
+      promotionEvaluation: evaluateDraftIntakePromotion(emptyProposal, options),
+    };
+  }
+
+  const codeGapDraft = buildWorkItemDraftFromCodeGapSuggestion(suggestion, {
+    ...options,
+    sourceReportPath: body.sourceReportPath ?? options.sourceReportPath,
+  });
+
+  const validationErrors = validateStepAtomDraft(codeGapDraft.draft);
+  let formattedAtom = null;
+
+  if (validationErrors.length === 0) {
+    try {
+      formattedAtom = formatStepAtomDraft(codeGapDraft.draft);
+    } catch (error) {
+      validationErrors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+
+  return {
+    schema: CODE_GAP_DRAFT_PROPOSAL_SCHEMA,
+    ok: validationErrors.length === 0,
+    error: validationErrors.length === 0 ? null : 'validation_failed',
+    codeGapDraft,
+    formattedAtom,
+    validationErrors,
+    reviewRequired: true,
+    promotionProtocol: 'protocols/workgraph-draft-intake.bvc',
+    promotionEvaluation: evaluateDraftIntakePromotion({
+      ok: validationErrors.length === 0,
+      validationErrors,
+      codeGapDraft,
+    }, options),
+  };
+}
+
+export function parseCodeGapDraftIntakeRequestBody(rawBody) {
+  if (rawBody === undefined || rawBody === null) {
+    return {};
+  }
+
+  if (typeof rawBody === 'string' && rawBody.trim() === '') {
+    return {};
+  }
+
+  const body = typeof rawBody === 'string' ? JSON.parse(rawBody) : rawBody;
+
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    throw new TypeError('code-gap draft intake body must be a JSON object');
+  }
+
+  return body;
+}
+
+export async function executeCodeGapDraftProposal(options = {}) {
+  const body = parseCodeGapDraftIntakeRequestBody(options.body ?? {});
+  return buildCodeGapDraftProposal(body, options);
+}
+
+export function buildCodeGapBacklogCandidateList(feedOrProjection, options = {}) {
+  const suggestions = Array.isArray(feedOrProjection?.suggestions)
+    ? feedOrProjection.suggestions
+    : [];
+
+  const entries = suggestions.map((suggestion) => ({
+    suggestion,
+    proposal: buildCodeGapDraftProposal(
+      {
+        suggestion,
+        sourceReportPath: feedOrProjection?.sourceReportPath ?? options.sourceReportPath,
+      },
+      options,
+    ),
+  }));
+
+  return partitionDraftIntakeCandidates(entries, options);
+}
+
+export async function executeCodeGapDraftApply(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const body = parseCodeGapDraftIntakeRequestBody(options.body ?? {});
+
+  const proposal = body.proposal ?? buildCodeGapDraftProposal(body, options);
+
+  if (!proposal.ok || !proposal.codeGapDraft?.draft) {
+    return {
+      schema: CODE_GAP_DRAFT_APPLY_SCHEMA,
+      ok: false,
+      error: proposal.error ?? 'invalid_proposal',
+      workId: null,
+      persistedBacklog: false,
+      validationErrors: proposal.validationErrors ?? [],
+    };
+  }
+
+  const workId = String(proposal.codeGapDraft.suggestedWorkId ?? '').trim();
+  const draft = {
+    ...proposal.codeGapDraft.draft,
+    labels: {
+      ...proposal.codeGapDraft.draft.labels,
+      'intake.review_status': 'approved',
+      'intake.promoted_work.id': workId,
+    },
+  };
+
+  let formattedAtom = proposal.formattedAtom;
+  try {
+    formattedAtom = formatStepAtomDraft(draft);
+  } catch (error) {
+    return {
+      schema: CODE_GAP_DRAFT_APPLY_SCHEMA,
+      ok: false,
+      error: 'validation_failed',
+      workId,
+      persistedBacklog: false,
+      validationErrors: [error instanceof Error ? error.message : String(error)],
+    };
+  }
+
+  if (options.backlogText !== undefined || options.backlogPath) {
+    const backlogPath = resolve(cwd, options.backlogPath ?? 'work/backlog.bvc');
+    const backlogText = options.backlogText ?? await readFile(backlogPath, 'utf8');
+
+    if (findWorkItemAtomSpan(backlogText, workId)) {
+      return {
+        schema: CODE_GAP_DRAFT_APPLY_SCHEMA,
+        ok: false,
+        error: 'duplicate_work_id',
+        workId,
+        persistedBacklog: false,
+        validationErrors: [`work.id already exists: ${workId}`],
+      };
+    }
+
+    const nextText = appendWorkItemAtomToBacklogText(backlogText, formattedAtom);
+
+    if (options.persistBacklog !== false) {
+      await writeBacklogTextAtomically(backlogPath, nextText);
+    }
+
+    return {
+      schema: CODE_GAP_DRAFT_APPLY_SCHEMA,
+      ok: true,
+      error: null,
+      workId,
+      persistedBacklog: options.persistBacklog !== false,
+      validationErrors: [],
+      formattedAtom,
+      intakeSourceKind: 'code-gap-analyzer',
+    };
+  }
+
+  try {
+    await readWorkItemAtomFromRepo(workId, { ...options, cwd });
+    return {
+      schema: CODE_GAP_DRAFT_APPLY_SCHEMA,
+      ok: false,
+      error: 'duplicate_work_id',
+      workId,
+      persistedBacklog: false,
+      validationErrors: [`work.id already exists: ${workId}`],
+    };
+  } catch (error) {
+    if (!String(error instanceof Error ? error.message : error).includes('not found')) {
+      throw error;
+    }
+  }
+
+  if (options.persistBacklog !== false) {
+    await appendWorkItemAtomToIntentTree(formattedAtom, { ...options, cwd });
+  }
+
+  return {
+    schema: CODE_GAP_DRAFT_APPLY_SCHEMA,
+    ok: true,
+    error: null,
+    workId,
+    persistedBacklog: options.persistBacklog !== false,
+    validationErrors: [],
+    formattedAtom,
+    intakeSourceKind: 'code-gap-analyzer',
+  };
+}