ultra-builder-pro-cli 0.24.0 → 0.24.2

package/hooks/health_check.py

@@ -73,26 +73,31 @@ def inspect(root: Path) -> dict:
 
             envelope = context.get("envelope", {}) if context else {}
             diagnostics = envelope.get("diagnostics", {})
-            baseline_codes = [
+            baseline_blockers = [
                 str(item.get("code"))
                 for item in [
                     *diagnostics.get("needs_attention", []),
-                    *diagnostics.get("warnings", []),
                     *diagnostics.get("hard_conflicts", []),
                 ]
                 if str(item.get("code", "")).startswith("BASELINE_")
             ]
+            baseline_warnings = [
+                str(item.get("code"))
+                for item in diagnostics.get("warnings", [])
+                if str(item.get("code", "")).startswith("BASELINE_")
+            ]
             baseline = envelope.get("baseline")
             baseline_is_ready = isinstance(baseline, dict) and baseline.get("status") == "ready"
             baseline_status = (
-                "fail" if baseline_codes and baseline_is_ready
-                else "warning" if baseline_codes
+                "fail" if baseline_blockers and baseline_is_ready
+                else "warning" if baseline_blockers or baseline_warnings
                 else "pass"
             )
             report["checks"]["baseline"] = {
                 "baseline": baseline,
-                "blockers": baseline_codes,
-                "readiness": "blocked" if baseline_codes else "ready",
+                "blockers": baseline_blockers,
+                "warnings": baseline_warnings,
+                "readiness": "blocked" if baseline_blockers else "ready",
                 "status": baseline_status,
             }
             if baseline_status == "fail":

package/mcp-server/lib/artifact-registry.cjs

@@ -473,6 +473,13 @@ function invalidateConsumersFromEndpointInTx(db, start, {
     const key = endpointKey(endpoint);
     if (seen.has(key) || excluded.has(key) || key === endpointKey(start)) continue;
     seen.add(key);
+    if (endpoint.type === 'workflow') {
+      // Workflow rows are retained only as pre-v0.24 audit history. Preserve
+      // graph traversal for downstream current authorities, but never rewrite
+      // the historical workflow row or claim that it was invalidated.
+      queue.push(...outgoingEdges(db, endpoint));
+      continue;
+    }
     invalidated.push({ type: endpoint.type, id: endpoint.id });
     if (endpoint.type === 'artifact') {
       const row = db.prepare('SELECT status FROM artifacts WHERE id = ?').get(endpoint.id);
@@ -503,62 +510,6 @@ function invalidateConsumersFromEndpointInTx(db, start, {
         });
       }
     }
-    if (endpoint.type === 'workflow') {
-      const row = db.prepare(
-        'SELECT status, metadata_json, change_id, task_id FROM workflow_runs WHERE id = ?',
-      ).get(endpoint.id);
-      if (row) {
-        const metadata = parseJson(row.metadata_json, {});
-        if (['active', 'blocked', 'ready'].includes(row.status)) {
-          delete metadata.authority_invalidation;
-          metadata.draft_dirty = true;
-          db.prepare(
-            `UPDATE workflow_runs
-             SET status = CASE WHEN status = 'ready' THEN 'active' ELSE status END,
-                 metadata_json = ?,
-                 updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
-             WHERE id = ?`,
-          ).run(JSON.stringify(metadata), endpoint.id);
-          ops.appendEventInTx(db, {
-            type: 'workflow_draft_changed',
-            change_id: row.change_id,
-            task_id: row.task_id,
-            payload: {
-              workflow_id: endpoint.id,
-              source_type: start.type,
-              source_id: start.id,
-              reason,
-            },
-          });
-          queue.push(...outgoingEdges(db, endpoint));
-          continue;
-        }
-        if (metadata.authority_invalidation?.invalidated !== true) {
-          metadata.authority_invalidation = {
-            invalidated: true,
-            source_type: start.type,
-            source_id: start.id,
-            reason,
-            invalidated_at: new Date().toISOString(),
-          };
-          db.prepare(
-            `UPDATE workflow_runs SET metadata_json = ?,
-             updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?`,
-          ).run(JSON.stringify(metadata), endpoint.id);
-          ops.appendEventInTx(db, {
-            type: 'workflow_invalidated',
-            change_id: row.change_id,
-            task_id: row.task_id,
-            payload: {
-              workflow_id: endpoint.id,
-              source_type: start.type,
-              source_id: start.id,
-              reason,
-            },
-          });
-        }
-      }
-    }
     queue.push(...outgoingEdges(db, endpoint));
   }
   return invalidated;

package/mcp-server/lib/baseline-workflow.cjs

@@ -660,27 +660,10 @@ function storedReadyInvariantBlockers(baseline) {
   if (!Array.isArray(baseline.scope) || baseline.scope.length === 0) {
     blockers.push('BASELINE_SCOPE_MISSING');
   }
-  if (Array.isArray(baseline.spec_refs)) {
-    for (const kind of ['discovery', 'product', 'architecture']) {
-      if (!baseline.spec_refs.some((item) => item?.kind === kind)) {
-        blockers.push(`BASELINE_SPEC_MISSING:${kind}`);
-      }
-    }
-  }
-  if (!Array.isArray(baseline.evidence) || baseline.evidence.length === 0) {
-    blockers.push('BASELINE_EVIDENCE_MISSING');
-  } else if (baseline.mode === 'brownfield'
-    && !baseline.evidence.some((item) => item?.kind === 'source')) {
-    blockers.push('BASELINE_SOURCE_EVIDENCE_MISSING');
-  }
-  if (!Array.isArray(baseline.verification) || baseline.verification.length === 0) {
-    blockers.push('BASELINE_VERIFICATION_MISSING');
-  } else {
+  if (Array.isArray(baseline.verification)) {
     for (const item of baseline.verification) {
       if (!item || typeof item !== 'object') {
         blockers.push('BASELINE_STATE_INVALID:verification');
-      } else if (item.status === 'not_run') {
-        blockers.push(`BASELINE_VERIFICATION_NOT_RUN:${item.name || 'unknown'}`);
       } else if (item.status === 'known_red') {
         if (!String(item.rationale || '').trim()) {
           blockers.push(`BASELINE_KNOWN_RED_RATIONALE_MISSING:${item.name || 'unknown'}`);
@@ -688,7 +671,7 @@ function storedReadyInvariantBlockers(baseline) {
         if (!baseline.known_red_accepted) {
           blockers.push(`BASELINE_KNOWN_RED_NOT_ACCEPTED:${item.name || 'unknown'}`);
         }
-      } else if (item.status !== 'pass') {
+      } else if (!['pass', 'not_run'].includes(item.status)) {
         blockers.push(`BASELINE_VERIFICATION_STATUS_INVALID:${item.name || 'unknown'}`);
       }
     }
@@ -697,25 +680,54 @@ function storedReadyInvariantBlockers(baseline) {
     blockers.push('BASELINE_REVISION_MISSING');
   }
   if (!String(baseline.approved_by || '').trim()) blockers.push('BASELINE_APPROVER_MISSING');
-  if (String(baseline.approval_note || '').trim().length < 3) {
+  if (!String(baseline.approval_note || '').trim()) {
     blockers.push('BASELINE_APPROVAL_NOTE_MISSING');
   }
   if (!baseline.converged_at || Number.isNaN(Date.parse(baseline.converged_at))) {
     blockers.push('BASELINE_CONVERGENCE_TIMESTAMP_MISSING');
   }
+  return [...new Set(blockers)];
+}
+
+function storedReadySemanticWarnings(baseline) {
+  const warnings = [];
+  if (Array.isArray(baseline.spec_refs)) {
+    for (const kind of ['discovery', 'product', 'architecture']) {
+      if (!baseline.spec_refs.some((item) => item?.kind === kind)) {
+        warnings.push(`BASELINE_SPEC_MISSING:${kind}`);
+      }
+    }
+  }
+  if (Array.isArray(baseline.evidence) && baseline.evidence.length === 0) {
+    warnings.push('BASELINE_EVIDENCE_MISSING');
+  }
+  if (baseline.mode === 'brownfield'
+    && Array.isArray(baseline.evidence)
+    && !baseline.evidence.some((item) => item?.kind === 'source')) {
+    warnings.push('BASELINE_SOURCE_EVIDENCE_MISSING');
+  }
+  if (Array.isArray(baseline.verification) && baseline.verification.length === 0) {
+    warnings.push('BASELINE_VERIFICATION_MISSING');
+  } else if (Array.isArray(baseline.verification)) {
+    for (const item of baseline.verification) {
+      if (item?.status === 'not_run') {
+        warnings.push(`BASELINE_VERIFICATION_NOT_RUN:${item.name || 'unknown'}`);
+      }
+    }
+  }
   if (Array.isArray(baseline.unknowns)) {
     for (const item of baseline.unknowns.filter((unknown) => unknown?.blocking === true)) {
-      blockers.push(`BASELINE_UNKNOWN_BLOCKING:${item.summary || 'unknown'}`);
+      warnings.push(`BASELINE_UNKNOWN_RECORDED:${item.summary || 'unknown'}`);
     }
   }
   if (Array.isArray(baseline.gaps)) {
     for (const gap of baseline.gaps.filter((item) => (
       item?.status === 'open' && item?.blocking === true
     ))) {
-      blockers.push(`BASELINE_GAP_BLOCKING:${gap.id || 'unknown'}`);
+      warnings.push(`BASELINE_GAP_RECORDED:${gap.id || 'unknown'}`);
     }
   }
-  return [...new Set(blockers)];
+  return [...new Set(warnings)];
 }
 
 function acceptedBaselineResearch(db, baseline) {
@@ -736,7 +748,7 @@ function convergenceResearchBlockers(db, baseline) {
 function storedResearchHealth(db, baseline) {
   const checkpointId = baseline.research_checkpoint_id || baseline.research_run_id;
   if (!checkpointId) {
-    return { blockers: ['BASELINE_RESEARCH_PROVENANCE_MISSING'], warnings: [] };
+    return { blockers: [], warnings: ['BASELINE_RESEARCH_PROVENANCE_MISSING'] };
   }
   let checkpoint;
   try {
@@ -751,10 +763,19 @@ function storedResearchHealth(db, baseline) {
       || checkpoint.stage !== 'research'
       || checkpoint.scope_type !== 'baseline'
       || checkpoint.scope_id !== baseline.id
-      || checkpoint.status !== 'accepted'
       || checkpoints.checkpointDigest(checkpoint) !== checkpoint.digest) {
     return { blockers: ['BASELINE_RESEARCH_RECORD_INVALID'], warnings: [] };
   }
+  if (checkpoint.status !== 'accepted') {
+    return {
+      blockers: [],
+      warnings: [
+        checkpoint.status === 'superseded'
+          ? 'BASELINE_RESEARCH_SUPERSEDED'
+          : `BASELINE_RESEARCH_NOT_ACCEPTED:${checkpoint.status}`,
+      ],
+    };
+  }
   return { blockers: [], warnings: checkpoint.diagnostics || [] };
 }
 
@@ -774,10 +795,6 @@ function convergenceBlockers(db, baseline, input, rootDir) {
   if (baseline.repository_branch && snapshot.branch
     && baseline.repository_branch !== snapshot.branch) blockers.add('BASELINE_BRANCH_STALE');
   if (!Array.isArray(baseline.scope) || baseline.scope.length === 0) blockers.add('BASELINE_SCOPE_MISSING');
-  for (const kind of ['discovery', 'product', 'architecture']) {
-    if (!baseline.spec_refs.some((ref) => ref.kind === kind)) blockers.add(`BASELINE_SPEC_MISSING:${kind}`);
-  }
-  for (const blocker of convergenceResearchBlockers(db, baseline)) blockers.add(blocker);
   for (const blocker of storedSpecBlockers(baseline, rootDir)) blockers.add(blocker);
   for (const blocker of storedEvidenceBlockers(baseline, rootDir)) blockers.add(blocker);
   for (const blocker of storedScopeBlockers(baseline, rootDir)) blockers.add(blocker);
@@ -788,29 +805,23 @@ function convergenceBlockers(db, baseline, input, rootDir) {
   if (baseline.worktree_state === 'dirty' && input.accept_dirty_worktree !== true) {
     blockers.add('BASELINE_DIRTY_WORKTREE_NOT_ACCEPTED');
   }
-  if (baseline.evidence.length === 0) blockers.add('BASELINE_EVIDENCE_MISSING');
-  if (baseline.mode === 'brownfield' && !baseline.evidence.some((item) => item.kind === 'source')) {
-    blockers.add('BASELINE_SOURCE_EVIDENCE_MISSING');
-  }
-  if (baseline.verification.length === 0) blockers.add('BASELINE_VERIFICATION_MISSING');
   for (const item of baseline.verification) {
-    if (item.status === 'not_run') blockers.add(`BASELINE_VERIFICATION_NOT_RUN:${item.name}`);
     if (item.status === 'known_red') {
       if (input.accept_known_red !== true) blockers.add(`BASELINE_KNOWN_RED_NOT_ACCEPTED:${item.name}`);
       if (!item.rationale) blockers.add(`BASELINE_KNOWN_RED_RATIONALE_MISSING:${item.name}`);
     }
   }
-  for (const item of baseline.unknowns.filter((unknown) => unknown.blocking)) {
-    blockers.add(`BASELINE_UNKNOWN_BLOCKING:${item.summary}`);
-  }
-  for (const gap of baseline.gaps.filter((item) => item.status === 'open' && item.blocking)) {
-    blockers.add(`BASELINE_GAP_BLOCKING:${gap.id}`);
-  }
   if (!String(input.approved_by || '').trim()) blockers.add('BASELINE_APPROVER_REQUIRED');
-  if (String(input.approval_note || '').trim().length < 3) blockers.add('BASELINE_APPROVAL_NOTE_REQUIRED');
+  if (!String(input.approval_note || '').trim()) blockers.add('BASELINE_APPROVAL_NOTE_REQUIRED');
   return [...blockers].sort();
 }
 
+function convergenceWarnings(db, baseline) {
+  const warnings = new Set(storedReadySemanticWarnings(baseline));
+  for (const warning of convergenceResearchBlockers(db, baseline)) warnings.add(warning);
+  return [...warnings].sort();
+}
+
 function convergeBaseline(db, input = {}, { rootDir = process.cwd(), emitEvent = true } = {}) {
   const current = readBaseline(db, input.id);
   if (!current) throw new BaselineWorkflowError('BASELINE_NOT_FOUND', `baseline ${input.id} not found`);
@@ -818,6 +829,7 @@ function convergeBaseline(db, input = {}, { rootDir = process.cwd(), emitEvent =
     throw new BaselineWorkflowError('BASELINE_NOT_CONVERGEABLE', `baseline ${current.id} is ${current.status}`);
   }
   const blockers = convergenceBlockers(db, current, input, rootDir);
+  const warnings = convergenceWarnings(db, current);
   const ts = nowIso();
   if (blockers.length > 0) {
     ops.tx(db, () => {
@@ -829,7 +841,13 @@ function convergeBaseline(db, input = {}, { rootDir = process.cwd(), emitEvent =
         });
       }
     });
-    return { ready: false, status: 'blocked', blockers, baseline: readBaseline(db, current.id) };
+    return {
+      ready: false,
+      status: 'blocked',
+      blockers,
+      warnings,
+      baseline: readBaseline(db, current.id),
+    };
   }
   const research = acceptedBaselineResearch(db, current);
   ops.tx(db, () => {
@@ -841,7 +859,7 @@ function convergeBaseline(db, input = {}, { rootDir = process.cwd(), emitEvent =
     ).run(
       String(input.approved_by).trim(), String(input.approval_note).trim(),
       input.accept_dirty_worktree === true ? 1 : 0,
-      input.accept_known_red === true ? 1 : 0, research.id, ts, ts, current.id,
+      input.accept_known_red === true ? 1 : 0, research?.id || null, ts, ts, current.id,
     );
     if (emitEvent) {
       ops.appendEventInTx(db, {
@@ -849,7 +867,13 @@ function convergeBaseline(db, input = {}, { rootDir = process.cwd(), emitEvent =
       });
     }
   });
-  return { ready: true, status: 'ready', blockers: [], baseline: readBaseline(db, current.id) };
+  return {
+    ready: true,
+    status: 'ready',
+    blockers: [],
+    warnings,
+    baseline: readBaseline(db, current.id),
+  };
 }
 
 function inspectBaseline(db, { rootDir = process.cwd(), id } = {}) {
@@ -880,6 +904,10 @@ function inspectBaseline(db, { rootDir = process.cwd(), id } = {}) {
     ...(Array.isArray(baseline.evidence) ? storedEvidenceBlockers(baseline, rootDir) : []),
     ...research.blockers,
   ];
+  const warnings = [
+    ...storedReadySemanticWarnings(baseline),
+    ...research.warnings,
+  ];
   const snapshot = gitWorktreeSnapshot(
     rootDir, Array.isArray(baseline.scope) && baseline.scope.length > 0 ? baseline.scope : ['.'],
   );
@@ -909,7 +937,7 @@ function inspectBaseline(db, { rootDir = process.cwd(), id } = {}) {
   }
   return {
     status: blockers.length === 0 ? 'pass' : 'fail', blockers: [...new Set(blockers)].sort(),
-    warnings: research.warnings, baseline,
+    warnings: [...new Set(warnings)], baseline,
   };
 }
 

package/mcp-server/lib/change-authority.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+function parseJson(value, fallback = {}) {
+  if (typeof value !== 'string' || !value.trim()) return fallback;
+  try { return JSON.parse(value); } catch { return fallback; }
+}
+
+function changeStateDigest(change) {
+  if (!change) return null;
+  const payload = {
+    id: change.id,
+    kind: change.kind,
+    intent: change.intent,
+    docs_impact: change.docs_impact || parseJson(change.docs_impact_json, {}),
+    provider_refs: change.provider_refs || parseJson(change.provider_refs_json, {}),
+    contract: change.contract || parseJson(change.contract_json, {}),
+    classification: change.classification || parseJson(change.classification_json, {}),
+    research_disposition: change.research_disposition
+      || parseJson(change.research_disposition_json, {}),
+  };
+  return crypto.createHash('sha256').update(JSON.stringify(payload)).digest('hex');
+}
+
+module.exports = { changeStateDigest };

package/mcp-server/lib/change-packet.cjs

@@ -77,25 +77,8 @@ function requireInside(rootDir, relative, prefix, field) {
   return resolved;
 }
 
-function latestWorkflowConsumer(db, changeId) {
-  const row = db.prepare(
-    `SELECT id FROM workflow_runs
-     WHERE change_id = ?
-     ORDER BY CASE
-       WHEN status IN ('active', 'blocked', 'ready') THEN 0
-       WHEN status = 'completed' THEN 1
-       ELSE 2 END,
-       CASE kind WHEN 'deliver' THEN 0 WHEN 'plan' THEN 1 WHEN 'research' THEN 2 ELSE 3 END,
-       updated_at DESC, rowid DESC
-     LIMIT 1`,
-  ).get(changeId);
-  if (!row) {
-    throw new ChangePacketError(
-      'ARTIFACT_CONSUMER_MISSING',
-      `change ${changeId} has no workflow consumer`,
-    );
-  }
-  return { type: 'workflow', id: row.id, relation: 'consumed_by' };
+function deliveryConsumer() {
+  return { type: 'external', id: 'ultra-deliver', relation: 'consumed_by' };
 }
 
 function readCurrentArtifact(db, changeId, kind) {
@@ -118,17 +101,6 @@ function exactBaselineAnchor(db, change, input) {
       'typed Change delta requires one approved ready baseline',
     );
   }
-  const changeRun = db.prepare(
-    `SELECT baseline_id FROM workflow_runs
-     WHERE kind = 'change' AND change_id = ?
-     ORDER BY started_at DESC, rowid DESC LIMIT 1`,
-  ).get(change.id);
-  if (!changeRun || changeRun.baseline_id !== baseline.id) {
-    throw new ChangePacketError(
-      'CHANGE_BASELINE_AUTHORITY_MISMATCH',
-      `change ${change.id} is not bound to baseline ${baseline.id}`,
-    );
-  }
   const anchor = input.baseline_anchor;
   if (!anchor || anchor.baseline_id !== baseline.id
     || (anchor.repository_revision || null) !== (baseline.repository_revision || null)) {
@@ -371,7 +343,7 @@ function recordDelta(db, change, input, { rootDir = process.cwd() } = {}) {
   let rollbackProgress = null;
   try {
     const result = ops.tx(db, () => {
-      const consumer = latestWorkflowConsumer(db, change.id);
+      const consumer = deliveryConsumer();
       const payloads = delta.mutations.map((mutation) => (
         artifacts.recordArtifactInTx(db, {
           id: `change-${change.id}-delta-${mutation.id}`,
@@ -578,7 +550,7 @@ function recordDocumentationReconciliation(
   let rollbackProgress = null;
   try {
     return ops.tx(db, () => {
-      const fallbackConsumer = latestWorkflowConsumer(db, change.id);
+      const fallbackConsumer = deliveryConsumer();
       const payloads = normalized.reconciliation.documents.map((document, index) => (
         artifacts.recordArtifactInTx(db, {
           id: `change-${change.id}-documentation-${index + 1}`,