ultra-builder-pro-cli 0.24.0 → 0.24.2

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));

package/mcp-server/lib/task-expander.cjs

@@ -81,7 +81,11 @@ function expandTask(db, {
   });
 
   return ops.tx(db, () => {
-    changes.assertTaskCreationAllowed(db, { change_id: parent.change_id }, { rootDir });
+    const admission = changes.assertTaskCreationAllowed(
+      db,
+      { change_id: parent.change_id },
+      { rootDir },
+    );
     for (const child of normalized) {
       ops.createTask(db, child);
     }
@@ -89,6 +93,7 @@ function expandTask(db, {
     return {
       parent_id: parent.id,
       children: normalized,
+      diagnostics: admission.diagnostics,
     };
   });
 }

package/mcp-server/lib/ultra-facade.cjs

@@ -45,6 +45,10 @@ const HARD_ERROR_CODES = new Set([
   'ARCHIVE_RUNTIME_UNAVAILABLE',
   'BACKUP_FAILED',
   'CHECKPOINT_DIGEST_MISMATCH',
+  'CHECKPOINT_EVIDENCE_AUTHORITY_MISSING',
+  'CHECKPOINT_EVIDENCE_DIGEST_MISMATCH',
+  'CHECKPOINT_SCOPE_MISMATCH',
+  'CHECKPOINT_SCOPE_NOT_FOUND',
   'CONTEXT_ENVELOPE_LIMIT_EXCEEDED',
   'CONTEXT_ENVELOPE_DIGEST_MISMATCH',
   'CONTEXT_ENVELOPE_FILE_DRIFT',
@@ -131,6 +135,48 @@ function rememberResult(db, {
   });
 }
 
+function rememberRejectedAttempt(db, tool, input, result) {
+  if (!db || result?.accepted !== false) return result;
+  const nested = Array.isArray(result.results)
+    ? result.results.flatMap((item) => item.diagnostics || [])
+    : [];
+  const diagnostics = [...(result.diagnostics || []), ...nested]
+    .map((item) => ({
+      code: item.code || 'NEEDS_ATTENTION',
+      severity: item.severity || 'needs_attention',
+      message: item.message || null,
+      ...(item.details === undefined ? {} : { details: item.details }),
+    }));
+  const entries = Array.isArray(input.entries) ? input.entries : [];
+  const changeIds = [...new Set(entries.flatMap((entry) => [
+    entry.data?.change_id,
+    entry.kind === 'change_contract' ? entry.data?.id : null,
+  ]).filter(Boolean))];
+  const taskIds = [...new Set(entries.flatMap((entry) => [
+    entry.kind.startsWith('task_') ? entry.data?.id : null,
+    input.scope?.task_id,
+  ]).filter(Boolean))];
+  const scopeChangeId = input.scope?.change_id || input.change_id || null;
+  ops.appendEvent(db, {
+    type: 'ultra_kernel_attempt',
+    change_id: changeIds.length === 1 ? changeIds[0] : scopeChangeId,
+    task_id: taskIds.length === 1 ? taskIds[0] : null,
+    payload: {
+      tool,
+      accepted: false,
+      mutable: result.mutable !== false,
+      operations: entries.map((entry) => `${entry.kind}:${entry.action}`),
+      idempotency_keys: entries.length > 0
+        ? entries.map((entry) => entry.idempotency_key).filter(Boolean)
+        : [input.idempotency_key].filter(Boolean),
+      scope: input.scope || (input.change_id ? { change_id: input.change_id } : {}),
+      blockers: result.blockers || [],
+      diagnostics,
+    },
+  });
+  return result;
+}
+
 function diagnostic(error, severity = 'needs_attention') {
   return {
     code: errorCode(error),
@@ -140,17 +186,79 @@ function diagnostic(error, severity = 'needs_attention') {
   };
 }
 
+function rejectedAttemptAudit(db) {
+  return db.prepare(
+    `SELECT id, ts, task_id, change_id, payload_json
+     FROM events
+     WHERE type = 'ultra_kernel_attempt'
+     ORDER BY id DESC
+     LIMIT 5`,
+  ).all().map((row) => {
+    const payload = parseJson(row.payload_json, {});
+    return {
+      event_id: row.id,
+      recorded_at: row.ts,
+      tool: payload.tool || null,
+      task_id: row.task_id || null,
+      change_id: row.change_id || null,
+      operations: (payload.operations || []).slice(0, 12),
+      blockers: (payload.blockers || []).slice(0, 12),
+      diagnostics: (payload.diagnostics || []).slice(0, 8).map((item) => ({
+        code: item.code || 'NEEDS_ATTENTION',
+        severity: item.severity || 'needs_attention',
+        message: typeof item.message === 'string'
+          ? item.message.slice(0, 500)
+          : null,
+      })),
+    };
+  });
+}
+
 function selectedScope(db, input = {}) {
   const scope = input.scope || {};
-  if (scope.task_id) {
-    const task = ops.readTask(db, scope.task_id);
-    if (!task) return { task_id: scope.task_id };
+  const task = scope.task_id ? ops.readTask(db, scope.task_id) : null;
+  if (scope.task_id && !task) {
+    throw Object.assign(
+      new Error(`checkpoint task scope does not exist: ${scope.task_id}`),
+      {
+        code: 'CHECKPOINT_SCOPE_NOT_FOUND',
+        details: { scope_type: 'task', scope_id: scope.task_id },
+      },
+    );
+  }
+  const changeId = scope.change_id || task?.change_id || null;
+  const change = changeId ? changes.readChange(db, changeId) : null;
+  if (changeId && !change) {
+    throw Object.assign(
+      new Error(`checkpoint Change scope does not exist: ${changeId}`),
+      {
+        code: 'CHECKPOINT_SCOPE_NOT_FOUND',
+        details: { scope_type: 'change', scope_id: changeId },
+      },
+    );
+  }
+  if (task && scope.change_id && task.change_id !== scope.change_id) {
+    throw Object.assign(
+      new Error(
+        `checkpoint task ${task.id} belongs to Change ${task.change_id || '(none)'}, not ${scope.change_id}`,
+      ),
+      {
+        code: 'CHECKPOINT_SCOPE_MISMATCH',
+        details: {
+          task_id: task.id,
+          task_change_id: task.change_id || null,
+          requested_change_id: scope.change_id,
+        },
+      },
+    );
+  }
+  if (task) {
     return {
-      change_id: scope.change_id || task.change_id || undefined,
+      ...(changeId ? { change_id: changeId } : {}),
       task_id: task.id,
     };
   }
-  if (scope.change_id) return { change_id: scope.change_id };
+  if (change) return { change_id: change.id };
   const baseline = baselines.readBaseline(db);
   return baseline ? { baseline_id: baseline.id } : { project_id: 'project' };
 }
@@ -159,7 +267,28 @@ function readContext(db, input = {}, {
   rootDir = process.cwd(),
   runtime = 'unknown',
 } = {}) {
-  return contextEnvelope.buildEnvelope(db, input, { rootDir, runtime });
+  const result = contextEnvelope.buildEnvelope(db, input, { rootDir, runtime });
+  const rejectedAttempts = rejectedAttemptAudit(db);
+  let visible = {
+    ...result,
+    audit: {
+      rejected_attempts: rejectedAttempts,
+    },
+  };
+  delete visible.bytes;
+  const limit = input.detail === 'full'
+    ? contextEnvelope.FULL_LIMIT
+    : contextEnvelope.SUMMARY_LIMIT;
+  while (Buffer.byteLength(JSON.stringify(visible)) > limit
+      && rejectedAttempts.length > 0) {
+    rejectedAttempts.pop();
+  }
+  if (Buffer.byteLength(JSON.stringify(visible)) > limit) {
+    visible = { ...result };
+    delete visible.bytes;
+  }
+  visible.bytes = Buffer.byteLength(JSON.stringify(visible));
+  return visible;
 }
 
 function initializeProject(data = {}) {
@@ -184,12 +313,16 @@ function baselineRecord(db, action, data, rootDir) {
     const result = baselines.convergeBaseline(db, data, { rootDir });
     return {
       ...result,
-      diagnostics: result.ready
-        ? []
-        : (result.blockers || []).map((code) => ({
+      diagnostics: [
+        ...(result.blockers || []).map((code) => ({
           code,
           severity: 'needs_attention',
         })),
+        ...(result.warnings || []).map((code) => ({
+          code,
+          severity: 'warning',
+        })),
+      ],
     };
   }
   throw Object.assign(new Error(`unsupported baseline action: ${action}`), {
@@ -199,7 +332,7 @@ function baselineRecord(db, action, data, rootDir) {
 
 function changeContractRecord(db, action, data, rootDir) {
   if (action === 'open') {
-    return changes.createChange(db, data, { rootDir, kernelMode: true });
+    return changes.createChange(db, data, { rootDir });
   }
   if (action === 'revise') {
     return {
@@ -207,7 +340,7 @@ function changeContractRecord(db, action, data, rootDir) {
         db,
         data.id,
         data.patch || {},
-        { rootDir, kernelMode: true },
+        { rootDir },
       ),
     };
   }
@@ -217,7 +350,7 @@ function changeContractRecord(db, action, data, rootDir) {
         db,
         data.id,
         { status: 'cancelled' },
-        { rootDir, kernelMode: true },
+        { rootDir },
       ),
     };
   }
@@ -332,6 +465,17 @@ function applyRecord(db, entry, { rootDir }) {
   if (kind === 'task_contract') return taskContractRecord(db, action, data);
   if (kind === 'task_outcome') return taskOutcomeRecord(db, action, data, rootDir);
   if (kind === 'artifact' && action === 'bind') {
+    const legacyWorkflowReference = data.owner_type === 'workflow'
+      || [...(data.source_refs || []), ...(data.consumer_refs || [])]
+        .some((reference) => reference?.type === 'workflow');
+    if (legacyWorkflowReference) {
+      throw Object.assign(
+        new Error(
+          'workflow-owned artifact authority is retired and remains read-only history',
+        ),
+        { code: 'LEGACY_AUTHORITY_READ_ONLY' },
+      );
+    }
     return artifactRegistry.recordArtifact(db, data, { rootDir });
   }
   if (kind === 'event' && action === 'append') {
@@ -423,14 +567,17 @@ function checkpointDiagnostics(input, context) {
     }));
 }
 
-function stageReadinessDiagnostics(db, input, scope) {
+function stageAdvisoryDiagnostics(db, input, scope) {
   const payload = input.payload || {};
   const evidence = Array.isArray(payload.evidence) ? payload.evidence : [];
-  const needs = (code, message) => ({ code, severity: 'needs_attention', message });
+  const warning = (code, message) => ({ code, severity: 'warning', message });
   if (input.stage === 'research') {
     return evidence.length > 0
       ? []
-      : [needs('RESEARCH_EVIDENCE_REQUIRED', 'Research checkpoint requires at least one evidence reference.')];
+      : [warning(
+        'RESEARCH_EVIDENCE_MISSING',
+        'No research evidence was declared; the caller remains responsible for semantic sufficiency.',
+      )];
   }
   if (input.stage === 'dev') {
     const task = scope.task_id ? ops.readTask(db, scope.task_id) : null;
@@ -442,14 +589,14 @@ function stageReadinessDiagnostics(db, input, scope) {
       ).get(task.id)
       : null;
     const diagnostics = [];
-    if (!task) diagnostics.push(needs('TASK_NOT_FOUND', 'Dev checkpoint requires a task scope.'));
+    if (!task) diagnostics.push(warning('TASK_NOT_FOUND', 'No task scope was found for this Dev checkpoint.'));
     else if (task.status !== 'completed') {
-      diagnostics.push(needs('TASK_OUTCOME_INCOMPLETE', `Task ${task.id} is not completed.`));
+      diagnostics.push(warning('TASK_OUTCOME_INCOMPLETE', `Task ${task.id} is not completed.`));
     }
     if (task && !outcome) {
-      diagnostics.push(needs(
-        'WORKER_OUTCOME_REQUIRED',
-        `Task ${task.id} requires an artifact bound to its exact Worker Packet.`,
+      diagnostics.push(warning(
+        'WORKER_OUTCOME_MISSING',
+        `Task ${task.id} has no current Worker Packet outcome artifact.`,
       ));
     }
     return diagnostics;
@@ -457,22 +604,32 @@ function stageReadinessDiagnostics(db, input, scope) {
   if (input.stage === 'test') {
     const result = String(payload.result || '').toLowerCase();
     const diagnostics = [];
-    if (!['pass', 'known_red'].includes(result)) {
-      diagnostics.push(needs('TEST_RESULT_REQUIRED', 'Test checkpoint requires result=pass or known_red.'));
+    if (!result) {
+      diagnostics.push(warning('TEST_RESULT_MISSING', 'No test result was declared.'));
+    } else if (!['pass', 'known_red'].includes(result)) {
+      diagnostics.push(warning(
+        'TEST_RESULT_RECORDED',
+        `The caller recorded test result ${result}; MCP does not reinterpret it.`,
+      ));
     }
     if (evidence.length === 0) {
-      diagnostics.push(needs('TEST_EVIDENCE_REQUIRED', 'Test checkpoint requires evidence.'));
+      diagnostics.push(warning('TEST_EVIDENCE_MISSING', 'No test evidence was declared.'));
     }
     return diagnostics;
   }
   if (input.stage === 'review') {
     const verdict = String(payload.verdict || '').toLowerCase();
     const diagnostics = [];
-    if (!['approve', 'pass'].includes(verdict)) {
-      diagnostics.push(needs('REVIEW_VERDICT_REQUIRED', 'Review checkpoint requires an approved verdict.'));
+    if (!verdict) {
+      diagnostics.push(warning('REVIEW_VERDICT_MISSING', 'No review verdict was declared.'));
+    } else if (!['approve', 'pass'].includes(verdict)) {
+      diagnostics.push(warning(
+        'REVIEW_VERDICT_RECORDED',
+        `The caller recorded review verdict ${verdict}; MCP does not reinterpret it.`,
+      ));
     }
     if (evidence.length === 0) {
-      diagnostics.push(needs('REVIEW_EVIDENCE_REQUIRED', 'Review checkpoint requires evidence.'));
+      diagnostics.push(warning('REVIEW_EVIDENCE_MISSING', 'No review evidence was declared.'));
     }
     return diagnostics;
   }
@@ -485,23 +642,87 @@ function stageReadinessDiagnostics(db, input, scope) {
         { change_id: scope.change_id },
         { includeDraft: false },
       )) {
-        diagnostics.push(needs(
-          `${stage.toUpperCase()}_CHECKPOINT_REQUIRED`,
-          `Deliver checkpoint requires an accepted ${stage} checkpoint.`,
+        diagnostics.push(warning(
+          `${stage.toUpperCase()}_CHECKPOINT_MISSING`,
+          `No accepted ${stage} checkpoint was found; the caller owns the delivery decision.`,
         ));
       }
     }
     if (String(payload.summary || '').trim().length < 3) {
-      diagnostics.push(needs('DELIVERY_SUMMARY_REQUIRED', 'Deliver checkpoint requires a summary.'));
+      diagnostics.push(warning('DELIVERY_SUMMARY_MISSING', 'No durable delivery summary was declared.'));
     }
     if (evidence.length === 0) {
-      diagnostics.push(needs('DELIVERY_EVIDENCE_REQUIRED', 'Deliver checkpoint requires evidence.'));
+      diagnostics.push(warning('DELIVERY_EVIDENCE_MISSING', 'No delivery evidence was declared.'));
     }
     return diagnostics;
   }
   return [];
 }
 
+function normalizeCheckpointEvidence(db, input, rootDir) {
+  const evidence = Array.isArray(input.payload?.evidence) ? input.payload.evidence : [];
+  return evidence.map((item, index) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+      const error = new Error(`checkpoint evidence[${index}] must be an object`);
+      error.code = 'VALIDATION_ERROR';
+      throw error;
+    }
+    const normalized = { ...item };
+    let relative = typeof item.ref === 'string' ? item.ref.trim() : '';
+    let artifact = null;
+    if (item.artifact_id) {
+      try {
+        artifact = artifactRegistry.getArtifact(db, { id: String(item.artifact_id) });
+      } catch (error) {
+        if (error?.code !== 'ARTIFACT_NOT_FOUND') throw error;
+      }
+      if (!artifact || artifact.status !== 'current') {
+        const error = new Error(`checkpoint evidence artifact is not current: ${item.artifact_id}`);
+        error.code = 'CHECKPOINT_EVIDENCE_AUTHORITY_MISSING';
+        throw error;
+      }
+      if (relative && artifact.path !== relative) {
+        const error = new Error(`checkpoint evidence path does not match artifact ${item.artifact_id}`);
+        error.code = 'CHECKPOINT_EVIDENCE_AUTHORITY_MISSING';
+        throw error;
+      }
+      relative = artifact.path;
+      normalized.artifact_id = artifact.id;
+      if (item.digest && String(item.digest) !== artifact.digest) {
+        const error = new Error(
+          `checkpoint evidence digest contradicts artifact ${item.artifact_id}`,
+        );
+        error.code = 'CHECKPOINT_EVIDENCE_DIGEST_MISMATCH';
+        error.details = {
+          path: relative,
+          expected: artifact.digest,
+          actual: String(item.digest),
+        };
+        throw error;
+      }
+    }
+    if (!item.digest && !item.artifact_id) return normalized;
+    if (!relative) {
+      const error = new Error(`checkpoint evidence[${index}] requires ref when digest is supplied`);
+      error.code = 'VALIDATION_ERROR';
+      throw error;
+    }
+    const read = readStableProjectFile(rootDir, relative);
+    const expected = item.artifact_id
+      ? artifact.digest
+      : String(item.digest);
+    if (read.digest !== expected) {
+      const error = new Error(`checkpoint evidence digest mismatch: ${relative}`);
+      error.code = 'CHECKPOINT_EVIDENCE_DIGEST_MISMATCH';
+      error.details = { path: relative, expected, actual: read.digest };
+      throw error;
+    }
+    normalized.ref = relative;
+    normalized.digest = read.digest;
+    return normalized;
+  });
+}
+
 async function checkpoint(db, input = {}, {
   rootDir = process.cwd(),
   runtime = 'unknown',
@@ -517,14 +738,22 @@ async function checkpoint(db, input = {}, {
     scope,
     detail: 'summary',
   }, { rootDir, runtime });
+  const evidence = normalizeCheckpointEvidence(db, input, rootDir);
   const diagnostics = [
     ...checkpointDiagnostics(input, view),
-    ...stageReadinessDiagnostics(db, input, scope),
+    ...stageAdvisoryDiagnostics(db, input, scope),
+    ...evidence
+      .filter((item) => !item.digest && !item.artifact_id)
+      .map((item, index) => ({
+        code: 'CHECKPOINT_EVIDENCE_UNBOUND',
+        severity: 'warning',
+        message: `Evidence declaration ${item.ref || item.kind || index} has no current digest or managed artifact binding.`,
+      })),
   ];
   let result = null;
 
   if (input.stage === 'plan'
-      && !diagnostics.some((item) => item.severity !== 'warning')) {
+      && !diagnostics.some((item) => item.severity === 'hard_conflict')) {
     try {
       result = planCheckpoint.publishPlan(db, {
         change_id: scope.change_id,
@@ -532,7 +761,7 @@ async function checkpoint(db, input = {}, {
       }, { rootDir, markRecoveryRequired: markPlanRecoveryRequired });
     } catch (error) {
       if (isHardError(error)) throw error;
-      diagnostics.push(diagnostic(error));
+      diagnostics.push(diagnostic(error, 'hard_conflict'));
     }
   }
 
@@ -548,12 +777,12 @@ async function checkpoint(db, input = {}, {
     payload: input.stage === 'plan' && result
       ? { ...(input.payload || {}), plan: result }
       : (input.payload || {}),
-    evidence: Array.isArray(input.payload?.evidence) ? input.payload.evidence : [],
+    evidence,
     diagnostics,
     context_envelope_id: context.id,
     idempotency_key: `${input.idempotency_key}:draft`,
   });
-  if (diagnostics.some((item) => item.severity !== 'warning')) {
+  if (diagnostics.some((item) => item.severity === 'hard_conflict')) {
     return {
       accepted: false,
       mutable: true,
@@ -770,7 +999,7 @@ async function archive(db, input = {}, {
     const result = changes.archiveChange(
       db,
       { id: input.change_id, ...(input.payload || {}) },
-      { rootDir, kernelMode: true },
+      { rootDir },
     );
     const output = {
       accepted: true,
@@ -802,22 +1031,26 @@ async function archive(db, input = {}, {
 }
 
 async function dispatch(name, input, db, context = {}) {
-  if (name === 'ultra.context') return readContext(db, input, context);
-  if (name === 'ultra.record') return record(db, input, context);
-  if (name === 'ultra.checkpoint') return checkpoint(db, input, context);
-  if (name === 'ultra.sync') return sync(db, input, context);
-  if (name === 'ultra.session') return session(db, input, context);
-  if (name === 'ultra.archive') return archive(db, input, context);
+  let result;
+  if (name === 'ultra.context') result = readContext(db, input, context);
+  else if (name === 'ultra.record') result = await record(db, input, context);
+  else if (name === 'ultra.checkpoint') result = await checkpoint(db, input, context);
+  else if (name === 'ultra.sync') result = sync(db, input, context);
+  else if (name === 'ultra.session') result = await session(db, input, context);
+  else if (name === 'ultra.archive') result = await archive(db, input, context);
   if (name === 'ultra.doctor') {
-    return doctor.runDoctor(db, {
+    result = doctor.runDoctor(db, {
       rootDir: context.rootDir || process.cwd(),
       repair: input.repair === true,
       project: context.projector,
     });
   }
-  const error = new Error(`unhandled public tool ${name}`);
-  error.code = 'UNKNOWN_TOOL';
-  throw error;
+  if (result === undefined) {
+    const error = new Error(`unhandled public tool ${name}`);
+    error.code = 'UNKNOWN_TOOL';
+    throw error;
+  }
+  return rememberRejectedAttempt(db, name, input, result);
 }
 
 module.exports = {

package/mcp-server/server.cjs

@@ -284,7 +284,7 @@ function startServer({
         );
         const own = processed.jobs.find((item) => item.id === job.id);
         runtimeMeta = {
-          state_commit: 'committed',
+          projection_commit: 'committed',
           projection_status: own?.status || 'failed',
           projection_job_id: job.id,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultra-builder-pro-cli",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "description": "Explicitly invoked Ultra Builder Pro workflows for Claude Code, OpenCode, Codex CLI, Kimi Code, and Grok Build, with a project-local MCP persistence and safety kernel.",
   "bin": {
     "ultra-builder-pro-cli": "bin/install.js",

package/skills/ultra-change/SKILL.md

@@ -39,7 +39,8 @@ manufacturing a mutation.
 
 Changing accepted intent creates a new accepted checkpoint revision and makes only
 genuinely dependent evidence stale. Readiness is derived, not a stored absorbing
-state. A semantic rejection returns diagnostics; repair and retry the same draft.
+state. Semantic diagnostics remain advisory; structural, digest, path, or concurrency
+conflicts require repair and retry of the same draft.
 Use `change_contract / cancel` only when the owner intentionally abandons the Change.
 
 Publish the durable Change contract with `ultra.sync { action: publish }` when it is a

package/skills/ultra-deliver/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ultra-deliver
-description: Converge a verified Ultra Change, reconcile baseline specifications, and archive it with recoverable local evidence. Use when implementation, testing, and review are current.
+description: Reconcile and archive an explicitly accepted Ultra Change with recoverable local evidence. Use when the caller is ready to make a local delivery handoff with current managed evidence and an explicit rationale for any omitted capability.
 ---
 
 # Converge and archive local authority
@@ -12,8 +12,10 @@ publication, deployment, or another external effect.
 
 1. Call `ultra.context { stage: deliver, scope: { change_id }, detail: full }`.
 2. Import a newer team checkpoint with `ultra.sync`; stop on a real conflict.
-3. Require current task outcomes, test report, both review axes, accepted decisions,
-   typed delta, documentation reconciliation, and current checkout evidence.
+3. Inspect current task outcomes, tests, both review axes, accepted decisions, typed
+   delta, documentation reconciliation, and checkout evidence. Decide whether the
+   actual Change is sufficiently complete; explicitly record any omitted stage and its
+   evidence-based rationale instead of inventing a fixed recipe.
 4. Resolve every specification-learning candidate. Keep updates inside the Change
    overlay until archive.
 5. Write and register documentation reconciliation and an
@@ -27,20 +29,16 @@ Use one typed `ultra.record` batch for `artifact / bind`, any normalized
 ## Archive once
 
 Call `ultra.archive` once with the Change id, stable idempotency key, archive summary,
-reconciliation fields, delivery evidence steps, and report output. The operation
-internally:
-
-- compiles or reuses convergence context;
-- checks the deliver draft;
-- derives convergence from current dev, test, review, delta, docs, and checkout;
-- applies the overlay and archive through the recoverable filesystem/DB transaction;
-- rebinds registered artifacts into a self-contained archive;
-- accepts one immutable delivery checkpoint revision;
-- publishes the updated team checkpoint.
-
-A semantic rejection returns mutable blockers. Repair the same packet and retry. A
-hard corruption, path, concurrency, or recovery error remains fail-closed and routes to
-`ultra-doctor`.
+reconciliation fields, delivery evidence steps, explicit omissions, and report output.
+The model's report is the semantic handoff. MCP validates its current registered
+authority, paths, digests, reconciliation structure, and idempotency; applies the
+overlay and archive through the recoverable filesystem/DB transaction; rebinds
+registered artifacts into a self-contained archive; and publishes the updated team
+checkpoint. It does not require a hard-coded Plan/Dev/Test/Review/Deliver sequence.
+
+Semantic warnings remain in the archive history but do not reject an explicit local
+handoff. Corruption, unsafe paths, digest/CAS conflicts, permissions, or recovery
+failure remain fail-closed and route to `ultra-doctor`.
 
 Verify the archived packet, baseline, checkpoint, and rollback state. Handle any
 separately authorized Git or release effect only after local delivery and report it as

package/skills/ultra-dev/SKILL.md

@@ -45,7 +45,9 @@ Fix blocking findings and refresh affected evidence.
 
 Call `ultra.checkpoint` once with `stage: dev`, the exact Change/Task scope, evidence,
 and stable idempotency key. It binds the exact Context Envelope and Worker Packet and
-reports outcome diagnostics. A rejection leaves the draft mutable.
+reports outcome diagnostics. The model decides whether the implemented slice satisfies
+the Task; semantic warnings remain visible. A rejection means the declared authority,
+path, digest, or concurrency boundary was unsafe and leaves the draft mutable.
 
 After acceptance, mark the task durably completed, publish with `ultra.sync`, and
 create at most one authorized local task commit containing code and semantic