@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-execution-enabled-closeout-boundary.mjs

@@ -0,0 +1,89 @@
+const closeoutIsolationStage = 'P37';
+const closeoutIsolationKind = 'execution-enabled-closeout-isolation';
+
+export function executionEnabledCloseoutIsolation({ digestObject } = {}) {
+  const core = {
+    version: 1,
+    stage: closeoutIsolationStage,
+    isolation_kind: closeoutIsolationKind,
+    execution_evidence_use: {
+      accepted_as_verification_evidence: true,
+      completion_readiness_input: true,
+      source_write_authorized: false,
+      git_authorized: false,
+      subagent_authorized: false,
+      platform_or_model_authorized: false,
+    },
+    required_separate_gates: {
+      source_write: 'source approval gate remains required',
+      git_write: 'task commit gate remains required',
+      subagent: 'explicit permission gate remains required',
+      platform_or_model: 'not authorized by execution-enabled closeout evidence',
+    },
+    allowed_followup: [
+      'use execution audit as verification evidence',
+      'rerun closeout readiness with local evidence',
+      'manual source/git/subagent decision only through separate gates',
+    ],
+    forbidden_actions: [
+      'source write by execution evidence alone',
+      'git add/commit/push/PR/merge by execution evidence alone',
+      'subagent session or adapter dispatch by execution evidence alone',
+      'platform API, external network, model, or MCP call by execution evidence alone',
+      'hidden background chain after closeout evidence passes',
+    ],
+    boundary_assertions: executionEnabledCloseoutIsolationBoundary(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const findings = executionEnabledCloseoutIsolationFindings(core);
+  return {
+    ...core,
+    isolation_pass: findings.length === 0,
+    findings,
+    isolation_digest: typeof digestObject === 'function' ? digestObject(core) : '',
+  };
+}
+
+export function executionEnabledCloseoutIsolationBoundary() {
+  return {
+    evidence_read: true,
+    sidecar_write: false,
+    state_directory_created: false,
+    source_write: false,
+    business_source_write: false,
+    worktree: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    push: false,
+    pr: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    command_execution: false,
+    runtime_action: false,
+    hidden_background_chain: false,
+  };
+}
+
+export function executionEnabledCloseoutIsolationFindings(isolation) {
+  const use = isolation.execution_evidence_use || {};
+  const boundary = isolation.boundary_assertions || {};
+  const writable = Object.entries(boundary)
+    .filter(([key, value]) => key !== 'evidence_read' && value !== false)
+    .map(([key]) => key);
+  return [
+    ...(use.accepted_as_verification_evidence === true ? [] : ['execution evidence must remain accepted as verification evidence only']),
+    ...(use.source_write_authorized === false ? [] : ['execution evidence must not authorize source write']),
+    ...(use.git_authorized === false ? [] : ['execution evidence must not authorize git']),
+    ...(use.subagent_authorized === false ? [] : ['execution evidence must not authorize subagent']),
+    ...(use.platform_or_model_authorized === false ? [] : ['execution evidence must not authorize platform or model access']),
+    ...writable.map((key) => `boundary assertion must remain false: ${key}`),
+  ];
+}

package/tools/vibe-runtime/runtime-execution-enabled-preflight-model.mjs

@@ -0,0 +1,185 @@
+import {
+  controlledLocalRuntimePolicyProfileName,
+  executionEnabledProfileName,
+  manualExecutionProfileName,
+  normalizeExecutionProfile,
+} from './runtime-execution-enabled-profile-contract.mjs';
+import { buildControlledExecutionGateContract } from './runtime-controlled-execution-gate-contract.mjs';
+
+const EXECUTION_AUTOPILOT_BUDGET_PROFILE = 'autopilot-lab';
+
+function profileView(config) {
+  const automationProfile = config?.automation_profile || 'default';
+  const executionProfile = normalizeExecutionProfile(config?.execution_profile || manualExecutionProfileName());
+  return {
+    automation_profile: automationProfile,
+    execution_profile: executionProfile,
+    effective_profile: executionProfile === executionEnabledProfileName() ? executionEnabledProfileName() : automationProfile,
+    policy_profile: config?.execution_profile_policy || manualExecutionProfileName(),
+  };
+}
+
+function knownAllowedActions(policy, actions) {
+  const allowed = new Set(policy.allowed_runtime_actions || []);
+  return actions
+    .filter((action) => allowed.has(action.id) && action.deprecated !== true)
+    .map((action) => action.id)
+    .sort();
+}
+
+function knownBlockedActions(policy, actions) {
+  const allowed = new Set(policy.allowed_runtime_actions || []);
+  return actions
+    .filter((action) => !allowed.has(action.id) || action.deprecated === true)
+    .map((action) => action.id)
+    .sort();
+}
+
+function gateValue(ok) {
+  return ok ? 'passed' : 'blocked';
+}
+
+function preflightFailures({ configReadable, configRead, enabled, budgetProfileMatches, policyMatches, allowedActions, withinActiveLimit, noTempPath }) {
+  return [
+    ...(configReadable ? [] : [configRead.present ? `profile config is invalid: ${configRead.error}` : 'profile config is missing']),
+    ...(enabled ? [] : ['execution profile is not enabled by config']),
+    ...(budgetProfileMatches ? [] : [`automation profile must be ${EXECUTION_AUTOPILOT_BUDGET_PROFILE}`]),
+    ...(policyMatches ? [] : [`execution profile policy must be ${controlledLocalRuntimePolicyProfileName()}`]),
+    ...(allowedActions.length > 0 ? [] : ['no allowed runtime action is available in the builtin catalog']),
+    ...(withinActiveLimit ? [] : ['active run limit is reached']),
+    ...(noTempPath ? [] : ['temporary workspace path is present']),
+  ];
+}
+
+function preflightGates({ configReadable, enabled, budgetProfileMatches, policyMatches, allowedActions, withinActiveLimit, noTempPath, policy }) {
+  return {
+    config_profile: gateValue(configReadable && enabled),
+    task_authorization_budget: gateValue(budgetProfileMatches),
+    policy_profile: gateValue(policyMatches),
+    action_catalog: gateValue(allowedActions.length > 0),
+    active_limit: gateValue(withinActiveLimit),
+    temp_boundary: gateValue(noTempPath),
+    approval_required: policy.approval?.required === true ? 'passed' : 'blocked',
+  };
+}
+
+export function buildExecutionEnabledPreflight({ root, configRead, policy, actions = [], testProfiles = [], activeCount = 0, statePresent = false, tempPresent = false, approvalFreshnessMs = 0 }) {
+  const profileConfigRead = configRead || { file: '', config: null, present: false, error: '' };
+  const view = profileView(profileConfigRead.config);
+  const enabled = view.execution_profile === executionEnabledProfileName();
+  const budgetProfileMatches = view.automation_profile === EXECUTION_AUTOPILOT_BUDGET_PROFILE;
+  const policyMatches = view.policy_profile === controlledLocalRuntimePolicyProfileName();
+  const allowedActions = knownAllowedActions(policy, actions);
+  const blockedActions = knownBlockedActions(policy, actions);
+  const maxActive = Number(policy.limits?.max_active_runs || 0);
+  const withinActiveLimit = maxActive > 0 && activeCount < maxActive;
+  const configReadable = profileConfigRead.present && !profileConfigRead.error;
+  const noTempPath = tempPresent !== true;
+  const facts = { configReadable, configRead: profileConfigRead, enabled, budgetProfileMatches, policyMatches, allowedActions, withinActiveLimit, noTempPath, policy };
+  const failures = preflightFailures(facts);
+  const ready = failures.length === 0;
+  const preflight = {
+    mode: 'execution-enabled-preflight',
+    ok: ready,
+    root,
+    config_file: profileConfigRead.file,
+    config_present: profileConfigRead.present,
+    config_readable: configReadable,
+    enabled_by_config: enabled,
+    automation_profile: view.automation_profile,
+    execution_profile: view.execution_profile,
+    effective_profile: view.effective_profile,
+    policy_profile: controlledLocalRuntimePolicyProfileName(),
+    configured_policy_profile: view.policy_profile,
+    policy_digest: policy.policy_digest,
+    allowed_actions: allowedActions,
+    blocked_actions: blockedActions,
+    allowed_test_profiles: testProfiles.map((profile) => profile.id).sort(),
+    limits: {
+      max_active_runs: maxActive,
+      active_runs: activeCount,
+    },
+    approval_freshness_ms: approvalFreshnessMs,
+    state_present: Boolean(statePresent),
+    temp_path_present: Boolean(tempPresent),
+    state_write_requires_confirm: true,
+    ready_for_candidate: ready,
+    gates: preflightGates(facts),
+    writes: false,
+    quality: failures,
+    action: 'read-only execution-enabled preflight inspected local config and builtin policy data. No state, source, git, platform, model, subagent, or runtime action occurred.',
+  };
+  return {
+    ...preflight,
+    controlled_execution_gate: buildControlledExecutionGateContract({
+      phase: 'profile-preflight',
+      profilePreflight: preflight,
+      policy,
+    }),
+  };
+}
+
+function profileRuntimeActionCatalog({ actionAllowed, actionName, catalogDigest, catalogStage, catalogVersion }) {
+  return {
+    stage: catalogStage,
+    version: catalogVersion,
+    catalog_digest: catalogDigest,
+    action_id: actionName,
+    known: actionAllowed,
+    allowed: actionAllowed,
+    blocked_reasons: actionAllowed ? [] : ['runtime action is not allowed by profile preflight'],
+  };
+}
+
+function profileExecutionBlock({ actionAllowed, actionName, actionCatalog, policy, forbiddenActions }) {
+  return {
+    status: 'profile-preflight',
+    event_file: '',
+    event_sha256: '',
+    claim_status: 'not_required',
+    actor: '',
+    from_skill: '',
+    target_skill: '',
+    allowlisted: actionAllowed,
+    idempotency_key: '',
+    policy,
+    runtime_action: actionName,
+    runtime_action_catalog: actionCatalog,
+    manual_action: 'Create a candidate only after this preflight is ready and an explicit dispatch event is supplied.',
+    writes: [],
+    forbidden_actions: forbiddenActions,
+  };
+}
+
+function profileWriteBoundary(forbiddenActions) {
+  return {
+    expected_writes: [],
+    forbidden_actions: forbiddenActions,
+    state_write_requires_confirm: true,
+    business_source_write: false,
+    git: false,
+    worktree: false,
+  };
+}
+
+export function buildExecutionProfilePreflightEnvelope({ profilePreflight, policy, actionName, catalogDigest, catalogStage, catalogVersion, forbiddenActions, safety }) {
+  const actionAllowed = profilePreflight.allowed_actions.includes(actionName);
+  const actionCatalog = profileRuntimeActionCatalog({ actionAllowed, actionName, catalogDigest, catalogStage, catalogVersion });
+  return {
+    mode: 'execute-preflight',
+    ok: profilePreflight.ok,
+    state_present: profilePreflight.state_present,
+    execution: profileExecutionBlock({ actionAllowed, actionName, actionCatalog, policy, forbiddenActions }),
+    dispatch: null,
+    claim: null,
+    verification: { ok: true, failures: [] },
+    gates: profilePreflight.gates,
+    controlled_execution_gate: profilePreflight.controlled_execution_gate,
+    execution_enabled_preflight: profilePreflight,
+    policy,
+    write_boundary: profileWriteBoundary(forbiddenActions),
+    safety,
+    quality: profilePreflight.quality,
+    action: profilePreflight.action,
+  };
+}

package/tools/vibe-runtime/runtime-execution-enabled-profile-contract.mjs

@@ -0,0 +1,127 @@
+import { buildControlledExecutionGateContract } from './runtime-controlled-execution-gate-contract.mjs';
+
+const EXECUTION_ENABLED_PROFILE = 'execution-enabled';
+const EXECUTION_POLICY_PROFILE = 'controlled-local-runtime';
+const MANUAL_EXECUTION_PROFILE = 'manual';
+const CONTRACT_SYNC_MARKER = 'runtime-cli-usage';
+
+const allowedLocalControls = Object.freeze([
+  'local foreground run after explicit approval',
+  'built-in action catalog item only',
+  'fixed allowlisted test profile only',
+  'candidate, approval, ordered snapshot, and audit sidecars only after confirm',
+]);
+
+const forbiddenControls = Object.freeze([
+  'hidden background chain',
+  'arbitrary shell string',
+  'platform API access',
+  'model invocation',
+  'real subagent session creation',
+  'MCP expansion',
+  'background service or watcher',
+  'business source write by profile alone',
+  'git write, commit, push, PR, or merge',
+  'automatic repair or repeat-on-failure',
+]);
+
+const boundaryAssertions = Object.freeze({
+  profile_config_write: false,
+  state_directory_created: false,
+  sidecar_write: false,
+  command_execution: false,
+  runtime_action: false,
+  auto_execution: false,
+  foreground_only: true,
+  allowlisted_only: true,
+  approval_required: true,
+  arbitrary_shell: false,
+  platform_api: false,
+  external_network: false,
+  model_invocation: false,
+  subagent: false,
+  mcp: false,
+  background_service: false,
+  source_write: false,
+  business_source_write: false,
+  git: false,
+  git_write: false,
+  commit: false,
+  pr: false,
+  push: false,
+  merge: false,
+});
+
+export function executionEnabledProfileName() {
+  return EXECUTION_ENABLED_PROFILE;
+}
+
+export function manualExecutionProfileName() {
+  return MANUAL_EXECUTION_PROFILE;
+}
+
+export function controlledLocalRuntimePolicyProfileName() {
+  return EXECUTION_POLICY_PROFILE;
+}
+
+export function isExecutionEnabledProfile(profile = '') {
+  return profile === EXECUTION_ENABLED_PROFILE;
+}
+
+export function normalizeExecutionProfile(profile = '') {
+  return isExecutionEnabledProfile(profile) ? EXECUTION_ENABLED_PROFILE : MANUAL_EXECUTION_PROFILE;
+}
+
+export function executionEnabledBoundaryAssertions(overrides = {}) {
+  return { ...boundaryAssertions, ...overrides };
+}
+
+export function buildExecutionEnabledProfileContract({ enabled = false, configWrite = false } = {}) {
+  const active = enabled === true;
+  const boundary = executionEnabledBoundaryAssertions({
+    profile_config_write: configWrite === true,
+    command_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+  });
+  const controlledExecutionGate = buildControlledExecutionGateContract({
+    phase: active ? 'profile-enabled' : 'profile-inactive',
+    policy: { allowlisted_skills: [] },
+    writes: false,
+  });
+  return {
+    version: 1,
+    profile: EXECUTION_ENABLED_PROFILE,
+    execution_profile: active ? EXECUTION_ENABLED_PROFILE : MANUAL_EXECUTION_PROFILE,
+    policy_profile: EXECUTION_POLICY_PROFILE,
+    enabled_by_config: active,
+    contract_kind: 'controlled-local-profile-contract',
+    summary: active
+      ? 'explicit local foreground execution gates are available after separate preflight, candidate, approval, and audit steps'
+      : 'execution-enabled contract is known but inactive until explicit config confirmation',
+    allowed_local_controls: allowedLocalControls,
+    forbidden_controls: forbiddenControls,
+    approval_required_before: [
+      'candidate sidecar write',
+      'approval package write',
+      'ordered snapshot write',
+      'foreground run',
+      'test profile run',
+    ],
+    does_not_authorize: [
+      'business source mutation',
+      'git mutation',
+      'subagent session creation',
+      'platform or model calls',
+      'hidden background work',
+    ],
+    controlled_execution_gate: controlledExecutionGate,
+    contract_sync: CONTRACT_SYNC_MARKER,
+    next_gate: active ? 'execution preflight' : 'confirm execution-enabled profile config',
+    boundary_assertions: boundary,
+    writes: configWrite === true,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+}

package/tools/vibe-runtime/runtime-execution-enabled-run-envelope.mjs

@@ -0,0 +1,153 @@
+import {
+  controlledLocalRuntimePolicyProfileName,
+  executionEnabledProfileName,
+} from './runtime-execution-enabled-profile-contract.mjs';
+import { boundedForegroundExecutorEnvelopeFailures } from './runtime-bounded-foreground-command-executor-contract.mjs';
+
+const foregroundSyncMarker = 'runtime-cli-usage';
+
+function list(...groups) {
+  return groups.flat().filter(Boolean);
+}
+
+function candidateBinding(candidate) {
+  return candidate?.candidate?.profile_binding || {};
+}
+
+function approvalBinding(approval) {
+  return approval?.approval?.profile_binding || {};
+}
+
+export function controlledForegroundBinding({ approval, approvalDigest, candidate, candidateDigest, profilePreflight, policyDigest, actionCatalogDigest }) {
+  const candidateProfile = candidateBinding(candidate);
+  const approvalProfile = approvalBinding(approval);
+  const effectiveProfile = profilePreflight?.effective_profile || '';
+  const enabled = profilePreflight?.enabled_by_config === true;
+  const blockedReasons = list(
+    enabled ? '' : 'execution profile is not enabled by config',
+    effectiveProfile === executionEnabledProfileName() ? '' : 'effective profile must be execution-enabled',
+    profilePreflight?.policy_profile === controlledLocalRuntimePolicyProfileName() ? '' : `policy profile must be ${controlledLocalRuntimePolicyProfileName()}`,
+    candidateProfile.effective_profile === executionEnabledProfileName() ? '' : 'candidate effective profile must be execution-enabled',
+    approvalProfile.effective_profile === executionEnabledProfileName() ? '' : 'approval effective profile must be execution-enabled',
+    candidateProfile.enabled_by_config === true ? '' : 'candidate execution profile must be enabled by config',
+    approvalProfile.enabled_by_config === true ? '' : 'approval execution profile must be enabled by config',
+    candidateProfile.policy_profile === controlledLocalRuntimePolicyProfileName() ? '' : `candidate policy profile must be ${controlledLocalRuntimePolicyProfileName()}`,
+    approvalProfile.policy_profile === controlledLocalRuntimePolicyProfileName() ? '' : `approval policy profile must be ${controlledLocalRuntimePolicyProfileName()}`,
+    candidate?.candidate?.ready_for_simulation === true ? '' : 'candidate is not ready',
+    approval?.approval?.ready_for_auto_run === true ? '' : 'approval is not ready',
+    approvalDigest ? '' : 'approval digest is required',
+    candidateDigest ? '' : 'candidate digest is required',
+    approval?.approval?.candidate_digest === candidateDigest ? '' : 'approval candidate digest drifted',
+    candidateProfile.policy_digest === policyDigest ? '' : 'candidate policy digest drifted',
+    approvalProfile.policy_digest === policyDigest ? '' : 'approval policy digest drifted',
+    candidateProfile.action_catalog_digest === actionCatalogDigest ? '' : 'candidate action catalog digest drifted',
+    approvalProfile.action_catalog_digest === actionCatalogDigest ? '' : 'approval action catalog digest drifted',
+    ...(candidateProfile.blocked_reasons || []).map((reason) => `candidate profile: ${reason}`),
+    ...(approvalProfile.blocked_reasons || []).map((reason) => `approval profile: ${reason}`),
+  );
+  return {
+    profile: executionEnabledProfileName(),
+    effective_profile: effectiveProfile,
+    enabled_by_config: enabled,
+    policy_profile: controlledLocalRuntimePolicyProfileName(),
+    candidate_file: approval?.approval?.candidate_file || '',
+    candidate_digest: candidateDigest || '',
+    approval_digest: approvalDigest || '',
+    policy_digest: policyDigest || '',
+    candidate_policy_digest: candidateProfile.policy_digest || '',
+    approval_policy_digest: approvalProfile.policy_digest || '',
+    action_catalog_digest: actionCatalogDigest || '',
+    candidate_action_catalog_digest: candidateProfile.action_catalog_digest || '',
+    approval_action_catalog_digest: approvalProfile.action_catalog_digest || '',
+    ready_for_foreground: blockedReasons.length === 0,
+    blocked_reasons: [...new Set(blockedReasons)],
+    contract_sync: foregroundSyncMarker,
+  };
+}
+
+export function controlledForegroundBindingFailures(execution) {
+  const binding = execution?.execution?.profile_binding || {};
+  return list(
+    binding.effective_profile === executionEnabledProfileName() ? '' : 'foreground effective profile must be execution-enabled',
+    binding.enabled_by_config === true ? '' : 'foreground execution profile must be enabled by config',
+    binding.policy_profile === controlledLocalRuntimePolicyProfileName() ? '' : `foreground policy profile must be ${controlledLocalRuntimePolicyProfileName()}`,
+    binding.ready_for_foreground === true ? '' : 'foreground profile binding must be ready',
+    binding.candidate_digest ? '' : 'foreground candidate digest is required',
+    binding.approval_digest ? '' : 'foreground approval digest is required',
+    binding.policy_digest ? '' : 'foreground policy digest is required',
+    binding.action_catalog_digest ? '' : 'foreground action catalog digest is required',
+    ...(binding.blocked_reasons || []).map((reason) => `foreground profile: ${reason}`),
+  );
+}
+
+export function controlledForegroundEnvelopeFailures({ execution, status, digestObject }) {
+  const details = execution?.execution || {};
+  const failures = [];
+  if (execution?.safety?.controlled_auto_execution !== true) failures.push('safety.controlled_auto_execution must be true');
+  if (execution?.safety?.command_execution !== true) failures.push('safety.command_execution must be true for controlled foreground command');
+  if (execution?.safety?.bounded_foreground_command_execution !== true) failures.push('safety.bounded_foreground_command_execution must be true for controlled foreground command');
+  if (execution?.safety?.auto_execution !== true) failures.push('safety.auto_execution must be true for controlled auto-run');
+  if (details.auto_controlled !== true) failures.push('execution.auto_controlled must be true');
+  for (const key of ['approval_digest', 'lock_digest', 'candidate_file', 'candidate_digest']) if (!details[key]) failures.push(`execution.${key} is required`);
+  failures.push(...controlledForegroundBindingFailures(execution));
+  if (details.duration_ms !== undefined && typeof details.duration_ms !== 'number') failures.push('execution.duration_ms must be a number');
+  if (status !== 'running' && !execution?.evidence?.evidence_digest) failures.push('evidence.evidence_digest is required');
+  else if (status !== 'running' && digestObject(foregroundEvidenceDigestPayload(execution)) !== execution.evidence.evidence_digest) failures.push('evidence.evidence_digest mismatch');
+  failures.push(...boundedForegroundExecutorEnvelopeFailures({ execution, status, digestObject }));
+  return failures;
+}
+
+export function foregroundPreflightGates({ verification, claim, normalizedActor, targetSkill, stopConditionSet, readiness, review, profilePreflight, allowedTargetSkills, reviewBypassSkill }) {
+  return {
+    profile_config: profilePreflight.gates.config_profile,
+    task_authorization_budget: profilePreflight.gates.task_authorization_budget,
+    policy_profile: profilePreflight.gates.policy_profile,
+    action_catalog: profilePreflight.gates.action_catalog,
+    active_limit: profilePreflight.gates.active_limit,
+    temp_boundary: profilePreflight.gates.temp_boundary,
+    dispatch: verification.ok ? 'passed' : 'failed',
+    claim_exists: claim ? 'passed' : 'failed',
+    actor_match: normalizedActor ? (claim?.actor === normalizedActor ? 'passed' : 'failed') : 'not-required',
+    claim_picked: claim?.status === 'picked' ? 'passed' : 'failed',
+    target_allowlisted: allowedTargetSkills.has(targetSkill) ? 'passed' : 'failed',
+    stop_condition: stopConditionSet ? 'blocked' : 'passed',
+    task_readiness: readiness.waiting > 0 || readiness.blocked > 0 ? 'blocked' : 'passed',
+    review: review === 'needs_fix' && targetSkill !== reviewBypassSkill ? 'blocked' : 'passed',
+  };
+}
+
+export function foregroundPreflightFailures(gates, profilePreflight) {
+  return [
+    ...profilePreflight.quality,
+    ...Object.entries(gates)
+      .filter(([, value]) => !['passed', 'not-required'].includes(value))
+      .map(([key, value]) => `${key}:${value}`),
+  ];
+}
+
+export function foregroundEvidenceDigestPayload(envelope) {
+  const details = envelope?.execution || {};
+  const evidence = envelope?.evidence || {};
+  const binding = details.profile_binding || {};
+  return {
+    mode: envelope?.mode || '',
+    status: details.status || '',
+    event_file: details.event_file || '',
+    actor: envelope?.claim?.actor || details.actor || '',
+    target_skill: details.target_skill || '',
+    runtime_action: details.runtime_action || '',
+    started_at: details.started_at || '',
+    ended_at: details.ended_at || '',
+    duration_ms: details.duration_ms ?? null,
+    exit_code: details.exit_code ?? null,
+    candidate_digest: binding.candidate_digest || details.candidate_digest || '',
+    approval_digest: binding.approval_digest || details.approval_digest || '',
+    policy_digest: binding.policy_digest || details.policy_digest || '',
+    action_catalog_digest: binding.action_catalog_digest || details.action_catalog_digest || '',
+    command_profile_id: details.command_profile_id || evidence.command_profile_id || '',
+    command_digest: details.command_digest || evidence.command_digest || '',
+    budget_consumption: evidence.budget_consumption || null,
+    stdout_excerpt: evidence.stdout_excerpt || '',
+    stderr_excerpt: evidence.stderr_excerpt || '',
+  };
+}