@besales/ops-framework 0.1.10 → 0.1.12

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 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.
+- 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.

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 });
@@ -239,25 +252,50 @@ export function initiativeIntake({
   const intakeDir = path.join(initiative.initiativeDir, 'intake');
   const changes = [];
   ensureDirectory(intakeDir, changes);
-  const sources = collectSourceDocuments({ projectRoot, docsDir: absoluteDocsDir, include });
+  const allSources = collectSourceDocuments({ projectRoot, docsDir: absoluteDocsDir });
+  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 });
   writeFileIfAllowed(path.join(intakeDir, 'source-index.json'), JSON.stringify({
     schemaVersion: 1,
     generatedAt: new Date().toISOString(),
     docsDir: path.relative(projectRoot, absoluteDocsDir),
     phaseFilter: phase,
-    include,
+    include: resolvedInclude,
+    requestedInclude: include,
+    includeRelevant,
+    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,
   };
 }
@@ -275,13 +313,16 @@ 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),
     source: candidate.source,
     sourceHash: candidate.sourceHash,
     phase: candidate.phase || 'unknown',
+    quality: candidate.quality || 'unknown',
+    qualityIssue: candidate.qualityIssue || '',
     text: candidate.text,
     workPackage: '',
     acceptance: '',
@@ -299,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,
@@ -363,22 +442,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 = requirementFingerprint(block.text);
       if (seen.has(key)) {
-        return;
+        continue;
       }
       seen.add(key);
       candidates.push({
@@ -386,9 +473,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 +490,72 @@ function sourceIncluded({ projectRoot, filePath, include }) {
   return include.some((pattern) => relative === pattern || relative.endsWith(pattern) || relative.includes(pattern));
 }
 
+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,
+    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}`,
+    `- 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',
+    '',
+    ...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 +565,119 @@ 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;
+  const maxContinuationLines = 12;
+  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));
+      if (continuation.length >= maxContinuationLines) {
+        break;
+      }
+      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) {
+    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 (isDanglingRequirementFragment(text)) {
+    return {
+      kind: 'fragment',
+      issue: 'Candidate appears to end mid-list or mid-sentence; rewrite before planning.',
+    };
+  }
+  return {
+    kind: 'complete',
+    issue: '',
+  };
+}
+
+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;
   }
-  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 +705,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 +722,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 +735,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 +748,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 +776,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 +793,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) => requirementNeedsRewrite(req));
   return [
     '# Initiative Coverage',
     '',
@@ -531,6 +804,18 @@ 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}`,
+    `- Quality run-on block: ${qualityCounts.run_on_block || 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,24 +858,199 @@ 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) || isNoisySourceLine(normalized)) {
+        return;
+      }
+      const key = sha256(normalizeForDedup(normalized)).slice(0, 16);
+      if (seen.has(key)) {
+        return;
+      }
+      seen.add(key);
+      results.push({
+        source: `${source.path}:${index + 1}`,
+        text: normalized,
+      });
+    });
+  }
+  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.',
     '',
-    '- 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',
+    '# Assumption Candidates',
     '',
-    '- Add assumptions that were required to interpret source docs.',
+    'Deterministic candidates only. Rewrite into real assumptions during requirements synthesis before planning.',
+    '',
+    ...(assumptions.length
+      ? assumptions.map((assumption) => `- \`${assumption.source}\`: ${assumption.text}`)
+      : ['- No deterministic assumptions found. Add assumptions required to interpret source docs.']),
     '',
   ].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';
 
@@ -158,6 +159,222 @@ 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('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 });
+    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.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');
+  });
 });
 
 function makeProject() {

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

@@ -40,6 +40,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],
 ]);
 

package/package.json

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