@besales/ops-framework 0.1.9 → 0.1.11

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.11
+
+- Improved initiative requirements extraction with continuation-block capture for lists, tables and fenced blocks.
+- Added requirement quality metadata and planning quality warnings for fragments and heading-only candidates.
+- Added source coverage warnings plus deterministic open-question and assumption extraction during initiative intake.
+
+## 0.1.10
+
+- Fixed `project.ops.yaml` parsing for comment-only lines, including generated header comments and placeholder root comments.
+
 ## 0.1.9
 
 - Added `--phase` and `--include` filters to initiative intake/requirements flows.

package/bin/initiative.mjs

@@ -239,25 +239,34 @@ export function initiativeIntake({
   const intakeDir = path.join(initiative.initiativeDir, 'intake');
   const changes = [];
   ensureDirectory(intakeDir, changes);
+  const allSources = collectSourceDocuments({ projectRoot, docsDir: absoluteDocsDir });
   const sources = collectSourceDocuments({ projectRoot, docsDir: absoluteDocsDir, include });
+  const sourceCoverage = buildSourceCoverage({ allSources, sources, include });
   const candidates = collectRequirementCandidates({ projectRoot, sources, phase });
+  const questions = collectOpenQuestions({ projectRoot, sources });
+  const assumptions = collectAssumptions({ projectRoot, sources });
   writeFileIfAllowed(path.join(intakeDir, 'source-index.json'), JSON.stringify({
     schemaVersion: 1,
     generatedAt: new Date().toISOString(),
     docsDir: path.relative(projectRoot, absoluteDocsDir),
     phaseFilter: phase,
     include,
+    sourceCoverage,
     sources,
   }, null, 2), { force: true, changes });
   writeFileIfAllowed(path.join(intakeDir, 'sources.md'), renderSourcesMarkdown({ docsDir: absoluteDocsDir, projectRoot, sources }), { force, changes });
+  writeFileIfAllowed(path.join(intakeDir, 'source-coverage.md'), renderSourceCoverage(sourceCoverage), { force: true, changes });
   writeFileIfAllowed(path.join(intakeDir, 'extracted-requirements.md'), renderRequirementCandidatesMarkdown(candidates), { force: true, changes });
-  writeFileIfAllowed(path.join(intakeDir, 'open-questions.md'), buildOpenQuestionsMarkdown(), { force, changes });
-  writeFileIfAllowed(path.join(intakeDir, 'assumptions.md'), buildAssumptionsMarkdown(), { force, changes });
+  writeFileIfAllowed(path.join(intakeDir, 'open-questions.md'), buildOpenQuestionsMarkdown(questions), { force: true, changes });
+  writeFileIfAllowed(path.join(intakeDir, 'assumptions.md'), buildAssumptionsMarkdown(assumptions), { force: true, changes });
   return {
     initiativeId,
     intakeDir,
     sources,
+    sourceCoverage,
     candidates,
+    questions,
+    assumptions,
     changes,
   };
 }
@@ -282,6 +291,8 @@ export function initiativeRequirements({
     source: candidate.source,
     sourceHash: candidate.sourceHash,
     phase: candidate.phase || 'unknown',
+    quality: candidate.quality || 'unknown',
+    qualityIssue: candidate.qualityIssue || '',
     text: candidate.text,
     workPackage: '',
     acceptance: '',
@@ -363,22 +374,30 @@ function collectRequirementCandidates({ projectRoot, sources, phase = null }) {
     const sourcePath = path.join(projectRoot, source.path);
     const lines = fs.readFileSync(sourcePath, 'utf8').split(/\r?\n/);
     let headingContext = '';
-    lines.forEach((line, index) => {
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index];
       const heading = /^#{1,6}\s+(.+)$/.exec(line);
       if (heading) {
         headingContext = heading[1].trim();
       }
       const normalized = normalizeRequirementCandidate(line);
       if (!isRequirementCandidate(normalized)) {
-        return;
+        continue;
       }
       const candidatePhase = inferPhase(`${source.path} ${headingContext} ${normalized}`);
       if (phase && candidatePhase !== phase) {
-        return;
+        continue;
       }
-      const key = sha256(`${source.path}:${normalized}`).slice(0, 16);
+      const block = collectRequirementBlock({ lines, index, baseText: normalized });
+      const quality = classifyRequirementQuality({
+        rawLine: line,
+        baseText: normalized,
+        text: block.text,
+        continuation: block.continuation,
+      });
+      const key = sha256(`${source.path}:${block.text}`).slice(0, 16);
       if (seen.has(key)) {
-        return;
+        continue;
       }
       seen.add(key);
       candidates.push({
@@ -386,9 +405,11 @@ function collectRequirementCandidates({ projectRoot, sources, phase = null }) {
         source: `${source.path}:${index + 1}`,
         sourceHash: source.sha256,
         phase: candidatePhase,
-        text: normalized,
+        quality: quality.kind,
+        qualityIssue: quality.issue,
+        text: block.text,
       });
-    });
+    }
   }
   return candidates;
 }
@@ -401,6 +422,63 @@ function sourceIncluded({ projectRoot, filePath, include }) {
   return include.some((pattern) => relative === pattern || relative.endsWith(pattern) || relative.includes(pattern));
 }
 
+function buildSourceCoverage({ allSources, sources, include }) {
+  const included = new Set(sources.map((source) => source.path));
+  const excluded = allSources.filter((source) => !included.has(source.path));
+  const relevantExcluded = excluded.filter((source) => isLikelyRelevantSource(source.path));
+  return {
+    include,
+    totalSources: allSources.length,
+    includedSources: sources.length,
+    excludedSources: excluded.length,
+    relevantExcludedSources: relevantExcluded.map((source) => ({
+      path: source.path,
+      title: source.title,
+      reason: relevantSourceReason(source.path),
+    })),
+  };
+}
+
+function isLikelyRelevantSource(sourcePath) {
+  return /(skills?|profiles?|adr|governance|risk|feedback|glossary|stack|tools?|contract|workspace)/i.test(sourcePath);
+}
+
+function relevantSourceReason(sourcePath) {
+  if (/feedback/i.test(sourcePath)) {
+    return 'feedback/decision log may contain newer product or scope decisions.';
+  }
+  if (/skills?/i.test(sourcePath)) {
+    return 'skills catalog may contain implementation requirements for MVP skills.';
+  }
+  if (/profiles?/i.test(sourcePath)) {
+    return 'extraction profiles may contain acceptance and workflow requirements.';
+  }
+  if (/adr/i.test(sourcePath)) {
+    return 'ADRs may contain architecture constraints.';
+  }
+  if (/governance|risk/i.test(sourcePath)) {
+    return 'governance/risk docs may affect approval, trust, security or rollout gates.';
+  }
+  return 'source may contain constraints relevant to requirements review.';
+}
+
+function renderSourceCoverage(sourceCoverage) {
+  return [
+    '# Source Coverage',
+    '',
+    `- Total supported sources: ${sourceCoverage.totalSources}`,
+    `- Included sources: ${sourceCoverage.includedSources}`,
+    `- Excluded sources: ${sourceCoverage.excludedSources}`,
+    `- Relevant excluded sources: ${sourceCoverage.relevantExcludedSources.length}`,
+    '',
+    '## Relevant Sources Not Included',
+    '',
+    ...sourceCoverage.relevantExcludedSources.map((source) => `- \`${source.path}\`: ${source.reason}`),
+    ...(sourceCoverage.relevantExcludedSources.length ? [] : ['- None.']),
+    '',
+  ].join('\n');
+}
+
 function normalizeRequirementCandidate(line) {
   return line
     .replace(/^#{1,6}\s+/, '')
@@ -410,11 +488,102 @@ function normalizeRequirementCandidate(line) {
     .trim();
 }
 
+function collectRequirementBlock({ lines, index, baseText }) {
+  const continuation = [];
+  const shouldExpand = /[:：]$/.test(baseText) || isMarkdownTableRow(lines[index]);
+  if (!shouldExpand) {
+    return {
+      text: baseText,
+      continuation,
+    };
+  }
+  let inCodeBlock = false;
+  for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+    const line = lines[cursor];
+    if (/^#{1,6}\s+/.test(line)) {
+      break;
+    }
+    if (/^\s*```/.test(line)) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (!line.trim()) {
+      if (continuation.length || inCodeBlock) {
+        break;
+      }
+      continue;
+    }
+    if (inCodeBlock) {
+      continuation.push(normalizeContinuationLine(line));
+      continue;
+    }
+    if (isContinuationLine(line)) {
+      continuation.push(normalizeContinuationLine(line));
+      continue;
+    }
+    break;
+  }
+  return {
+    text: [baseText, ...continuation].filter(Boolean).join(' '),
+    continuation,
+  };
+}
+
+function isContinuationLine(line) {
+  return /^\s*[-*]\s+/.test(line)
+    || /^\s*\d+[.)]\s+/.test(line)
+    || isMarkdownTableRow(line)
+    || /^\s{2,}\S/.test(line);
+}
+
+function normalizeContinuationLine(line) {
+  return line
+    .replace(/^\s*[-*]\s+/, '')
+    .replace(/^\s*\d+[.)]\s+/, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function isMarkdownTableRow(line) {
+  return /^\s*\|.+\|\s*$/.test(line);
+}
+
+function classifyRequirementQuality({ rawLine, baseText, text, continuation }) {
+  if (isMarkdownTableRow(rawLine)) {
+    return {
+      kind: 'table_row',
+      issue: 'Candidate came from a markdown table row; verify headers/context before planning.',
+    };
+  }
+  if (/[:：]$/.test(baseText) && continuation.length === 0) {
+    return {
+      kind: 'heading_only',
+      issue: 'Candidate ends with a colon and no continuation block was captured; rewrite before planning.',
+    };
+  }
+  if (continuation.length > 0) {
+    return {
+      kind: 'expanded_block',
+      issue: '',
+    };
+  }
+  if (/[,;]$/.test(text) || /\b(and|or|и|или)$/i.test(text)) {
+    return {
+      kind: 'fragment',
+      issue: 'Candidate appears to end mid-list or mid-sentence; rewrite before planning.',
+    };
+  }
+  return {
+    kind: 'complete',
+    issue: '',
+  };
+}
+
 function isRequirementCandidate(text) {
   if (text.length < 20 || text.length > 500) {
     return false;
   }
-  return /(must|should|required|requirement|user can|user must|system must|needs to|нужно|должен|должна|должны|требован|пользователь может|пользователь должен|система должна|необходимо|важно)/i.test(text);
+  return /(must|should|required|requirement|includes?|does not include|user can|user must|system must|needs to|нужно|должен|должна|должны|требован|включает|не включает|пользователь может|пользователь должен|система должна|необходимо|важно)/i.test(text);
 }
 
 function renderSourcesMarkdown({ docsDir, projectRoot, sources }) {
@@ -442,6 +611,8 @@ function renderRequirementCandidatesMarkdown(candidates) {
       `- Source: \`${candidate.source}\``,
       `- Source hash: \`${candidate.sourceHash}\``,
       `- Phase: \`${candidate.phase || 'unknown'}\``,
+      `- Quality: \`${candidate.quality || 'unknown'}\``,
+      `- Quality issue: ${candidate.qualityIssue || '(none)'}`,
       `- Candidate: ${candidate.text}`,
       '',
     ].join('\n')),
@@ -457,6 +628,8 @@ function parseRequirementCandidates(content) {
       source: readMarkdownListField(body, 'Source'),
       sourceHash: readMarkdownListField(body, 'Source hash'),
       phase: readMarkdownListField(body, 'Phase') || 'unknown',
+      quality: readMarkdownListField(body, 'Quality') || 'unknown',
+      qualityIssue: readMarkdownListField(body, 'Quality issue').replace(/^\(none\)$/, ''),
       text: readMarkdownListField(body, 'Candidate'),
     };
   }).filter((candidate) => candidate.id && candidate.source && candidate.text);
@@ -468,9 +641,9 @@ function renderRequirementsMap(requirements) {
     '',
     'Statuses: `candidate | approved | planned | implemented | rejected`.',
     '',
-    '| ID | Status | Phase | Requirement | Source | Work package | Acceptance |',
-    '| --- | --- | --- | --- | --- | --- | --- |',
-    ...requirements.map((req) => `| ${req.id} | ${req.status} | ${req.phase || 'unknown'} | ${escapeTable(req.title)} | \`${req.source}\` | ${req.workPackage || ''} | ${req.acceptance || ''} |`),
+    '| ID | Status | Phase | Quality | Requirement | Source | Work package | Acceptance |',
+    '| --- | --- | --- | --- | --- | --- | --- | --- |',
+    ...requirements.map((req) => `| ${req.id} | ${req.status} | ${req.phase || 'unknown'} | ${req.quality || 'unknown'} | ${escapeTable(req.title)} | \`${req.source}\` | ${req.workPackage || ''} | ${req.acceptance || ''} |`),
     '',
     '## Requirement Details',
     '',
@@ -481,6 +654,8 @@ function renderRequirementsMap(requirements) {
       `- Source: \`${req.source}\``,
       `- Source hash: \`${req.sourceHash}\``,
       `- Phase: \`${req.phase || 'unknown'}\``,
+      `- Quality: \`${req.quality || 'unknown'}\``,
+      `- Quality issue: ${req.qualityIssue || '(none)'}`,
       `- Work package: ${req.workPackage || '(unassigned)'}`,
       `- Acceptance: ${req.acceptance || '(fill before implementation)'}`,
       `- Decision: \`${req.decision || 'pending'}\``,
@@ -507,6 +682,8 @@ function renderRequirementsReview(requirements) {
       `- Source: \`${req.source}\``,
       `- Source hash: \`${req.sourceHash}\``,
       `- Phase: \`${req.phase || 'unknown'}\``,
+      `- Quality: \`${req.quality || 'unknown'}\``,
+      `- Quality issue: ${req.qualityIssue || '(none)'}`,
       `- Suggested status: \`${req.status}\``,
       `- Requirement: ${req.text}`,
       `- Proposed work package: ${req.workPackage || '(unassigned)'}`,
@@ -522,6 +699,8 @@ function renderRequirementsReview(requirements) {
 
 function renderCoverage({ requirements }) {
   const counts = countBy(requirements, (req) => req.status || 'candidate');
+  const qualityCounts = countBy(requirements, (req) => req.quality || 'unknown');
+  const blockingQuality = requirements.filter((req) => ['fragment', 'heading_only'].includes(req.quality));
   return [
     '# Initiative Coverage',
     '',
@@ -531,6 +710,17 @@ function renderCoverage({ requirements }) {
     `- Planned: ${counts.planned || 0}`,
     `- Implemented: ${counts.implemented || 0}`,
     `- Rejected: ${counts.rejected || 0}`,
+    `- Quality complete: ${qualityCounts.complete || 0}`,
+    `- Quality expanded block: ${qualityCounts.expanded_block || 0}`,
+    `- Quality table row: ${qualityCounts.table_row || 0}`,
+    `- Quality fragment: ${qualityCounts.fragment || 0}`,
+    `- Quality heading only: ${qualityCounts.heading_only || 0}`,
+    `- Planning blocked by quality: ${blockingQuality.length ? 'yes' : 'no'}`,
+    '',
+    '## Quality Warnings',
+    '',
+    ...blockingQuality.map((req) => `- ${req.id}: ${req.qualityIssue || 'Rewrite before planning.'}`),
+    ...(blockingQuality.length ? [] : ['- None.']),
     '',
     '## Unassigned Requirements',
     '',
@@ -573,20 +763,65 @@ function normalizePhaseLabel(text) {
   return null;
 }
 
-function buildOpenQuestionsMarkdown() {
+function collectOpenQuestions({ projectRoot, sources }) {
+  return collectSourceLines({
+    projectRoot,
+    sources,
+    pattern: /(open question|question|tbd|to decide|needs decision|под вопросом|открыт(ый|ые)? вопрос|нужно решить|решить позже)/i,
+  });
+}
+
+function collectAssumptions({ projectRoot, sources }) {
+  return collectSourceLines({
+    projectRoot,
+    sources,
+    pattern: /(assumption|default hypothesis|decision|decided|решено|предположение|гипотеза|не включает|не делаем|deferred|отложен|scope)/i,
+  });
+}
+
+function collectSourceLines({ projectRoot, sources, pattern }) {
+  const results = [];
+  const seen = new Set();
+  for (const source of sources) {
+    const sourcePath = path.join(projectRoot, source.path);
+    const lines = fs.readFileSync(sourcePath, 'utf8').split(/\r?\n/);
+    lines.forEach((line, index) => {
+      const normalized = normalizeRequirementCandidate(line);
+      if (normalized.length < 12 || !pattern.test(normalized)) {
+        return;
+      }
+      const key = sha256(`${source.path}:${normalized}`).slice(0, 16);
+      if (seen.has(key)) {
+        return;
+      }
+      seen.add(key);
+      results.push({
+        source: `${source.path}:${index + 1}`,
+        text: normalized,
+      });
+    });
+  }
+  return results;
+}
+
+function buildOpenQuestionsMarkdown(questions = []) {
   return [
     '# Open Questions',
     '',
-    '- Add human decisions discovered during initiative intake.',
+    ...(questions.length
+      ? questions.map((question) => `- \`${question.source}\`: ${question.text}`)
+      : ['- No deterministic open questions found. Add human decisions discovered during initiative intake.']),
     '',
   ].join('\n');
 }
 
-function buildAssumptionsMarkdown() {
+function buildAssumptionsMarkdown(assumptions = []) {
   return [
     '# Assumptions',
     '',
-    '- Add assumptions that were required to interpret source docs.',
+    ...(assumptions.length
+      ? assumptions.map((assumption) => `- \`${assumption.source}\`: ${assumption.text}`)
+      : ['- No deterministic assumptions found. Add assumptions required to interpret source docs.']),
     '',
   ].join('\n');
 }

package/bin/initiative.test.mjs

@@ -158,6 +158,100 @@ describe('initiative framework', () => {
     expect(requirements.requirements).toHaveLength(1);
     expect(requirements.requirements[0].text).toContain('meeting transcripts');
   });
+
+  it('captures continuation blocks and flags requirement quality', () => {
+    const root = makeProject();
+    const docsDir = path.join(root, 'docs', 'delivery-os');
+    fs.mkdirSync(docsDir, { recursive: true });
+    fs.writeFileSync(path.join(docsDir, 'phase1.md'), [
+      '# Phase 1',
+      '',
+      'В Phase 1 НЕ нужно создавать все таблицы. Минимум:',
+      '',
+      '```',
+      'team_members',
+      'clients',
+      'evidence',
+      '```',
+      '',
+      'Phase 1 намеренно не включает contribution loop, skill router,',
+    ].join('\n'));
+    createInitiative({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      title: 'Delivery OS MVP',
+    });
+
+    const intake = initiativeIntake({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      docsDir: 'docs/delivery-os',
+      phase: 'phase-1',
+    });
+    const requirements = initiativeRequirements({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      phase: 'phase-1',
+    });
+
+    expect(intake.candidates[0]).toMatchObject({
+      quality: 'expanded_block',
+    });
+    expect(intake.candidates[0].text).toContain('team_members');
+    expect(requirements.requirements[0].quality).toBe('expanded_block');
+    expect(requirements.requirements[1].quality).toBe('fragment');
+    const initiativeDir = path.join(root, 'ops', 'agent-pipeline', 'initiatives', 'delivery-os-mvp');
+    const coverage = fs.readFileSync(path.join(initiativeDir, 'coverage.md'), 'utf8');
+    const review = fs.readFileSync(path.join(initiativeDir, 'requirements-review.md'), 'utf8');
+    expect(coverage).toContain('- Planning blocked by quality: yes');
+    expect(review).toContain('- Quality: `fragment`');
+  });
+
+  it('writes source coverage warnings plus open questions and assumptions', () => {
+    const root = makeProject();
+    const docsDir = path.join(root, 'docs', 'delivery-os');
+    fs.mkdirSync(docsDir, { recursive: true });
+    fs.writeFileSync(path.join(docsDir, '06-roadmap.md'), [
+      '# Phase 1',
+      '',
+      '- System must import meeting transcripts.',
+      '- Admin UI provider is TBD and needs decision.',
+      '- Phase 1 не включает Telegram capture.',
+    ].join('\n'));
+    fs.writeFileSync(path.join(docsDir, '05-skills-catalog.md'), [
+      '# Skills Catalog',
+      '',
+      '- System must define /process-meeting.',
+    ].join('\n'));
+    fs.writeFileSync(path.join(docsDir, '99-feedback-log.md'), [
+      '# Feedback Log',
+      '',
+      '- Decision: backfill heavy extraction is deferred.',
+    ].join('\n'));
+    createInitiative({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      title: 'Delivery OS MVP',
+    });
+
+    const intake = initiativeIntake({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      docsDir: 'docs/delivery-os',
+      phase: 'phase-1',
+      include: ['06-roadmap.md'],
+    });
+
+    const initiativeDir = path.join(root, 'ops', 'agent-pipeline', 'initiatives', 'delivery-os-mvp');
+    const sourceCoverage = fs.readFileSync(path.join(initiativeDir, 'intake', 'source-coverage.md'), 'utf8');
+    const questions = fs.readFileSync(path.join(initiativeDir, 'intake', 'open-questions.md'), 'utf8');
+    const assumptions = fs.readFileSync(path.join(initiativeDir, 'intake', 'assumptions.md'), 'utf8');
+    expect(intake.sourceCoverage.relevantExcludedSources.map((source) => source.path)).toContain('docs/delivery-os/05-skills-catalog.md');
+    expect(intake.sourceCoverage.relevantExcludedSources.map((source) => source.path)).toContain('docs/delivery-os/99-feedback-log.md');
+    expect(sourceCoverage).toContain('Relevant Sources Not Included');
+    expect(questions).toContain('Admin UI provider is TBD');
+    expect(assumptions).toContain('Phase 1 не включает Telegram capture.');
+  });
 });
 
 function makeProject() {

package/bin/lib/project-config.mjs

@@ -56,6 +56,9 @@ export function parseProjectOpsConfig(content) {
   const config = {};
   const stack = [{ indent: -1, value: config, parent: null, key: null }];
   for (const rawLine of content.split(/\r?\n/)) {
+    if (/^\s*#/.test(rawLine)) {
+      continue;
+    }
     const withoutComment = rawLine.replace(/\s+#.*$/, '');
     if (!withoutComment.trim()) {
       continue;

package/bin/lib/project-config.test.mjs

@@ -33,6 +33,36 @@ risk:
     expect(config.risk.backendRoots).toEqual(['services/api']);
   });
 
+  it('ignores comment-only and inline comments in project.ops.yaml', () => {
+    const config = parseProjectOpsConfig(`
+# Internal development tooling only. This agent pipeline helps plan/check repo work.
+name: ExampleProject # inline project name note
+ops:
+  legacyPipelineDir: ops/agent-pipeline
+  tasksDir: ops/agent-pipeline/tasks
+  initiativesDir: ops/agent-pipeline/initiatives
+  memoryDir: ops/agent-pipeline/memory
+  cacheDir: ops/agent-pipeline/cache
+  playbooksDir: ops/agent-pipeline/playbooks
+agents:
+  configFile: ops/agent-pipeline/config/agents.json
+risk:
+  uiRoots:
+    # - apps/web
+    - web/app # real UI root
+  backendRoots:
+    # - apps/api
+  workerRoots:
+    # - apps/workers
+`);
+
+    expect(config.name).toBe('ExampleProject');
+    expect(config.ops.initiativesDir).toBe('ops/agent-pipeline/initiatives');
+    expect(config.risk.uiRoots).toEqual(['web/app']);
+    expect(config.risk.backendRoots).toEqual({});
+    expect(config.risk.workerRoots).toEqual({});
+  });
+
   it('finds project config by walking upward from cwd', () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ops-project-'));
     const nested = path.join(root, 'apps', 'tool');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@besales/ops-framework",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "bin": {
     "ops-agent": "bin/ops-agent.mjs"