@besales/ops-framework 0.1.11 → 0.1.13

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.1.13
+
+- Fixed `ops-agent --version` to read the installed package version instead of printing a stale hardcoded value.
+
+## 0.1.12
+
+- Auto-included detected relevant initiative sources when an intake run uses `--include`, unless `--no-include-relevant` is passed.
+- Tightened initiative requirement quality checks for dangling fragments, table rows, run-on blocks and duplicate candidates.
+- Added `initiative-requirements-synthesis` to produce the human/LLM synthesis pack before requirements are approved or planned.
+- Renamed deterministic assumptions/open-question outputs to candidate packs and filtered schema/code noise.
+
 ## 0.1.11
 
 - Improved initiative requirements extraction with continuation-block capture for lists, tables and fenced blocks.

package/README.md

@@ -234,6 +234,7 @@ ops-agent initiative-create delivery-os-mvp --title "Delivery OS MVP" --mode fas
 ops-agent initiative-add-work-package delivery-os-mvp WP-001-foundation --title "Foundation"
 ops-agent initiative-intake delivery-os-mvp docs/delivery-os --phase phase-1 --include "06-roadmap.md,04-data-model.md,11-tooling-and-data-flows.md"
 ops-agent initiative-requirements delivery-os-mvp --phase phase-1
+ops-agent initiative-requirements-synthesis delivery-os-mvp
 ops-agent initiative-status delivery-os-mvp
 ops-agent initiative-next delivery-os-mvp --materialize-task
 ```
@@ -258,10 +259,12 @@ Raw docs
  -> tasks
 ```
 
-`initiative-intake <initiative> <docs-dir>` indexes supported source documents, writes source SHA hashes and deterministic requirement candidates into `intake/`. Use `--include "file-a.md,file-b.md"` to restrict the first pass to the most relevant source files, and `--phase phase-1` to keep candidates whose local heading/source context matches the target phase.
+`initiative-intake <initiative> <docs-dir>` indexes supported source documents, writes source SHA hashes and deterministic requirement candidates into `intake/`. Use `--include "file-a.md,file-b.md"` to restrict the first pass to the most relevant source files, and `--phase phase-1` to keep candidates whose local heading/source context matches the target phase. When `--include` is used, detected relevant docs such as feedback, skills, profiles, ADRs and risk/governance docs are auto-included by default; pass `--no-include-relevant` only when intentionally running a narrow diagnostic pass.
 
 `initiative-requirements <initiative>` turns those candidates into `REQ-*` rows in `requirements-map.md`, writes `requirements-review.md` approval cards and writes `coverage.md`. Human review is still required before treating candidates as approved or planned.
 
+`initiative-requirements-synthesis <initiative>` writes `requirements-synthesis.md`: the human/LLM synthesis pack for converting raw candidates into clean requirements with acceptance criteria. It highlights source coverage gaps, fragments, table rows, run-on blocks and candidate assumptions/questions that must be rewritten before planning.
+
 ## Feedback Intake
 
 Feedback is stage-agnostic. Any user question, correction, review note or learning observation during an active task should be captured before it is acted on:

package/bin/initiative.mjs

@@ -72,6 +72,7 @@ export function main() {
         docsDir: args.positional[1],
         phase: normalizePhaseFilter(getFlag(args, 'phase', null)),
         include: parseIncludeFilter(getFlag(args, 'include', null)),
+        includeRelevant: !args.flags.has('no-include-relevant'),
         force: args.flags.has('force'),
       });
       printChangeSummary(`Initiative intake written: ${result.initiativeId}`, result.changes);
@@ -90,7 +91,18 @@ export function main() {
       console.log(`- requirements: ${result.requirements.length}`);
       return;
     }
-    fail('Usage: ops-agent initiative-create|initiative-add-work-package|initiative-status|initiative-next|initiative-intake|initiative-requirements ...');
+    if (command === 'initiative-requirements-synthesis') {
+      const result = initiativeRequirementsSynthesis({
+        projectRoot: process.cwd(),
+        initiativeId: args.positional[0],
+        force: args.flags.has('force'),
+      });
+      printChangeSummary(`Initiative requirements synthesis pack written: ${result.initiativeId}`, result.changes);
+      console.log(`- rewrite required: ${result.rewriteRequired}`);
+      console.log(`- requirement candidates: ${result.requirements.length}`);
+      return;
+    }
+    fail('Usage: ops-agent initiative-create|initiative-add-work-package|initiative-status|initiative-next|initiative-intake|initiative-requirements|initiative-requirements-synthesis ...');
   } catch (error) {
     fail(error.message);
   }
@@ -226,6 +238,7 @@ export function initiativeIntake({
   docsDir,
   phase = null,
   include = [],
+  includeRelevant = true,
   force = false,
 } = {}) {
   const initiative = readInitiative({ projectRoot, initiativeId });
@@ -240,8 +253,22 @@ export function initiativeIntake({
   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 initialSources = collectSourceDocuments({ projectRoot, docsDir: absoluteDocsDir, include });
+  const initialCoverage = buildSourceCoverage({ allSources, sources: initialSources, include });
+  const resolvedInclude = includeRelevant && include.length
+    ? uniqueStrings([
+      ...include,
+      ...initialCoverage.relevantExcludedSources.map((source) => source.path),
+    ])
+    : include;
+  const sources = collectSourceDocuments({ projectRoot, docsDir: absoluteDocsDir, include: resolvedInclude });
+  const sourceCoverage = buildSourceCoverage({
+    allSources,
+    sources,
+    include: resolvedInclude,
+    requestedInclude: include,
+    autoIncludedRelevantSources: resolvedInclude.filter((item) => !include.includes(item)),
+  });
   const candidates = collectRequirementCandidates({ projectRoot, sources, phase });
   const questions = collectOpenQuestions({ projectRoot, sources });
   const assumptions = collectAssumptions({ projectRoot, sources });
@@ -250,7 +277,9 @@ export function initiativeIntake({
     generatedAt: new Date().toISOString(),
     docsDir: path.relative(projectRoot, absoluteDocsDir),
     phaseFilter: phase,
-    include,
+    include: resolvedInclude,
+    requestedInclude: include,
+    includeRelevant,
     sourceCoverage,
     sources,
   }, null, 2), { force: true, changes });
@@ -284,7 +313,8 @@ export function initiativeRequirements({
   }
   const candidates = parseRequirementCandidates(fs.readFileSync(candidatesPath, 'utf8'))
     .filter((candidate) => !phase || candidate.phase === phase);
-  const requirements = candidates.map((candidate, index) => ({
+  const dedupedCandidates = dedupeRequirementCandidates(candidates);
+  const requirements = dedupedCandidates.map((candidate, index) => ({
     id: `REQ-${String(index + 1).padStart(3, '0')}`,
     status: 'candidate',
     title: summarizeRequirementTitle(candidate.text),
@@ -310,6 +340,44 @@ export function initiativeRequirements({
   };
 }
 
+export function initiativeRequirementsSynthesis({
+  projectRoot = process.cwd(),
+  initiativeId,
+  force = false,
+} = {}) {
+  const initiative = readInitiative({ projectRoot, initiativeId });
+  const requirementsPath = path.join(initiative.initiativeDir, 'requirements-map.md');
+  const sourceIndexPath = path.join(initiative.initiativeDir, 'intake', 'source-index.json');
+  if (!fs.existsSync(requirementsPath)) {
+    throw new Error('Missing requirements-map.md. Run initiative-requirements first.');
+  }
+  if (!fs.existsSync(sourceIndexPath)) {
+    throw new Error('Missing intake/source-index.json. Run initiative-intake first.');
+  }
+  const sourceIndex = JSON.parse(fs.readFileSync(sourceIndexPath, 'utf8'));
+  const requirements = parseRequirementsMap(fs.readFileSync(requirementsPath, 'utf8'));
+  const assumptionsPath = path.join(initiative.initiativeDir, 'intake', 'assumptions.md');
+  const questionsPath = path.join(initiative.initiativeDir, 'intake', 'open-questions.md');
+  const assumptions = fs.existsSync(assumptionsPath) ? fs.readFileSync(assumptionsPath, 'utf8') : '';
+  const questions = fs.existsSync(questionsPath) ? fs.readFileSync(questionsPath, 'utf8') : '';
+  const rewriteRequired = requirements.some((req) => requirementNeedsRewrite(req))
+    || Boolean(sourceIndex.sourceCoverage?.relevantExcludedSources?.length);
+  const changes = [];
+  writeFileIfAllowed(path.join(initiative.initiativeDir, 'requirements-synthesis.md'), renderRequirementsSynthesis({
+    sourceCoverage: sourceIndex.sourceCoverage,
+    requirements,
+    assumptions,
+    questions,
+    rewriteRequired,
+  }), { force: true, changes });
+  return {
+    initiativeId,
+    requirements,
+    rewriteRequired,
+    changes,
+  };
+}
+
 function materializeWorkPackageTask({ projectRoot, initiativeId, workPackage, taskId, force }) {
   const task = createTask({
     projectRoot,
@@ -395,7 +463,7 @@ function collectRequirementCandidates({ projectRoot, sources, phase = null }) {
         text: block.text,
         continuation: block.continuation,
       });
-      const key = sha256(`${source.path}:${block.text}`).slice(0, 16);
+      const key = requirementFingerprint(block.text);
       if (seen.has(key)) {
         continue;
       }
@@ -422,12 +490,14 @@ function sourceIncluded({ projectRoot, filePath, include }) {
   return include.some((pattern) => relative === pattern || relative.endsWith(pattern) || relative.includes(pattern));
 }
 
-function buildSourceCoverage({ allSources, sources, include }) {
+function buildSourceCoverage({ allSources, sources, include, requestedInclude = include, autoIncludedRelevantSources = [] }) {
   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,
+    requestedInclude,
+    autoIncludedRelevantSources,
     totalSources: allSources.length,
     includedSources: sources.length,
     excludedSources: excluded.length,
@@ -470,6 +540,13 @@ function renderSourceCoverage(sourceCoverage) {
     `- Included sources: ${sourceCoverage.includedSources}`,
     `- Excluded sources: ${sourceCoverage.excludedSources}`,
     `- Relevant excluded sources: ${sourceCoverage.relevantExcludedSources.length}`,
+    `- Auto-included relevant sources: ${sourceCoverage.autoIncludedRelevantSources?.length || 0}`,
+    '',
+    '## Auto-Included Relevant Sources',
+    '',
+    ...(sourceCoverage.autoIncludedRelevantSources?.length
+      ? sourceCoverage.autoIncludedRelevantSources.map((sourcePath) => `- \`${sourcePath}\``)
+      : ['- None.']),
     '',
     '## Relevant Sources Not Included',
     '',
@@ -490,7 +567,7 @@ function normalizeRequirementCandidate(line) {
 
 function collectRequirementBlock({ lines, index, baseText }) {
   const continuation = [];
-  const shouldExpand = /[:：]$/.test(baseText) || isMarkdownTableRow(lines[index]);
+  const shouldExpand = /[:：]$/.test(baseText) && !isMarkdownTableRow(lines[index]);
   if (!shouldExpand) {
     return {
       text: baseText,
@@ -498,6 +575,7 @@ function collectRequirementBlock({ lines, index, baseText }) {
     };
   }
   let inCodeBlock = false;
+  const maxContinuationLines = 12;
   for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
     const line = lines[cursor];
     if (/^#{1,6}\s+/.test(line)) {
@@ -519,6 +597,9 @@ function collectRequirementBlock({ lines, index, baseText }) {
     }
     if (isContinuationLine(line)) {
       continuation.push(normalizeContinuationLine(line));
+      if (continuation.length >= maxContinuationLines) {
+        break;
+      }
       continue;
     }
     break;
@@ -562,12 +643,18 @@ function classifyRequirementQuality({ rawLine, baseText, text, continuation }) {
     };
   }
   if (continuation.length > 0) {
+    if (text.length > 700 || continuation.length >= 12) {
+      return {
+        kind: 'run_on_block',
+        issue: 'Candidate captured a large continuation block; synthesize a clean requirement with explicit acceptance before planning.',
+      };
+    }
     return {
       kind: 'expanded_block',
       issue: '',
     };
   }
-  if (/[,;]$/.test(text) || /\b(and|or|и|или)$/i.test(text)) {
+  if (isDanglingRequirementFragment(text)) {
     return {
       kind: 'fragment',
       issue: 'Candidate appears to end mid-list or mid-sentence; rewrite before planning.',
@@ -579,6 +666,13 @@ function classifyRequirementQuality({ rawLine, baseText, text, continuation }) {
   };
 }
 
+function isDanglingRequirementFragment(text) {
+  return /[,;]$/.test(text)
+    || /\b(and|or|и|или)$/i.test(text)
+    || /(?:^|\s)(?:должна|должен|должны|must|should)\s+(?:включать|include|contain)$/i.test(text)
+    || /(?:^|\s)(?:включает|includes?|contains?)$/i.test(text);
+}
+
 function isRequirementCandidate(text) {
   if (text.length < 20 || text.length > 500) {
     return false;
@@ -700,7 +794,7 @@ 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));
+  const blockingQuality = requirements.filter((req) => requirementNeedsRewrite(req));
   return [
     '# Initiative Coverage',
     '',
@@ -715,6 +809,7 @@ function renderCoverage({ requirements }) {
     `- Quality table row: ${qualityCounts.table_row || 0}`,
     `- Quality fragment: ${qualityCounts.fragment || 0}`,
     `- Quality heading only: ${qualityCounts.heading_only || 0}`,
+    `- Quality run-on block: ${qualityCounts.run_on_block || 0}`,
     `- Planning blocked by quality: ${blockingQuality.length ? 'yes' : 'no'}`,
     '',
     '## Quality Warnings',
@@ -787,10 +882,10 @@ function collectSourceLines({ projectRoot, sources, pattern }) {
     const lines = fs.readFileSync(sourcePath, 'utf8').split(/\r?\n/);
     lines.forEach((line, index) => {
       const normalized = normalizeRequirementCandidate(line);
-      if (normalized.length < 12 || !pattern.test(normalized)) {
+      if (normalized.length < 12 || !pattern.test(normalized) || isNoisySourceLine(normalized)) {
         return;
       }
-      const key = sha256(`${source.path}:${normalized}`).slice(0, 16);
+      const key = sha256(normalizeForDedup(normalized)).slice(0, 16);
       if (seen.has(key)) {
         return;
       }
@@ -804,9 +899,19 @@ function collectSourceLines({ projectRoot, sources, pattern }) {
   return results;
 }
 
+function isNoisySourceLine(text) {
+  return /^(create table|alter table|insert into|select |update |delete from)\b/i.test(text)
+    || /\b(jsonb|varchar|integer|bigint|boolean|timestamp|default\s+['"[]|primary key|foreign key)\b/i.test(text)
+    || /^[a-z_]+\s+(text|jsonb|integer|bigint|boolean|timestamp)\b/i.test(text)
+    || /^[-\w]+\s*:\s*(string|number|boolean|array|object|null)\b/i.test(text)
+    || /--\s*markdown описание/i.test(text);
+}
+
 function buildOpenQuestionsMarkdown(questions = []) {
   return [
-    '# Open Questions',
+    '# Open Question Candidates',
+    '',
+    'Deterministic candidates only. Rewrite into real open questions during requirements synthesis before planning.',
     '',
     ...(questions.length
       ? questions.map((question) => `- \`${question.source}\`: ${question.text}`)
@@ -817,7 +922,9 @@ function buildOpenQuestionsMarkdown(questions = []) {
 
 function buildAssumptionsMarkdown(assumptions = []) {
   return [
-    '# Assumptions',
+    '# Assumption Candidates',
+    '',
+    'Deterministic candidates only. Rewrite into real assumptions during requirements synthesis before planning.',
     '',
     ...(assumptions.length
       ? assumptions.map((assumption) => `- \`${assumption.source}\`: ${assumption.text}`)
@@ -826,6 +933,124 @@ function buildAssumptionsMarkdown(assumptions = []) {
   ].join('\n');
 }
 
+function dedupeRequirementCandidates(candidates) {
+  const seen = new Set();
+  const result = [];
+  for (const candidate of candidates) {
+    const key = requirementFingerprint(candidate.text);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push(candidate);
+  }
+  return result;
+}
+
+function requirementFingerprint(text) {
+  return sha256(normalizeForDedup(text)).slice(0, 16);
+}
+
+function normalizeForDedup(text) {
+  return String(text || '')
+    .toLowerCase()
+    .replace(/`[^`]+`/g, ' ')
+    .replace(/\|/g, ' ')
+    .replace(/https?:\/\/\S+/g, ' ')
+    .replace(/[^\p{L}\p{N}]+/gu, ' ')
+    .replace(/\b(phase|фаза)\s*[- ]?\d+\b/gi, 'phase')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function requirementNeedsRewrite(req) {
+  return ['fragment', 'heading_only', 'table_row', 'run_on_block'].includes(req.quality);
+}
+
+function parseRequirementsMap(content) {
+  return content.split(/^###\s+/m).slice(1).map((section) => {
+    const [rawId, ...bodyLines] = section.split('\n');
+    const body = bodyLines.join('\n');
+    return {
+      id: rawId.trim(),
+      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\)$/, ''),
+      workPackage: readMarkdownListField(body, 'Work package').replace(/^\(unassigned\)$/, ''),
+      acceptance: readMarkdownListField(body, 'Acceptance').replace(/^\(fill before implementation\)$/, ''),
+      decision: readMarkdownListField(body, 'Decision') || 'pending',
+      notes: readMarkdownListField(body, 'Notes').replace(/^\(empty\)$/, ''),
+      text: readMarkdownListField(body, 'Requirement'),
+    };
+  }).filter((req) => req.id && req.source && req.text);
+}
+
+function renderRequirementsSynthesis({ sourceCoverage, requirements, assumptions, questions, rewriteRequired }) {
+  const rewriteCandidates = requirements.filter((req) => requirementNeedsRewrite(req));
+  return [
+    '# Requirements Synthesis Pack',
+    '',
+    `- Rewrite required before planning: ${rewriteRequired ? 'yes' : 'no'}`,
+    `- Requirement candidates: ${requirements.length}`,
+    `- Candidates needing rewrite: ${rewriteCandidates.length}`,
+    `- Relevant sources still missing: ${sourceCoverage?.relevantExcludedSources?.length || 0}`,
+    '',
+    '## Source Coverage Gate',
+    '',
+    ...(sourceCoverage?.relevantExcludedSources?.length
+      ? sourceCoverage.relevantExcludedSources.map((source) => `- Missing \`${source.path}\`: ${source.reason}`)
+      : ['- All detected relevant sources were included.']),
+    '',
+    '## Rewrite Required',
+    '',
+    ...(rewriteCandidates.length
+      ? rewriteCandidates.map((req) => `- ${req.id} (${req.quality}): ${req.qualityIssue || 'Rewrite into a clean requirement with acceptance.'}`)
+      : ['- None.']),
+    '',
+    '## Synthesis Instructions',
+    '',
+    'Create final requirements only after human/LLM synthesis. Each final requirement must have:',
+    '',
+    '- one clear behavior or constraint;',
+    '- source references;',
+    '- acceptance criteria;',
+    '- explicit phase/scope;',
+    '- decision: `approve | defer | reject | rewrite`.',
+    '',
+    'Do not approve raw table rows, fragments, duplicated source snippets or grep-derived assumptions/questions as final requirements.',
+    '',
+    '## Requirement Candidate Cards',
+    '',
+    ...requirements.map((req) => [
+      `### ${req.id}`,
+      '',
+      `- Source: \`${req.source}\``,
+      `- Phase: \`${req.phase || 'unknown'}\``,
+      `- Quality: \`${req.quality || 'unknown'}\``,
+      `- Quality issue: ${req.qualityIssue || '(none)'}`,
+      `- Raw candidate: ${req.text}`,
+      '- Synthesized requirement: `(write clean requirement)`',
+      '- Acceptance: `(write acceptance criteria)`',
+      '- Decision: `pending`',
+      '',
+    ].join('\n')),
+    '## Assumption Candidates',
+    '',
+    assumptions.trim() || '- No assumption candidates found.',
+    '',
+    '## Open Question Candidates',
+    '',
+    questions.trim() || '- No open question candidates found.',
+    '',
+  ].join('\n');
+}
+
+function uniqueStrings(items) {
+  return [...new Set(items.filter(Boolean))];
+}
+
 function readInitiative({ projectRoot, initiativeId }) {
   assertInitiativeId(initiativeId);
   const context = resolveProjectContext({ cwd: projectRoot });

package/bin/initiative.test.mjs

@@ -8,6 +8,7 @@ import {
   initiativeIntake,
   initiativeNext,
   initiativeRequirements,
+  initiativeRequirementsSynthesis,
   initiativeStatus,
 } from './initiative.mjs';
 
@@ -207,7 +208,7 @@ describe('initiative framework', () => {
     expect(review).toContain('- Quality: `fragment`');
   });
 
-  it('writes source coverage warnings plus open questions and assumptions', () => {
+  it('auto-includes relevant source docs and writes question/assumption candidates', () => {
     const root = makeProject();
     const docsDir = path.join(root, 'docs', 'delivery-os');
     fs.mkdirSync(docsDir, { recursive: true });
@@ -246,11 +247,133 @@ describe('initiative framework', () => {
     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(intake.sources.map((source) => source.path)).toContain('docs/delivery-os/05-skills-catalog.md');
+    expect(intake.sources.map((source) => source.path)).toContain('docs/delivery-os/99-feedback-log.md');
+    expect(intake.sourceCoverage.autoIncludedRelevantSources).toContain('docs/delivery-os/05-skills-catalog.md');
+    expect(intake.sourceCoverage.autoIncludedRelevantSources).toContain('docs/delivery-os/99-feedback-log.md');
+    expect(sourceCoverage).toContain('Auto-Included Relevant Sources');
     expect(questions).toContain('Admin UI provider is TBD');
+    expect(questions).toContain('Open Question Candidates');
     expect(assumptions).toContain('Phase 1 не включает Telegram capture.');
+    expect(assumptions).toContain('Assumption Candidates');
+  });
+
+  it('flags dangling fragments, avoids table over-capture and deduplicates repeated requirements', () => {
+    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',
+      '',
+      '- MVP taxonomy должна включать',
+      '| Tool | Phase | Requirement |',
+      '| --- | --- | --- |',
+      '| Golden set | Phase 1 | System must run golden set evaluation. |',
+      '| Telegram bot | Future | System must send Telegram digests. |',
+      '- Phase 1 не включает contribution loop, skill router.',
+    ].join('\n'));
+    fs.writeFileSync(path.join(docsDir, '11-architecture.md'), [
+      '# Phase 1',
+      '',
+      '- 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',
+    });
+
+    const dangling = intake.candidates.find((candidate) => candidate.text.includes('MVP taxonomy'));
+    const table = intake.candidates.find((candidate) => candidate.text.includes('Golden set'));
+    expect(dangling.quality).toBe('fragment');
+    expect(table.quality).toBe('table_row');
+    expect(table.text).toContain('Golden set');
+    expect(table.text).not.toContain('Telegram bot');
+    expect(requirements.requirements.filter((req) => req.text.includes('contribution loop'))).toHaveLength(1);
+  });
+
+  it('filters schema noise out of assumption and question candidates', () => {
+    const root = makeProject();
+    const docsDir = path.join(root, 'docs', 'delivery-os');
+    fs.mkdirSync(docsDir, { recursive: true });
+    fs.writeFileSync(path.join(docsDir, '99-feedback-log.md'), [
+      '# Feedback',
+      '',
+      'CREATE TABLE decisions (',
+      "decided_by JSONB DEFAULT '[]',",
+      'scope TEXT, -- markdown описание scope',
+      '- Decision: Phase 1 uses client and internal profiles only.',
+      '- Open question: Admin UI provider must be decided.',
+    ].join('\n'));
+    createInitiative({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      title: 'Delivery OS MVP',
+    });
+
+    initiativeIntake({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      docsDir: 'docs/delivery-os',
+    });
+
+    const initiativeDir = path.join(root, 'ops', 'agent-pipeline', 'initiatives', 'delivery-os-mvp');
+    const questions = fs.readFileSync(path.join(initiativeDir, 'intake', 'open-questions.md'), 'utf8');
+    const assumptions = fs.readFileSync(path.join(initiativeDir, 'intake', 'assumptions.md'), 'utf8');
+    expect(assumptions).toContain('Phase 1 uses client and internal profiles only');
+    expect(assumptions).not.toContain('decided_by JSONB');
+    expect(assumptions).not.toContain('scope TEXT');
+    expect(questions).toContain('Admin UI provider must be decided');
+  });
+
+  it('writes a requirements synthesis pack before planning', () => {
+    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',
+      '',
+      '- MVP taxonomy должна включать',
+    ].join('\n'));
+    createInitiative({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      title: 'Delivery OS MVP',
+    });
+
+    initiativeIntake({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      docsDir: 'docs/delivery-os',
+      phase: 'phase-1',
+    });
+    initiativeRequirements({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      phase: 'phase-1',
+    });
+    const synthesis = initiativeRequirementsSynthesis({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+    });
+
+    const initiativeDir = path.join(root, 'ops', 'agent-pipeline', 'initiatives', 'delivery-os-mvp');
+    const pack = fs.readFileSync(path.join(initiativeDir, 'requirements-synthesis.md'), 'utf8');
+    expect(synthesis.rewriteRequired).toBe(true);
+    expect(pack).toContain('Requirements Synthesis Pack');
+    expect(pack).toContain('Synthesized requirement');
   });
 });
 

package/bin/lib/bootstrap-utils.mjs

@@ -127,6 +127,7 @@ export function buildOpsScripts(packageSpec) {
     'agent:initiative-next': run('initiative-next'),
     'agent:initiative-intake': run('initiative-intake'),
     'agent:initiative-requirements': run('initiative-requirements'),
+    'agent:initiative-requirements-synthesis': run('initiative-requirements-synthesis'),
     'agent:test': run('test/self-test'),
   };
 }

package/bin/lib/bootstrap-utils.test.mjs

@@ -144,6 +144,7 @@ describe('buildOpsScripts', () => {
     expect(scripts['agent:initiative-next']).toBe('ops-agent initiative-next');
     expect(scripts['agent:initiative-intake']).toBe('ops-agent initiative-intake');
     expect(scripts['agent:initiative-requirements']).toBe('ops-agent initiative-requirements');
+    expect(scripts['agent:initiative-requirements-synthesis']).toBe('ops-agent initiative-requirements-synthesis');
     expect(scripts['agent:test']).toBe('ops-agent test/self-test');
   });
 });

package/bin/ops-agent.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import fs from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -40,6 +41,7 @@ const COMMANDS = new Map([
   ['initiative-next', 'initiative.mjs'],
   ['initiative-intake', 'initiative.mjs'],
   ['initiative-requirements', 'initiative.mjs'],
+  ['initiative-requirements-synthesis', 'initiative.mjs'],
   ['test/self-test', null],
 ]);
 
@@ -50,7 +52,7 @@ function main() {
     process.exit(command ? 0 : 1);
   }
   if (command === '--version' || command === '-v') {
-    console.log('0.1.0');
+    console.log(readPackageVersion());
     return;
   }
   if (!COMMANDS.has(command)) {
@@ -86,4 +88,13 @@ function printHelp() {
   }
 }
 
+function readPackageVersion() {
+  const packageJsonPath = path.join(binRoot, '..', 'package.json');
+  try {
+    return JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
 main();

package/package.json

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