@work-graph/cli 0.2.0

package/vendor/src/atomInspector.mjs

@@ -0,0 +1,253 @@
+import {
+  findWorkItemAtomSpan,
+  writeBacklogTextAtomically,
+} from './workGraphBacklogPersist.mjs';
+import { readWorkItemAtomFromRepo } from './intentTreeWorkItems.mjs';
+import { buildClosingAnalysisSuggestion } from './closingAnalysisSuggest.mjs';
+import { parseWorkItems } from './workGraphRuntime.mjs';
+import {
+  formatStepAtomDraft,
+  parseStepAtomDrafts,
+  validateStepAtomDraft,
+} from './stepAtomFormatter.mjs';
+
+export const ATOM_INSPECTOR_PROPOSAL_SCHEMA = 'atom-inspector.proposal.v1';
+export const ATOM_INSPECTOR_APPLY_SCHEMA = 'atom-inspector.apply.response.v1';
+
+const WORK_ITEM_STATUS_OPTIONS = [
+  'backlog',
+  'ready',
+  'claimed',
+  'doing',
+  'verify',
+  'done',
+  'blocked',
+];
+
+export function importStepAtomDraftForWorkItem(backlogText, workId) {
+  const span = findWorkItemAtomSpan(backlogText, workId);
+  if (!span) {
+    throw new Error(`work item atom not found: ${workId}`);
+  }
+
+  const [record] = parseStepAtomDrafts(span.fullMatch);
+  if (!record) {
+    throw new Error(`failed to parse work item atom: ${workId}`);
+  }
+
+  return {
+    workId,
+    atomName: span.atomName,
+    draft: record.draft,
+    warnings: record.warnings,
+    validationErrors: record.errors,
+    sourceBlock: span.fullMatch,
+  };
+}
+
+export function normalizeAtomInspectorDraftInput(rawDraft) {
+  if (!rawDraft || typeof rawDraft !== 'object' || Array.isArray(rawDraft)) {
+    throw new TypeError('draft must be an object');
+  }
+
+  const draft = {
+    profile: String(rawDraft.profile ?? 'work_item').trim(),
+    name: String(rawDraft.name ?? '').trim(),
+    basis: normalizeTextArray(rawDraft.basis),
+    vector: normalizeTextArray(rawDraft.vector),
+    goal: normalizeTextArray(rawDraft.goal),
+    labels: normalizeLabels(rawDraft.labels),
+  };
+
+  if (rawDraft.checks !== undefined) {
+    draft.checks = normalizeTextArray(rawDraft.checks, { allowEmpty: true });
+  }
+
+  if (rawDraft.evidence !== undefined) {
+    draft.evidence = normalizeTextArray(rawDraft.evidence, { allowEmpty: true });
+  }
+
+  if (rawDraft.analysis !== undefined) {
+    draft.analysis = normalizeTextArray(rawDraft.analysis, { allowEmpty: true });
+  }
+
+  if (rawDraft.decision !== undefined) {
+    draft.decision = normalizeTextArray(rawDraft.decision, { allowEmpty: true });
+  }
+
+  if (rawDraft.uiRefs !== undefined) {
+    draft.uiRefs = normalizeTextArray(rawDraft.uiRefs, { allowEmpty: true });
+  }
+
+  if (draft.labels['atom.profile'] === undefined || draft.labels['atom.profile'] === '') {
+    draft.labels['atom.profile'] = draft.profile;
+  }
+
+  return draft;
+}
+
+export function buildAtomInspectorProposal(draft, options = {}) {
+  const normalizedDraft = normalizeAtomInspectorDraftInput(draft);
+  const validationErrors = validateStepAtomDraft(normalizedDraft);
+
+  if (validationErrors.length > 0) {
+    return {
+      schema: ATOM_INSPECTOR_PROPOSAL_SCHEMA,
+      ok: false,
+      workId: normalizedDraft.labels?.['work.id'] ?? options.workId ?? null,
+      targetFile: options.targetFile ?? 'work/backlog.bvc',
+      draft: normalizedDraft,
+      generatedStep: null,
+      warnings: [],
+      validationErrors,
+    };
+  }
+
+  const generatedStep = formatStepAtomDraft(normalizedDraft);
+  const reparsed = parseStepAtomDrafts(generatedStep)[0];
+
+  return {
+    schema: ATOM_INSPECTOR_PROPOSAL_SCHEMA,
+    ok: true,
+    workId: normalizedDraft.labels['work.id'] ?? options.workId ?? null,
+    targetFile: options.targetFile ?? 'work/backlog.bvc',
+    draft: normalizedDraft,
+    generatedStep,
+    warnings: reparsed?.warnings ?? [],
+    validationErrors: reparsed?.errors ?? [],
+  };
+}
+
+export function replaceWorkItemAtomInBacklogText(backlogText, workId, generatedStep) {
+  const span = findWorkItemAtomSpan(backlogText, workId);
+  if (!span) {
+    throw new Error(`work item atom not found: ${workId}`);
+  }
+
+  const atomText = String(generatedStep ?? '').trimEnd();
+  if (!atomText.startsWith('#')) {
+    throw new Error('generatedStep must be a formatted step atom block');
+  }
+
+  const suffix = backlogText.slice(span.end);
+  const separator = suffix.startsWith('\n') ? '' : '\n';
+  return `${backlogText.slice(0, span.start)}${atomText}${separator}${suffix}`;
+}
+
+export async function applyAtomInspectorProposalToBacklogFile(options = {}) {
+  const workId = String(options.workId ?? '').trim();
+  if (workId === '') {
+    throw new TypeError('workId is required');
+  }
+
+  const proposal = buildAtomInspectorProposal(options.draft, {
+    workId,
+    targetFile: options.targetFile,
+  });
+
+  if (!proposal.ok || proposal.validationErrors.length > 0) {
+    return {
+      schema: ATOM_INSPECTOR_APPLY_SCHEMA,
+      ok: false,
+      error: 'validation_failed',
+      workId,
+      proposal,
+      persistedBacklog: false,
+    };
+  }
+
+  if (proposal.workId !== workId) {
+    return {
+      schema: ATOM_INSPECTOR_APPLY_SCHEMA,
+      ok: false,
+      error: 'work_id_mismatch',
+      workId,
+      proposal,
+      persistedBacklog: false,
+    };
+  }
+
+  const source = options.backlogText !== undefined || options.backlogPath
+    ? {
+        path: resolveBacklogPath(options),
+        text: options.backlogText ?? await readBacklog(resolveBacklogPath(options)),
+        mode: 'backlog',
+      }
+    : await readWorkItemAtomFromRepo(workId, options);
+  const previousItem = parseWorkItems(source.text).find((entry) => entry.id === workId) ?? null;
+  const newText = replaceWorkItemAtomInBacklogText(source.text, workId, proposal.generatedStep);
+  const nextItem = parseWorkItems(newText).find((entry) => entry.id === workId) ?? null;
+  const closingAnalysisSuggestion = buildClosingAnalysisSuggestion(previousItem, nextItem);
+
+  if (options.persistBacklog !== false) {
+    await writeBacklogTextAtomically(source.path, newText);
+  }
+
+  return {
+    schema: ATOM_INSPECTOR_APPLY_SCHEMA,
+    ok: true,
+    error: null,
+    workId,
+    proposal,
+    persistedBacklog: options.persistBacklog !== false,
+    path: source.relativePath ?? source.path,
+    mode: source.mode,
+    ...(closingAnalysisSuggestion ? { closingAnalysisSuggestion } : {}),
+  };
+}
+
+export function workItemStatusOptions() {
+  return [...WORK_ITEM_STATUS_OPTIONS];
+}
+
+function normalizeTextArray(value, options = {}) {
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => String(entry ?? '').trim())
+      .filter((entry) => entry !== '');
+  }
+
+  if (typeof value === 'string') {
+    const lines = value
+      .split(/\r?\n/u)
+      .map((line) => line.replace(/^-\s*/u, '').trim())
+      .filter(Boolean);
+    return lines;
+  }
+
+  if (options.allowEmpty) {
+    return [];
+  }
+
+  return [];
+}
+
+function normalizeLabels(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+
+  const labels = {};
+  for (const [key, rawValue] of Object.entries(value)) {
+    labels[String(key).trim()] = String(rawValue ?? '').trim();
+  }
+
+  return labels;
+}
+
+async function readBacklog(backlogPath) {
+  const { readFile } = await import('node:fs/promises');
+  return readFile(backlogPath, 'utf8');
+}
+
+function resolveBacklogPath(options) {
+  if (!options.backlogPath) {
+    throw new TypeError('backlogPath is required for backlog compatibility writes');
+  }
+
+  if (/^(?:[A-Za-z]:[\\/]|\\\\|\/)/u.test(options.backlogPath)) {
+    return options.backlogPath;
+  }
+
+  return `${options.cwd ?? process.cwd()}/${options.backlogPath}`;
+}

package/vendor/src/atomInspectorApi.mjs

@@ -0,0 +1,130 @@
+import {
+  applyAtomInspectorProposalToBacklogFile,
+  buildAtomInspectorProposal,
+  importStepAtomDraftForWorkItem,
+} from './atomInspector.mjs';
+import {
+  readWorkItemAtomFromRepo,
+  readWorkItemsFromRepo,
+} from './intentTreeWorkItems.mjs';
+
+export function parseAtomInspectorRequestBody(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('atom inspector body must be a JSON object');
+  }
+
+  return body;
+}
+
+export async function readAtomInspectorDraftResponse(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const workId = String(options.workId ?? '').trim();
+
+  if (workId === '') {
+    throw new TypeError('workId is required');
+  }
+
+  const source = await readWorkItemAtomFromRepo(workId, { ...options, cwd });
+  const imported = importStepAtomDraftForWorkItem(source.atomText, workId);
+  const items = await readWorkItemsFromRepo({ ...options, cwd });
+  const item = items.find((entry) => entry.id === workId) ?? null;
+
+  return {
+    schema: 'atom-inspector.draft.v1',
+    workId,
+    atomName: imported.atomName,
+    draft: imported.draft,
+    warnings: imported.warnings,
+    validationErrors: imported.validationErrors,
+    snapshot: item
+      ? {
+          id: item.id,
+          title: item.title,
+          status: item.status,
+          ownerRole: item.ownerRole,
+          department: item.department,
+          priority: item.priority,
+          risk: item.risk,
+          dependsOn: item.dependsOn,
+          targetFiles: item.targetFiles,
+          nextAction: item.nextAction,
+          blocker: item.blocker,
+        }
+      : null,
+  };
+}
+
+export async function executeAtomInspectorProposal(options = {}) {
+  const body = parseAtomInspectorRequestBody(options.body ?? {});
+  const workId = String(body.workId ?? body.taskId ?? '').trim();
+  const cwd = options.cwd ?? process.cwd();
+
+  if (workId === '') {
+    return buildAtomInspectorProposal({}, { targetFile: options.backlogPath ?? 'intent/index.bvc' });
+  }
+
+  if (!body.draft) {
+    const draftResponse = await readAtomInspectorDraftResponse({ ...options, cwd, workId });
+    return buildAtomInspectorProposal(draftResponse.draft, {
+      workId,
+      targetFile: options.backlogPath ?? 'intent/index.bvc',
+    });
+  }
+
+  return buildAtomInspectorProposal(body.draft, {
+    workId,
+    targetFile: options.backlogPath ?? 'intent/index.bvc',
+  });
+}
+
+export async function executeAtomInspectorApply(options = {}) {
+  const body = parseAtomInspectorRequestBody(options.body ?? {});
+  const workId = String(body.workId ?? body.taskId ?? '').trim();
+  const cwd = options.cwd ?? process.cwd();
+
+  if (workId === '') {
+    return {
+      schema: 'atom-inspector.apply.response.v1',
+      ok: false,
+      error: 'work_id_required',
+      workId: null,
+      persistedBacklog: false,
+    };
+  }
+
+  if (!body.draft) {
+    return {
+      schema: 'atom-inspector.apply.response.v1',
+      ok: false,
+      error: 'draft_required',
+      workId,
+      persistedBacklog: false,
+    };
+  }
+
+  return applyAtomInspectorProposalToBacklogFile({
+    ...options,
+    cwd,
+    workId,
+    draft: body.draft,
+    targetFile: options.backlogPath ?? 'intent/index.bvc',
+    persistBacklog: body.persistBacklog !== false && options.persistBacklog !== false,
+  });
+}
+
+export {
+  buildCodeGapDraftProposal,
+  buildWorkItemDraftFromCodeGapSuggestion,
+  executeCodeGapDraftApply,
+  executeCodeGapDraftProposal,
+} from './codeGapDraftIntakeApi.mjs';

package/vendor/src/auditGapMatrixRefresh.mjs

@@ -0,0 +1,121 @@
+import { access, readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+
+export const AUDIT_GAP_MATRIX_SYNC_SCHEMA = 'workgraph.audit-gap-matrix.sync.v1';
+
+const REQUIRED_MATRIX_STATUSES = ['implemented', 'contract-only', 'stub', 'deferred', 'replace'];
+const REQUIRED_MATRIX_SECTIONS = [
+  '## Легенда статусов',
+  '## Матрица: capability → strategy → fact → follow-up',
+  '## Post-rollout backlog',
+];
+
+const RECONCILE_PROCEDURE_HEADING = '## Процедура сверки при изменениях ioHasC';
+
+/**
+ * @param {string} text
+ * @param {string[]} needles
+ */
+function includesAll(text, needles) {
+  return needles.every((needle) => text.includes(needle));
+}
+
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {{ cwd?: string, matrixPath?: string, rebuildPlanPath?: string, iohascStatusPath?: string, matrixText?: string, rebuildPlanText?: string }} [options]
+ */
+export async function evaluateAuditGapMatrixSync(options = {}) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const matrixPath = resolve(cwd, options.matrixPath ?? 'docs/plan-iohasc-rebuild-audit-gap-matrix.md');
+  const rebuildPlanPath = resolve(cwd, options.rebuildPlanPath ?? 'docs/plan-iohasc-full-rebuild-backlog.md');
+  const iohascStatusPath = resolve(cwd, options.iohascStatusPath ?? '../project/docs/architecture-v2/IMPLEMENTATION_STATUS.md');
+
+  const checks = [];
+  const matrixText = options.matrixText ?? await readFile(matrixPath, 'utf8');
+  const rebuildPlanText = options.rebuildPlanText ?? await readFile(rebuildPlanPath, 'utf8');
+
+  checks.push({
+    id: 'matrix-status-legend',
+    label: 'Audit-gap matrix documents implemented/contract-only/stub/deferred/replace legend',
+    met: includesAll(matrixText, REQUIRED_MATRIX_STATUSES),
+    evidence: matrixPath,
+  });
+
+  checks.push({
+    id: 'matrix-required-sections',
+    label: 'Audit-gap matrix includes legend, capability table, and post-rollout backlog sections',
+    met: includesAll(matrixText, REQUIRED_MATRIX_SECTIONS),
+    evidence: matrixPath,
+  });
+
+  checks.push({
+    id: 'rebuild-plan-matrix-link',
+    label: 'Full rebuild backlog links to audit-gap matrix',
+    met: rebuildPlanText.includes('plan-iohasc-rebuild-audit-gap-matrix.md'),
+    evidence: rebuildPlanPath,
+  });
+
+  checks.push({
+    id: 'reconcile-procedure-documented',
+    label: 'Full rebuild backlog documents reconcile procedure heading',
+    met: rebuildPlanText.includes(RECONCILE_PROCEDURE_HEADING),
+    evidence: rebuildPlanPath,
+  });
+
+  checks.push({
+    id: 'reconcile-cli-referenced',
+    label: 'Full rebuild backlog references npm run check:audit-gap-matrix',
+    met: rebuildPlanText.includes('npm run check:audit-gap-matrix'),
+    evidence: rebuildPlanPath,
+  });
+
+  const iohascStatusExists = await pathExists(iohascStatusPath);
+  checks.push({
+    id: 'iohasc-status-source-present',
+    label: 'Sibling ioHasC IMPLEMENTATION_STATUS source is reachable when present',
+    met: !iohascStatusExists || rebuildPlanText.includes('IMPLEMENTATION_STATUS.md'),
+    evidence: iohascStatusExists ? iohascStatusPath : 'optional sibling ../project not checked in',
+  });
+
+  if (iohascStatusExists) {
+    const iohascStatusText = await readFile(iohascStatusPath, 'utf8');
+    checks.push({
+      id: 'iohasc-status-has-phase-headings',
+      label: 'ioHasC IMPLEMENTATION_STATUS contains phase headings for manual reconcile',
+      met: /Phase\s+\d+/u.test(iohascStatusText) || /##\s+/u.test(iohascStatusText),
+      evidence: iohascStatusPath,
+    });
+  }
+
+  const unmet = checks.filter((check) => !check.met);
+  return {
+    schema: AUDIT_GAP_MATRIX_SYNC_SCHEMA,
+    ok: unmet.length === 0,
+    matrixPath: join(cwd, 'docs/plan-iohasc-rebuild-audit-gap-matrix.md'),
+    rebuildPlanPath: join(cwd, 'docs/plan-iohasc-full-rebuild-backlog.md'),
+    iohascStatusPath: iohascStatusExists ? iohascStatusPath : null,
+    checkCount: checks.length,
+    unmetCount: unmet.length,
+    checks,
+  };
+}
+
+export function formatAuditGapMatrixSyncReport(report) {
+  const lines = [
+    `audit-gap matrix sync: ${report.ok ? 'ok' : 'failed'} (${report.unmetCount}/${report.checkCount} unmet)`,
+  ];
+
+  for (const check of report.checks) {
+    lines.push(`${check.met ? 'ok' : 'fail'}: [${check.id}] ${check.label}`);
+  }
+
+  return lines.join('\n');
+}

package/vendor/src/backlogSchemaLint.mjs

@@ -0,0 +1,176 @@
+import { resolve } from 'node:path';
+
+import { lintWorkItemHierarchyIssues } from './workItemHierarchy.mjs';
+import { lintPipelineStageIssues } from './pipelineStageLint.mjs';
+import { readWorkItemsFromRepo } from './intentTreeWorkItems.mjs';
+import { parseWorkItems } from './workGraphRuntime.mjs';
+import { evaluateWorkItemBvcQuality } from './workItemBvcQuality.mjs';
+import { evaluateWorkItemProseLint } from './workItemProseLint.mjs';
+
+export const ALLOWED_MIGRATION_STRATEGIES = new Set(['port', 'rebuild', 'replace', 'defer']);
+
+const ALLOWED_STATUSES = new Set(['backlog', 'ready', 'claimed', 'doing', 'in_progress', 'verify', 'done', 'verified', 'blocked']);
+const DONE_STATUSES = new Set(['done', 'verified']);
+const ACTIVE_STATUSES = new Set(['backlog', 'ready', 'claimed', 'doing', 'in_progress', 'verify']);
+
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+/**
+ * @param {Array<{ id: string, status: string, dependsOn?: string[], evidence?: string[], nextAction?: string, basis?: string, vector?: string, goal?: string }>} items
+ * @param {{ strictBvc?: boolean }} [options]
+ */
+export function lintBacklogItems(items, options = {}) {
+  if (!Array.isArray(items)) {
+    throw new TypeError('items must be an array');
+  }
+
+  const issues = [];
+  const seenIds = new Map();
+  const itemById = new Map(items.map((item) => [item.id, item]));
+
+  for (const item of items) {
+    if (typeof item.id !== 'string' || item.id.trim() === '') {
+      issues.push({
+        severity: 'error',
+        code: 'missing_work_id',
+        message: 'WorkItem missing work.id',
+        workId: item.id ?? '',
+      });
+      continue;
+    }
+
+    const count = (seenIds.get(item.id) ?? 0) + 1;
+    seenIds.set(item.id, count);
+    if (count > 1) {
+      issues.push({
+        severity: 'error',
+        code: 'duplicate_work_id',
+        message: `Duplicate work.id: ${item.id}`,
+        workId: item.id,
+      });
+    }
+
+    if (!ALLOWED_STATUSES.has(item.status)) {
+      issues.push({
+        severity: 'error',
+        code: 'invalid_status',
+        message: `Invalid work.status "${item.status}" for ${item.id}`,
+        workId: item.id,
+        status: item.status,
+      });
+    }
+
+    for (const dependencyId of item.dependsOn ?? []) {
+      if (dependencyId === item.id) {
+        issues.push({
+          severity: 'error',
+          code: 'self_dependency',
+          message: `WorkItem depends on itself: ${item.id}`,
+          workId: item.id,
+          dependencyId,
+        });
+      } else if (!itemById.has(dependencyId)) {
+        issues.push({
+          severity: 'error',
+          code: 'missing_dependency',
+          message: `Missing dependency "${dependencyId}" for ${item.id}`,
+          workId: item.id,
+          dependencyId,
+        });
+      }
+    }
+
+    if (ACTIVE_STATUSES.has(item.status) && String(item.nextAction ?? '').trim() === '') {
+      issues.push({
+        severity: 'warning',
+        code: 'missing_next_action',
+        message: `Active WorkItem ${item.id} has empty work.next_action`,
+        workId: item.id,
+        status: item.status,
+      });
+    }
+
+    if (DONE_STATUSES.has(item.status) && !(item.evidence?.length > 0)) {
+      issues.push({
+        severity: 'warning',
+        code: 'done_without_evidence',
+        message: `Done WorkItem ${item.id} has no Свидетельства section lines`,
+        workId: item.id,
+        status: item.status,
+      });
+    }
+
+    const migrationStrategy = String(item.labels?.['migration.strategy'] ?? '').trim();
+    if (migrationStrategy === '') {
+      issues.push({
+        severity: 'error',
+        code: 'missing_migration_strategy',
+        message: `WorkItem ${item.id} missing migration.strategy (allowed: port, rebuild, replace, defer)`,
+        workId: item.id,
+      });
+    } else if (!ALLOWED_MIGRATION_STRATEGIES.has(migrationStrategy)) {
+      issues.push({
+        severity: 'error',
+        code: 'invalid_migration_strategy',
+        message: `WorkItem ${item.id} has invalid migration.strategy "${migrationStrategy}"`,
+        workId: item.id,
+        migrationStrategy,
+      });
+    }
+
+    for (const bvcIssue of evaluateWorkItemBvcQuality(item)) {
+      issues.push({
+        ...bvcIssue,
+        severity: options.strictBvc ? 'error' : bvcIssue.severity,
+      });
+    }
+
+    for (const proseIssue of evaluateWorkItemProseLint(item)) {
+      issues.push(proseIssue);
+    }
+  }
+
+  for (const hierarchyIssue of lintWorkItemHierarchyIssues(items)) {
+    issues.push(hierarchyIssue);
+  }
+
+  for (const pipelineIssue of lintPipelineStageIssues(items)) {
+    issues.push(pipelineIssue);
+  }
+
+  const errors = issues.filter((issue) => issue.severity === 'error');
+  const warnings = issues.filter((issue) => issue.severity === 'warning');
+
+  return {
+    schema: 'workgraph.backlog.lint.v1',
+    ok: errors.length === 0,
+    itemCount: items.length,
+    errorCount: errors.length,
+    warningCount: warnings.length,
+    issues: [...errors, ...warnings].sort((left, right) => compareText(left.workId, right.workId) || compareText(left.code, right.code)),
+  };
+}
+
+export function formatBacklogLintReport(report) {
+  const lines = [
+    `backlog lint: ${report.ok ? 'ok' : 'failed'} (${report.errorCount} errors, ${report.warningCount} warnings, ${report.itemCount} items)`,
+  ];
+
+  for (const issue of report.issues) {
+    lines.push(`${issue.severity}: [${issue.code}] ${issue.message}`);
+  }
+
+  return lines.join('\n');
+}
+
+export async function lintBacklogFile(options = {}) {
+  const items = await readWorkItemsFromRepo({
+    cwd: resolve(options.cwd ?? process.cwd()),
+    backlogPath: options.backlogPath,
+    backlogText: options.backlogText,
+    intentIndexPath: options.intentIndexPath,
+  });
+  return lintBacklogItems(items, {
+    strictBvc: options.strictBvc === true,
+  });
+}