@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-context-budget-entry-defaults.mjs

@@ -0,0 +1,341 @@
+import crypto from 'node:crypto';
+
+const entryDefaultsStage = 'Stage 144';
+const entryDefaultsKind = 'context-budget-entry-defaults';
+const budgetStage = 'Stage 128';
+const scorecardStage = 'Stage 140';
+
+const profileOrder = ['tiny_entry', 'balanced_runtime', 'full_maintenance'];
+
+export function runtimeContextBudgetEntryDefaults({ budget = {}, scorecard = {}, source = {} } = {}) {
+  const tokenBudget = unwrapBudget(budget);
+  const parityScorecard = unwrapScorecard(scorecard);
+  const selectedProfile = recommendedProfile(tokenBudget, parityScorecard);
+  const surfaceNow = surfaceNowDefaults(tokenBudget, parityScorecard, selectedProfile);
+  const deferUntilNeeded = deferUntilNeededDefaults(tokenBudget, parityScorecard, selectedProfile, surfaceNow);
+  const boundary = tokenSavingBoundary(tokenBudget, parityScorecard, selectedProfile);
+  const core = {
+    version: 1,
+    stage: entryDefaultsStage,
+    defaults_kind: entryDefaultsKind,
+    source_bindings: sourceBindingSummary(source, tokenBudget, parityScorecard),
+    input_summary: inputSummary(tokenBudget, parityScorecard),
+    recommended_profile: selectedProfile,
+    surface_now: surfaceNow,
+    defer_until_needed: deferUntilNeeded,
+    token_saving_boundary: boundary,
+    boundary_assertions: runtimeContextBudgetEntryDefaultsBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeContextBudgetEntryDefaultsInvariants(core);
+  const defaults = {
+    ...core,
+    ok: invariants.pass,
+    entry_defaults_invariants: invariants,
+  };
+  return {
+    ...defaults,
+    entry_defaults_digest: digestContextBudgetEntryDefaults(runtimeContextBudgetEntryDefaultsDigestPayload(defaults)),
+  };
+}
+
+export function runtimeContextBudgetEntryDefaultsDigestPayload(defaults) {
+  return {
+    stage: defaults.stage,
+    defaults_kind: defaults.defaults_kind,
+    source_bindings: defaults.source_bindings,
+    input_summary: defaults.input_summary,
+    recommended_profile: defaults.recommended_profile,
+    surface_now: defaults.surface_now,
+    defer_until_needed: defaults.defer_until_needed,
+    token_saving_boundary: defaults.token_saving_boundary,
+    boundary_assertions: defaults.boundary_assertions,
+    entry_defaults_invariants: defaults.entry_defaults_invariants,
+  };
+}
+
+export function runtimeContextBudgetEntryDefaultsBoundaryAssertions() {
+  return {
+    context_budget_entry_defaults_artifact: false,
+    entry_defaults_artifact: false,
+    token_budget_artifact: false,
+    parity_scorecard_artifact: false,
+    prompt_write: false,
+    prompt_mutation: false,
+    template_mutation: false,
+    skill_mutation: false,
+    hook_registration: false,
+    hook_execution: false,
+    adapter_execution: false,
+    full_skill_injection: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: 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,
+    repair_execution: false,
+    dynamic_tool_execution: false,
+    embeddings: false,
+    remote_config: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    git_write: false,
+    git_add: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeContextBudgetEntryDefaultsInvariants(defaults) {
+  const unsafeBoundaries = Object.entries(defaults.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = Object.keys(runtimeContextBudgetEntryDefaultsBoundaryAssertions())
+    .filter((key) => defaults.boundary_assertions?.[key] !== false);
+  const surface = listValue(defaults.surface_now);
+  const defer = listValue(defaults.defer_until_needed);
+  const boundary = listValue(defaults.token_saving_boundary);
+  const surfaceFullInjection = surface
+    .filter((item) => item.full_skill_text === true || /full skill injection|完整 skill 注入/i.test(`${item.default || ''} ${item.reason || ''}`))
+    .map((item) => item.id);
+  const executableSurface = surface
+    .filter((item) => /(^|\s)(--confirm|--run|--once|--auto-run|git\s+(commit|push|merge|tag)|gh\s+pr)(\s|$)/i.test(item.preview || item.default || ''))
+    .map((item) => item.id);
+  const findings = [
+    ...(defaults.stage === entryDefaultsStage ? [] : [`stage must be ${entryDefaultsStage}`]),
+    ...(defaults.defaults_kind === entryDefaultsKind ? [] : [`defaults_kind must be ${entryDefaultsKind}`]),
+    ...(defaults.source_bindings?.budget_file ? [] : ['budget file binding is required']),
+    ...(defaults.source_bindings?.budget_digest ? [] : ['budget digest binding is required']),
+    ...(defaults.source_bindings?.scorecard_file ? [] : ['scorecard file binding is required']),
+    ...(defaults.source_bindings?.scorecard_digest ? [] : ['scorecard digest binding is required']),
+    ...(defaults.input_summary?.budget_stage === budgetStage ? [] : [`budget input must be ${budgetStage}`]),
+    ...(defaults.input_summary?.scorecard_stage === scorecardStage ? [] : [`scorecard input must be ${scorecardStage}`]),
+    ...(profileOrder.includes(defaults.recommended_profile) ? [] : [`recommended_profile must be one of ${profileOrder.join(', ')}`]),
+    ...(surface.length >= 3 ? [] : ['surface_now must include at least profile, entry gate, and evidence/default pointer items']),
+    ...(defer.length >= 2 ? [] : ['defer_until_needed must include deferred context items']),
+    ...(boundary.length >= 5 ? [] : ['token_saving_boundary must include fixed non-execution boundaries']),
+    ...(surface.some((item) => item.id === 'using-vibecoding-lightweight-entry') ? [] : ['surface_now must include using-vibecoding lightweight entry default']),
+    ...(defer.some((item) => item.id === 'full-using-vibecoding-skill-text') ? [] : ['defer_until_needed must defer full using-vibecoding skill text']),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingForbidden.map((key) => `forbidden boundary missing or not false: ${key}`),
+    ...surfaceFullInjection.map((id) => `surface_now must not imply full skill injection: ${id}`),
+    ...executableSurface.map((id) => `surface_now must remain preview-only and non-executing: ${id}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['stage_128_budget_binding', 'stage_140_scorecard_binding', 'profile_selection', 'surface_now_defaults', 'defer_until_needed_defaults', 'token_saving_boundaries', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestContextBudgetEntryDefaults(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function unwrapBudget(input) {
+  return objectValue(input.token_savior_budget || input.budget || input);
+}
+
+function unwrapScorecard(input) {
+  return objectValue(input.superpowers_parity_scorecard || input.scorecard || input);
+}
+
+function sourceBindingSummary(source, tokenBudget, parityScorecard) {
+  return {
+    budget_file: stringValue(source.budget_file),
+    budget_digest: stringValue(source.budget_digest),
+    scorecard_file: stringValue(source.scorecard_file),
+    scorecard_digest: stringValue(source.scorecard_digest),
+    budget_stage: stringValue(tokenBudget.stage),
+    scorecard_stage: stringValue(parityScorecard.stage),
+    budget_artifact_digest: stringValue(tokenBudget.budget_digest),
+    scorecard_artifact_digest: stringValue(parityScorecard.parity_digest),
+  };
+}
+
+function inputSummary(tokenBudget, parityScorecard) {
+  const contextAxis = scorecardAxis(parityScorecard, 'token_and_context_economy');
+  return {
+    budget_stage: stringValue(tokenBudget.stage),
+    budget_kind: stringValue(tokenBudget.budget_kind),
+    budget_recommended_profile: stringValue(tokenBudget.recommended_profile),
+    budget_max_context_tokens: numberValue(tokenBudget.context_budget?.max_context_tokens),
+    surfaced_skill_count: listValue(tokenBudget.skills_to_surface).length,
+    deferred_skill_count: listValue(tokenBudget.skills_to_defer).length,
+    scorecard_stage: stringValue(parityScorecard.stage),
+    scorecard_kind: stringValue(parityScorecard.scorecard_kind),
+    parity_score: numberValue(parityScorecard.parity_score),
+    token_context_axis_score: numberValue(contextAxis.axis_score),
+    token_context_axis_status: stringValue(contextAxis.status),
+    next_cycle_candidate_id: stringValue(parityScorecard.next_cycle_bet?.candidate_id),
+  };
+}
+
+function recommendedProfile(tokenBudget, parityScorecard) {
+  const budgetProfile = normalizeProfile(tokenBudget.recommended_profile);
+  const contextAxis = scorecardAxis(parityScorecard, 'token_and_context_economy');
+  const dailyAxis = scorecardAxis(parityScorecard, 'daily_user_friction');
+  const score = numberValue(contextAxis.axis_score, 0);
+  const dailyScore = numberValue(dailyAxis.axis_score, 0);
+  const nextCandidate = stringValue(parityScorecard.next_cycle_bet?.candidate_id);
+  if (nextCandidate.includes('context') || nextCandidate.includes('token')) return budgetProfile === 'full_maintenance' ? 'balanced_runtime' : budgetProfile;
+  if (budgetProfile === 'full_maintenance' && score >= 70 && dailyScore >= 70) return 'balanced_runtime';
+  if (budgetProfile === 'balanced_runtime' && score >= 86 && dailyScore >= 80) return 'tiny_entry';
+  return budgetProfile;
+}
+
+function surfaceNowDefaults(tokenBudget, parityScorecard, profile) {
+  const contextBudget = objectValue(tokenBudget.context_budget);
+  const surfacedSkills = listValue(tokenBudget.skills_to_surface).map((item) => stringValue(item.skill)).filter(Boolean);
+  const previewCommands = listValue(tokenBudget.commands_to_surface).slice(0, profile === 'tiny_entry' ? 1 : 2);
+  const axis = scorecardAxis(parityScorecard, 'token_and_context_economy');
+  const items = [
+    {
+      id: 'recommended-profile',
+      default: profile,
+      reason: `Use ${profile} as the visible entry context budget instead of loading every workflow instruction.`,
+      max_context_tokens: numberValue(contextBudget.max_context_tokens),
+      full_skill_text: false,
+    },
+    {
+      id: 'using-vibecoding-lightweight-entry',
+      default: 'Show the using-vibecoding routing sentence and selected workflow lane only.',
+      reason: 'Keep the entry skill visible while deferring full skill text until the user actually needs the workflow depth.',
+      skills: surfacedSkills.includes('using-vibecoding') ? ['using-vibecoding'] : ['using-vibecoding'],
+      full_skill_text: false,
+    },
+    {
+      id: 'local-evidence-pointer',
+      default: 'Point to the local budget and parity scorecard evidence files by path and digest.',
+      reason: 'Users can verify why context was surfaced without expanding the whole workflow manual.',
+      full_skill_text: false,
+    },
+    {
+      id: 'token-context-axis-signal',
+      default: `token_and_context_economy=${numberValue(axis.axis_score)} (${stringValue(axis.status) || 'unknown'})`,
+      reason: 'Expose the parity signal that justifies a compact default.',
+      full_skill_text: false,
+    },
+  ];
+  for (const command of previewCommands) {
+    items.push({
+      id: `preview-${stringValue(command.id) || 'command'}`,
+      default: 'Preview command only; do not execute from entry defaults.',
+      preview: stringValue(command.command),
+      reason: stringValue(command.reason || 'Keep command discovery visible without authorizing execution.'),
+      full_skill_text: false,
+    });
+  }
+  return dedupeById(items);
+}
+
+function deferUntilNeededDefaults(tokenBudget, parityScorecard, profile, surfaceNow) {
+  const surfacedIds = new Set(listValue(surfaceNow).map((item) => item.id));
+  const deferredSkills = listValue(tokenBudget.skills_to_defer).map((item) => ({
+    id: `skill-${slug(stringValue(item.skill))}`,
+    defer: stringValue(item.skill),
+    until: 'User selects the matching workflow lane or local evidence shows the workflow step needs that skill.',
+    reason: stringValue(item.reason || 'Deferred to preserve the entry context budget.'),
+  }));
+  const fixed = [
+    {
+      id: 'full-using-vibecoding-skill-text',
+      defer: 'Full using-vibecoding skill body',
+      until: 'The user explicitly asks for full workflow context or the selected workflow requires deeper method instructions.',
+      reason: 'Stage 144 keeps the default entry visible but avoids default full skill injection.',
+    },
+    {
+      id: 'all-workflow-skills',
+      defer: 'Unselected workflow skills and long method docs',
+      until: 'A later local contract selects that workflow path.',
+      reason: profile === 'tiny_entry' ? 'Tiny entry mode should stay below the minimum visible routing budget.' : 'Balanced entry mode still should not load unrelated workflow branches.',
+    },
+    {
+      id: 'live-eval-or-agent-context',
+      defer: 'Live eval, model judge, agent-session, or subagent context',
+      until: 'A separate explicit user permission and local guardrail contract exists.',
+      reason: 'Entry defaults are deterministic advice only.',
+    },
+  ];
+  return dedupeById([...fixed, ...deferredSkills]).filter((item) => !surfacedIds.has(item.id));
+}
+
+function tokenSavingBoundary(tokenBudget, parityScorecard, profile) {
+  return [
+    { id: 'no-full-skill-injection', boundary: 'Do not inject complete using-vibecoding or workflow skill text by default.', enforced: true },
+    { id: 'no-embeddings-or-models', boundary: 'Do not use embeddings, remote config, model calls, or platform APIs to choose the profile.', enforced: true },
+    { id: 'no-command-execution', boundary: 'Preview commands may be shown, but entry defaults never execute checks, tests, shell commands, hooks, adapters, or workflows.', enforced: true },
+    { id: 'no-state-or-source-writes', boundary: 'Do not write sidecars, state directories, prompts, templates, hooks, skills, docs, manifests, or source files from this capability.', enforced: true },
+    { id: 'no-git-or-pr-actions', boundary: 'Do not run git add/commit/push/merge/tag or PR operations.', enforced: true },
+    { id: 'no-subagent-or-mcp', boundary: 'Do not invoke subagents, MCP, daemons, or agent sessions.', enforced: true },
+    { id: 'budget-evidence-only', boundary: `Use ${stringValue(tokenBudget.recommended_profile)} and parity score ${numberValue(parityScorecard.parity_score)} as local evidence only; recommended entry profile is ${profile}.`, enforced: true },
+  ];
+}
+
+function scorecardAxis(scorecard, id) {
+  return listValue(scorecard.parity_axes).find((axis) => stringValue(axis.id) === id) || {};
+}
+
+function normalizeProfile(value) {
+  const profile = stringValue(value);
+  return profileOrder.includes(profile) ? profile : 'balanced_runtime';
+}
+
+function dedupeById(items) {
+  const seen = new Set();
+  return items.filter((item) => {
+    const id = stringValue(item.id);
+    if (!id || seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+}
+
+function slug(value) {
+  return String(value || 'unknown').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'unknown';
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function stringValue(value) {
+  return typeof value === 'string' ? value.trim() : value == null ? '' : String(value).trim();
+}
+
+function numberValue(value, fallback = 0) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/runtime-contract-marker-registry.mjs

@@ -0,0 +1,13 @@
+export const runtimeContractSyncMarker = Object.freeze({
+  runtime_check_owner: 'tools/vibe-runtime-check/index.mjs',
+  doctor_owner: 'tools/vibe-doctor/index.mjs',
+  release_check_owner: 'tools/vibe-release-check',
+  runtime_readme_owner: 'tools/vibe-runtime/README.md',
+});
+
+export function runtimeContractSyncOwner(owner) {
+  return Object.freeze({
+    owner,
+    ...runtimeContractSyncMarker,
+  });
+}

package/tools/vibe-runtime/runtime-contributor-guardrail-command.mjs

@@ -0,0 +1,78 @@
+import {
+  ensureRoot,
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  runtimeContributorGuardrailEvidence,
+} from './runtime-contributor-guardrail-evidence.mjs';
+
+function printList(title, items, format = (item) => String(item)) {
+  if (!items || items.length === 0) return;
+  console.log(`${title}:`);
+  for (const item of items) console.log(`- ${format(item)}`);
+}
+
+export function contributorGuardrailEvidenceEnvelope(root, { scorecardFile = '', evidencePromptsFile = '' } = {}) {
+  ensureRoot(root);
+  if (!scorecardFile) throw new Error('governance --contributor-guardrails requires --from-scorecard <local-parity-scorecard-json>');
+  if (!evidencePromptsFile) throw new Error('governance --contributor-guardrails requires --from-evidence-prompts <local-evidence-prompts-json>');
+  const scorecardInput = localJsonFileWithinRoot(root, scorecardFile, 'governance --contributor-guardrails --from-scorecard');
+  const evidencePromptsInput = localJsonFileWithinRoot(root, evidencePromptsFile, 'governance --contributor-guardrails --from-evidence-prompts');
+  const guardrails = runtimeContributorGuardrailEvidence({
+    scorecard: scorecardInput.data,
+    evidencePrompts: evidencePromptsInput.data,
+    source: {
+      scorecard_file: scorecardInput.relative,
+      scorecard_digest: scorecardInput.digest,
+      evidence_prompts_file: evidencePromptsInput.relative,
+      evidence_prompts_digest: evidencePromptsInput.digest,
+    },
+  });
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'contributor-guardrail-evidence',
+    ok: guardrails.ok,
+    payloadKey: 'contributor_guardrail_evidence',
+    payload: guardrails,
+    safety: { stage: 'Stage 146', ...guardrails.boundary_assertions },
+    quality: guardrails.guardrail_invariants.findings,
+    action: 'contributor guardrail evidence was computed read-only from local Stage 140 parity scorecard JSON and local Stage 143 next-action evidence prompts JSON. It only emits local guardrail findings, required disclosures, unsafe closeout risks, and a non-authorizing closeout contract; no PR creation, remote PR/review search, push, merge, command/check/test/workflow execution, auto-fix, source/state/artifact write, git, platform API, model, MCP, or subagent action occurred.',
+  });
+}
+
+export function printContributorGuardrailEvidence(envelope) {
+  const guardrails = envelope.contributor_guardrail_evidence;
+  console.log('Vibecoding Runtime Contributor Guardrail Evidence');
+  console.log(`Stage: ${guardrails.stage}; Kind: ${guardrails.guardrail_kind}; pass=${guardrails.ok}`);
+  console.log(`Inputs: scorecard=${guardrails.input_summary.scorecard_stage}; evidence_prompts=${guardrails.input_summary.evidence_prompts_stage}; findings=${guardrails.input_summary.guardrail_finding_count}`);
+  printList('Guardrail findings', guardrails.guardrail_findings, (item) => `${item.id}: ${item.severity}; ${item.action}`);
+  printList('Required disclosures', guardrails.required_disclosures, (item) => `${item.id}: ${item.disclosure}`);
+  printList('Unsafe closeout risks', guardrails.unsafe_closeout_risks, (item) => `${item.id}: ${item.severity}; ${item.risk}`);
+  console.log(`Closeout contract: evidence_required=${guardrails.closeout_contract.evidence_required_before_completion_claim}; commit_allowed=${guardrails.closeout_contract.commit_allowed_by_contract}; pr_allowed=${guardrails.closeout_contract.pr_allowed_by_contract}; push_allowed=${guardrails.closeout_contract.push_allowed_by_contract}`);
+  console.log('Boundary: writes=false; contributor_guardrail_evidence_artifact=false; guardrail_artifact=false; parity_scorecard_artifact=false; evidence_prompts_artifact=false; disclosure_artifact=false; closeout_artifact=false; pr_readiness_artifact=false; pr_review_artifact=false; remote_pr_search=false; remote_review_search=false; source_write=false; sidecar_write=false; state_directory_created=false; evidence_write=false; disclosure_write=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; eval_execution=false; verification_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; repair_execution=false; auto_fix=false; prompt_mutation=false; template_mutation=false; skill_mutation=false; hook_execution=false; adapter_execution=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(`Guardrail digest: ${guardrails.guardrail_digest}`);
+  if (envelope.quality.length > 0) printList('Findings', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runContributorGuardrailCommand(options, deps) {
+  if (options.governanceReport) throw new Error('governance --contributor-guardrails does not accept --report');
+  if (options.confirm || options.dryRun || options.write || options.preflight || options.dispatch || options.dispatchIntent || options.scan || options.once || options.run || options.autoRun || options.fromDispatch || options.dispatchEvent || options.actor || options.approval) throw new Error('governance --contributor-guardrails is read-only and evidence-only');
+  if (!options.fromScorecard) throw new Error('governance --contributor-guardrails requires --from-scorecard <local-parity-scorecard-json>');
+  if (!options.fromEvidencePrompts) throw new Error('governance --contributor-guardrails requires --from-evidence-prompts <local-evidence-prompts-json>');
+  if (options.fromFile || options.fromSuperpowers || options.fromReadiness || options.fromFriction || options.fromConsole || options.fromTokenBudget || options.fromBudget || options.fromLearningPattern || options.fromComparison || options.fromDashboard || options.fromInstallExperience || options.fromShape || options.fromEntryDiscipline || options.fromDiscipline || options.fromUpgrades || options.fromBootstrapMatrix || options.fromEntryAcceptance || options.fromStylePack || options.fromEntryTightening || options.fromRunbook || options.fromEvidence || options.fromExecutablePlan || options.fromPlan || options.selectedStage || options.task || options.commitSubject || options.confirmPlan || options.fromGap || options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile || options.methodologyIntent || options.methodologyKind || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0 || options.prompt) throw new Error('governance --contributor-guardrails only accepts --from-scorecard, --from-evidence-prompts, --json, and --root');
+  const envelope = contributorGuardrailEvidenceEnvelope(options.root, {
+    scorecardFile: options.fromScorecard,
+    evidencePromptsFile: options.fromEvidencePrompts,
+  });
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'governance',
+    envelope,
+    print: printContributorGuardrailEvidence,
+  });
+}