@besales/ops-framework 0.1.15 → 0.1.16

package/CHANGELOG.md

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

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;
@@ -1100,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

@@ -497,6 +497,102 @@ describe('initiative framework', () => {
     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.15",
+  "version": "0.1.16",
   "type": "module",
   "bin": {
     "ops-agent": "bin/ops-agent.mjs"