create-agdf 0.14.2 → 0.14.4

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/cli/delivery-path-search-command.js

@@ -12,21 +12,25 @@ import { enforcementForSurface } from '../delivery-path-search/surfaces/capabili
 import { persistSearchResult } from '../delivery-path-search/persistence.js';
 
 function unavailableOpenCodeResult({ options, preflight, input = null, error = null }) {
+  const surface = options.surface ?? "opencode";
   const mutation = error?.code === "OPENCODE_EVALUATOR_MUTATION_DETECTED";
-  const attempted = Boolean(input);
+  const attempted = Boolean(input && error);
   const nextAction = mutation
     ? "Investigate and revert the detected repository mutation before any evaluator fallback or retry."
     : "Repair the reported OpenCode capability and retry, or use the existing instruction-only Delivery Path Search workflow.";
   return {
     contract_version: "1",
-    surface: "opencode",
+    surface,
     scope_key: input?.scope_key ?? options.runId ?? null,
+    scope_revision: input?.scope_revision ?? "unversioned",
+    objective: input?.objective ?? "Delivery Path Search evaluator capability",
     current_gate: input?.current_gate ?? null,
+    outcome_phase: "evaluation",
     status: mutation ? "evaluator_error" : "evaluator_unavailable",
     recommendation: null,
-    enforcement: enforcementForSurface("opencode"),
+    enforcement: enforcementForSurface(surface),
     evaluator: {
-      name: "opencode",
+      name: surface,
       preflight: preflight?.code ?? "not_run",
       failure_code: error?.code ?? preflight?.code,
       detail: error?.message ?? preflight?.detail,
@@ -38,6 +42,16 @@ function unavailableOpenCodeResult({ options, preflight, input = null, error = n
       failure_code: error?.code ?? preflight?.code,
       evidence: preflight?.evidence ?? [],
     },
+    provenance: {
+      baseline_candidates: Math.min(input?.allowed_actions?.length ?? 0, input?.budgets?.max_candidates ?? 0),
+      generated_candidates: 0,
+      legal_candidates: attempted ? 1 : 0,
+      rejected_candidates: 0,
+      evaluation_attempts: attempted ? 1 : 0,
+      valid_evaluations: 0,
+      invalid_evaluations: attempted ? 1 : 0,
+    },
+    failure_code: error?.code ?? preflight?.code,
     stopping_reason: mutation ? "opencode_mutation_detected" : attempted ? "opencode_evaluator_failed" : "opencode_preflight_failed",
     next_action: nextAction,
     next_gate_action: nextAction,
@@ -46,11 +60,26 @@ function unavailableOpenCodeResult({ options, preflight, input = null, error = n
 
 export async function executeDeliveryPathSearch(options, io = console, dependencies = {}) {
   const fixture = options.fixture ? JSON.parse(readFileSync(options.fixture, "utf8")) : null;
+  const fixtureGeneration = fixture?.generator_response;
+  const generationEnabled = Boolean(fixtureGeneration || options.generateCandidates);
+  const initialEnforcement = fixture?.input?.enforcement ?? enforcementForSurface(options.surface);
+  const initialInput = fixture?.input ?? (dependencies.searchInputFromControl ?? searchInputFromControl)(options.dir, {
+    scopeKey: options.runId,
+    enforcement: initialEnforcement,
+    generation: generationEnabled ? {
+      enabled: true,
+      maxProposals: options.maxGeneratedCandidates,
+      maxDurationMs: options.generationTimeoutMs,
+      maxCostUnits: options.generationCostUnits,
+    } : undefined,
+  });
   const preflight = !fixture && options.surface === "opencode"
     ? (dependencies.preflightOpenCodeEvaluator ?? preflightOpenCodeEvaluator)({ cwd: options.dir })
     : null;
   if (preflight?.status === "failed") {
-    const result = unavailableOpenCodeResult({ options, preflight });
+    const result = initialInput.input_failure_code
+      ? await runDeliveryPathSearch(initialInput, { name: "not-invoked", async evaluate() { throw new Error("input failure must stop before evaluation"); } })
+      : unavailableOpenCodeResult({ options, preflight, input: initialInput });
     printDeliveryPathSearchResult(result, options, io);
     return result;
   }
@@ -58,18 +87,7 @@ export async function executeDeliveryPathSearch(options, io = console, dependenc
     ?? (preflight
       ? enforcementForSurface("opencode", preflight.evidence, { preflight })
       : enforcementForSurface(options.surface));
-  const fixtureGeneration = fixture?.generator_response;
-  const generationEnabled = Boolean(fixtureGeneration || options.generateCandidates);
-  const baseInput = fixture?.input ?? (dependencies.searchInputFromControl ?? searchInputFromControl)(options.dir, {
-    scopeKey: options.runId,
-    enforcement,
-    generation: generationEnabled ? {
-      enabled: true,
-      maxProposals: options.maxGeneratedCandidates,
-      maxDurationMs: options.generationTimeoutMs,
-      maxCostUnits: options.generationCostUnits,
-    } : undefined,
-  });
+  const baseInput = fixture ? initialInput : { ...initialInput, enforcement };
   const input = generationEnabled && !baseInput.generation ? {
     ...baseInput,
     generation: {
@@ -90,7 +108,13 @@ export async function executeDeliveryPathSearch(options, io = console, dependenc
           ? (dependencies.openCodeEvaluator ?? openCodeEvaluator)({ cwd: options.dir, model: options.model, preflight })
           : null;
   if (!evaluator) {
-    throw new Error(`${options.surface} has no executable evaluator in this release. Codex, Claude and preflight-qualified OpenCode are the executable adapters; --fixture is available for deterministic contract testing.`);
+    const detail = `${options.surface} has no executable evaluator in this release. Codex, Claude and preflight-qualified OpenCode are the executable adapters; --fixture is available for deterministic contract testing.`;
+    const result = {
+      ...unavailableOpenCodeResult({ options, preflight: { code: "surface_evaluator_unavailable", detail, evidence: [] }, input }),
+      surface: options.surface,
+    };
+    printDeliveryPathSearchResult(result, options, io);
+    return result;
   }
   const generator = fixtureGeneration
     ? fixtureGenerator(fixtureGeneration)
@@ -125,15 +149,23 @@ function printDeliveryPathSearchResult(result, options, io) {
     return;
   }
   io.log(`AGDF Delivery Path Search: ${result.status}`);
+  io.log(`Scope: ${result.scope_key ?? "unknown"} @ ${result.scope_revision ?? "unversioned"}`);
+  if (result.objective) io.log(`Objective: ${result.objective}`);
   io.log(`Current gate: ${result.current_gate ?? "unknown"}`);
+  io.log(`Outcome phase: ${result.outcome_phase ?? "unknown"}`);
   io.log(`Enforcement: ${result.enforcement.level}`);
   io.log(`Recommendation: ${result.recommendation?.action ?? "none"}`);
   if (result.budgets) io.log(`Evaluations: ${result.budgets.evaluations}`);
+  if (result.provenance) {
+    io.log(`Candidates: ${result.provenance.legal_candidates} legal, ${result.provenance.rejected_candidates} rejected`);
+    io.log(`Evaluation provenance: ${result.provenance.valid_evaluations}/${result.provenance.evaluation_attempts} valid, ${result.provenance.invalid_evaluations} invalid`);
+  }
   if (result.generation) {
     io.log(`Generation: ${result.generation.status} (${result.generation.accepted}/${result.generation.returned} accepted)`);
     io.log(`Generation budget: ${result.generation.cost_units} cost units, ${result.generation.duration_ms} ms`);
     if (result.generation.failure_code) io.log(`Generation failure: ${result.generation.failure_code}`);
   }
   io.log(`Stopping reason: ${result.stopping_reason}`);
-  io.log(result.next_gate_action);
+  if (result.failure_code) io.log(`Failure: ${result.failure_code}`);
+  io.log(result.next_action ?? result.next_gate_action);
 }

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/cli/parse-args.js

@@ -45,6 +45,7 @@ export function parseArgs(argv, dependencies = {}) {
   let allActive = false;
   let scope;
   let confirm = false;
+  let shared = false;
   let runtimeChecksDecision;
   let runtimeChecksAction;
 
@@ -61,6 +62,7 @@ export function parseArgs(argv, dependencies = {}) {
     if (arg === "--generate-candidates") { generateCandidates = true; continue; }
     if (arg === "--all-active") { allActive = true; continue; }
     if (arg === "--confirm") { confirm = true; continue; }
+    if (arg === "--shared") { shared = true; continue; }
 
     if (arg === "--runtime-checks") {
       const next = requiredValue(args, i, arg);
@@ -162,6 +164,7 @@ export function parseArgs(argv, dependencies = {}) {
       allActive,
       scope,
       confirm,
+      shared,
       runtimeChecksDecision,
       runtimeChecksAction: runtimeChecksAction ?? "status",
       generatorModel,

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/control-evaluation/doctor.js

@@ -130,6 +130,19 @@ export function evaluateDoctor(targetDir, selection = {}) {
           "Add at least one evidence row or explicitly document that no evidence exists yet.",
         );
       }
+
+      for (const identityFinding of selectedRunState.identity_findings ?? []) {
+        addFinding(
+          findings,
+          "revise",
+          identityFinding.code,
+          identityFinding.code === "AGDF_RUN_ID_INVALID"
+            ? "The selected run state has a missing or invalid run_id; interaction cards cannot be rendered for it."
+            : "The selected run state has a missing or invalid revision_id; approval interactions cannot be rendered for it.",
+          runPath,
+          "Run run-migrate to repair the run identity, or migrate the legacy state to a canonical run record.",
+        );
+      }
     }
 
     const backlogPath = join(".agdf", "control", "MASTER_BACKLOG.md");

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/control-evaluation/gate-check.js

@@ -1,4 +1,4 @@
-import { attachApprovalOrientationSnapshot, buildArtefactRefs, buildQualityReadiness, gateTitle, localePack, renderApprovalOrientationSnapshot, renderOperationalStatusCard, resolveHumanRunTitle } from '../interaction-presentation.js';
+import { attachApprovalOrientationSnapshot, buildArtefactRefs, buildQualityReadiness, gateTitle, localePack, renderApprovalOrientationSnapshot, renderOperationalStatusCard, resolveHumanRunTitle, validateApprovalOrientationPreconditions, validateApprovalOrientationSnapshot, validateOperationalStatusCardPreconditions } from '../interaction-presentation.js';
 import { interactionLocales, resolveConfiguredChatLanguage } from '../cli/runtime-context.js';
 import { evaluateDoctor } from './doctor.js';
 import { analyzeDeliveryMap, deriveQualityOutlook } from './delivery-map.js';
@@ -300,8 +300,9 @@ export function evaluateGateCheck(targetDir, selection = {}) {
     humanPresentation,
     revisionId,
   });
+  const readyForApproval = isReadyUserGateApproval({ status, currentGate, missingApproval });
   const approvalOrientation = attachApprovalOrientationSnapshot(statusCard, {
-    ready: isReadyUserGateApproval({ status, currentGate, missingApproval }),
+    ready: readyForApproval,
     humanPresentation,
     revisionId,
     registry: interactionLocales,
@@ -312,6 +313,50 @@ export function evaluateGateCheck(targetDir, selection = {}) {
     enumerable: false,
   });
 
+  const approvalPresentation = renderApprovalOrientationSnapshot(approvalOrientation, {
+    registry: interactionLocales,
+    expectedIdentity: {
+      run_id: statusCard.run_id,
+      revision_id: revisionId,
+      current_gate: currentGate,
+      presentation_language: statusCard.presentation_language,
+    },
+  });
+  const presentationDiagnostics = {};
+  if (!statusPresentation) {
+    presentationDiagnostics.status_presentation_errors = [
+      ...validateOperationalStatusCardPreconditions(statusCard, {
+        registry: interactionLocales,
+        humanPresentation,
+      }).errors,
+    ];
+  }
+  if (readyForApproval && !approvalPresentation) {
+    presentationDiagnostics.approval_presentation_errors = approvalOrientation
+      ? [
+          ...validateApprovalOrientationSnapshot(approvalOrientation, {
+            registry: interactionLocales,
+            expectedIdentity: {
+              run_id: statusCard.run_id,
+              revision_id: revisionId,
+              current_gate: currentGate,
+              presentation_language: statusCard.presentation_language,
+            },
+          }).errors,
+        ]
+      : [
+          ...validateApprovalOrientationPreconditions({
+            statusCard,
+            humanPresentation,
+            registry: interactionLocales,
+            requestedLocale: presentationLocale,
+          }).errors,
+        ];
+    if (!presentationDiagnostics.approval_presentation_errors.length) {
+      presentationDiagnostics.approval_presentation_errors = ["snapshot_unavailable"];
+    }
+  }
+
   return {
     schema_version: "1",
     status,
@@ -332,15 +377,8 @@ export function evaluateGateCheck(targetDir, selection = {}) {
     candidate_runs: runState.candidate_runs ?? [],
     status_card: statusCard,
     status_presentation: statusPresentation,
-    approval_presentation: renderApprovalOrientationSnapshot(approvalOrientation, {
-      registry: interactionLocales,
-      expectedIdentity: {
-        run_id: statusCard.run_id,
-        revision_id: revisionId,
-        current_gate: currentGate,
-        presentation_language: statusCard.presentation_language,
-      },
-    }),
+    approval_presentation: approvalPresentation,
+    ...(Object.keys(presentationDiagnostics).length ? { presentation_diagnostics: presentationDiagnostics } : {}),
     delivery_map: {
       relationships: deliveryMap.relationships,
       mode_slice_decision: runState.mode_slice_decision,
@@ -368,6 +406,14 @@ export function printApprovalEnvelope(report, { io = console, reEvaluate } = {})
   if (report?.approval_presentation) {
     io.log(report.approval_presentation.blocks.run_status_card.markdown);
     io.log("");
+    if (report.status_presentation?.markdown) {
+      io.log(report.status_presentation.markdown);
+    } else {
+      const pack = localePack(interactionLocales, report.approval_presentation.presentation_language || "en");
+      const codes = report.presentation_diagnostics?.status_presentation_errors ?? [];
+      io.log(codes.length ? `${pack.interaction.statusPresentationFailure} (${codes.join(", ")})` : pack.interaction.statusPresentationFailure);
+    }
+    io.log("");
     io.log(report.approval_presentation.blocks.gate_transition_card.markdown);
     io.log("");
     io.log(report.approval_presentation.approval_interaction.exact_text_fallback);
@@ -386,7 +432,10 @@ export function printApprovalEnvelope(report, { io = console, reEvaluate } = {})
   const pack = localePack(interactionLocales, refreshed?.status_card?.presentation_language || report?.status_card?.presentation_language || "en");
   const refreshedApproval = canonicalApprovalForReport(refreshed);
   if (initialApproval && refreshedApproval) {
-    io.log(pack.interaction.presentationFailure);
+    const codes = refreshed?.presentation_diagnostics?.approval_presentation_errors
+      ?? report?.presentation_diagnostics?.approval_presentation_errors
+      ?? [];
+    io.log(codes.length ? `${pack.interaction.presentationFailure} (${codes.join(", ")})` : pack.interaction.presentationFailure);
     io.log(pack.interaction.exactTextRequest.replace("{approval}", refreshedApproval));
     return Object.freeze({ outcome: "exact_text_recovery", requested_decision: true, status: refreshed.status });
   }
@@ -404,7 +453,9 @@ export function printApprovalEnvelope(report, { io = console, reEvaluate } = {})
 function printGateCheckStatusCard(report, io) {
   const card = report.status_card;
   if (!report.status_presentation?.markdown) {
-    io.log(localePack(interactionLocales, card?.presentation_language || "en").interaction.statusPresentationFailure);
+    const failure = localePack(interactionLocales, card?.presentation_language || "en").interaction.statusPresentationFailure;
+    const codes = report.presentation_diagnostics?.status_presentation_errors ?? [];
+    io.log(codes.length ? `${failure} (${codes.join(", ")})` : failure);
     return false;
   }
   io.log(report.status_presentation.markdown);

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/control-evaluation/run-state.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import process from "node:process";
 import { parseControlState, resolveRuns } from "../control-state/index.js";
+import { validateRunIdentity } from "../control-state/run-identity.js";
 import { buildRunCandidates } from "../interaction-presentation.js";
 import { cleanStatusCell, filled, isPlaceholderValue, readTargetFile } from "./shared.js";
 import { extractField, isSafeRepoRelativePath, readVerifiedChangeRecord } from "./verified-change.js";
@@ -87,6 +88,7 @@ export function readRunState(targetDir, selection = {}) {
       memory: {},
       candidate_runs: candidateRuns,
       resolution_error: resolutionError,
+      identity_findings: [],
     };
   }
 
@@ -101,6 +103,10 @@ export function readRunState(targetDir, selection = {}) {
     path: runPath,
     content,
     ...parsed,
+    identity_findings: validateRunIdentity({
+      runId: extractField(content, "run_id").replace(/^`|`$/g, ""),
+      revisionId: extractField(content, "revision_id").replace(/^`|`$/g, ""),
+    }),
   };
 }
 

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/control-state/run-identity.js

@@ -0,0 +1,9 @@
+export const RUN_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+export const REVISION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+export function validateRunIdentity({ runId, revisionId } = {}) {
+  const findings = [];
+  if (!RUN_ID_PATTERN.test(String(runId ?? ""))) findings.push({ code: "AGDF_RUN_ID_INVALID" });
+  if (!REVISION_ID_PATTERN.test(String(revisionId ?? ""))) findings.push({ code: "AGDF_RUN_REVISION_ID_INVALID" });
+  return findings;
+}

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/control-state/run-state-parser.js

@@ -1,4 +1,6 @@
-export const RUN_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+import { REVISION_ID_PATTERN, RUN_ID_PATTERN } from "./run-identity.js";
+
+export { RUN_ID_PATTERN } from "./run-identity.js";
 export const LIFECYCLES = new Set([
   "active",
   "completed",
@@ -34,7 +36,7 @@ export function parseRunState(content, expected) {
     findings.push({ code: "AGDF_RUN_LIFECYCLE_INVALID" });
   if (!/^[1-9]\d*$/.test(values.get("revision") ?? ""))
     findings.push({ code: "AGDF_RUN_REVISION_INVALID" });
-  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(values.get("revision_id") ?? ""))
+  if (!REVISION_ID_PATTERN.test(values.get("revision_id") ?? ""))
     findings.push({ code: "AGDF_RUN_REVISION_ID_INVALID" });
   return {
     content,

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/delivery-path-search/contracts.js

@@ -68,6 +68,10 @@ export function validateSearchInput(value) {
   }
   requireString(input.objective, "objective");
   requireString(input.current_gate, "current_gate");
+  optionalBoundedString(input.scope_revision, "scope_revision", 200);
+  optionalBoundedString(input.input_failure_code, "input_failure_code", 200);
+  optionalBoundedString(input.input_failure_detail, "input_failure_detail", 1000);
+  optionalBoundedString(input.input_recovery_action, "input_recovery_action", 1000);
   stringArray(input.allowed_actions, "allowed_actions");
   stringArray(input.forbidden_actions, "forbidden_actions");
   stringArray(input.evidence_refs ?? [], "evidence_refs");
@@ -81,6 +85,39 @@ export function validateSearchInput(value) {
   return structuredClone(input);
 }
 
+const RESULT_PHASE_BY_STATUS = new Map([
+  ["input_unavailable", "input"],
+  ["no_legal_candidates", "candidate"],
+  ["evaluator_unavailable", "evaluation"],
+  ["evaluator_error", "evaluation"],
+  ["recommendation", "search"],
+  ["no_safe_recommendation", "search"],
+]);
+
+export function validateSearchResult(value) {
+  const result = requireObject(value, "search result");
+  if (result.contract_version !== CONTRACT_VERSION) throw new Error(`unsupported search result contract_version: ${result.contract_version}`);
+  const status = requireString(result.status, "result.status");
+  const expectedPhase = RESULT_PHASE_BY_STATUS.get(status);
+  if (!expectedPhase) throw new Error(`unsupported search result status: ${status}`);
+  if (result.outcome_phase !== expectedPhase) throw new Error(`${status} requires outcome_phase ${expectedPhase}`);
+  requireString(result.scope_key, "result.scope_key");
+  optionalBoundedString(result.scope_revision, "result.scope_revision", 200);
+  const provenance = requireObject(result.provenance, "result.provenance");
+  for (const key of ["baseline_candidates", "generated_candidates", "legal_candidates", "rejected_candidates", "evaluation_attempts", "valid_evaluations", "invalid_evaluations"]) {
+    if (!Number.isInteger(provenance[key]) || provenance[key] < 0) throw new Error(`result.provenance.${key} must be a non-negative integer`);
+  }
+  if (provenance.evaluation_attempts !== provenance.valid_evaluations + provenance.invalid_evaluations) throw new Error("result evaluation provenance counts are inconsistent");
+  const recommendationFacing = status === "recommendation" || status === "no_safe_recommendation";
+  if (recommendationFacing && provenance.valid_evaluations < 1) throw new Error(`${status} requires at least one valid evaluation`);
+  if (status === "recommendation" && !result.recommendation) throw new Error("recommendation status requires recommendation content");
+  if (status !== "recommendation" && result.recommendation != null) throw new Error(`${status} must not contain recommendation content`);
+  if (status === "no_legal_candidates" && (provenance.legal_candidates !== 0 || provenance.evaluation_attempts !== 0)) throw new Error("no_legal_candidates requires zero legal candidates and evaluation attempts");
+  if (status === "input_unavailable" && provenance.evaluation_attempts !== 0) throw new Error("input_unavailable requires zero evaluation attempts");
+  if ((status === "evaluator_unavailable" || status === "evaluator_error") && provenance.valid_evaluations !== 0) throw new Error(`${status} requires zero valid evaluations`);
+  return structuredClone(result);
+}
+
 export function validateCandidate(value) {
   const candidate = requireObject(value, "candidate");
   requireString(candidate.id, "candidate.id");

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/delivery-path-search/persistence.js

@@ -1,5 +1,6 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { validateSearchResult } from "./contracts.js";
 
 function safeResult(result) {
   return JSON.parse(JSON.stringify(result, (key, value) => {
@@ -9,22 +10,33 @@ function safeResult(result) {
 }
 
 export function persistSearchResult(targetDir, result) {
-  const root = join(targetDir, ".agdf", "control", "artefacts", result.scope_key);
+  const validated = validateSearchResult(result);
+  if (!["recommendation", "no_safe_recommendation"].includes(validated.status)) {
+    throw new Error(`search result status ${validated.status} is not persistable`);
+  }
+  if (validated.provenance.valid_evaluations < 1) {
+    throw new Error("search result requires at least one valid evaluation before persistence");
+  }
+  const root = join(targetDir, ".agdf", "control", "artefacts", validated.scope_key);
   const jsonPath = join(root, "DELIVERY_PATH_SEARCH.json");
   const markdownPath = join(root, "DELIVERY_PATH_SEARCH.md");
   mkdirSync(dirname(jsonPath), { recursive: true });
-  const safe = safeResult(result);
+  const safe = safeResult(validated);
   writeFileSync(jsonPath, `${JSON.stringify(safe, null, 2)}\n`, "utf8");
   const recommendation = safe.recommendation?.action ?? "No safe recommendation";
   writeFileSync(markdownPath, [
     "# Delivery Path Search Decision",
     "",
     `- status: ${safe.status}`,
+    `- outcome_phase: ${safe.outcome_phase}`,
+    `- scope_revision: ${safe.scope_revision}`,
     `- current_gate: ${safe.current_gate}`,
     `- enforcement: ${safe.enforcement.level}`,
     `- recommendation: ${recommendation}`,
     `- stopping_reason: ${safe.stopping_reason}`,
     `- evaluations: ${safe.budgets.evaluations}`,
+    `- evaluation_attempts: ${safe.provenance.evaluation_attempts}`,
+    `- invalid_evaluations: ${safe.provenance.invalid_evaluations}`,
     `- generation_status: ${safe.generation?.status ?? "legacy_deterministic"}`,
     `- generated_candidates: ${safe.generation ? `${safe.generation.accepted}/${safe.generation.returned}` : "0/0"}`,
     `- generation_cost_units: ${safe.generation?.cost_units ?? 0}`,