ultra-builder-pro-cli 0.24.0 → 0.24.1

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-workflow.cjs

@@ -9,6 +9,7 @@ const Ajv = require('ajv/dist/2020');
 const ops = require('./state-ops.cjs');
 const artifacts = require('./artifact-registry.cjs');
 const canonical = require('./canonical-json.cjs');
+const changeAuthority = require('./change-authority.cjs');
 const { writeManagedFile } = require('./managed-file-write.cjs');
 const providerRefs = require('./provider-refs.cjs');
 const baselines = require('./baseline-workflow.cjs');
@@ -30,10 +31,6 @@ function loadLegacyModule(filename) {
   return module.require(path.join(__dirname, filename));
 }
 
-function legacyContextSpine() {
-  return loadLegacyModule('context-spine.cjs');
-}
-
 function legacySpecLearning() {
   return loadLegacyModule('spec-learning.cjs');
 }
@@ -46,6 +43,10 @@ function legacyDecisions() {
   return loadLegacyModule('decision-dialogue.cjs');
 }
 
+function legacyContextSpine() {
+  return loadLegacyModule('context-spine.cjs');
+}
+
 const CHANGE_ID = /^[a-zA-Z0-9_-]+$/;
 const CHANGE_PATCH_FIELDS = new Set([
   'title', 'intent', 'status', 'docs_impact', 'provider_refs',
@@ -1191,8 +1192,8 @@ function updateChange(db, id, patch = {}, {
       const semanticFields = Object.keys(patch)
         .filter((field) => SEMANTIC_AUTHORITY_FIELDS.has(field));
       if (semanticFields.length > 0
-        && legacyContextSpine().changeStateDigest(current)
-          !== legacyContextSpine().changeStateDigest(updated)) {
+        && changeAuthority.changeStateDigest(current)
+          !== changeAuthority.changeStateDigest(updated)) {
         invalidated.push(...artifacts.invalidateConsumersFromEndpointInTx(
           db,
           { type: 'change', id },
@@ -1354,6 +1355,60 @@ function generatePacketReconciliation(db, change, packet, rootDir) {
   }
 }
 
+function generateCallerNoChangeReconciliation(db, change, input, rootDir) {
+  const baseline = baselines.readBaseline(db);
+  const manifest = {
+    $schema: 'ultra-baseline-reconciliation-v1',
+    change_id: change.id,
+    baseline_id: baseline?.id || null,
+    baseline_updates: [],
+    semantic_changes: [],
+    semantic_no_change_reason: String(input.no_baseline_change_reason).trim(),
+    resolved_gap_ids: [],
+    resolved_unknowns: [],
+    verification: [{
+      name: 'explicit archive handoff',
+      command: 'ultra.archive',
+      status: 'pass',
+      evidence: String(input.summary).trim(),
+    }],
+  };
+  const relative = `${change.artifact_root}/baseline-reconciliation.json`;
+  const serialized = `${JSON.stringify(manifest, null, 2)}\n`;
+  const file = safeRelativePath(rootDir, relative);
+  const previous = fs.existsSync(file) ? fs.readFileSync(file) : null;
+  const published = writeManagedFile(rootDir, relative, Buffer.from(serialized));
+  try {
+    const recorded = artifacts.recordArtifact(db, {
+      id: `${change.id}-baseline-reconciliation`,
+      owner_type: 'change',
+      owner_id: change.id,
+      kind: 'baseline_reconciliation',
+      path: relative,
+      content_digest: published.digest,
+      source_refs: [],
+      consumer_refs: [],
+      provenance: { writer: 'ultra.archive', generated: true },
+      metadata: {
+        terminal_role: true,
+        schema: manifest.$schema,
+        caller_declared: true,
+      },
+    }, { rootDir }).artifact;
+    return {
+      manifest,
+      relative,
+      file,
+      digest: recorded.digest,
+      artifact: recorded,
+    };
+  } catch (error) {
+    if (previous === null) fs.rmSync(file, { force: true });
+    else fs.writeFileSync(file, previous);
+    throw error;
+  }
+}
+
 function baselineConvergenceBlockers(db, change, rootDir) {
   const baselineHealth = baselines.inspectBaseline(db, { rootDir });
   return legacyContextSpine().baselineGateForChange(db, change, baselineHealth).blockers;
@@ -2487,35 +2542,6 @@ function archiveChange(db, input, {
   }
 
   let packet = null;
-  if (kernelMode) {
-    const requiredStages = ['plan', 'test', 'review', 'deliver'];
-    const missing = requiredStages.filter((stage) => !stageCheckpoints.currentCheckpoint(
-      db,
-      stage,
-      { change_id: change.id },
-      { includeDraft: false },
-    ));
-    const tasks = ops.listTasks(db, { change_id: change.id });
-    if (tasks.length === 0) missing.push('tasks');
-    for (const task of tasks.filter((item) => item.status !== 'expanded')) {
-      if (task.status !== 'completed') missing.push(`task:${task.id}:completed`);
-      if (!stageCheckpoints.currentCheckpoint(
-        db,
-        'dev',
-        { task_id: task.id },
-        { includeDraft: false },
-      )) {
-        missing.push(`task:${task.id}:dev`);
-      }
-    }
-    if (missing.length > 0) {
-      throw new ChangeWorkflowError(
-        'CHANGE_EVIDENCE_INCOMPLETE',
-        `change ${change.id} lacks accepted delivery checkpoints`,
-        { missing },
-      );
-    }
-  }
   if (changePacket.readDeltaAuthority(db, change.id)) {
     if (!kernelMode) {
       legacyWorkflows().validateDeliveryPrerequisites(
@@ -2553,7 +2579,14 @@ function archiveChange(db, input, {
 
   const reconciliation = packet
     ? generatePacketReconciliation(db, change, packet, rootDir)
-    : readReconciliationManifest(db, change, input, rootDir);
+    : (
+      kernelMode && updates.length === 0 && !String(input.reconciliation_path || '').trim()
+        ? generateCallerNoChangeReconciliation(db, change, {
+          summary: input.summary,
+          no_baseline_change_reason: noChangeReason,
+        }, rootDir)
+        : readReconciliationManifest(db, change, input, rootDir)
+    );
   if (kernelMode) {
     materializeKernelArchiveAuthority(db, change, rootDir);
   }

package/mcp-server/lib/state-ops.cjs

@@ -21,7 +21,7 @@ const STATUS_TRANSITIONS = Object.freeze({
   in_progress: new Set(['completed', 'blocked', 'pending']),
   blocked:     new Set(['pending', 'in_progress']),
   expanded:    new Set(['completed']),
-  completed:   new Set(),
+  completed:   new Set(['in_progress']),
 });
 
 const TASK_FIELDS = Object.freeze([
@@ -529,6 +529,16 @@ function patchTask(db, id, patch = {}) {
           `cannot transition task ${id} from ${current.status} to ${nextStatus}`,
         );
       }
+      if (current.status === 'completed' && nextStatus === 'in_progress') {
+        if (!Object.prototype.hasOwnProperty.call(patch, 'completion_commit')) {
+          sets.push('completion_commit = ?');
+          params.push(null);
+        }
+        if (!Object.prototype.hasOwnProperty.call(patch, 'session_id')) {
+          sets.push('session_id = ?');
+          params.push(null);
+        }
+      }
       sets.push('status = ?');
       params.push(nextStatus);
     }
@@ -542,10 +552,18 @@ function patchTask(db, id, patch = {}) {
 
     if (nextStatus && nextStatus !== current.status) {
       appendEventInTx(db, {
-        type: statusEventType(nextStatus),
+        type: current.status === 'completed' && nextStatus === 'in_progress'
+          ? 'task_reopened'
+          : statusEventType(nextStatus),
         task_id: id,
         change_id: patch.change_id !== undefined ? patch.change_id : current.change_id,
-        payload: { from: current.status, to: nextStatus },
+        payload: {
+          from: current.status,
+          to: nextStatus,
+          ...(current.status === 'completed' && nextStatus === 'in_progress'
+            ? { previous_completion_commit: current.completion_commit }
+            : {}),
+        },
       });
     }
     const contractFields = Object.keys(patch).filter((field) => TASK_CONTRACT_PATCH_FIELDS.has(field));