ultra-builder-pro-cli 0.23.0 → 0.24.0

package/hooks/workflow_resume.py

@@ -1,16 +1,16 @@
 #!/usr/bin/env python3
-"""Re-inject live DB authority after compaction; checkpoints are advisory only."""
+"""Re-inject the live Context Envelope after compaction; checkpoints are advisory."""
 
 import json
 import sys
 from datetime import datetime
 from pathlib import Path
 
-from context_spine import (
-    ContextSpineError,
+from context_envelope import (
+    ContextEnvelopeError,
     find_root_for_hook,
-    read_breadcrumb,
-    render_breadcrumb,
+    read_context_envelope,
+    render_context_envelope,
 )
 
 
@@ -35,10 +35,11 @@ def _checkpoint_advisory(root: Path):
         return None
     if (
         not isinstance(value, dict)
-        or value.get("schema") != 2
-        or not isinstance(value.get("breadcrumb"), dict)
+        or value.get("schema") != 3
+        or not isinstance(value.get("context"), dict)
         or not isinstance(value.get("rendered"), str)
         or not value["rendered"].strip()
+        or value.get("context_digest") != value["context"].get("digest")
     ):
         print(f"[workflow_resume] invalid checkpoint schema in {file}", file=sys.stderr)
         return None
@@ -46,7 +47,7 @@ def _checkpoint_advisory(root: Path):
         "[Ultra checkpoint advisory]",
         "Live .ultra/.runtime/state.db could not be read; this checkpoint is not authority.",
         value["rendered"],
-        "Run ultra-doctor before mutation.",
+        "Run ultra.doctor before mutation.",
     ])
 
 
@@ -66,11 +67,11 @@ def main() -> None:
         return
     text = None
     try:
-        breadcrumb = read_breadcrumb(root)
-        if breadcrumb and breadcrumb.get("workflow"):
-            text = render_breadcrumb(root, breadcrumb)
-    except ContextSpineError as exc:
-        print(f"[workflow_resume] cannot inspect Context Spine: {exc}", file=sys.stderr)
+        envelope = read_context_envelope(root)
+        if envelope:
+            text = render_context_envelope(root, envelope)
+    except ContextEnvelopeError as exc:
+        print(f"[workflow_resume] cannot inspect Context Envelope: {exc}", file=sys.stderr)
         text = _checkpoint_advisory(root)
     if not text:
         print(json.dumps({}))

package/mcp-server/{breadcrumb.cjs → hook-context.cjs}

@@ -13,18 +13,16 @@ function main() {
   const requested = path.resolve(process.argv[discover ? 3 : 2] || process.cwd());
   const rootDir = discover ? runtime.findProjectRoot(requested) : requested;
   if (!rootDir) {
-    process.stdout.write(`${JSON.stringify({
-      root: null,
-      breadcrumb: null,
-      text: null,
-    })}\n`);
+    process.stdout.write(`${JSON.stringify({ root: null, context: null, text: null })}\n`);
     return;
   }
-  const breadcrumb = runtime.readProjectBreadcrumb(rootDir);
+  const context = runtime.readProjectContextEnvelope(rootDir, {
+    runtime: process.env.UBP_HOOK_RUNTIME || 'hook',
+  });
   process.stdout.write(`${JSON.stringify({
     root: rootDir,
-    breadcrumb,
-    text: breadcrumb ? runtime.renderProjectBreadcrumb(rootDir, breadcrumb) : null,
+    context,
+    text: context ? runtime.renderProjectContextEnvelope(rootDir, context) : null,
   })}\n`);
 }
 
@@ -32,7 +30,7 @@ if (require.main === module) {
   try {
     main();
   } catch (error) {
-    process.stderr.write(`${error.code || 'BREADCRUMB_FAILED'}: ${error.message}\n`);
+    process.stderr.write(`${error.code || 'CONTEXT_ENVELOPE_FAILED'}: ${error.message}\n`);
     process.exitCode = 2;
   }
 }

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

@@ -7,7 +7,7 @@ const { spawnSync } = require('node:child_process');
 
 const ops = require('./state-ops.cjs');
 const providerRefs = require('./provider-refs.cjs');
-const workflows = require('./workflow-state.cjs');
+const checkpoints = require('./stage-checkpoints.cjs');
 
 const BASELINE_ID = /^[a-zA-Z0-9_-]+$/;
 const MODES = new Set(['greenfield', 'brownfield']);
@@ -718,47 +718,44 @@ function storedReadyInvariantBlockers(baseline) {
   return [...new Set(blockers)];
 }
 
-function completedBaselineResearch(db, baseline, rootDir) {
-  const acceptedMode = baseline.mode === 'greenfield' ? 'full' : 'adoption';
-  const rows = db.prepare(
-    `SELECT id FROM workflow_runs
-     WHERE kind = 'research' AND baseline_id = ? AND mode = ? AND status = 'completed'
-     ORDER BY completed_at DESC, rowid DESC`,
-  ).all(baseline.id, acceptedMode);
-  const row = rows.find((candidate) => workflows.isConsumableWorkflowAuthority(
-    workflows.readWorkflow(db, candidate.id, { rootDir }),
-  ));
-  return row ? workflows.readWorkflow(db, row.id, { rootDir }) : null;
+function acceptedBaselineResearch(db, baseline) {
+  return checkpoints.currentCheckpoint(
+    db,
+    'research',
+    { baseline_id: baseline.id },
+    { includeDraft: false },
+  );
 }
 
-function convergenceResearchBlockers(db, baseline, rootDir) {
-  const run = completedBaselineResearch(db, baseline, rootDir);
-  if (!run) return ['BASELINE_RESEARCH_INCOMPLETE'];
-  return run.artifact_health.blockers.map((item) => `BASELINE_RESEARCH_${item}`);
+function convergenceResearchBlockers(db, baseline) {
+  const checkpoint = acceptedBaselineResearch(db, baseline);
+  if (!checkpoint) return ['BASELINE_RESEARCH_INCOMPLETE'];
+  return [];
 }
 
-function storedResearchHealth(db, baseline, rootDir) {
-  if (!baseline.research_run_id) {
+function storedResearchHealth(db, baseline) {
+  const checkpointId = baseline.research_checkpoint_id || baseline.research_run_id;
+  if (!checkpointId) {
     return { blockers: ['BASELINE_RESEARCH_PROVENANCE_MISSING'], warnings: [] };
   }
-  const run = workflows.readWorkflow(db, baseline.research_run_id, { rootDir });
-  if (!run || run.kind !== 'research' || run.status !== 'completed') {
+  let checkpoint;
+  try {
+    checkpoint = checkpoints.readCheckpoint(db, checkpointId);
+  } catch (error) {
+    if (error?.code === 'CHECKPOINT_DIGEST_MISMATCH') {
+      return { blockers: ['BASELINE_RESEARCH_RECORD_INVALID'], warnings: [] };
+    }
+    throw error;
+  }
+  if (!checkpoint
+      || 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: [] };
   }
-  const livingSpecifications = new Set(
-    (Array.isArray(baseline.spec_refs) ? baseline.spec_refs : [])
-      .map((item) => item?.path).filter(Boolean),
-  );
-  const blockers = run.artifact_health.blockers.filter((item) => {
-    const separator = item.indexOf(':');
-    if (separator < 0) return true;
-    const artifactPath = item.slice(separator + 1);
-    return !livingSpecifications.has(artifactPath);
-  });
-  return {
-    blockers: blockers.map((item) => `BASELINE_RESEARCH_${item}`),
-    warnings: [],
-  };
+  return { blockers: [], warnings: checkpoint.diagnostics || [] };
 }
 
 function convergenceBlockers(db, baseline, input, rootDir) {
@@ -780,7 +777,7 @@ function convergenceBlockers(db, baseline, input, rootDir) {
   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, rootDir)) blockers.add(blocker);
+  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);
@@ -834,11 +831,12 @@ function convergeBaseline(db, input = {}, { rootDir = process.cwd(), emitEvent =
     });
     return { ready: false, status: 'blocked', blockers, baseline: readBaseline(db, current.id) };
   }
-  const research = completedBaselineResearch(db, current, rootDir);
+  const research = acceptedBaselineResearch(db, current);
   ops.tx(db, () => {
     db.prepare(
       `UPDATE baselines SET status = 'ready', approved_by = ?, approval_note = ?,
-       worktree_accepted = ?, known_red_accepted = ?, research_run_id = ?,
+       worktree_accepted = ?, known_red_accepted = ?, research_checkpoint_id = ?,
+       research_run_id = NULL,
        converged_at = ?, updated_at = ? WHERE id = ?`,
     ).run(
       String(input.approved_by).trim(), String(input.approval_note).trim(),
@@ -874,7 +872,7 @@ function inspectBaseline(db, { rootDir = process.cwd(), id } = {}) {
       status: 'fail', blockers: [`BASELINE_NOT_READY:${baseline.status}`], warnings: [], baseline,
     };
   }
-  const research = storedResearchHealth(db, baseline, rootDir);
+  const research = storedResearchHealth(db, baseline);
   const blockers = [
     ...storedReadyInvariantBlockers(baseline),
     ...(Array.isArray(baseline.scope) ? storedScopeBlockers(baseline, rootDir) : []),

package/mcp-server/lib/canonical-json.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map(
+      (key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`,
+    ).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function digest(value) {
+  return crypto.createHash('sha256').update(canonicalJson(value)).digest('hex');
+}
+
+module.exports = { canonicalJson, digest };