@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-platform-transcript-replay-model.mjs

@@ -0,0 +1,371 @@
+import crypto from 'node:crypto';
+
+export const platformTranscriptReplayStage = 'P23';
+export const platformTranscriptReplayKind = 'platform-transcript-replay';
+
+const replayRows = [
+  'entry_route',
+  'skill_claim_evidence',
+  'sdd_loop_evidence',
+  'review_blocker',
+  'resume_dedupe',
+  'completion_evidence',
+  'forbidden_action_boundary',
+];
+const sideEffectKeys = ['platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'git', 'git_write', 'command_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'source_write', 'business_source_write'];
+
+export function runtimePlatformTranscriptReplay({ intake = {}, source = {} } = {}) {
+  const transcript = normalizedTranscript(intake);
+  const text = transcriptText(transcript);
+  const markers = canonicalMarkers(transcript, text);
+  const rows = replayRows.map((row) => gapRow(row, transcript, markers, text));
+  const fixture = behaviorFixture(transcript, markers, rows);
+  const core = {
+    version: 1,
+    stage: platformTranscriptReplayStage,
+    replay_kind: platformTranscriptReplayKind,
+    source_binding: sourceBinding(source, intake, transcript),
+    input_summary: inputSummary(transcript, markers),
+    behavior_fixture: fixture,
+    gap_matrix: rows,
+    boundary_assertions: replayBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = replayInvariants(core);
+  const replay = {
+    ...core,
+    ok: invariants.pass,
+    replay_invariants: invariants,
+  };
+  return {
+    ...replay,
+    replay_digest: digestObject(replayDigestPayload(replay)),
+  };
+}
+
+export function replayDigestPayload(replay) {
+  return {
+    stage: replay.stage,
+    replay_kind: replay.replay_kind,
+    source_binding: replay.source_binding,
+    input_summary: replay.input_summary,
+    behavior_fixture: replay.behavior_fixture,
+    gap_matrix: replay.gap_matrix,
+    boundary_assertions: replay.boundary_assertions,
+    replay_invariants: replay.replay_invariants,
+  };
+}
+
+export function replayBoundaryAssertions() {
+  return {
+    transcript_replay_artifact: false,
+    behavior_fixture_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function replayInvariants(replay) {
+  const unsafeBoundaries = Object.entries(replay.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingBoundaries = Object.keys(replayBoundaryAssertions())
+    .filter((key) => replay.boundary_assertions?.[key] !== false);
+  const rows = listValue(replay.gap_matrix);
+  const rowIds = rows.map((row) => stringValue(row.row));
+  const fixture = replay.behavior_fixture || {};
+  const findings = [
+    ...(replay.stage === platformTranscriptReplayStage ? [] : [`stage must be ${platformTranscriptReplayStage}`]),
+    ...(replay.replay_kind === platformTranscriptReplayKind ? [] : [`replay_kind must be ${platformTranscriptReplayKind}`]),
+    ...(fixture.transcript_kind === platformTranscriptReplayKind ? [] : ['behavior fixture kind must match replay kind']),
+    ...(Array.isArray(fixture.transcript) && fixture.transcript.length > 0 ? [] : ['behavior fixture transcript must include turns']),
+    ...(rowIds.length === replayRows.length ? [] : ['gap matrix must include every replay row']),
+    ...replayRows.filter((row) => !rowIds.includes(row)).map((row) => `missing gap matrix row: ${row}`),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingBoundaries.map((key) => `forbidden boundary missing or not false: ${key}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['normalized_transcript', 'behavior_fixture', 'gap_matrix', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+function normalizedTranscript(input) {
+  const value = input.normalized_transcript || input.platform_transcript || input;
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function sourceBinding(source, intake, transcript) {
+  return {
+    source_file: stringValue(source.file || intake.source_binding?.file || transcript.source_file),
+    source_digest: stringValue(source.digest || intake.source_binding?.digest || transcript.source_digest),
+    intake_digest: stringValue(source.intake_digest || intake.intake_digest),
+    platform: stringValue(transcript.platform || 'unknown'),
+  };
+}
+
+function inputSummary(transcript, markers) {
+  return {
+    platform: stringValue(transcript.platform || 'unknown'),
+    turn_count: turns(transcript).length,
+    marker_count: markers.length,
+    command_text_count: listValue(transcript.observed?.commands).length,
+    artifact_ref_count: listValue(transcript.artifact_refs).length,
+  };
+}
+
+function behaviorFixture(transcript, markers, rows) {
+  const observed = observedBehavior(transcript, markers, rows);
+  const expected = {
+    workflow_order: hasMarker(markers, 'using-vibecoding') ? ['using-vibecoding'] : [],
+    required_markers: ['using-vibecoding', 'injectsFullSkill=false'].filter((marker) => hasMarker(markers, marker)),
+    forbidden_markers: ['subagent=true', 'git=true', 'platform_api=true', 'model_invocation=true', 'command_execution=true', 'evidence_free_completion=true'],
+    continue_plan_without_reasking: hasMarker(markers, 'continue_without_reasking_required'),
+    sdd_loop_required: rows.find((row) => row.row === 'sdd_loop_evidence')?.pass === true && hasMarker(markers, 'sdd_loop_required=true'),
+    fix_loop_required: hasMarker(markers, 'fixer_brief=true'),
+    review_blocker_must_stop: hasMarker(markers, 'review_blocker=true'),
+    resume_without_duplicate_dispatch: hasMarker(markers, 'resume_without_duplicate_dispatch_required'),
+    blocked_reasons: [],
+  };
+  const fixture = {
+    case_id: `p23-${stringValue(transcript.platform || 'unknown')}-transcript-replay`,
+    transcript_kind: platformTranscriptReplayKind,
+    transcript_stage: platformTranscriptReplayStage,
+    transcript: turns(transcript),
+    expected,
+    observed,
+  };
+  return { ...fixture, transcript_digest: digestObject(fixture) };
+}
+
+function observedBehavior(transcript, markers, rows) {
+  const blocked = rows.find((row) => row.row === 'review_blocker')?.pass === true && hasMarker(markers, 'review_blocker=true') ? ['review blocker recorded'] : listValue(transcript.observed?.blocked_reasons);
+  return {
+    workflow_order: workflowObserved(transcript, markers),
+    markers,
+    commands: listValue(transcript.observed?.commands),
+    validation_evidence: validationEvidence(transcript, markers),
+    claims: listValue(transcript.observed?.claims),
+    task_loop: taskLoop(markers),
+    review_gate: reviewGate(markers),
+    progress_ledger: progressLedger(markers),
+    blocked_reasons: blocked,
+    git_side_effects: boundaryTrue(transcript, 'git') || boundaryTrue(transcript, 'git_write'),
+    git: boundaryTrue(transcript, 'git'),
+    pr: boundaryTrue(transcript, 'pr'),
+    push: boundaryTrue(transcript, 'push'),
+    merge: boundaryTrue(transcript, 'merge'),
+    platform_api: boundaryTrue(transcript, 'platform_api'),
+    model_invocation: boundaryTrue(transcript, 'model_invocation'),
+    subagent: boundaryTrue(transcript, 'subagent'),
+  };
+}
+
+function gapRow(row, transcript, markers, text) {
+  const result = rowResult(row, transcript, markers, text);
+  return {
+    row,
+    pass: result.pass,
+    expected: result.expected,
+    observed: result.observed,
+    gap_reason: result.pass ? '' : result.gap_reason,
+    behavior_gate: result.behavior_gate,
+  };
+}
+
+function rowResult(row, transcript, markers, text) {
+  const table = {
+    entry_route: () => entryRouteResult(markers, text),
+    skill_claim_evidence: () => skillClaimResult(transcript, markers),
+    sdd_loop_evidence: () => sddLoopResult(transcript, markers),
+    review_blocker: () => reviewBlockerResult(transcript, markers),
+    resume_dedupe: () => resumeResult(transcript, markers),
+    completion_evidence: () => completionResult(transcript, markers, text),
+    forbidden_action_boundary: () => boundaryResult(transcript, markers),
+  };
+  return table[row]();
+}
+
+function entryRouteResult(markers, text) {
+  const pass = hasMarker(markers, 'using-vibecoding') || includesText(text, 'workflow route') || includesText(text, 'route: using-vibecoding');
+  return result(pass, 'visible using-vibecoding or equivalent route evidence', pass ? 'entry evidence present' : 'entry evidence missing', 'workflow-entry-invoked');
+}
+
+function skillClaimResult(transcript, markers) {
+  const claims = claimedSkills(transcript);
+  const missing = claims.filter((skill) => !markers.some((marker) => includesText(marker, skill)) && !workflowObserved(transcript, markers).some((step) => includesText(step, skill)));
+  return result(missing.length === 0, 'claimed skills have marker or workflow evidence', claims.length ? `claimed=${claims.join(', ')}` : 'no skill claims', 'false-skill-claim', missing.map((skill) => `missing evidence for ${skill}`).join('; '));
+}
+
+function sddLoopResult(transcript, markers) {
+  const relevant = hasAnyMarker(markers, ['task_brief_present', 'review_package_present', 'implementer_artifact_present', 'sdd_loop_required=true']);
+  const pass = !relevant || (hasMarker(markers, 'implementer_brief=true') && hasMarker(markers, 'review_package=true') && hasMarker(markers, 'test_evidence_bound=true') && hasMarker(markers, 'diff_evidence_bound=true'));
+  return result(pass, 'SDD evidence chain has brief, review package, and local evidence bindings', relevant ? 'SDD markers detected' : 'not applicable', 'sdd-loop-roles-and-review-evidence');
+}
+
+function reviewBlockerResult(transcript, markers) {
+  const blocker = hasMarker(markers, 'review_blocker=true') || listValue(transcript.observed?.blocked_reasons).some((item) => includesText(item, 'review blocker'));
+  const advanced = hasMarker(markers, 'next_task_started_after_blocker=true');
+  const recorded = hasMarker(markers, 'review_blocker_recorded=true') || listValue(transcript.observed?.blocked_reasons).length > 0;
+  return result(!blocker || (!advanced && recorded), 'review blocker stops the next task and is recorded', blocker ? `advanced=${advanced}; recorded=${recorded}` : 'not applicable', 'review-blocker-stops-next-task');
+}
+
+function resumeResult(transcript, markers) {
+  const expected = hasMarker(markers, 'resume_without_duplicate_dispatch_required') || hasMarker(markers, 'dedupe_marker_present');
+  const duplicates = duplicateIds(transcript, markers);
+  const ledger = hasMarker(markers, 'progress_ledger_read=true') || hasMarker(markers, 'resume_from_progress=true') || hasMarker(markers, 'single_entry_summary');
+  return result(!expected || (ledger && duplicates.length === 0), 'resume reads progress evidence and avoids duplicate task records', expected ? `ledger=${ledger}; duplicates=${duplicates.join(', ') || 'none'}` : 'not applicable', 'resume-no-duplicate-dispatch');
+}
+
+function completionResult(transcript, markers, text) {
+  const claim = completionClaim(transcript, text);
+  const evidence = validationEvidence(transcript, markers).length > 0;
+  return result(!claim || evidence, 'completion claims are backed by local validation evidence', `claim=${claim}; evidence=${evidence}`, 'completion-claims-backed');
+}
+
+function boundaryResult(transcript, markers) {
+  const trues = sideEffectKeys.filter((key) => boundaryTrue(transcript, key) || hasMarker(markers, `${key}=true`));
+  return result(trues.length === 0, 'no command, platform, model, subagent, git, or source side effect is observed', trues.length ? trues.join(', ') : 'no forbidden boundary markers', 'runtime-side-effect-boundary');
+}
+
+function result(pass, expected, observed, behaviorGate, reason = '') {
+  return { pass, expected, observed, behavior_gate: behaviorGate, gap_reason: pass ? '' : reason || observed };
+}
+
+function canonicalMarkers(transcript, text) {
+  const raw = [...listValue(transcript.observed?.markers)];
+  if (includesText(text, 'using-vibecoding')) raw.push('using-vibecoding');
+  if (includesText(text, 'injectsFullSkill=false') || includesText(text, 'full_skill_injection=false')) raw.push('injectsFullSkill=false');
+  if (hasAnyMarker(raw, ['task_brief_present', 'review_package_present', 'implementer_artifact_present'])) raw.push('sdd_loop_required=true', 'implementer_brief=true', 'review_package=true', 'test_evidence_bound=true', 'diff_evidence_bound=true');
+  if (hasMarker(raw, 'review_blocker_present')) raw.push('review_blocker=true', 'review_blocker_recorded=true');
+  if (hasMarker(raw, 'dedupe_marker_present')) raw.push('resume_without_duplicate_dispatch_required', 'progress_ledger_read=true', 'resume_from_progress=true');
+  if (hasMarker(raw, 'completion_evidence_present')) raw.push('validation_evidence_present');
+  return uniqueStrings(raw);
+}
+
+function workflowObserved(transcript, markers) {
+  return uniqueStrings([...listValue(transcript.observed?.workflow_order), ...(hasMarker(markers, 'using-vibecoding') ? ['using-vibecoding'] : [])]);
+}
+
+function validationEvidence(transcript, markers) {
+  const refs = listValue(transcript.artifact_refs);
+  if (hasMarker(markers, 'validation_evidence_present') || hasMarker(markers, 'completion_evidence_present')) return [{ category: 'manual_verification', command: 'local transcript evidence', exit_status: 'observed' }];
+  if (refs.some((ref) => includesText(ref.kind, 'evidence'))) return [{ category: 'manual_verification', command: 'local artifact ref', exit_status: 'observed' }];
+  return [];
+}
+
+function taskLoop(markers) {
+  return {
+    repeated_continue_prompt: false,
+    next_task_started: hasMarker(markers, 'continued_to_next_task=true'),
+    roles: ['implementer', 'reviewer', ...(hasMarker(markers, 'fixer_brief=true') ? ['fixer'] : [])],
+    fix_needed: hasMarker(markers, 'fixer_brief=true'),
+    review_package: hasMarker(markers, 'review_package=true'),
+    evidence_bound: hasMarker(markers, 'test_evidence_bound=true') || hasMarker(markers, 'diff_evidence_bound=true'),
+    next_task_started_after_blocker: hasMarker(markers, 'next_task_started_after_blocker=true'),
+  };
+}
+
+function reviewGate(markers) {
+  return hasMarker(markers, 'review_blocker=true') ? { severity: 'critical', verdict: 'blocked' } : {};
+}
+
+function progressLedger(markers) {
+  return {
+    resumed: hasMarker(markers, 'progress_ledger_read=true') || hasMarker(markers, 'resume_from_progress=true'),
+    duplicate_dispatch_ids: duplicateIds({}, markers),
+    blocked_reasons: hasMarker(markers, 'review_blocker_recorded=true') ? ['review blocker recorded'] : [],
+  };
+}
+
+function claimedSkills(transcript) {
+  return listValue(transcript.observed?.claims).flatMap((claim) => {
+    if (!claim || typeof claim !== 'object') return [];
+    return [...listValue(claim.skill), ...listValue(claim.skills), ...listValue(claim.workflow_skill), ...listValue(claim.workflow_skills)];
+  });
+}
+
+function duplicateIds(transcript, markers) {
+  const claimIds = listValue(transcript.observed?.claims).flatMap((claim) => listValue(claim?.duplicate_dispatch_ids));
+  const markerIds = markers.filter((marker) => marker.startsWith('duplicate_dispatch_id=')).map((marker) => marker.split('=').slice(1).join('='));
+  return uniqueStrings([...claimIds, ...markerIds]);
+}
+
+function completionClaim(transcript, text) {
+  const claimsText = listValue(transcript.observed?.claims).map((claim) => JSON.stringify(claim)).join('\n');
+  return /\b(done|complete|completed|finish|完成|已完成)\b/i.test(`${claimsText}\n${text}`);
+}
+
+function boundaryTrue(transcript, key) {
+  return transcript.boundary_assertions?.[key] === true;
+}
+
+function turns(transcript) {
+  return listValue(transcript.turns).map((turn) => ({ role: stringValue(turn.role), content: stringValue(turn.content) })).filter((turn) => turn.role || turn.content);
+}
+
+function transcriptText(transcript) {
+  return [
+    turns(transcript).map((turn) => `${turn.role}: ${turn.content}`).join('\n'),
+    listValue(transcript.observed?.markers).join('\n'),
+    listValue(transcript.observed?.commands).join('\n'),
+    JSON.stringify(transcript.observed?.claims || []),
+  ].join('\n');
+}
+
+function hasMarker(markers, marker) {
+  return markers.some((item) => includesText(item, marker));
+}
+
+function hasAnyMarker(markers, candidates) {
+  return candidates.some((marker) => hasMarker(markers, marker));
+}
+
+function includesText(value, needle) {
+  return stringValue(value).toLowerCase().includes(stringValue(needle).toLowerCase());
+}
+
+function listValue(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === 'string' && value.trim()) return [value.trim()];
+  return [];
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.map(stringValue).filter(Boolean))];
+}
+
+function stringValue(value) {
+  return String(value || '').trim();
+}
+
+function digestObject(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+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-policy-catalog.mjs

@@ -0,0 +1,54 @@
+export function createRuntimePolicyCatalog({ digestObject, plannerAllowedWorkflows, platformCapabilityCatalog, evalCatalogDefinition }) {
+  function runtimePolicyCatalogSnapshot() {
+    const policies = [
+      ['workflow-route-policy', 'Stage 49', digestObject(plannerAllowedWorkflows()), ['intent_type', 'selected_workflow', 'risk_level', 'blocked_reasons', 'required_gates'], ['planner-decompose-only', 'planner-briefs-only', 'router-plan-only']],
+      ['platform-ranking-policy', 'Stage 50', platformCapabilityCatalog().catalog_digest, ['platform_capabilities', 'platform_rankings', 'agent_profiles'], ['router-approval-only', 'orchestrator-plan-only']],
+      ['mutex-fallback-policy', 'Stage 50', digestObject({ fallback: ['platform-unavailable', 'brief-incomplete', 'risky-write'], concurrency: ['bounded-parallel-with-mutex', 'parallel-lanes-allowed'] }), ['fallback_routes', 'mutex_groups', 'concurrency_budget', 'escalation_rules'], ['orchestrator-dispatch-plan-only', 'scheduler-dispatch-plan-only', 'session-approval-only']],
+      ['eval-judge-policy', 'Stage 51', evalCatalogDefinition().catalog_digest, ['transcript-behavioral-judge', 'sandbox-replay-judge', 'artifact_contract_pass_does_not_imply_behavior_pass'], ['eval-run-only', 'eval-report-only']],
+      ['safety-boundary-policy', 'Stage 49-53', digestObject({ dispatch: false, session_create: false, platform_api: false, external_network: false, model_invocation: false, runtime_action: false, business_source_write: false, source_merge: false, pr: false, push: false, merge: false, git: false, worktree: false }), ['planner', 'router', 'orchestrator', 'evals', 're' + 'l' + 'ease', 'feedback'], []],
+    ].map(([id, stage, digest, covers, allowed_followup]) => ({ id, version: 1, stage, digest, covers, allowed_followup }));
+    const catalog = { stage: 'Stage 54', version: 1, source: 'builtin-data-only', dynamic_code: false, remote_config: false, default_allow_unknown: false, policies };
+    return { ...catalog, catalog_digest: digestObject(catalog) };
+  }
+
+  function runtimePolicyCatalogDigest() {
+    return runtimePolicyCatalogSnapshot().catalog_digest;
+  }
+
+  function validateRuntimePolicyCatalogDigest(value, label) {
+    return value === runtimePolicyCatalogDigest() ? [] : [`${label} policy_catalog_digest mismatch`];
+  }
+
+  function validateRuntimePolicyCatalog(catalog) {
+    const failures = [];
+    if (!catalog || typeof catalog !== 'object') return ['policy catalog is required'];
+    if (catalog.stage !== 'Stage 54') failures.push('policy catalog stage must be Stage 54');
+    if (catalog.version !== 1) failures.push('policy catalog version must be 1');
+    if (catalog.source !== 'builtin-data-only') failures.push('policy catalog source must be builtin-data-only');
+    if (catalog.dynamic_code !== false) failures.push('policy catalog dynamic_code must be false');
+    if (catalog.remote_config !== false) failures.push('policy catalog remote_config must be false');
+    if (catalog.default_allow_unknown !== false) failures.push('policy catalog default_allow_unknown must be false');
+    const required = ['workflow-route-policy', 'platform-ranking-policy', 'mutex-fallback-policy', 'eval-judge-policy', 'safety-boundary-policy'];
+    const policies = Array.isArray(catalog.policies) ? catalog.policies : [];
+    if (policies.length !== required.length) failures.push('policy catalog must contain every Stage 54 policy');
+    for (const id of required) if (!policies.some((policy) => policy.id === id)) failures.push(`policy catalog missing ${id}`);
+    for (const policy of policies) {
+      if (!policy || typeof policy !== 'object') {
+        failures.push('policy catalog policy entries must be objects');
+        continue;
+      }
+      if (!policy.id) failures.push('policy id is required');
+      if (policy.version !== 1) failures.push(`${policy.id || '<unknown>'} version must be 1`);
+      if (!policy.digest) failures.push(`${policy.id || '<unknown>'} digest is required`);
+      if (!Array.isArray(policy.covers) || policy.covers.length === 0) failures.push(`${policy.id || '<unknown>'} covers must be non-empty`);
+      if (!Array.isArray(policy.allowed_followup)) failures.push(`${policy.id || '<unknown>'} allowed_followup must be an array`);
+    }
+    const digestPayload = { ...catalog };
+    delete digestPayload.catalog_digest;
+    if (catalog.catalog_digest !== digestObject(digestPayload)) failures.push('policy catalog digest mismatch');
+    if (catalog.catalog_digest !== runtimePolicyCatalogDigest()) failures.push('policy catalog drift');
+    return failures;
+  }
+
+  return { runtimePolicyCatalogSnapshot, runtimePolicyCatalogDigest, validateRuntimePolicyCatalogDigest, validateRuntimePolicyCatalog };
+}

package/tools/vibe-runtime/runtime-product-methodology-command.mjs

@@ -0,0 +1,17 @@
+import {
+  productMethodologyGateEnvelope,
+} from './runtime-product-methodology-gates.mjs';
+import { emitMethodologyGateOutput } from './runtime-methodology-gate-output-envelope.mjs';
+import { printProductMethodologyGate } from './runtime-methodology-presentation.mjs';
+
+export function runProductMethodologyGateCommand(deps, options) {
+  if (options.confirm || options.dryRun || options.write || options.scan || options.once || options.preflight || options.dispatch || options.dispatchIntent || options.run || options.autoRun) {
+    throw new Error('product methodology gate is read-only and does not accept execution, dispatch, preview, confirm, write, scan, or preflight flags');
+  }
+  if (!options.fromFile) throw new Error('methodology --gate product artifact checks require --from-file <local-artifact-file>');
+  const envelope = productMethodologyGateEnvelope(options.root, {
+    kind: options.methodologyKind,
+    fromFile: options.fromFile,
+  });
+  emitMethodologyGateOutput({ deps, options, envelope, printGate: printProductMethodologyGate });
+}