@besales/ops-framework 0.1.22 → 0.1.24

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.1.24
+
+- Raised `standard_plus` Check/Verify context cap so near-cap plans stay in compact mode instead of jumping to slow strict context.
+- Stabilized Check LLM `taskManifest` input by removing volatile `llmInput`, `lastCheckResult`, timestamps and verbose loop history from the prompt payload.
+- Reduced duplicate external Check reruns after `task-manifest.json` refreshes by keeping prompt input stable when plan, memory and risk inputs have not changed.
+
+## 0.1.23
+
+- Added deterministic import/ingestion planning gates for representative real fixtures, raw downstream metadata extraction and explicit duplicate-import behavior.
+- Tightened Source Sync / Provider gates so idempotency must name a dedupe key and concrete duplicate action, not only "detected/reported".
+- Added work-package dependency preflight for Execute/Verify/Human Gate so materialized WP tasks cannot proceed while declared dependencies remain in progress.
+- Expanded Source Sync playbook and checker prompt with import/manual-upload fixture, metadata and dedupe expectations.
+
 ## 0.1.22
 
 - Added a compact `standard_plus` LLM context mode between `standard` and `strict` so near-cap Check/Verify runs avoid full strict context when compact evidence is sufficient.

package/bin/lib/check-context-utils.mjs

@@ -636,10 +636,10 @@ export function classifyRisk({ structuralLines, referencedFiles, planSections, r
   if (hasRef((ref) => matchesAnyRoot(ref, workerRoots)) || hasText(/\b(worker|scheduler|queue|bullmq|backfill|pacing)\b/)) {
     triggers.add('worker-queue');
   }
-  if (hasText(/\b(source ingestion|source-ingestion|connector|oauth|callback|provider api|sync plan)\b/)) {
+  if (hasText(/\b(source ingestion|source-ingestion|connector|oauth|callback|provider api|sync plan|manual upload|upload path|import smoke|transcript import|transcripts?|vtt|evidence capture)\b/)) {
     triggers.add('ingestion-provider');
   }
-  if (hasText(/\b(source sync|source-sync|raw record|raw records|pagination|rate limit|retry|retries|idempotency|partial failure|provider stream|sync worker|sync scheduler)\b/)) {
+  if (hasText(/\b(source sync|source-sync|raw record|raw records|pagination|rate limit|retry|retries|idempotency|partial failure|provider stream|sync worker|sync scheduler|content hash|content_hash|dedupe|duplicate import|backfill|replay)\b/)) {
     triggers.add('source-sync-provider');
   }
   if (hasText(/\b(production|railway|deploy|runtime env|environment variable)\b/)) {
@@ -776,6 +776,7 @@ export function analyzePlanQualityGates({ planContent, risk, referencedFiles = [
   const optimizationStrategy = inspectOptimizationStrategy(sections);
   const productionRollout = inspectProductionRolloutGate(sections);
   const sourceSyncProvider = inspectSourceSyncProviderGate(sections);
+  const importIngestion = inspectImportIngestionGate(sections, planContent);
   const missingSignals = [];
 
   if (!executionMetadata.present) {
@@ -814,6 +815,9 @@ export function analyzePlanQualityGates({ planContent, risk, referencedFiles = [
   if (sourceSyncProviderRequired && !sourceSyncProvider.present) {
     missingSignals.push('Source sync/provider risk detected but `## Source Sync / Provider Gate` is missing or incomplete.');
   }
+  if (sourceSyncProviderRequired && importIngestion.required && !importIngestion.present) {
+    missingSignals.push('Import/ingestion plan must include an Import / Ingestion Contract naming representative real fixtures or an explicit no-real-fixtures reason, raw metadata/speaker-label extraction, and duplicate-import policy.');
+  }
 
   return {
     executionMetadata,
@@ -833,6 +837,7 @@ export function analyzePlanQualityGates({ planContent, risk, referencedFiles = [
     productionRollout,
     sourceSyncProviderRequired,
     sourceSyncProvider,
+    importIngestion,
     missingSignals,
   };
 }
@@ -1218,10 +1223,53 @@ export function inspectSourceSyncProviderGate(sections) {
     present: true,
     hasScope: /scope|window|provider|stream|pagination|rate limit|raw record|объем|окно|провайдер/.test(normalized),
     hasIdempotency: /idempot|dedupe|duplicate|retry|replay|повтор|дубликат/.test(normalized),
+    hasDedupeKey: /content[_ -]?hash|idempotency key|dedupe key|unique key|natural key|source[_ -]?id|fingerprint|checksum|хеш|ключ/.test(normalized),
+    hasDuplicateAction: /skip|link|update|upsert|reject|error|report|mark|reuse|ignore|пропуск|связ|обнов|ошиб|отчет|помет/.test(normalized),
     hasFailureHandling: /partial failure|failure|timeout|backoff|resume|dead letter|ошиб|частич/.test(normalized),
     hasCoverageEvidence: /coverage|parity|count|sample|audit|evidence|metric|сверк|покрыт/.test(normalized),
   };
-  result.complete = result.hasScope && result.hasIdempotency && result.hasFailureHandling && result.hasCoverageEvidence;
+  result.complete = result.hasScope && result.hasIdempotency && result.hasDedupeKey && result.hasDuplicateAction && result.hasFailureHandling && result.hasCoverageEvidence;
+  result.present = result.complete;
+  return result;
+}
+
+export function inspectImportIngestionGate(sections, planContent = '') {
+  const text = planContent || '';
+  const required = /\b(import|ingest|ingestion|manual upload|upload path|transcripts?|vtt|fixture|fixtures|evidence capture|backfill)\b/i.test(text);
+  const body = [
+    readCanonicalSection(sections, ['import / ingestion contract', 'import ingestion contract', 'ingestion contract', 'import contract']),
+    readCanonicalSection(sections, ['source sync / provider gate', 'source sync provider gate', 'source sync gate', 'provider gate']),
+  ].filter(Boolean).join('\n');
+  if (!required) {
+    return {
+      required: false,
+      present: true,
+      hasRealFixtureDecision: false,
+      hasMetadataExtraction: false,
+      hasDedupePolicy: false,
+      hasDownstreamFields: false,
+    };
+  }
+  if (!body) {
+    return {
+      required,
+      present: false,
+      hasRealFixtureDecision: false,
+      hasMetadataExtraction: false,
+      hasDedupePolicy: false,
+      hasDownstreamFields: false,
+    };
+  }
+  const normalized = body.toLowerCase();
+  const result = {
+    required,
+    present: true,
+    hasRealFixtureDecision: /(real|representative|production-like|existing|fixture|fixtures|sample|golden|transcript|vtt|md|no real|unavailable|human-owned|реальн|репрезент|транскрипт)/.test(normalized),
+    hasMetadataExtraction: /(raw_speaker_labels|speaker labels?|speaker[_ -]?label|single-label|single label|is_single_label_export|speaker_resolution_status|metadata|метаданн|лейбл)/.test(normalized),
+    hasDedupePolicy: /(content[_ -]?hash|idempotency key|dedupe key|duplicate|skip|link|update|upsert|reject|report|повтор|дубликат|хеш)/.test(normalized),
+    hasDownstreamFields: /(downstream|wp-\d{3}|process-meeting|golden set|schema field|raw_speaker_labels|speaker_resolution_status|is_single_label_export|meeting_track|потребител|следующ)/.test(normalized),
+  };
+  result.complete = result.hasRealFixtureDecision && result.hasMetadataExtraction && result.hasDedupePolicy && result.hasDownstreamFields;
   result.present = result.complete;
   return result;
 }
@@ -1351,7 +1399,8 @@ export function buildCheckerContextPack({
       ? [
           '- Source sync/provider risk detected.',
           `- Source Sync / Provider Gate complete: \`${qualityGates.sourceSyncProvider.present ? 'yes' : 'no'}\`.`,
-          '- Checker must return `return_to_plan` if scope/window, idempotency, failure handling and coverage evidence are not named.',
+          `- Import / Ingestion Contract complete: \`${qualityGates.importIngestion?.present ? 'yes' : 'no'}\`.`,
+          '- Checker must return `return_to_plan` if scope/window, dedupe key, duplicate action, failure handling, representative fixtures and coverage evidence are not named.',
         ].join('\n')
       : '- Source sync/provider gate is not required by detected triggers.',
     '',
@@ -1559,7 +1608,7 @@ export function validateExecutionEvidenceForPlan({ planContent, executionContent
         category: 'missing_evidence',
         message: 'Plan contains Source Sync / Provider Gate but execution.md is missing Source Sync / Provider Evidence.',
       });
-    } else if (!/(idempot|retry|pagination|rate limit|raw record|coverage|parity|count|sample|partial failure|replay|audit)/i.test(evidence)) {
+    } else if (!/(idempot|retry|pagination|rate limit|raw record|coverage|parity|count|sample|partial failure|replay|audit|content[_ -]?hash|dedupe|duplicate)/i.test(evidence)) {
       errors.push({
         category: 'insufficient_evidence',
         message: 'Source Sync / Provider Evidence must include idempotency, retry/pagination/rate-limit, raw-record, coverage/parity, sample, replay, or failure-handling evidence.',
@@ -1567,6 +1616,21 @@ export function validateExecutionEvidenceForPlan({ planContent, executionContent
     }
   }
 
+  if (hasAnySection(planSections, ['import / ingestion contract', 'import ingestion contract', 'ingestion contract', 'import contract'])) {
+    const evidence = readAnySection(executionSections, ['import / ingestion evidence', 'import ingestion evidence', 'ingestion evidence', 'import evidence', 'source sync / provider evidence']);
+    if (!evidence) {
+      errors.push({
+        category: 'missing_evidence',
+        message: 'Plan contains Import / Ingestion Contract but execution.md is missing Import / Ingestion Evidence.',
+      });
+    } else if (!/(fixture|real|sample|transcript|vtt|raw_speaker_labels|speaker labels?|single-label|content[_ -]?hash|dedupe|duplicate|skip|link|update|upsert|report|count|audit)/i.test(evidence)) {
+      errors.push({
+        category: 'insufficient_evidence',
+        message: 'Import / Ingestion Evidence must include fixture choice, raw metadata/speaker labels, duplicate policy result, count or audit evidence.',
+      });
+    }
+  }
+
   return errors;
 }
 
@@ -1615,6 +1679,9 @@ function buildCheckerQuestions({ risk, qualityGates }) {
   if (qualityGates.sourceSyncProviderRequired || risk.riskTriggers.includes('worker-queue')) {
     questions.push('Does the plan bound provider/worker execution by scope, window, credentials, queue ownership and coverage evidence?');
   }
+  if (qualityGates.importIngestion?.required) {
+    questions.push('Does the import plan use representative real fixtures when available, extract raw metadata needed downstream, and define exact duplicate-import behavior?');
+  }
   return questions;
 }
 

package/bin/lib/check-context-utils.test.mjs

@@ -744,7 +744,7 @@ describe('agent pipeline quality gates', () => {
       '## Source Sync / Provider Gate',
       '',
       '- Scope / provider window: GetCourse stream for May, paginated by window.',
-      '- Idempotency / duplicate handling: idempotency key and dedupe on retry.',
+      '- Idempotency / duplicate handling: content_hash idempotency key; duplicate action is skip and link to existing record.',
       '- Failure handling / retry boundaries: backoff, timeout and partial failure resume.',
       '- Coverage / parity evidence: count audit and raw record samples.',
     ].join('\n'));
@@ -754,4 +754,83 @@ describe('agent pipeline quality gates', () => {
     expect(result.present).toBe(true);
     expect(result.hasCoverageEvidence).toBe(true);
   });
+
+  it('requires import ingestion contract for transcript import plans', () => {
+    const result = analyzePlanQualityGates({
+      planContent: [
+        '# Plan',
+        '',
+        '## Risk tier and execution budget',
+        '',
+        '- Risk tier: `R2`',
+        '- Speed mode: `Standard`',
+        '- Approved execution target: manual upload transcript import.',
+        '- Requires return to Plan/Check if: ingestion scope changes.',
+        '',
+        '## Verification ladder',
+        '',
+        '- Micro-verify during Execute: import smoke.',
+        '- Slice-verify before completion: count audit.',
+        '- External Verify required before closeout: yes.',
+        '',
+        '## Source Sync / Provider Gate',
+        '',
+        '- Scope / provider window: manual transcript upload fixtures.',
+        '- Idempotency / duplicate handling: content_hash exists and duplicates are detected.',
+        '- Failure handling / retry boundaries: parse errors report partial failure.',
+        '- Coverage / parity evidence: count audit.',
+      ].join('\n'),
+      risk: {
+        riskProfile: 'high',
+        riskTriggers: ['source-sync-provider', 'ingestion-provider'],
+      },
+    });
+
+    expect(result.importIngestion.required).toBe(true);
+    expect(result.importIngestion.present).toBe(false);
+    expect(result.missingSignals.some((signal) => signal.includes('Import/ingestion plan must include'))).toBe(true);
+  });
+
+  it('accepts import ingestion contract with real fixtures metadata and dedupe behavior', () => {
+    const result = analyzePlanQualityGates({
+      planContent: [
+        '# Plan',
+        '',
+        '## Risk tier and execution budget',
+        '',
+        '- Risk tier: `R2`',
+        '- Speed mode: `Standard`',
+        '- Approved execution target: manual upload transcript import.',
+        '- Requires return to Plan/Check if: ingestion scope changes.',
+        '',
+        '## Verification ladder',
+        '',
+        '- Micro-verify during Execute: import smoke.',
+        '- Slice-verify before completion: count audit.',
+        '- External Verify required before closeout: yes.',
+        '',
+        '## Source Sync / Provider Gate',
+        '',
+        '- Scope / provider window: manual transcript upload from real VTT fixtures.',
+        '- Idempotency / duplicate handling: content_hash idempotency key; duplicate action is skip and link to existing evidence.',
+        '- Failure handling / retry boundaries: parse errors report partial failure.',
+        '- Coverage / parity evidence: count audit and raw record samples.',
+        '',
+        '## Import / Ingestion Contract',
+        '',
+        '- Representative fixtures: real May transcript VTT/MD fixtures; no synthetic fixtures unless real files are unavailable.',
+        '- Raw metadata extraction: raw_speaker_labels, speaker_resolution_status and is_single_label_export are populated at import time.',
+        '- Downstream fields: WP-003 process-meeting consumes raw_speaker_labels and WP-005 golden set consumes the same fixtures.',
+        '- Duplicate policy: content_hash duplicate imports skip creation and link/reuse existing evidence.',
+      ].join('\n'),
+      risk: {
+        riskProfile: 'high',
+        riskTriggers: ['source-sync-provider', 'ingestion-provider'],
+      },
+    });
+
+    expect(result.sourceSyncProvider.present).toBe(true);
+    expect(result.importIngestion.present).toBe(true);
+    expect(result.missingSignals.some((signal) => signal.includes('Import/ingestion plan must include'))).toBe(false);
+  });
 });

package/bin/lib/llm-input-pack-utils.mjs

@@ -12,8 +12,8 @@ export const LLM_CONTEXT_MODES = ['fast', 'standard', 'standard_plus', 'strict']
 export const LLM_CONTEXT_CAPS = {
   fast: 8000,
   standard: 20000,
-  standard_plus: 26000,
-  strict: 45000,
+  standard_plus: 30000,
+  strict: 50000,
 };
 
 const TOKEN_ESTIMATE_CHARS_PER_TOKEN = 1.8;
@@ -225,7 +225,7 @@ export function buildCheckerLlmInputPack({
     relevantPlaybooks: selectedMode === 'strict'
       ? renderRelevantPlaybooks(readRelevantPlaybooks(checkContext.riskTriggers || []), { mode: 'strict' })
       : renderRelevantPlaybooks(readRelevantPlaybooks(checkContext.riskTriggers || []), { mode: 'compact' }),
-    taskManifest,
+    taskManifest: stableTaskManifestForCheck(taskManifest),
     projectMemory: compactProjectMemory(projectMemory, selectedMode),
     taskArtifacts: artifacts,
     outputContract: {
@@ -249,6 +249,61 @@ export function buildCheckerLlmInputPack({
   return withPackMetadata(input, selectedMode);
 }
 
+export function stableTaskManifestForCheck(taskManifest) {
+  let parsed = null;
+  if (typeof taskManifest === 'string') {
+    try {
+      parsed = JSON.parse(taskManifest);
+    } catch {
+      return taskManifest;
+    }
+  } else if (taskManifest && typeof taskManifest === 'object' && !Array.isArray(taskManifest)) {
+    parsed = taskManifest;
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return taskManifest || '';
+  }
+
+  const stable = {
+    schemaVersion: parsed.schemaVersion,
+    taskId: parsed.taskId,
+    mode: parsed.mode,
+    phase: parsed.phase,
+    gates: parsed.gates,
+    context: {
+      planSha: parsed.context?.planSha,
+      planFingerprintVersion: parsed.context?.planFingerprintVersion,
+      memorySha: parsed.context?.memorySha,
+      riskProfile: parsed.context?.riskProfile,
+      riskTriggers: parsed.context?.riskTriggers,
+      riskWarnings: parsed.context?.riskWarnings,
+      checkContextCurrent: parsed.context?.checkContextCurrent,
+    },
+    requiredEvidenceIssues: parsed.requiredEvidenceIssues,
+    qualitySignals: parsed.qualitySignals,
+    loopDetector: {
+      threshold: parsed.loopDetector?.threshold,
+      requiresConsolidatedRemediation: parsed.loopDetector?.requiresConsolidatedRemediation,
+      repeatedReasons: parsed.loopDetector?.repeatedReasons,
+    },
+    consolidatedRemediationAccepted: parsed.consolidatedRemediationAccepted,
+    consolidatedRemediationArtifact: parsed.consolidatedRemediationArtifact,
+  };
+  return JSON.stringify(pruneUndefined(stable), null, 2);
+}
+
+function pruneUndefined(value) {
+  if (Array.isArray(value)) {
+    return value.map(pruneUndefined);
+  }
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value)
+    .filter(([, item]) => item !== undefined)
+    .map(([key, item]) => [key, pruneUndefined(item)]));
+}
+
 export function buildVerifierLlmInputPack({
   taskDir,
   taskId,

package/bin/lib/llm-input-pack-utils.test.mjs

@@ -112,12 +112,61 @@ describe('llm input pack utilities', () => {
     });
 
     expect(pack.meta.mode).toBe('standard_plus');
-    expect(pack.meta.capTokens).toBe(26000);
+    expect(pack.meta.capTokens).toBe(30000);
     expect(pack.input.llmInputPolicy.contextInsufficientFallback).toBe('rerun_strict');
     expect(pack.input.taskArtifacts['plan.md']).toContain('<!-- compacted:plan.md');
     expect(pack.meta.compactedArtifacts).toContain('plan.md');
   });
 
+  it('stabilizes checker task manifest by excluding volatile check telemetry', () => {
+    const taskDir = createTask();
+    const pack = buildCheckerLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      checkerPromptSha: 'sha256:test',
+      cacheKey: { test: true },
+      checkContext: {
+        planSha: 'sha256:plan',
+        memorySha: 'sha256:memory',
+        riskProfile: 'high',
+        riskTriggers: ['source-sync-provider'],
+      },
+      checkEvidence: '# Evidence\n\nok',
+      checkerContextPack: '# Checker Context Pack\n\nok',
+      taskManifest: JSON.stringify({
+        schemaVersion: 1,
+        taskId: 'TASK-999-token-pack',
+        mode: 'standard',
+        phase: 'check',
+        gates: { sourceSyncProvider: { required: true, planComplete: true } },
+        context: {
+          planSha: 'sha256:plan',
+          memorySha: 'sha256:memory',
+          riskProfile: 'high',
+          riskTriggers: ['source-sync-provider'],
+          checkContextCurrent: true,
+        },
+        llmInput: { check: { updatedAt: 'volatile', attempts: [{ mode: 'strict' }] } },
+        lastCheckResult: { verdict: 'ready_for_human_gate', createdAt: 'volatile' },
+        timestamps: { updatedAt: 'volatile' },
+        loopDetector: {
+          threshold: 2,
+          requiresConsolidatedRemediation: true,
+          repeatedReasons: [{ normalizedReason: 'context_overflow', count: 3 }],
+          reasons: { noisy: { normalizedReason: 'verbose history' } },
+        },
+      }, null, 2),
+      projectMemory: [],
+      mode: 'standard',
+    });
+
+    expect(pack.input.taskManifest).toContain('"requiresConsolidatedRemediation": true');
+    expect(pack.input.taskManifest).not.toContain('lastCheckResult');
+    expect(pack.input.taskManifest).not.toContain('llmInput');
+    expect(pack.input.taskManifest).not.toContain('timestamps');
+    expect(pack.input.taskManifest).not.toContain('verbose history');
+  });
+
   it('preserves protected verification sections when compacting long plans', () => {
     const taskDir = createTask();
     const longPlan = [

package/bin/lib/task-manifest-utils.mjs

@@ -78,6 +78,12 @@ export function buildTaskManifest({ taskDir, now = new Date().toISOString(), exi
         evidenceRequired: hasPlanGate(inputs.taskArtifacts.get('plan.md'), ['source sync / provider gate', 'source sync provider gate', 'source sync gate', 'provider gate']),
         evidenceComplete: !evidenceIssues.some((issue) => issue.message.includes('Source Sync / Provider')),
       },
+      importIngestion: {
+        required: Boolean(inputs.qualityGates.importIngestion?.required),
+        planComplete: Boolean(inputs.qualityGates.importIngestion?.present),
+        evidenceRequired: hasPlanGate(inputs.taskArtifacts.get('plan.md'), ['import / ingestion contract', 'import ingestion contract', 'ingestion contract', 'import contract']),
+        evidenceComplete: !evidenceIssues.some((issue) => issue.message.includes('Import / Ingestion')),
+      },
     },
     context: {
       planSha: inputs.planFingerprint.planSha,
@@ -167,6 +173,9 @@ export function preflightTask({ taskDir, targetPhase }) {
       message: 'Repeated checker/verifier return reason detected. Add consolidated remediation before continuing.',
     });
   }
+  if (targetPhase === 'execute' || targetPhase === 'verify' || targetPhase === 'human_gate') {
+    issues.push(...inspectWorkPackageDependencyPreflight(taskDir));
+  }
 
   return {
     ok: issues.length === 0,
@@ -177,6 +186,84 @@ export function preflightTask({ taskDir, targetPhase }) {
   };
 }
 
+function inspectWorkPackageDependencyPreflight(taskDir) {
+  const brief = readTaskFile(taskDir, 'brief.md');
+  const initiativeMatch = /-\s+Initiative:\s+`?([^`\n]+)`?/i.exec(brief);
+  const workPackageMatch = /-\s+Work package:\s+`?([^`\n]+)`?/i.exec(brief);
+  const initiativeId = initiativeMatch?.[1]?.trim();
+  const workPackageId = workPackageMatch?.[1]?.trim();
+  if (!initiativeId || !workPackageId) {
+    return [];
+  }
+
+  const initiativesRoot = resolveInitiativesRootForTask(taskDir);
+  const initiativeDir = path.join(initiativesRoot, initiativeId);
+  const workPackagePath = path.join(initiativeDir, 'work-packages', workPackageId, 'work-package.md');
+  if (!fs.existsSync(workPackagePath)) {
+    return [{
+      category: 'work_package_dependency',
+      message: `Task declares initiative work package ${initiativeId}/${workPackageId}, but its work-package.md was not found.`,
+    }];
+  }
+
+  const workPackage = fs.readFileSync(workPackagePath, 'utf8');
+  const dependencies = readWorkPackageDependsOn(workPackage);
+  const issues = [];
+  for (const dependencyId of dependencies) {
+    const dependencyPath = path.join(initiativeDir, 'work-packages', dependencyId, 'work-package.md');
+    if (!fs.existsSync(dependencyPath)) {
+      issues.push({
+        category: 'work_package_dependency',
+        message: `Work package ${workPackageId} depends on ${dependencyId}, but dependency work-package.md was not found.`,
+      });
+      continue;
+    }
+    const dependency = fs.readFileSync(dependencyPath, 'utf8');
+    const status = readInlineField(dependency, 'Status') || 'unknown';
+    if (!/^(done|complete|completed|verified|closed)$/i.test(status)) {
+      issues.push({
+        category: 'work_package_dependency',
+        message: `Work package ${workPackageId} depends on ${dependencyId}, but dependency status is ${status}; complete/verify it before Execute.`,
+      });
+    }
+  }
+  return issues;
+}
+
+function resolveInitiativesRootForTask(taskDir) {
+  const normalized = path.resolve(taskDir);
+  const parts = normalized.split(path.sep);
+  const tasksIndex = parts.lastIndexOf('tasks');
+  if (
+    tasksIndex >= 2
+    && parts[tasksIndex - 1] === 'agent-pipeline'
+    && parts[tasksIndex - 2] === 'ops'
+  ) {
+    return path.join(parts.slice(0, tasksIndex).join(path.sep) || path.sep, 'initiatives');
+  }
+  return projectContext.initiativesRoot || path.join(projectContext.pipelineRoot, 'initiatives');
+}
+
+function readWorkPackageDependsOn(content) {
+  const match = /^-\s+Depends on:\s*(.*)$/im.exec(content || '');
+  if (!match) {
+    return [];
+  }
+  return String(match[1] || '')
+    .split(/[,;]/)
+    .map((item) => item.trim())
+    .filter((item) => item && !/^\(?none\)?$/i.test(item) && !/^\[?fill in\]?$/i.test(item));
+}
+
+function readInlineField(content, field) {
+  const match = new RegExp(`^${escapeRegExp(field)}:\\s*(.*)$`, 'm').exec(content || '');
+  return match ? match[1].trim() : '';
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 export function transitionTaskManifest({ taskDir, targetPhase, now = new Date().toISOString() }) {
   const normalizedPhase = normalizePhase(targetPhase);
   const preflight = preflightTask({ taskDir, targetPhase: normalizedPhase });

package/bin/lib/task-manifest-utils.test.mjs

@@ -130,6 +130,74 @@ describe('task manifest utilities', () => {
     expect(result.manifest.mode).toBe('fast');
   });
 
+  it('blocks execute preflight when work-package dependencies are not completed', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ops-wp-deps-'));
+    tempDirs.push(root);
+    const taskDir = path.join(root, 'ops', 'agent-pipeline', 'tasks', 'TASK-002-import');
+    const initiativeDir = path.join(root, 'ops', 'agent-pipeline', 'initiatives', 'delivery-os-mvp');
+    fs.mkdirSync(path.join(initiativeDir, 'work-packages', 'WP-001-foundation'), { recursive: true });
+    fs.mkdirSync(path.join(initiativeDir, 'work-packages', 'WP-002-import'), { recursive: true });
+    fs.mkdirSync(taskDir, { recursive: true });
+    fs.writeFileSync(path.join(initiativeDir, 'work-packages', 'WP-001-foundation', 'work-package.md'), [
+      '# Work Package',
+      '',
+      'ID: WP-001-foundation',
+      'Status: in_progress',
+      '',
+    ].join('\n'));
+    fs.writeFileSync(path.join(initiativeDir, 'work-packages', 'WP-002-import', 'work-package.md'), [
+      '# Work Package',
+      '',
+      'ID: WP-002-import',
+      'Status: in_progress',
+      '',
+      '## Dependencies',
+      '',
+      '- Depends on: WP-001-foundation',
+      '',
+    ].join('\n'));
+    fs.writeFileSync(path.join(taskDir, 'brief.md'), [
+      '# Brief',
+      '',
+      '## Initiative Context',
+      '',
+      '- Initiative: `delivery-os-mvp`',
+      '- Work package: `WP-002-import`',
+      '',
+    ].join('\n'));
+    fs.writeFileSync(path.join(taskDir, 'research.md'), '# Research\n\n## Findings\n\n- `docs/example.md`\n');
+    fs.writeFileSync(path.join(taskDir, 'plan.md'), [
+      '# Plan',
+      '',
+      '## Risk tier and execution budget',
+      '',
+      '- Risk tier: `R1`',
+      '- Speed mode: `Fast`',
+      '- Approved execution target: docs/example.md only.',
+      '- Requires return to Plan/Check if: code changes are needed.',
+      '',
+      '## Verification ladder',
+      '',
+      '- Micro-verify during Execute: markdown review.',
+      '- Slice-verify before completion: self-test.',
+      '- External Verify required before closeout: no.',
+      '',
+      '## Затронутые модули и файлы',
+      '',
+      '- `docs/example.md`',
+      '',
+    ].join('\n'));
+    fs.writeFileSync(path.join(taskDir, 'status.md'), '# Status\n\n## Текущий этап\n\nplan\n');
+
+    const result = preflightTask({ taskDir, targetPhase: 'execute' });
+
+    expect(result.ok).toBe(false);
+    expect(result.issues).toContainEqual({
+      category: 'work_package_dependency',
+      message: 'Work package WP-002-import depends on WP-001-foundation, but dependency status is in_progress; complete/verify it before Execute.',
+    });
+  });
+
   it('blocks verify preflight when required execution evidence is missing', () => {
     const taskDir = createTask({
       plan: [

package/package.json

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

package/playbooks/source-sync-provider.md

@@ -4,6 +4,9 @@ Use this for sync/import/provider pipelines, raw records, retries, pagination, r
 
 - Plan must include `## Source Sync / Provider Gate`.
 - Name scope/provider window, idempotency or duplicate handling, retry/failure boundaries and coverage/parity evidence.
+- For import/manual-upload work, add `## Import / Ingestion Contract`: representative real fixtures when available (or an explicit no-real-fixtures reason), raw metadata extraction required by downstream work, and exact duplicate-import behavior.
+- Duplicate handling must name the dedupe key and action on repeat import: skip, link/reuse, update/upsert, reject/error, or report-only.
+- If raw source data contains speaker labels or similar downstream metadata, extraction should happen at import time unless explicitly deferred with a downstream reason.
 - Keep provider credentials, queue ownership and affected windows explicit.
 - Execution must include `## Source Sync / Provider Evidence`.
-- Acceptable evidence includes raw-record samples, counts/parity, replay/audit output, retry/idempotency checks and partial-failure recovery proof.
+- Acceptable evidence includes raw-record samples, representative fixture names, counts/parity, replay/audit output, retry/idempotency checks, duplicate-import results and partial-failure recovery proof.

package/prompts/checker.md

@@ -67,7 +67,7 @@ Project-specific context приходит только через task artifacts
 19. Для O2/O3 hot-path work план обязан содержать `## Optimization Strategy`: tier, hot paths, expected size, chosen efficient approach, anti-patterns avoided and bounded optimizer budget/stop rule. Checker должен блокировать weak strategy before Execute, но не требовать endless optimization: O2 = one focused review on touched hot paths; O3 = one focused review plus one representative measurement.
 20. Checker должен оценивать не только наличие UI/browser smoke path, а его результативность: смог бы этот сценарий поймать реальные ошибки пользователя, которые задача может породить?
 21. Если `checker-context-pack.md`, `task-manifest.json` или risk triggers показывают migrations/env vars/cron/workers/billing/auth/external APIs/deployment/runtime behavior, план обязан содержать `## Production Rollout Gate`: impact/blast radius, environment/deploy variables, rollback/disable path and post-deploy evidence.
-22. Если `checker-context-pack.md`, `task-manifest.json` или risk triggers показывают sync/import/provider/raw records/retries/pagination/rate limits/idempotency/replay/backfill/partial failure, план обязан содержать `## Source Sync / Provider Gate`: scope/provider window, idempotency, failure handling/retry boundaries and coverage/parity evidence.
+22. Если `checker-context-pack.md`, `task-manifest.json` или risk triggers показывают sync/import/provider/raw records/retries/pagination/rate limits/idempotency/replay/backfill/partial failure, план обязан содержать `## Source Sync / Provider Gate`: scope/provider window, idempotency with dedupe key and duplicate action, failure handling/retry boundaries and coverage/parity evidence. Для import/manual-upload/transcript/evidence-capture задач план также обязан содержать `## Import / Ingestion Contract`: real representative fixtures when available or explicit no-real-fixtures reason, raw metadata/speaker-label extraction needed downstream, and repeat-import policy. Размытое "duplicates detected or reported" без skip/link/update/reject/report-only semantics недостаточно.
 23. Если `task-manifest.json.loopDetector.requiresConsolidatedRemediation=true`, Checker должен блокировать повторный мелкий loop, пока plan/check-resolution не содержит consolidated remediation секцию, которая объединяет repeated reasons.
 24. Если `llmInputPolicy.mode` не `strict` и отсутствующий full artifact реально нужен для честной оценки, verdict должен быть `context_insufficient`. Не используй `context_insufficient`, если deterministic gate уже явно показывает `return_to_plan`.