@besales/ops-framework 0.1.14 → 0.1.16

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.16
+
+- Added a schema compatibility readiness gate that blocks planning when a closed/minimal schema requirement does not support dependent approved requirements such as speaker resolution, aliases and meeting track classification.
+- Added a schema attribution/access warning when sources mention `created_by`, `app.current_user_id`, `owner_id`, `entity_history` or deferred enforcement but the schema requirement omits them.
+
+## 0.1.15
+
+- Strengthened the initiative track-scope/storage synthesis gate to detect wide meeting tracks routed to commitments/decisions/risks via `related_person_id` when that storage is deferred.
+- Linked the track-scope gate action to the apply-contract decision so synthesis resolves both scope and write semantics together.
+
 ## 0.1.14
 
 - Added initiative synthesis readiness gates for missing critical concepts, ADR/NFR coverage, scope/storage conflicts, apply-contract ambiguity, sequencing hints and stronger source-reference warnings.

package/bin/initiative.mjs

@@ -1035,6 +1035,8 @@ function buildSynthesisReadinessGates({ requirements, sourceDocs }) {
   });
   addScopeStorageConflictGate({ gates, sourceText, requirementText });
   addApplyContractGate({ gates, sourceText, requirementText });
+  addSchemaCompatibilityGate({ gates, sourceText, requirements });
+  addSchemaAttributionWarningGate({ gates, sourceText, requirements });
   addSequencingGate({ gates, sourceText, requirementText });
   addStrongerSourceRefGate({ gates, sourceDocs, requirements });
   return gates;
@@ -1064,18 +1066,21 @@ function addMissingConceptGate({
 }
 
 function addScopeStorageConflictGate({ gates, sourceText, requirementText }) {
-  const mentionsWideTrackTaxonomy = /(tracker|advisor[_ -]?network|investor|grant[_ -]?funding)/i.test(requirementText);
-  const defersFactStorage = /(commitments?|decisions?|risks?|related_person_id).{0,120}(phase\s*2|future|defer|отлож)/is.test(`${requirementText}\n${sourceText}`)
-    || /(phase\s*2|future|defer|отлож).{0,120}(commitments?|decisions?|risks?|related_person_id)/is.test(`${requirementText}\n${sourceText}`);
+  const combinedText = `${requirementText}\n${sourceText}`;
+  const mentionsWideTrackTaxonomy = /(tracker|advisor[_ -]?network|advisor-network|investor|grant[_ -]?funding|fundraising|grants?)/i.test(combinedText);
+  const mapsWideTracksToFactStorage = /(advisor[_ -]?network|advisor-network|fundraising|investor|grant[_ -]?funding|grants?|tracker).{0,240}(commitments?|decisions?|risks?|related_person_id|nullable client_id|meeting_track\s+in)/is.test(sourceText)
+    || /(commitments?|decisions?|risks?|related_person_id|nullable client_id|meeting_track\s+in).{0,240}(advisor[_ -]?network|advisor-network|fundraising|investor|grant[_ -]?funding|grants?|tracker)/is.test(sourceText);
+  const defersFactStorage = /(commitments?|decisions?|risks?|related_person_id).{0,160}(phase\s*2|future|defer|deferred|отлож)/is.test(combinedText)
+    || /(phase\s*2|future|defer|deferred|отлож).{0,160}(commitments?|decisions?|risks?|related_person_id)/is.test(combinedText);
   const hasExplicitTrackScopeDecision = /(client\s*\+\s*internal|client and internal|только client|только клиент|only client|track[- ]scope|6 tracks?.{0,80}(phase\s*2|future|defer))/i.test(requirementText);
-  if (mentionsWideTrackTaxonomy && defersFactStorage && !hasExplicitTrackScopeDecision) {
+  if (mentionsWideTrackTaxonomy && mapsWideTracksToFactStorage && defersFactStorage && !hasExplicitTrackScopeDecision) {
     gates.push({
       id: 'scope-storage-track-conflict',
       severity: 'needs_decision',
       blocking: true,
       title: 'Track taxonomy conflicts with deferred fact storage',
-      issue: 'Requirements mention non-client/internal tracks while storage for commitments/decisions/risks or related-person facts appears deferred.',
-      action: 'Decide explicitly: Phase 1 taxonomy is client+internal only, or Phase 1 includes minimal fact storage for the wider track set.',
+      issue: 'Sources connect non-client/internal meeting tracks to commitments/decisions/risks or related-person facts while that storage appears deferred.',
+      action: 'Decide explicitly with the apply-contract gate: Phase 1 extraction is client+internal only, or Phase 1 includes minimal commitments/decisions/risks storage with related_person_id for the wider track set.',
     });
   }
 }
@@ -1097,6 +1102,82 @@ function addApplyContractGate({ gates, sourceText, requirementText }) {
   }
 }
 
+function addSchemaCompatibilityGate({ gates, sourceText, requirements }) {
+  const schemaReq = findSchemaRequirement(requirements);
+  if (!schemaReq) {
+    return;
+  }
+  const schemaText = requirementFullText(schemaReq);
+  const allRequirementText = requirements.map((req) => requirementFullText(req)).join('\n');
+  const schemaLooksClosed = /(includes?\s+only|only\s+includes?|schema\s+includes\s+only|только|исключительно)/i.test(schemaText);
+  const hasSpeakerResolutionRequirement = /(speaker[_ -]?resolution|speaker identity|raw speaker|raw_speaker|person_aliases|aliases?|alias-хранилище)/i.test(allRequirementText);
+  const schemaSupportsSpeakerResolution = /(person_aliases|raw_speaker_labels?|speaker_resolution_status|speaker alias|speaker label|aliases?)/i.test(schemaText);
+  const hasTrackClassificationRequirement = /(meeting_track|track classification|classif(?:y|ication).{0,80}track|классификац.{0,80}трек)/i.test(`${allRequirementText}\n${sourceText}`);
+  const schemaSupportsTrackClassification = /meeting_track/i.test(schemaText);
+  const sourceMentionsMeetingOperationalFields = /(series_id|asr_quality)/i.test(sourceText);
+  const schemaSupportsMeetingOperationalFields = !sourceMentionsMeetingOperationalFields || /(series_id|asr_quality)/i.test(schemaText);
+  const missing = [];
+  if (hasSpeakerResolutionRequirement && !schemaSupportsSpeakerResolution) {
+    missing.push('speaker resolution storage (`person_aliases` or `raw_speaker_labels` + `speaker_resolution_status`)');
+  }
+  if (hasTrackClassificationRequirement && !schemaSupportsTrackClassification) {
+    missing.push('`meeting_track` on meetings');
+  }
+  if (!schemaSupportsMeetingOperationalFields) {
+    missing.push('meeting operational fields mentioned by sources, such as `series_id` and `asr_quality`');
+  }
+  if (missing.length && schemaLooksClosed) {
+    gates.push({
+      id: 'schema-supports-derived-requirements',
+      severity: 'critical',
+      blocking: true,
+      title: 'Schema requirement does not support dependent requirements',
+      issue: `Schema requirement ${schemaReq.id} is written as a closed/minimal schema list but omits ${missing.join(', ')}.`,
+      action: 'Update the schema requirement before WP planning: add the missing schema support, or explicitly state the alternative Phase 1 storage contract and defer the dependent behavior.',
+    });
+  }
+}
+
+function addSchemaAttributionWarningGate({ gates, sourceText, requirements }) {
+  const schemaReq = findSchemaRequirement(requirements);
+  if (!schemaReq) {
+    return;
+  }
+  const schemaText = requirementFullText(schemaReq);
+  const sourceMentionsAttribution = /(created_by|app\.current_user_id|owner_id|entity_history|enforcement[- ]deferred)/i.test(sourceText);
+  const missing = [
+    ['created_by', /created_by/i],
+    ['app.current_user_id', /app\.current_user_id/i],
+    ['owner_id', /owner_id/i],
+    ['entity_history', /entity_history/i],
+    ['enforcement-deferred', /enforcement[- ]deferred/i],
+  ].filter(([, pattern]) => !pattern.test(schemaText)).map(([name]) => name);
+  if (sourceMentionsAttribution && missing.length) {
+    gates.push({
+      id: 'schema-attribution-nfr-warning',
+      severity: 'planning_hint',
+      blocking: false,
+      title: 'Schema attribution/access fields are not explicit',
+      issue: `Sources mention attribution/access schema decisions, but schema requirement ${schemaReq.id} omits ${missing.join(', ')}.`,
+      action: 'Before WP-001, add acceptance for created_by/app.current_user_id, owner_id, entity_history and deferred role enforcement if these are Phase 1 schema foundations.',
+    });
+  }
+}
+
+function findSchemaRequirement(requirements) {
+  return requirements.find((req) => /(schema|migration|tables?|таблиц|схем)/i.test(requirementFullText(req)));
+}
+
+function requirementFullText(req) {
+  return [
+    req.id,
+    req.text,
+    req.acceptance,
+    req.notes,
+    req.workPackage,
+  ].filter(Boolean).join('\n');
+}
+
 function addSequencingGate({ gates, sourceText, requirementText }) {
   const hasGoldenSet = /(golden set|golden-set|regression baseline|baseline regression)/i.test(`${sourceText}\n${requirementText}`);
   const hasMeetingExtraction = /(process-meeting|process meeting|\/process-meeting|meeting extraction)/i.test(requirementText);

package/bin/initiative.test.mjs

@@ -388,6 +388,7 @@ describe('initiative framework', () => {
       '- Golden set baseline Week 1-2 for meeting extraction regression.',
       '- Migration 001b: person_aliases. Meeting fields: meeting_track, series_id, asr_quality, speaker_resolution_status.',
       '- Analysis found single-label exports, alias zoo, committed_by_person attribution risk.',
+      '- advisor_network, fundraising and grants are routed into commitments, decisions and risks by meeting_track.',
       '- Phase 2 defers commitments decisions risks related_person_id storage.',
     ].join('\n'));
     fs.writeFileSync(path.join(docsDir, '07-adrs.md'), [
@@ -445,6 +446,153 @@ describe('initiative framework', () => {
     expect(pack).toContain('Golden set should baseline meeting extraction');
     expect(pack).toContain('Stronger source reference available');
   });
+
+  it('detects track scope storage conflicts when routing evidence is only in source docs', () => {
+    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 must cover client, internal, tracker, advisor_network, investor, grant_funding.',
+      '- Minimal Phase 1 schema defers commitments, decisions, risks and related_person_id storage to Phase 2.',
+    ].join('\n'));
+    fs.writeFileSync(path.join(docsDir, '12-para-workspace-contract.md'), [
+      '# Workspace Contract',
+      '',
+      '- advisor-network / fundraising / grants are routed into commitments, decisions and risks where meeting_track IN (...).',
+    ].join('\n'));
+    fs.writeFileSync(path.join(docsDir, '13-meeting-extraction-profiles.md'), [
+      '# Profiles',
+      '',
+      '- Non-client tracks require nullable client_id plus related_person_id on commitments, decisions and risks.',
+    ].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 gate = synthesis.gates.find((item) => item.id === 'scope-storage-track-conflict');
+    expect(gate).toMatchObject({
+      severity: 'needs_decision',
+      blocking: true,
+    });
+    expect(gate.action).toContain('client+internal');
+    expect(gate.action).toContain('related_person_id');
+  });
+
+  it('blocks planning when closed schema requirements do not support dependent approved 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',
+      '',
+      '- Migration 001b: person_aliases. Meeting fields: meeting_track, series_id, asr_quality, speaker_resolution_status.',
+    ].join('\n'));
+    fs.writeFileSync(path.join(docsDir, '07-adrs.md'), [
+      '# ADR-6',
+      '',
+      '- Schema-ready enforcement-deferred: created_by, app.current_user_id, owner_id, entity_history.',
+    ].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',
+    });
+    const initiativeDir = path.join(root, 'ops', 'agent-pipeline', 'initiatives', 'delivery-os-mvp');
+    fs.writeFileSync(path.join(initiativeDir, 'requirements-map.md'), [
+      '# Requirements Map',
+      '',
+      '## Requirement Details',
+      '',
+      '### REQ-002',
+      '',
+      '- Status: `approved`',
+      '- Source: `docs/delivery-os/04-data-model.md:1206`',
+      '- Source hash: `sha`',
+      '- Phase: `phase-1`',
+      '- Quality: `complete`',
+      '- Quality issue: (none)',
+      '- Work package: WP-001',
+      '- Acceptance: Schema includes only team_members, clients, people, meetings, evidence, change_groups, proposed_changes, skill_executions, entity_history.',
+      '- Decision: `approve`',
+      '- Notes: Human-approved minimal schema.',
+      '- Requirement: Minimal Phase 1 schema includes only team_members, clients, people, meetings, evidence, change_groups, proposed_changes, skill_executions, entity_history.',
+      '',
+      '### REQ-003',
+      '',
+      '- Status: `approved`',
+      '- Source: `docs/delivery-os/06-roadmap.md:10`',
+      '- Source hash: `sha`',
+      '- Phase: `phase-1`',
+      '- Quality: `complete`',
+      '- Quality issue: (none)',
+      '- Work package: WP-003',
+      '- Acceptance: Meetings are classified with `meeting_track`.',
+      '- Decision: `approve`',
+      '- Notes: (empty)',
+      '- Requirement: Phase 1 classifies meetings by track using meeting_track.',
+      '',
+      '### REQ-004',
+      '',
+      '- Status: `approved`',
+      '- Source: `docs/delivery-os/06-roadmap.md:11`',
+      '- Source hash: `sha`',
+      '- Phase: `phase-1`',
+      '- Quality: `complete`',
+      '- Quality issue: (none)',
+      '- Work package: WP-001, WP-003',
+      '- Acceptance: Speaker resolution stores raw speaker labels and aliases and does not attribute unresolved aliases automatically.',
+      '- Decision: `approve`',
+      '- Notes: (empty)',
+      '- Requirement: Phase 1 supports speaker identity resolution by storing raw speaker labels and aliases.',
+      '',
+    ].join('\n'));
+
+    const synthesis = initiativeRequirementsSynthesis({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+    });
+
+    const schemaGate = synthesis.gates.find((gate) => gate.id === 'schema-supports-derived-requirements');
+    const attributionGate = synthesis.gates.find((gate) => gate.id === 'schema-attribution-nfr-warning');
+    expect(schemaGate).toMatchObject({
+      severity: 'critical',
+      blocking: true,
+    });
+    expect(schemaGate.issue).toContain('person_aliases');
+    expect(schemaGate.issue).toContain('meeting_track');
+    expect(schemaGate.issue).toContain('series_id');
+    expect(attributionGate).toMatchObject({
+      severity: 'planning_hint',
+      blocking: false,
+    });
+    expect(synthesis.rewriteRequired).toBe(true);
+  });
 });
 
 function makeProject() {

package/package.json

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