@aifabrix/builder 2.54.1 → 2.55.0

package/lib/role-assistant/test-cases-bid.js

@@ -5,6 +5,8 @@
 
 'use strict';
 
+const { skipRow } = require('./test-case-assertion-row');
+
 function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
@@ -71,10 +73,71 @@ function collectBidSchemaAssertions(expectedBid, observed, assertions, soft) {
   }
 }
 
-function assertDefinitionHash(expectedBid, observed, assertions, soft) {
-  if (expectedBid.requireDefinitionHash !== true) {
+function isDatasourceRecord(value) {
+  const key = String(value.key || value.datasourceKey || '').trim();
+  return Boolean(key && (Array.isArray(value.capabilities) || value.entityType || value.resourceType));
+}
+
+function nestedBidContainers(value) {
+  const nested = [];
+  if (Array.isArray(value.datasources)) {
+    nested.push(value.datasources);
+  }
+  if (value.spec && typeof value.spec === 'object') {
+    nested.push(value.spec);
+  }
+  if (value.emitted && typeof value.emitted === 'object') {
+    nested.push(value.emitted);
+  }
+  if (value.bid && typeof value.bid === 'object') {
+    nested.push(value.bid);
+  }
+  return nested;
+}
+
+function collectBidObjects(value, acc) {
+  if (Array.isArray(value)) {
+    value.forEach((item) => collectBidObjects(item, acc));
     return;
   }
+  if (!value || typeof value !== 'object') {
+    return;
+  }
+  nestedBidContainers(value).forEach((child) => collectBidObjects(child, acc));
+  if (isDatasourceRecord(value)) {
+    acc.push(value);
+  }
+}
+
+function bidBlob(observed) {
+  return observed.emitted || observed.emitRow || observed.applyRow || {};
+}
+
+function datasourceKeysFromBid(observed) {
+  const objects = [];
+  collectBidObjects(bidBlob(observed), objects);
+  return new Set(objects.map((row) => String(row.key || row.datasourceKey || '').trim()).filter(Boolean));
+}
+
+function datasourceHasCapability(observed, datasource, capKey) {
+  const objects = [];
+  collectBidObjects(bidBlob(observed), objects);
+  const match = objects.find((row) => String(row.key || row.datasourceKey || '') === datasource);
+  const caps = asArray(match && match.capabilities);
+  return caps.some((cap) => String((cap && cap.key) || cap || '') === capKey);
+}
+
+function pushBooleanBidFlag(expectedBid, field, observed, assertions, soft, assertFn) {
+  if (expectedBid[field] === false) {
+    assertions.push(skipRow(`expected.bid.${field}`, `${field} is false — check skipped.`));
+    return;
+  }
+  if (expectedBid[field] === true) {
+    assertFn(expectedBid, observed, assertions, soft);
+  }
+}
+
+function assertDefinitionHash(expectedBid, observed, assertions, soft) {
   const { emitRow, applyRow, emitted } = observed;
   const hash =
     (emitted && emitted.definitionHash) ||
@@ -112,11 +175,60 @@ function assertSuiteRunId(expectedBid, observed, assertions, soft) {
 }
 
 function collectBidProvenanceAssertions(expectedBid, observed, assertions, soft) {
-  assertDefinitionHash(expectedBid, observed, assertions, soft);
-  assertSuiteRunId(expectedBid, observed, assertions, soft);
+  pushBooleanBidFlag(expectedBid, 'requireDefinitionHash', observed, assertions, soft, assertDefinitionHash);
+  pushBooleanBidFlag(expectedBid, 'requireSuiteRunId', observed, assertions, soft, assertSuiteRunId);
+}
+
+function collectBidDatasourceAssertions(expectedBid, observed, assertions, soft) {
+  if (Array.isArray(expectedBid.minDatasources)) {
+    collectMinDatasources(expectedBid.minDatasources, observed, assertions, soft);
+  }
+  if (expectedBid.requireCapability && typeof expectedBid.requireCapability === 'object') {
+    collectRequireCapability(expectedBid.requireCapability, observed, assertions, soft);
+  }
+}
+
+function collectMinDatasources(requiredKeys, observed, assertions, soft) {
+  if (requiredKeys.length === 0) {
+    assertions.push(skipRow('expected.bid.minDatasources', 'minDatasources is empty — nothing to assert.'));
+    return;
+  }
+  const actual = datasourceKeysFromBid(observed);
+  for (const raw of requiredKeys) {
+    const key = String(raw || '').trim();
+    const passed = hasEmitOrApply(observed) && actual.has(key);
+    pushBidAssertion(
+      assertions,
+      soft,
+      `expected.bid.minDatasources:${key}`,
+      passed,
+      `BID lists datasource "${key}".`,
+      `BID does not list required datasource "${key}".`
+    );
+  }
+}
+
+function collectRequireCapability(spec, observed, assertions, soft) {
+  const datasource = String(spec.datasource || '').trim();
+  const capKey = String(spec.key || '').trim();
+  const passed = hasEmitOrApply(observed) && datasourceHasCapability(observed, datasource, capKey);
+  pushBidAssertion(
+    assertions,
+    soft,
+    'expected.bid.requireCapability',
+    passed,
+    `BID datasource "${datasource}" lists capability "${capKey}".`,
+    `BID datasource "${datasource}" does not list capability "${capKey}".`
+  );
 }
 
 function collectBidPathAssertions(expectedBid, observed, assertions, soft) {
+  if (expectedBid.forbidGoldPaths === false) {
+    assertions.push(
+      skipRow('expected.bid.forbidGoldPaths', 'forbidGoldPaths is false — gold-path check skipped.')
+    );
+    return;
+  }
   if (expectedBid.forbidGoldPaths === true) {
     const { emitRow, applyRow, emitted } = observed;
     const blob = JSON.stringify(emitted || emitRow || applyRow || {});
@@ -146,6 +258,7 @@ function collectBidAssertions(expectedBid, observation, options = {}) {
   const soft = options.soft === true;
   collectBidSchemaAssertions(expectedBid, observed, assertions, soft);
   collectBidProvenanceAssertions(expectedBid, observed, assertions, soft);
+  collectBidDatasourceAssertions(expectedBid, observed, assertions, soft);
   collectBidPathAssertions(expectedBid, observed, assertions, soft);
   return assertions;
 }

package/lib/role-assistant/test-cases-evaluate.js

@@ -18,12 +18,41 @@ const {
   evaluateSearchExpectations,
   evaluateSkillsExpectations
 } = require('./test-cases-search');
+const { notesRow, withKind } = require('./test-case-assertion-row');
+
+const UNSAFE_FACT_SEGMENTS = new Set(['__proto__', 'prototype', 'constructor']);
+const WILDCARD_FACT_SEGMENTS = new Set(['*', '**']);
+
+function splitDottedPath(dottedPath) {
+  return String(dottedPath || '').split('.').filter((part) => part.length > 0);
+}
+
+function factPathSafetyMessage(parts) {
+  for (const part of parts) {
+    if (UNSAFE_FACT_SEGMENTS.has(part)) {
+      return `Fact path rejects prototype segment "${part}" before lookup.`;
+    }
+    if (WILDCARD_FACT_SEGMENTS.has(part)) {
+      return `Fact path rejects wildcard segment "${part}".`;
+    }
+    if (part === 'latest') {
+      return 'Fact path rejects latest-global record lookup.';
+    }
+  }
+  return null;
+}
 
 function getValueAtPath(obj, dottedPath) {
-  const parts = String(dottedPath || '').split('.').filter(Boolean);
+  const parts = splitDottedPath(dottedPath);
+  if (factPathSafetyMessage(parts)) {
+    return undefined;
+  }
   let cursor = obj;
   for (const key of parts) {
-    if (!cursor || typeof cursor !== 'object' || !(key in cursor)) {
+    if (cursor === null || cursor === undefined || typeof cursor !== 'object') {
+      return undefined;
+    }
+    if (!Object.prototype.hasOwnProperty.call(cursor, key)) {
       return undefined;
     }
     cursor = cursor[key];
@@ -31,6 +60,10 @@ function getValueAtPath(obj, dottedPath) {
   return cursor;
 }
 
+function stringifyObserved(value) {
+  return value === undefined ? 'missing' : JSON.stringify(value);
+}
+
 function evaluateLifecycleStateExpectation(expectedState, observedState) {
   if (!expectedState) {
     return null;
@@ -46,7 +79,7 @@ function evaluateLifecycleStateExpectation(expectedState, observedState) {
   };
 }
 
-function evaluateCapabilityExpectations(requiredList, observedCapabilities) {
+function evaluateCapabilityExpectations(kind, requiredList, observedCapabilities) {
   if (!Array.isArray(requiredList) || requiredList.length === 0) {
     return [];
   }
@@ -55,29 +88,39 @@ function evaluateCapabilityExpectations(requiredList, observedCapabilities) {
     const key = String(capability || '').trim();
     const passed = observedSet.has(key);
     return {
-      id: `expected.capabilities.required:${key}`,
+      id: `expected.capabilities.${kind}:${key}`,
       passed,
       message: passed
-        ? `Required capability "${key}" observed.`
-        : `Required capability "${key}" was not observed.`
+        ? `${kind === 'allowed' ? 'Allowed' : 'Required'} capability "${key}" observed.`
+        : `${kind === 'allowed' ? 'Allowed' : 'Required'} capability "${key}" was not observed.`
     };
   });
 }
 
+function evaluateOneFact(factPath, expectedValue, observation) {
+  const parts = splitDottedPath(factPath);
+  const safety = factPathSafetyMessage(parts);
+  const id = `expected.facts:${factPath}`;
+  if (safety) {
+    return { id, passed: false, message: safety };
+  }
+  const actualValue = getValueAtPath(observation, factPath);
+  const passed = JSON.stringify(actualValue) === JSON.stringify(expectedValue);
+  return {
+    id,
+    passed,
+    message: passed
+      ? `Fact "${factPath}" matched expected value.`
+      : `Fact "${factPath}" expected ${JSON.stringify(expectedValue)} but got ${stringifyObserved(actualValue)}.`
+  };
+}
+
 function evaluateFactExpectations(expectedFacts, observation) {
   if (!expectedFacts || typeof expectedFacts !== 'object' || Array.isArray(expectedFacts)) {
     return [];
   }
   return Object.entries(expectedFacts).map(([factPath, expectedValue]) => {
-    const actualValue = getValueAtPath(observation, factPath);
-    const passed = JSON.stringify(actualValue) === JSON.stringify(expectedValue);
-    return {
-      id: `expected.facts:${factPath}`,
-      passed,
-      message: passed
-        ? `Fact "${factPath}" matched expected value.`
-        : `Fact "${factPath}" expected ${JSON.stringify(expectedValue)} but got ${JSON.stringify(actualValue)}.`
-    };
+    return evaluateOneFact(factPath, expectedValue, observation);
   });
 }
 
@@ -86,6 +129,11 @@ function evaluateProhibitedExpectations(prohibited, observation) {
     return [];
   }
   return prohibited.map((factPath) => {
+    const parts = splitDottedPath(factPath);
+    const safety = factPathSafetyMessage(parts);
+    if (safety) {
+      return { id: `expected.prohibited:${factPath}`, passed: false, message: safety };
+    }
     const actualValue = getValueAtPath(observation, factPath);
     const passed = actualValue === undefined || actualValue === null || actualValue === false;
     return {
@@ -93,7 +141,7 @@ function evaluateProhibitedExpectations(prohibited, observation) {
       passed,
       message: passed
         ? `Prohibited marker "${factPath}" was not observed.`
-        : `Prohibited marker "${factPath}" observed: ${JSON.stringify(actualValue)}.`
+        : `Prohibited marker "${factPath}" observed: ${stringifyObserved(actualValue)}.`
     };
   });
 }
@@ -152,7 +200,60 @@ function softWrapFailedAssertion(assertion, soft) {
   return softWrapLifecycleAssertion(assertion, soft);
 }
 
-function collectCaseAssertions(expected, observation) {
+function collectSoftModifierRows(expected) {
+  const rows = [];
+  if (Object.prototype.hasOwnProperty.call(expected, 'soft')) {
+    rows.push(
+      notesRow(
+        'expected.soft',
+        expected.soft === true
+          ? 'soft: true — failures become warnings'
+          : 'soft: false — failures are blocking'
+      )
+    );
+  }
+  const notes = Array.isArray(expected.softNotes) ? expected.softNotes : [];
+  notes.forEach((item, index) => {
+    const text = typeof item === 'string'
+      ? item
+      : String((item && (item.description || item.note)) || JSON.stringify(item));
+    rows.push(notesRow(`expected.softNotes[${index}]`, text));
+  });
+  return rows;
+}
+
+function collectEvidenceContextRows(spec, prefix) {
+  if (!spec || typeof spec !== 'object' || Array.isArray(spec)) {
+    return [];
+  }
+  const rows = [];
+  if (spec.roleKey) {
+    rows.push(notesRow(`${prefix}.roleKey`, `Evidence roleKey "${spec.roleKey}" (preflight context).`));
+  }
+  if (spec.resourceType) {
+    rows.push(
+      notesRow(`${prefix}.resourceType`, `Evidence resourceType "${spec.resourceType}" (preflight context).`)
+    );
+  }
+  if (spec.requireStatus) {
+    rows.push(
+      notesRow(`${prefix}.requireStatus`, `Evidence requireStatus "${spec.requireStatus}" (preflight context).`)
+    );
+  }
+  return rows;
+}
+
+function collectCapabilityAssertions(capabilities, observedCapabilities, soft) {
+  const spec = capabilities && typeof capabilities === 'object' ? capabilities : {};
+  const rows = [
+    ...evaluateCapabilityExpectations('required', spec.required, observedCapabilities),
+    ...evaluateCapabilityExpectations('allowed', spec.allowed, observedCapabilities),
+    ...evaluateForbiddenCapabilities(spec.forbidden, observedCapabilities)
+  ];
+  return rows.map((row) => softWrapFailedAssertion(row, soft));
+}
+
+function collectCaseAssertions(expected, observation, preflight = {}) {
   const soft = expected.soft === true;
   const observedCapabilities = observation.capabilities?.observed || [];
   const assertions = [];
@@ -163,31 +264,35 @@ function collectCaseAssertions(expected, observation) {
   if (lifecycleAssertion) {
     assertions.push(lifecycleAssertion);
   }
+  assertions.push(...collectSoftModifierRows(expected));
+  assertions.push(...collectCapabilityAssertions(expected.capabilities, observedCapabilities, soft));
   assertions.push(
-    ...evaluateCapabilityExpectations(
-      expected?.capabilities?.required,
-      observedCapabilities
-    ).map((row) => softWrapFailedAssertion(row, soft))
+    ...evaluateFactExpectations(expected.facts, observation).map((row) =>
+      softWrapFailedAssertion(row, soft)
+    )
   );
   assertions.push(
-    ...evaluateForbiddenCapabilities(
-      expected?.capabilities?.forbidden,
-      observedCapabilities
-    ).map((row) => softWrapFailedAssertion(row, soft))
+    ...evaluateProhibitedExpectations(expected.prohibited, observation).map((row) =>
+      softWrapFailedAssertion(row, soft)
+    )
   );
-  assertions.push(...evaluateFactExpectations(expected.facts, observation));
-  assertions.push(...evaluateProhibitedExpectations(expected.prohibited, observation));
   assertions.push(...evaluateHonestyExpectations(expected.honesty, observation, { soft }));
   assertions.push(...collectBidAssertions(expected.bid, observation, { soft }));
   assertions.push(...evaluateEvidenceExpectations(expected.evidence, observation));
+  assertions.push(...collectEvidenceContextRows(expected.evidence, 'expected.evidence'));
+  assertions.push(...collectEvidenceContextRows(preflight.evidence, 'preflight.evidence'));
   assertions.push(...evaluateSearchExpectations(expected.search, observation));
   assertions.push(...evaluateSkillsExpectations(expected.skills, observation));
-  return assertions;
+  return assertions.map(withKind);
 }
 
 function evaluateRoleAssistantTestCase(testCase, result, lifecycleVerdict, portalUrl) {
   const observation = buildCaseObservation(result, lifecycleVerdict, portalUrl);
-  const assertions = collectCaseAssertions(testCase.expected || {}, observation);
+  const assertions = collectCaseAssertions(
+    testCase.expected || {},
+    observation,
+    testCase.preflight || {}
+  );
   const failed = assertions.filter((row) => !row.passed);
   return {
     caseId: testCase.caseId,
@@ -202,5 +307,7 @@ function evaluateRoleAssistantTestCase(testCase, result, lifecycleVerdict, porta
 }
 
 module.exports = {
-  evaluateRoleAssistantTestCase
+  evaluateRoleAssistantTestCase,
+  evaluateFactExpectations,
+  getValueAtPath
 };

package/lib/role-assistant/test-cases-honesty.js

@@ -4,6 +4,8 @@
 
 'use strict';
 
+const { skipRow, notesRow } = require('./test-case-assertion-row');
+
 const HONESTY_COMPLETION_STATES = new Set([
   'notEvaluated',
   'waiting',
@@ -26,6 +28,14 @@ const HONESTY_CONTRIB_STATUSES = new Set([
   'notRealized',
   'partial'
 ]);
+const OBJECTIVE_TEXT_KEYS = new Set([
+  'objective',
+  'goal',
+  'planObjective',
+  'objectiveSummary',
+  'acceptedObjective'
+]);
+const FORBIDDEN_BUILDER_TOKEN = /\b(?:knownPlatform|gold-package|[a-z][a-z0-9-]*\.[a-z][a-zA-Z0-9]+)\b/i;
 
 function emptyHonestyObservation() {
   return {
@@ -83,7 +93,59 @@ function pushHonestyAssertion(assertions, id, passed, message, options = {}) {
   assertions.push({ id, passed, message });
 }
 
-function assertWorkResultPresent(assertions, honesty, observation) {
+function collectObjectiveStrings(value, acc) {
+  if (Array.isArray(value)) {
+    value.forEach((item) => collectObjectiveStrings(item, acc));
+    return;
+  }
+  if (!value || typeof value !== 'object') {
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (OBJECTIVE_TEXT_KEYS.has(key) && typeof child === 'string') {
+      acc.push(child);
+    } else if (child && typeof child === 'object') {
+      collectObjectiveStrings(child, acc);
+    }
+  }
+}
+
+function interactionObjectiveText(row) {
+  if (!row || typeof row !== 'object') {
+    return '';
+  }
+  const role = String(row.role || row.type || '').toLowerCase();
+  if (role === 'user' || role === 'human') {
+    return '';
+  }
+  return [row.message, row.content, row.text, row.objective]
+    .filter((item) => typeof item === 'string')
+    .join('\n');
+}
+
+function governedObjectiveHaystack(observation) {
+  const parts = [];
+  collectObjectiveStrings(observation.workResult || {}, parts);
+  collectObjectiveStrings(observation.emittedBid || {}, parts);
+  for (const row of Array.isArray(observation.interactions) ? observation.interactions : []) {
+    const text = interactionObjectiveText(row);
+    if (text) {
+      parts.push(text);
+    }
+  }
+  return parts.join('\n');
+}
+
+function assertWorkResultPresent(assertions, honestySpec, honesty, observation, soft) {
+  if (honestySpec.requireWorkResult === false) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.requireWorkResult',
+        'requireWorkResult is false — work.result is not required.'
+      )
+    );
+    return;
+  }
   const present = honesty.present === true;
   const missingSuffix = observation.workResultError
     ? `: ${observation.workResultError}`
@@ -94,7 +156,8 @@ function assertWorkResultPresent(assertions, honesty, observation) {
     present,
     present
       ? 'work.result Output was present.'
-      : `work.result Output missing${missingSuffix}`
+      : `work.result Output missing${missingSuffix}`,
+    { soft }
   );
 }
 
@@ -102,6 +165,15 @@ function assertSchemaVersion(assertions, honestySpec, honesty, soft) {
   if (!honestySpec.schemaVersion) {
     return;
   }
+  if (!honesty.present) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.schemaVersion',
+        'schemaVersion skipped because work.result is absent.'
+      )
+    );
+    return;
+  }
   const expected = String(honestySpec.schemaVersion);
   const passed = String(honesty.schemaVersion || '') === expected;
   pushHonestyAssertion(
@@ -117,6 +189,12 @@ function assertSchemaVersion(assertions, honestySpec, honesty, soft) {
 
 function assertCompletion(assertions, honestySpec, honesty, soft) {
   if (honestySpec.requireCompletion === false) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.requireCompletion',
+        'requireCompletion is false — completion check skipped.'
+      )
+    );
     return;
   }
   const stateOk = HONESTY_COMPLETION_STATES.has(String(honesty.completionState || ''));
@@ -134,6 +212,12 @@ function assertCompletion(assertions, honestySpec, honesty, soft) {
 
 function assertContribution(assertions, honestySpec, honesty, soft) {
   if (honestySpec.requireContributionObservation === false) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.requireContributionObservation',
+        'requireContributionObservation is false — contribution check skipped.'
+      )
+    );
     return;
   }
   const ok = HONESTY_CONTRIB_STATUSES.has(String(honesty.contributionStatus || ''));
@@ -149,9 +233,28 @@ function assertContribution(assertions, honestySpec, honesty, soft) {
 }
 
 function assertMinResourceChanges(assertions, honestySpec, honesty, soft) {
+  if (typeof honestySpec.softResourceChanges === 'boolean') {
+    assertions.push(
+      notesRow(
+        'expected.honesty.softResourceChanges',
+        honestySpec.softResourceChanges
+          ? 'softResourceChanges: true — minResourceChanges misses are warnings.'
+          : 'softResourceChanges: false — minResourceChanges misses are blocking.'
+      )
+    );
+  }
   if (typeof honestySpec.minResourceChanges !== 'number') {
     return;
   }
+  if (!honesty.present) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.minResourceChanges',
+        'minResourceChanges skipped because work.result is absent.'
+      )
+    );
+    return;
+  }
   const count = Number(honesty.resourceChangeCount || 0);
   const passed = count >= honestySpec.minResourceChanges;
   const softChange = soft || honestySpec.softResourceChanges === true;
@@ -171,6 +274,53 @@ function assertMinResourceChanges(assertions, honestySpec, honesty, soft) {
   }
 }
 
+function assertForbidBuilderKeys(assertions, honestySpec, observation, soft) {
+  if (honestySpec.forbidBuilderKeysInObjective === false) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.forbidBuilderKeysInObjective',
+        'forbidBuilderKeysInObjective is false — Builder-key check skipped.'
+      )
+    );
+    return;
+  }
+  if (honestySpec.forbidBuilderKeysInObjective !== true) {
+    return;
+  }
+  const haystack = governedObjectiveHaystack(observation);
+  const match = haystack.match(FORBIDDEN_BUILDER_TOKEN);
+  const passed = !match;
+  pushHonestyAssertion(
+    assertions,
+    'expected.honesty.forbidBuilderKeysInObjective',
+    passed,
+    passed
+      ? 'Objective text has no Builder capability keys or generation tokens.'
+      : `Objective text contains forbidden token "${match[0]}".`,
+    { soft }
+  );
+}
+
+function emitPresentFlagRows(assertions, honestySpec, honesty, observation, soft) {
+  if (honestySpec.requireCompletion === false || honestySpec.requireCompletion === true) {
+    assertCompletion(assertions, honestySpec, honesty, soft);
+  }
+  if (
+    honestySpec.requireContributionObservation === false ||
+    honestySpec.requireContributionObservation === true
+  ) {
+    assertContribution(assertions, honestySpec, honesty, soft);
+  }
+  if (
+    typeof honestySpec.minResourceChanges === 'number' ||
+    typeof honestySpec.softResourceChanges === 'boolean'
+  ) {
+    assertMinResourceChanges(assertions, honestySpec, honesty, soft);
+  }
+  assertSchemaVersion(assertions, honestySpec, honesty, soft);
+  assertForbidBuilderKeys(assertions, honestySpec, observation, soft);
+}
+
 function evaluateHonestyExpectations(honestySpec, observation, options = {}) {
   if (!honestySpec || typeof honestySpec !== 'object' || Array.isArray(honestySpec)) {
     return [];
@@ -178,17 +328,16 @@ function evaluateHonestyExpectations(honestySpec, observation, options = {}) {
   const soft = options.soft === true;
   const honesty = observation.honesty || {};
   const assertions = [];
-  if (honestySpec.requireWorkResult !== false) {
-    assertWorkResultPresent(assertions, honesty, observation);
-  }
+  assertWorkResultPresent(assertions, honestySpec, honesty, observation, soft);
   if (!honesty.present) {
-    // Missing Output is always a hard failure when required — soft does not waive it.
+    emitPresentFlagRows(assertions, honestySpec, honesty, observation, soft);
     return assertions;
   }
   assertSchemaVersion(assertions, honestySpec, honesty, soft);
   assertCompletion(assertions, honestySpec, honesty, soft);
   assertContribution(assertions, honestySpec, honesty, soft);
   assertMinResourceChanges(assertions, honestySpec, honesty, soft);
+  assertForbidBuilderKeys(assertions, honestySpec, observation, soft);
   return assertions;
 }