@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-governance-surface-reports.mjs

@@ -0,0 +1,495 @@
+export function createRuntimeGovernanceSurfaceReports(deps) {
+  const {
+    fs,
+    path,
+    ensureRoot,
+    stateDir,
+    runtimeContractRoot,
+    backgroundProcessBoundaryKey,
+    digestObject,
+    localJsonFileWithinRoot,
+    printList,
+    runtimeCapabilityRegistry,
+    runtimeCapabilityRegistryDriftGuard,
+    runtimeCapabilityRegistryInvariants,
+    runtimeSkillRuntimeTraceabilityMap,
+    runtimeExperienceFrictionMatrix,
+    runtimeExperienceFrictionDigestPayload,
+    digestExperienceFriction,
+    runtimeExperienceRegressionDashboard,
+    runtimeExperienceRegressionDashboardDigestPayload,
+    digestExperienceRegressionDashboard,
+  } = deps;
+function governanceAdviceBoundaryAssertions() {
+  return {
+    sidecar_write: false,
+    release_gate_write: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    runtime_action: false,
+    auto_execution: false,
+    command_execution: false,
+    business_source_write: false,
+    source_merge: false,
+    skill_mutation: false,
+    hook_registration: false,
+    shell_interception: false,
+    git: false,
+    worktree: false,
+    subagent: false,
+    mcp: false,
+    [backgroundProcessBoundaryKey]: false,
+  };
+}
+
+function normalizeGovernanceAdviceIntent(intent) {
+  const value = String(intent || '').trim().toLowerCase().replace(/_/g, '-');
+  const known = new Set(['closeout', 'review', 'release', 'pr-readiness', 'pr-review-intake', 'convergence', 'compatibility']);
+  return known.has(value) ? value : 'unknown';
+}
+
+function governanceAdviceIntentRoute(intent) {
+  const routes = {
+    closeout: {
+      next: 'read-only-closeout-scan',
+      command: 'governance --convergence --report --json',
+      capabilities: ['Stage 59 convergence report', 'Stage 65 optional release convergence binding', 'Stage 57/58 PR governance sidecars'],
+      action: 'Start closeout with a read-only convergence report, then manually decide whether PR readiness, review intake, or release gate evidence is needed.',
+      hint: 'Use convergence output as orientation only; it does not prove tests, PR approval, or release readiness by itself.',
+    },
+    review: {
+      next: 'manual-review-intake-boundary',
+      command: 'governance --pr-review-intake --from-file <local-evidence-file> --preview --json',
+      capabilities: ['Stage 58 PR review / CI evidence intake', 'vibe-receiving-code-review', 'vibe-systematic-debugging'],
+      action: 'If a human-submitted PR has local review or CI evidence, preview PR review intake from that local file before deciding follow-up.',
+      hint: 'The evidence file must be local and root-scoped; runtime will not query GitHub, CI, review APIs, or platform state.',
+    },
+    release: {
+      next: 'release-gate-with-optional-governance-evidence',
+      command: 'release --gate --from-evals <eval-report-file...> --with-convergence --json',
+      capabilities: ['Stage 52 release gate', 'Stage 65 optional convergence evidence binding', 'Stage 68 release notes sidecar'],
+      action: 'Use release gate evidence only after fresh verification exists; optionally bind convergence evidence explicitly with --with-convergence.',
+      hint: 'Release advice does not create tags, PRs, pushes, release notes, or release gate sidecars.',
+    },
+    'pr-readiness': {
+      next: 'pr-readiness-preview',
+      command: 'governance --pr-readiness --preview --json',
+      capabilities: ['Stage 57 PR readiness governance', 'human PR submission boundary', 'manual duplicate search evidence'],
+      action: 'Preview local PR readiness before any human PR submission; blocked output is acceptable when tests, approval, or duplicate-search evidence is missing.',
+      hint: 'This only checks local readiness evidence and never creates a PR, branch push, merge, or platform call.',
+    },
+    'pr-review-intake': {
+      next: 'pr-review-intake-preview',
+      command: 'governance --pr-review-intake --from-file <local-evidence-file> --preview --json',
+      capabilities: ['Stage 58 PR review / CI evidence intake', 'review feedback routing', 'CI status routing'],
+      action: 'Capture review and CI results from a local evidence file after a human has submitted the PR.',
+      hint: 'Only local evidence is accepted; allowed_followup remains a suggestion and is not executed automatically.',
+    },
+    convergence: {
+      next: 'capability-convergence-report',
+      command: 'governance --convergence --report --json',
+      capabilities: ['Stage 59 convergence report', 'workflow experience', 'learning model', 'deterministic token economy', 'runtime governance'],
+      action: 'Run the read-only convergence report when deciding which capability lane or governance closeout boundary is relevant.',
+      hint: 'Convergence report is orientation evidence; it does not write state or promote optional capabilities into required release chain.',
+    },
+    compatibility: {
+      next: 'compatibility-report',
+      command: 'governance --compatibility --report --json',
+      capabilities: ['Stage 56 runtime compatibility report', 'local sidecar schema audit', 'digest drift orientation'],
+      action: 'Use compatibility report when existing local runtime artifacts may need manual migration or trust classification.',
+      hint: 'Compatibility report never rewrites old artifacts, relaxes verification, or silently migrates state.',
+    },
+    unknown: {
+      next: 'read-only-closeout-scan',
+      command: 'governance --convergence --report --json',
+      capabilities: ['Stage 59 convergence report', 'Stage 57/58 PR governance sidecars', 'Stage 65 optional release convergence binding'],
+      action: 'Unknown governance intent falls back to read-only closeout orientation before selecting a concrete governance command.',
+      hint: 'Clarify whether the task is PR readiness, review intake, release, compatibility, or convergence before writing any sidecar.',
+    },
+  };
+  return routes[intent] || routes.unknown;
+}
+
+function governanceAdviceCloseoutBoundary() {
+  return {
+    boundary_kind: 'manual-closeout-boundary',
+    pr_submission: 'manual-human-action-only',
+    review_intake: 'local-evidence-file-only',
+    release_gate: 'explicit-release-command-only',
+    convergence_binding: 'explicit --with-convergence only',
+    human_approval_required: true,
+    automatic_pr: false,
+    automatic_push: false,
+    automatic_merge: false,
+    automatic_release: false,
+  };
+}
+
+function governanceAdviceEnvelope(root, { intent = '' } = {}) {
+  const inputIntent = String(intent || '').trim();
+  const normalizedIntent = normalizeGovernanceAdviceIntent(inputIntent);
+  const route = governanceAdviceIntentRoute(normalizedIntent);
+  const boundaryAssertions = governanceAdviceBoundaryAssertions();
+  const quality = [];
+  if (inputIntent && normalizedIntent === 'unknown') quality.push('unknown governance advice intent; using read-only closeout orientation');
+  const advice = {
+    version: 1,
+    stage: 'Stage 81',
+    advice_kind: 'runtime-governance-advice',
+    intent: normalizedIntent,
+    input_intent: inputIntent,
+    recommended_next_governance_step: route.next,
+    recommended_command: route.command,
+    manual_action: route.action,
+    verification_hint: route.hint,
+    related_capabilities: route.capabilities,
+    closeout_boundary: governanceAdviceCloseoutBoundary(),
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+  };
+  return {
+    mode: 'runtime-governance-advice',
+    ok: true,
+    state_present: fs.existsSync(stateDir(root)),
+    governance_advice: { ...advice, advice_digest: digestObject(advice) },
+    safety: {
+      stage: 'Stage 81',
+      writes: false,
+      governance_advice_artifact: false,
+      ...boundaryAssertions,
+    },
+    quality,
+    action: `runtime governance advice was computed read-only from builtin Stage 56-59 and Stage 65 governance boundaries. No state directory, sidecar, release gate, PR, push, merge, tag, platform API, external network, model, runtime action, command execution, git, worktree, subagent, MCP, ${backgroundProcessBoundaryKey}, or business source mutation occurred.`,
+  };
+}
+
+const runtimeSurfaceAccessors = {
+  boundaryAssertions() {
+    return runtimeCapabilityRegistry().boundary_assertions;
+  },
+  capabilityGroups() {
+    return runtimeCapabilityRegistry().capability_groups;
+  },
+  stageInventory() {
+    return runtimeCapabilityRegistry().stage_inventory;
+  },
+  closeoutChain() {
+    return runtimeCapabilityRegistry().closeout_chain;
+  },
+};
+
+function runtimeSurfaceEnvelope(root) {
+  ensureRoot(root);
+  const registry = runtimeCapabilityRegistry();
+  const registryInvariants = runtimeCapabilityRegistryInvariants(registry);
+  const boundaryAssertions = runtimeSurfaceAccessors.boundaryAssertions();
+  const registryPayload = {
+    registry_stage: registry.registry_stage,
+    registry_kind: registry.registry_kind,
+    registry_version: registry.registry_version,
+    capability_groups: registry.capability_groups,
+    stage_inventory: registry.stage_inventory,
+    closeout_chain: registry.closeout_chain,
+    boundary_assertions: boundaryAssertions,
+  };
+  const surface = {
+    version: 2,
+    stage: 'Stage 100',
+    surface_kind: 'runtime-capability-surface',
+    registry_stage: registry.registry_stage,
+    registry_kind: registry.registry_kind,
+    registry_version: registry.registry_version,
+    registry_digest: digestObject(registryPayload),
+    registry_invariants: registryInvariants,
+    capability_groups: runtimeSurfaceAccessors.capabilityGroups(),
+    stage_inventory: runtimeSurfaceAccessors.stageInventory(),
+    closeout_chain: runtimeSurfaceAccessors.closeoutChain(),
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return {
+    mode: 'runtime-capability-surface',
+    ok: registryInvariants.pass,
+    state_present: fs.existsSync(stateDir(root)),
+    runtime_surface: { ...surface, surface_digest: digestObject(surface) },
+    safety: { stage: 'Stage 100', registry_stage: registry.registry_stage, ...boundaryAssertions },
+    quality: registryInvariants.findings,
+    action: `runtime capability surface was computed read-only from Stage 101 runtime capability registry metadata covering Stage 78-101 command inventory. No state directory, sidecar, workflow execution, verification command, runtime action, git, PR, push, merge, tag, platform API, external network, model, worktree, subagent, MCP, ${backgroundProcessBoundaryKey}, or business source mutation occurred.`,
+  };
+}
+
+function runtimeRegistryDriftGuardBoundaryAssertions() {
+  return {
+    ...runtimeSurfaceAccessors.boundaryAssertions(),
+    runtime_registry_drift_guard_artifact: false,
+    doc_write: false,
+    check_write: false,
+  };
+}
+
+function releaseCheckDriftGuardMarkerFiles(relativeFile) {
+  if (relativeFile !== 'tools/vibe-release-check/index.mjs') return [relativeFile];
+  return [
+    'tools/vibe-release-check/index.mjs',
+    'tools/vibe-release-check/release-check-command-manifest.mjs',
+    'tools/vibe-release-check/release-check-dispatch.mjs',
+    'tools/vibe-release-check/release-check-runtime.mjs',
+    'tools/vibe-release-check/release-check-stage50-53-smoke.mjs',
+    'tools/vibe-release-check/release-check-runtime-surface-smoke.mjs',
+    'tools/vibe-release-check/release-check-stage119-120-smoke.mjs',
+    'tools/vibe-release-check/release-check-stage137-140-smoke.mjs',
+    'tools/vibe-release-check/release-check-stage103-118-smoke.mjs',
+    'tools/vibe-release-check/release-check-stage121-136-smoke.mjs',
+  ];
+}
+
+function readStaticRuntimeContractFile(root, relativeFile) {
+  return releaseCheckDriftGuardMarkerFiles(relativeFile)
+    .map((fileName) => {
+      const file = path.join(root, fileName);
+      if (!fs.existsSync(file) || !fs.statSync(file).isFile()) return '';
+      return fs.readFileSync(file, 'utf8');
+    })
+    .join('\n');
+}
+
+function runtimeRegistryDriftGuardMarkerFindings(expectations) {
+  return expectations.flatMap((expectation) => {
+    const text = readStaticRuntimeContractFile(runtimeContractRoot, expectation.file);
+    if (!text) return [`doc_marker_expectation missing file: ${expectation.file}`];
+    return expectation.markers
+      .filter((marker) => !text.includes(marker))
+      .map((marker) => `doc_marker_expectation missing marker: ${expectation.file}:${marker}`);
+  });
+}
+
+function runtimeRegistryDriftGuardEnvelope(root) {
+  ensureRoot(root);
+  const surfaceEnvelope = runtimeSurfaceEnvelope(root);
+  const surface = surfaceEnvelope.runtime_surface;
+  const registry = runtimeCapabilityRegistry();
+  const guardResult = runtimeCapabilityRegistryDriftGuard(registry, surface);
+  const markerFindings = runtimeRegistryDriftGuardMarkerFindings(guardResult.doc_marker_expectations);
+  const findings = [...guardResult.findings, ...markerFindings];
+  const boundaryAssertions = runtimeRegistryDriftGuardBoundaryAssertions();
+  const guard = {
+    version: 1,
+    stage: 'Stage 102',
+    guard_kind: 'runtime-capability-registry-drift-guard',
+    registry_stage: registry.registry_stage,
+    registry_kind: registry.registry_kind,
+    registry_version: registry.registry_version,
+    surface_stage: surface.stage,
+    surface_kind: surface.surface_kind,
+    registry_digest: surface.registry_digest,
+    surface_digest: surface.surface_digest,
+    guard_pass: findings.length === 0,
+    checked: guardResult.checked,
+    findings,
+    doc_marker_expectations: guardResult.doc_marker_expectations,
+    manual_action: findings.length === 0
+      ? 'Registry, surface, docs, runtime-check, and release-check drift guard markers are synchronized.'
+      : 'Synchronize the listed registry, surface, docs, runtime-check, or release-check markers before relying on the capability surface.',
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return {
+    mode: 'runtime-capability-registry-drift-guard',
+    ok: guard.guard_pass,
+    state_present: fs.existsSync(stateDir(root)),
+    runtime_registry_drift_guard: { ...guard, drift_guard_digest: digestObject(guard) },
+    safety: { stage: 'Stage 102', registry_stage: registry.registry_stage, surface_stage: surface.stage, ...boundaryAssertions },
+    quality: findings,
+    action: `runtime capability registry drift guard checked fixed local Stage 100-102 registry, surface, docs, runtime-check, and release-check contracts read-only. No state directory, sidecar, command execution, workflow execution, verification command, runtime action, git, PR, push, merge, tag, platform API, external network, model, worktree, subagent, MCP, ${backgroundProcessBoundaryKey}, or business source mutation occurred.`,
+  };
+}
+
+const governanceTraceabilityPrinter = {
+  print(envelope) {
+    const traceability = envelope.skill_runtime_traceability_map;
+    console.log('Vibecoding Runtime Governance');
+    console.log('Mode: skill-to-runtime-traceability-map');
+    console.log(`Stage: ${traceability.stage}; Map: ${traceability.map_kind}; pass=${traceability.ok}`);
+    console.log(`Skills: ${traceability.skill_rows.length}; Links: ${traceability.traceability_rows.length}; Digest: ${traceability.traceability_digest}`);
+    for (const row of traceability.traceability_rows) console.log(`- ${row.skill}: pass=${row.pass}; group=${row.runtime_group}; commands=${row.runtime_commands.join(' | ')}`);
+    if (traceability.blockers.length > 0) printList('Blocked reasons', traceability.blockers);
+    console.log(`Action: ${envelope.action}`);
+  },
+};
+
+const printSkillRuntimeTraceabilityMap = governanceTraceabilityPrinter.print;
+
+function experienceFrictionEnvelope(root, inputFile) {
+  ensureRoot(root);
+  const input = localJsonFileWithinRoot(root, inputFile, 'governance --experience-friction --from-file');
+  const base = runtimeExperienceFrictionMatrix({
+    evidence: input.data,
+    source: {
+      input_file: input.relative,
+      input_digest: input.digest,
+    },
+  });
+  const matrix = {
+    ...base,
+    friction_digest: digestExperienceFriction(runtimeExperienceFrictionDigestPayload(base)),
+  };
+  return {
+    mode: 'experience-friction-matrix',
+    ok: matrix.ok,
+    state_present: fs.existsSync(stateDir(root)),
+    experience_friction_matrix: matrix,
+    safety: { stage: 'Stage 126', ...matrix.boundary_assertions },
+    quality: matrix.experience_friction_invariants.findings,
+    action: 'experience friction matrix was computed read-only from one local session evidence JSON file. No state directory, sidecar, command, check, test, workflow skill execution, runtime action, git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  };
+}
+
+const governanceExperienceFrictionPrinter = {
+  print(envelope) {
+    const matrix = envelope.experience_friction_matrix;
+    console.log('Vibecoding Runtime Experience Friction Matrix');
+    console.log(`Stage: ${matrix.stage}; Kind: ${matrix.matrix_kind}; pass=${matrix.ok}`);
+    console.log(`Source: ${matrix.source_bindings.input_file}; evidence=${matrix.source_bindings.evidence_kind}; case=${matrix.source_bindings.case_id || 'not-provided'}`);
+    console.log(`Friction score: ${matrix.friction_score}; level=${matrix.friction_level}`);
+    for (const dimension of matrix.dimensions) {
+      console.log(`- ${dimension.id}: severity=${dimension.severity}; score=${dimension.score}; weighted=${dimension.weighted_score}`);
+    }
+    printList('Priority fixes', matrix.priority_fixes.map((fix) => `${fix.id}: ${fix.recommended_stage}; ${fix.fix}`));
+    printList('Recommended stage sequence', matrix.recommended_stage_sequence);
+    console.log('Boundary: writes=false; experience_friction_artifact=false; command_execution=false; check_execution=false; test_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+    console.log(`Experience friction digest: ${matrix.friction_digest}`);
+    console.log(`Manual next action: ${matrix.manual_next_action}`);
+    console.log(`Action: ${envelope.action}`);
+  },
+};
+
+const printExperienceFrictionMatrix = governanceExperienceFrictionPrinter.print;
+
+function experienceRegressionDashboardEnvelope(root, { frictionFile = '', consoleFile = '', tokenBudgetFile = '', learningPatternFile = '' } = {}) {
+  ensureRoot(root);
+  if (!frictionFile) throw new Error('governance --experience-dashboard requires --from-friction <local-friction-json>');
+  const frictionInput = localJsonFileWithinRoot(root, frictionFile, 'governance --experience-dashboard --from-friction');
+  const consoleInput = consoleFile ? localJsonFileWithinRoot(root, consoleFile, 'governance --experience-dashboard --from-console') : null;
+  const tokenBudgetInput = tokenBudgetFile ? localJsonFileWithinRoot(root, tokenBudgetFile, 'governance --experience-dashboard --from-token-budget') : null;
+  const learningPatternInput = learningPatternFile ? localJsonFileWithinRoot(root, learningPatternFile, 'governance --experience-dashboard --from-learning-pattern') : null;
+  const base = runtimeExperienceRegressionDashboard({
+    friction: frictionInput.data,
+    console: consoleInput?.data || null,
+    tokenBudget: tokenBudgetInput?.data || null,
+    learningPattern: learningPatternInput?.data || null,
+    source: {
+      friction_file: frictionInput.relative,
+      friction_digest: frictionInput.digest,
+      console_file: consoleInput?.relative || '',
+      console_digest: consoleInput?.digest || '',
+      token_budget_file: tokenBudgetInput?.relative || '',
+      token_budget_digest: tokenBudgetInput?.digest || '',
+      learning_pattern_file: learningPatternInput?.relative || '',
+      learning_pattern_digest: learningPatternInput?.digest || '',
+    },
+  });
+  const dashboard = {
+    ...base,
+    dashboard_digest: digestExperienceRegressionDashboard(runtimeExperienceRegressionDashboardDigestPayload(base)),
+  };
+  return {
+    mode: 'experience-regression-dashboard',
+    ok: dashboard.ok,
+    state_present: fs.existsSync(stateDir(root)),
+    experience_regression_dashboard: dashboard,
+    safety: { stage: 'Stage 132', ...dashboard.boundary_assertions },
+    quality: dashboard.experience_dashboard_invariants.findings,
+    action: 'experience regression dashboard was computed read-only from local Stage 126 friction JSON plus optional local Stage 127 console, Stage 128 token budget, and Stage 129 learning pattern JSON. It only reports scorecard, comparison deltas, blockers, and next bet; no dashboard artifact, state directory, sidecar, command, check, smoke, test, workflow skill execution, runtime action, evidence write, git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  };
+}
+
+function governanceDashboardPrinterBoundary() {
+  return 'governance-dashboard-printer-boundary';
+}
+
+const governanceExperienceDashboardPrinter = {
+  print(envelope) {
+    const dashboard = envelope.experience_regression_dashboard;
+    const scorecard = dashboard.experience_scorecard;
+    console.log('Vibecoding Runtime Experience Regression Dashboard');
+    console.log(`Stage: ${dashboard.stage}; Kind: ${dashboard.dashboard_kind}; pass=${dashboard.ok}`);
+    console.log(`Score: ${scorecard.overall_experience_score}; rating=${scorecard.rating}; friction_relief=${scorecard.friction_relief_score}; next_action=${scorecard.next_action_clarity_score}; token=${scorecard.token_discipline_score}; learning=${scorecard.learning_discipline_score}; evidence=${scorecard.evidence_visibility_score}`);
+    console.log(`Superpowers delta: status=${dashboard.superpowers_comparison_delta.status}; score=${dashboard.superpowers_comparison_delta.score}; gap=${dashboard.superpowers_comparison_delta.superpowers_parity_gap_score}`);
+    console.log(`Token Savior delta: status=${dashboard.token_savior_delta.status}; profile=${dashboard.token_savior_delta.recommended_profile}; overhead=${dashboard.token_savior_delta.token_overhead_score}`);
+    console.log(`Learning loop delta: status=${dashboard.learning_loop_delta.status}; candidates=${dashboard.learning_loop_delta.candidate_count}; promotion_required=${dashboard.learning_loop_delta.promotion_required}`);
+    console.log(`Daily friction delta: status=${dashboard.daily_user_friction_delta.status}; friction_score=${dashboard.daily_user_friction_delta.friction_score}; top=${dashboard.daily_user_friction_delta.top_friction}`);
+    printList('Regression blockers', dashboard.regression_blockers.map((item) => `${item.id}: ${item.severity}; ${item.recommendation}`));
+    console.log(`Next bet: ${dashboard.next_bet.id}; target=${dashboard.next_bet.target_stage}; ${dashboard.next_bet.action}`);
+    console.log('Boundary: writes=false; experience_dashboard_artifact=false; regression_dashboard_artifact=false; sidecar_write=false; state_directory_created=false; source_write=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; verification_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; evidence_write=false; dashboard_write=false; dynamic_tool_execution=false; embeddings=false; remote_config=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; git_add=false; commit=false; pr=false; push=false; merge=false; business_source_write=false');
+    console.log(`Dashboard digest: ${dashboard.dashboard_digest}`);
+    if (envelope.quality.length > 0) printList('Findings', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  },
+};
+
+const printExperienceRegressionDashboard = governanceExperienceDashboardPrinter.print;
+
+function skillRuntimeTraceabilityEnvelope(root) {
+  const traceability = runtimeSkillRuntimeTraceabilityMap(root, runtimeCapabilityRegistry());
+  return {
+    mode: 'skill-to-runtime-traceability-map',
+    ok: traceability.ok,
+    state_present: fs.existsSync(stateDir(root)),
+    skill_runtime_traceability_map: traceability,
+    safety: {
+      stage: 'Stage 123',
+      writes: false,
+      traceability_map_artifact: false,
+      skill_write: false,
+      runtime_registry_write: false,
+      docs_write: false,
+      sidecar_write: false,
+      state_directory_created: false,
+      command_execution: false,
+      check_execution: false,
+      test_execution: false,
+      runtime_action: false,
+      workflow_execution: false,
+      skill_execution: false,
+      auto_execution: false,
+      platform_api: false,
+      external_network: false,
+      model_invocation: false,
+      subagent: false,
+      mcp: false,
+      [backgroundProcessBoundaryKey]: false,
+      git: false,
+      git_write: false,
+      worktree: false,
+      business_source_write: false,
+    },
+    quality: traceability.blockers,
+    action: 'skill-to-runtime traceability map read local skill files and the runtime capability registry only. No skill execution, runtime action, state write, platform API, subagent, git, worktree, check, or test occurred.',
+  };
+}
+
+  return {
+    governanceAdviceEnvelope,
+    runtimeSurfaceEnvelope,
+    runtimeRegistryDriftGuardEnvelope,
+    skillRuntimeTraceabilityEnvelope,
+    printSkillRuntimeTraceabilityMap,
+    experienceFrictionEnvelope,
+    printExperienceFrictionMatrix,
+    experienceRegressionDashboardEnvelope,
+    printExperienceRegressionDashboard,
+  };
+}