@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-install-experience-score.mjs

@@ -0,0 +1,334 @@
+import crypto from 'node:crypto';
+
+const installExperienceStage = 'Stage 137';
+const installExperienceKind = 'hook-adapter-install-experience-score';
+const expectedAdapters = ['claude', 'cursor', 'codex'];
+
+export function runtimeInstallExperienceScore({ bootstrapMatrix = {}, entryAcceptance = {}, source = {} } = {}) {
+  const matrix = unwrapBootstrapMatrix(bootstrapMatrix);
+  const acceptance = unwrapEntryAcceptance(entryAcceptance);
+  const adapterRows = normalizeAdapterRows(matrix);
+  const acceptanceRows = normalizeAcceptanceRows(acceptance);
+  const adapterScores = expectedAdapters.map((adapter) => adapterInstallScore(adapter, adapterRows, acceptanceRows));
+  const naturalEntryScore = average(adapterScores.map((row) => row.natural_entry_score));
+  const adapterConsistencyScore = average(adapterScores.map((row) => row.adapter_consistency_score));
+  const manualSteps = manualStepsRemaining(adapterScores);
+  const docsFriction = docsFrictionFindings(adapterScores);
+  const blockers = installExperienceBlockers(matrix, adapterRows, acceptanceRows, adapterScores);
+  const core = {
+    version: 1,
+    stage: installExperienceStage,
+    score_kind: installExperienceKind,
+    source_bindings: sourceBindingSummary(source, matrix, acceptance),
+    input_summary: inputSummary(matrix, acceptance, adapterRows, acceptanceRows),
+    install_experience_score: Math.round((naturalEntryScore * 0.55) + (adapterConsistencyScore * 0.45)),
+    natural_entry_score: naturalEntryScore,
+    adapter_consistency_score: adapterConsistencyScore,
+    adapter_scores: adapterScores,
+    manual_steps_remaining: manualSteps,
+    docs_friction: docsFriction,
+    blockers,
+    install_experience_digest_basis: {
+      bootstrap_digest: matrix.matrix_digest || '',
+      entry_acceptance_digest: acceptance.acceptance_digest || '',
+    },
+    next_install_experience_bet: nextInstallExperienceBet(manualSteps, docsFriction, blockers),
+    boundary_assertions: runtimeInstallExperienceBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeInstallExperienceInvariants(core);
+  const scorecard = {
+    ...core,
+    ok: blockers.length === 0 && invariants.pass,
+    install_experience_invariants: invariants,
+  };
+  return {
+    ...scorecard,
+    install_experience_digest: digestInstallExperience(runtimeInstallExperienceDigestPayload(scorecard)),
+  };
+}
+
+export function runtimeInstallExperienceDigestPayload(scorecard) {
+  return {
+    stage: scorecard.stage,
+    score_kind: scorecard.score_kind,
+    source_bindings: scorecard.source_bindings,
+    input_summary: scorecard.input_summary,
+    install_experience_score: scorecard.install_experience_score,
+    natural_entry_score: scorecard.natural_entry_score,
+    adapter_consistency_score: scorecard.adapter_consistency_score,
+    adapter_scores: scorecard.adapter_scores,
+    manual_steps_remaining: scorecard.manual_steps_remaining,
+    docs_friction: scorecard.docs_friction,
+    blockers: scorecard.blockers,
+    install_experience_digest_basis: scorecard.install_experience_digest_basis,
+    next_install_experience_bet: scorecard.next_install_experience_bet,
+    boundary_assertions: scorecard.boundary_assertions,
+    install_experience_invariants: scorecard.install_experience_invariants,
+  };
+}
+
+export function runtimeInstallExperienceBoundaryAssertions() {
+  return {
+    install_experience_artifact: false,
+    bootstrap_matrix_artifact: false,
+    entry_acceptance_artifact: false,
+    adapter_install: false,
+    adapter_execution: false,
+    hook_execution: false,
+    hook_registration: false,
+    manifest_write: false,
+    install_doc_write: false,
+    settings_write: false,
+    source_write: false,
+    transcript_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: 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 runtimeInstallExperienceInvariants(scorecard) {
+  const adapters = (scorecard.adapter_scores || []).map((row) => row.adapter);
+  const missingAdapters = expectedAdapters.filter((adapter) => !adapters.includes(adapter));
+  const duplicateAdapters = adapters.filter((adapter, index, items) => items.indexOf(adapter) !== index);
+  const unsafeBoundaries = Object.entries(scorecard.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = Object.keys(runtimeInstallExperienceBoundaryAssertions())
+    .filter((key) => scorecard.boundary_assertions?.[key] !== false);
+  const scores = [scorecard.install_experience_score, scorecard.natural_entry_score, scorecard.adapter_consistency_score];
+  const findings = [
+    ...(scorecard.stage === installExperienceStage ? [] : [`stage must be ${installExperienceStage}`]),
+    ...(scorecard.score_kind === installExperienceKind ? [] : [`score_kind must be ${installExperienceKind}`]),
+    ...(scorecard.source_bindings?.bootstrap_matrix_file ? [] : ['bootstrap matrix file binding is required']),
+    ...(scorecard.source_bindings?.entry_acceptance_file ? [] : ['entry acceptance file binding is required']),
+    ...(scorecard.input_summary?.bootstrap_stage === 'Stage 122' ? [] : ['bootstrap matrix must be Stage 122 evidence']),
+    ...(scorecard.input_summary?.entry_acceptance_stage === 'Stage 131' ? [] : ['entry acceptance must be Stage 131 evidence']),
+    ...(Array.isArray(scorecard.adapter_scores) && scorecard.adapter_scores.length === expectedAdapters.length ? [] : ['adapter_scores must cover claude, cursor, and codex']),
+    ...(Array.isArray(scorecard.manual_steps_remaining) ? [] : ['manual_steps_remaining must be a list']),
+    ...(Array.isArray(scorecard.docs_friction) ? [] : ['docs_friction must be a list']),
+    ...scores.flatMap((score) => Number.isInteger(score) && score >= 0 && score <= 100 ? [] : [`score must be integer 0..100: ${score}`]),
+    ...missingAdapters.map((adapter) => `missing adapter install score: ${adapter}`),
+    ...duplicateAdapters.map((adapter) => `duplicate adapter install score: ${adapter}`),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingForbidden.map((key) => `forbidden boundary missing or not false: ${key}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['source_bindings', 'stage_122_bootstrap_matrix', 'stage_131_entry_acceptance', 'natural_entry_score', 'adapter_consistency_score', 'manual_steps_remaining', 'docs_friction', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestInstallExperience(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function unwrapBootstrapMatrix(input) {
+  return input.adapter_bootstrap_matrix || input.bootstrap_matrix || input;
+}
+
+function unwrapEntryAcceptance(input) {
+  return input.adapter_entry_acceptance || input.entry_acceptance || input;
+}
+
+function normalizeAdapterRows(matrix) {
+  const rows = Array.isArray(matrix.adapter_rows) ? matrix.adapter_rows : [];
+  return rows.map((row) => ({
+    adapter: stringValue(row.adapter),
+    pass: row.pass === true,
+    entry_file: stringValue(row.entry_file),
+    bootstrap_policy: objectValue(row.bootstrap_policy),
+    runtime_bridge: objectValue(row.runtime_bridge),
+    blockers: listValue(row.blockers).map(stringValue),
+  }));
+}
+
+function normalizeAcceptanceRows(acceptance) {
+  const singleAdapter = stringValue(acceptance.adapter);
+  if (singleAdapter) return [{
+    adapter: singleAdapter,
+    ok: acceptance.ok === true,
+    accepted: acceptance.accepted === true,
+    acceptance_score: numberValue(acceptance.acceptance_score),
+    gate_results: listValue(acceptance.gate_results),
+    blockers: listValue(acceptance.blockers).map(stringValue),
+  }];
+  return listValue(acceptance.adapter_acceptance_rows || acceptance.acceptance_rows).map((row) => ({
+    adapter: stringValue(row.adapter),
+    ok: row.ok === true,
+    accepted: row.accepted === true,
+    acceptance_score: numberValue(row.acceptance_score),
+    gate_results: listValue(row.gate_results),
+    blockers: listValue(row.blockers).map(stringValue),
+  }));
+}
+
+function adapterInstallScore(adapter, adapterRows, acceptanceRows) {
+  const bootstrap = adapterRows.find((row) => row.adapter === adapter);
+  const acceptance = acceptanceRows.find((row) => row.adapter === adapter);
+  const bootstrapScore = bootstrap?.pass ? 100 : bootstrap ? 55 : 0;
+  const acceptanceScore = acceptance ? clampScore(acceptance.acceptance_score || (acceptance.ok ? 100 : 45)) : 0;
+  const naturalEntryScore = Math.round((bootstrapScore * 0.45) + (acceptanceScore * 0.55));
+  const policySignals = [
+    bootstrap?.bootstrap_policy?.supported === true,
+    bootstrap?.bootstrap_policy?.injectsFullSkill === false,
+    bootstrap?.bootstrap_policy?.writesRuntimeState === false,
+    bootstrap?.bootstrap_policy?.autoRunsNextSkill === false,
+    bootstrap?.runtime_bridge?.canAutoExecuteSkill === false,
+    bootstrap?.runtime_bridge?.canCallSubagent === false,
+    bootstrap?.runtime_bridge?.canTouchGit === false,
+    acceptance?.ok === true,
+  ];
+  const adapterConsistencyScore = Math.round((policySignals.filter(Boolean).length / policySignals.length) * 100);
+  return {
+    adapter,
+    bootstrap_pass: bootstrap?.pass === true,
+    entry_acceptance_present: Boolean(acceptance),
+    entry_acceptance_ok: acceptance?.ok === true,
+    entry_file: bootstrap?.entry_file || '',
+    natural_entry_score: naturalEntryScore,
+    adapter_consistency_score: adapterConsistencyScore,
+    manual_steps_remaining: adapterManualSteps(adapter, bootstrap, acceptance),
+    docs_friction: adapterDocsFriction(adapter, bootstrap, acceptance),
+  };
+}
+
+function adapterManualSteps(adapter, bootstrap, acceptance) {
+  return [
+    ...(bootstrap ? [] : [`${adapter}: provide Stage 122 bootstrap matrix row`]),
+    ...(bootstrap?.pass ? [] : [`${adapter}: fix adapter manifest/install-doc bootstrap blockers`]),
+    ...(acceptance ? [] : [`${adapter}: capture one installed-entry transcript and run Stage 131 entry acceptance`]),
+    ...(acceptance?.ok ? [] : [`${adapter}: make first installed-entry response visibly pass using-vibecoding lightweight routing`]),
+  ];
+}
+
+function adapterDocsFriction(adapter, bootstrap, acceptance) {
+  return [
+    ...(bootstrap?.entry_file ? [] : [`${adapter}: installed entry file is not visible from adapter manifest`]),
+    ...(bootstrap?.bootstrap_policy?.supported === true ? [] : [`${adapter}: sessionStartBootstrap support is not explicit`]),
+    ...(acceptance ? [] : [`${adapter}: no local transcript evidence for installed first response`]),
+  ].filter(Boolean);
+}
+
+function manualStepsRemaining(adapterScores) {
+  return adapterScores.flatMap((row) => row.manual_steps_remaining);
+}
+
+function docsFrictionFindings(adapterScores) {
+  return adapterScores.flatMap((row) => row.docs_friction);
+}
+
+function installExperienceBlockers(matrix, adapterRows, acceptanceRows, adapterScores) {
+  return [
+    ...(matrix.ok === true ? [] : ['Stage 122 bootstrap matrix is not passing']),
+    ...(adapterRows.length >= expectedAdapters.length ? [] : ['Stage 122 bootstrap matrix does not cover all expected adapters']),
+    ...(acceptanceRows.length > 0 ? [] : ['Stage 131 entry acceptance evidence is missing']),
+    ...adapterScores.flatMap((row) => row.natural_entry_score >= 70 ? [] : [`${row.adapter}: natural entry score below 70`]),
+  ];
+}
+
+function inputSummary(matrix, acceptance, adapterRows, acceptanceRows) {
+  return {
+    bootstrap_stage: stringValue(matrix.stage),
+    bootstrap_kind: stringValue(matrix.matrix_kind),
+    bootstrap_ok: matrix.ok === true,
+    bootstrap_adapter_count: adapterRows.length,
+    entry_acceptance_stage: stringValue(acceptance.stage),
+    entry_acceptance_kind: stringValue(acceptance.acceptance_kind),
+    entry_acceptance_ok: acceptance.ok === true,
+    entry_acceptance_adapter_count: acceptanceRows.length,
+  };
+}
+
+function sourceBindingSummary(source, matrix, acceptance) {
+  return {
+    bootstrap_matrix_file: stringValue(source.bootstrap_matrix_file),
+    bootstrap_matrix_digest: stringValue(source.bootstrap_matrix_digest || matrix.matrix_digest),
+    entry_acceptance_file: stringValue(source.entry_acceptance_file),
+    entry_acceptance_digest: stringValue(source.entry_acceptance_digest || acceptance.acceptance_digest),
+  };
+}
+
+function nextInstallExperienceBet(manualSteps, docsFriction, blockers) {
+  if (blockers.length > 0) return {
+    id: 'close-install-evidence-blockers',
+    target_stage: 'Stage 138',
+    action: 'Use the blockers as behavioral eval scenario seeds before changing hook or adapter behavior.',
+  };
+  if (manualSteps.length > 0 || docsFriction.length > 0) return {
+    id: 'reduce-install-docs-friction',
+    target_stage: 'Stage 138',
+    action: 'Turn remaining manual install evidence steps into explicit behavior scenarios without auto-running hooks.',
+  };
+  return {
+    id: 'preserve-natural-entry-contract',
+    target_stage: 'Stage 138',
+    action: 'Convert this install experience baseline into Superpowers-style behavioral eval scenarios.',
+  };
+}
+
+function average(values) {
+  const items = values.filter((value) => Number.isFinite(value));
+  if (items.length === 0) return 0;
+  return Math.round(items.reduce((sum, value) => sum + value, 0) / items.length);
+}
+
+function clampScore(value) {
+  return Math.max(0, Math.min(100, Math.round(numberValue(value))));
+}
+
+function numberValue(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : 0;
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function stringValue(value) {
+  return value === undefined || value === null ? '' : String(value);
+}
+
+function stableStringify(value) {
+  return JSON.stringify(sortForJson(value));
+}
+
+function sortForJson(value) {
+  if (Array.isArray(value)) return value.map(sortForJson);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, sortForJson(nested)]));
+  }
+  return value;
+}

package/tools/vibe-runtime/runtime-installed-multiround-ux-acceptance.mjs

@@ -0,0 +1,149 @@
+const installedMultiroundStage = 'Stage 27';
+const installedMultiroundKind = 'installed-multiround-ux-close-loop-acceptance';
+const installedMultiroundMarker = 'installed_multiround_close_loop';
+const requiredPromptTurns = Object.freeze(['first_turn', 'continue_task', 'bug_debug', 'completion_closeout', 'review_feedback']);
+
+export function runtimeInstalledMultiroundUxAcceptance(normalized = {}) {
+  const rawText = stringValue(normalized.raw_text);
+  const lower = rawText.toLowerCase();
+  const flags = objectValue(normalized.structured_flags);
+  const active = flags.installed_multiround === true
+    || stringValue(normalized.transcript_kind).toLowerCase().includes('installed-multiround')
+    || lower.includes(installedMultiroundMarker);
+  if (!active) return null;
+
+  const turnCoverage = promptTurnCoverage(lower);
+  const forbiddenClaims = forbiddenMultiroundClaims(normalized, lower);
+  const gateResults = [
+    gate('installed_multiround_prompt_coverage', requiredPromptTurns.every((turn) => turnCoverage[turn]), missingTurnFindings(turnCoverage)),
+    gate('visible_route_each_round', hasAll(lower, ['using-vibecoding', 'visible_route', 'next_manual_action']) && hasAny(lower, ['stop_condition', '停止条件', 'stop condition']), ['multi-round transcript must preserve using-vibecoding, visible_route, next_manual_action, and stop condition markers']),
+    gate('continue_task_plan_trace', hasAll(lower, ['continue_task']) && hasAny(lower, ['current todo', '当前 todo', 'plan trace', '计划']) && hasAny(lower, ['验证策略', 'validation strategy', 'verification strategy']), ['continue_task turn must show current TODO or plan trace and validation strategy before continuing']),
+    gate('bug_debug_reproduction_gate', hasAll(lower, ['bug_debug']) && hasAny(lower, ['reproduce', '复现', 'reproduction unavailable']) && hasAny(lower, ['root cause', '根因', '原因']), ['bug_debug turn must require reproduction or root-cause evidence before fix claims']),
+    gate('completion_closeout_evidence_gate', hasAll(lower, ['completion_closeout']) && hasAny(lower, ['completion_evidence.task_completion_summary', 'session --close', 'completion evidence']) && hasAny(lower, ['验证证据', 'validation evidence', 'evidence gap', '证据缺口']), ['completion_closeout turn must bind completion evidence summary, validation evidence, and evidence gaps']),
+    gate('review_feedback_gate_loop', hasAll(lower, ['review_feedback']) && hasAny(lower, ['feedback_category=blocking_bug', 'blocking_bug', 'design_concern', 'test_gap']) && hasAll(lower, ['affected_files', 'verification_plan']) && hasAny(lower, ['next_task_gate.blocked=true', 'next_task_blocked=true']), ['review_feedback turn must classify feedback, bind affected_files and verification_plan, and set next_task_gate.blocked=true when needed']),
+    gate('session_continuity_close_loop', hasAny(lower, ['session --checkpoint', 'session --handoff', 'session --resume']) && hasAny(lower, ['handoff', 'resume', '交接', '恢复']), ['multi-round transcript must keep checkpoint/handoff/resume continuity visible without executing the next skill']),
+    gate('no_multiround_execution_claims', forbiddenClaims.length === 0, forbiddenClaims),
+  ];
+  const blockers = gateResults.filter((result) => !result.pass).flatMap((result) => result.findings.map((finding) => `${result.gate}: ${finding}`));
+  return {
+    version: 1,
+    stage: installedMultiroundStage,
+    acceptance_kind: installedMultiroundKind,
+    marker: installedMultiroundMarker,
+    prompt_turn_coverage: turnCoverage,
+    round_count: countUserIntentTurns(normalized.messages || []),
+    gate_results: gateResults,
+    accepted: blockers.length === 0,
+    blockers,
+    next_manual_action: blockers.length === 0
+      ? 'continue with the next manually selected workflow step after reading the visible gate result'
+      : 'fix the installed multi-round transcript shape before claiming close-loop readiness',
+    boundary_assertions: boundaryAssertions(),
+    local_only: true,
+    deterministic: true,
+    writes: false,
+  };
+}
+
+export function installedMultiroundUxGateResults(acceptance) {
+  return acceptance ? acceptance.gate_results : [];
+}
+
+function promptTurnCoverage(lower) {
+  return Object.fromEntries(requiredPromptTurns.map((turn) => [turn, lower.includes(turn)]));
+}
+
+function missingTurnFindings(coverage) {
+  return requiredPromptTurns.filter((turn) => !coverage[turn]).map((turn) => `missing installed prompt turn: ${turn}`);
+}
+
+function countUserIntentTurns(messages) {
+  return messages.filter((message) => message.role === 'user' || requiredPromptTurns.some((turn) => stringValue(message.text).toLowerCase().includes(turn))).length;
+}
+
+function forbiddenMultiroundClaims(normalized, lower) {
+  const flags = objectValue(normalized.structured_flags);
+  const flagged = [
+    ['skill_executed', flags.skill_executed],
+    ['subagent_called', flags.subagent_called],
+    ['git_called', flags.git_called],
+    ['platform_api_called', flags.platform_api_called],
+    ['hook_executed', flags.hook_executed],
+    ['state_written', flags.state_written],
+    ['auto_repair', flags.auto_repair],
+    ['reviewer_called', flags.reviewer_called],
+  ].filter(([, value]) => value === true).map(([key]) => `structured flag must be false: ${key}`);
+  const actionText = [...(normalized.actions || []), ...(normalized.commands_run || [])].join('\n').toLowerCase();
+  const actionFindings = forbiddenPatterns(actionText).map((match) => `recorded action is forbidden in installed multi-round acceptance: ${match}`);
+  const textualFindings = forbiddenPatterns(lower)
+    .filter((match) => !isNegated(lower, match))
+    .map((match) => `transcript suggests forbidden multi-round execution: ${match}`)
+    .slice(0, 6);
+  return [...flagged, ...actionFindings, ...textualFindings];
+}
+
+function forbiddenPatterns(text) {
+  const source = stringValue(text);
+  const patterns = [/\bgit\s+(add|commit|push|merge|tag)\b/i, /\bgh\s+pr\b/i, /subagent\s+(call|dispatch|run|called|dispatched|ran)/i, /platform api/i, /auto[- ]?repair/i, /automatically repaired/i, /reviewer\s+(called|invoked|ran)/i, /ran tests/i, /tests passed/i, /\b--confirm\b/i, /\b--write\b/i, /\b--dispatch\b/i, /\b--auto-run\b/i];
+  return patterns.flatMap((pattern) => {
+    const match = source.match(pattern);
+    return match ? [match[0]] : [];
+  });
+}
+
+function isNegated(text, match) {
+  const index = text.indexOf(match.toLowerCase());
+  if (index < 0) return false;
+  const window = text.slice(Math.max(0, index - 80), index + match.length + 24);
+  return /不|未|不会|无需|禁止|没有|no |without |does not|do not|must not|false/.test(window);
+}
+
+function gate(name, pass, findings = []) {
+  return { gate: name, pass: Boolean(pass), findings: pass ? [] : findings };
+}
+
+function hasAll(text, markers) {
+  return markers.every((marker) => text.includes(marker.toLowerCase()));
+}
+
+function hasAny(text, markers) {
+  return markers.some((marker) => text.includes(marker.toLowerCase()));
+}
+
+function boundaryAssertions() {
+  return {
+    installed_multiround_acceptance_artifact: false,
+    transcript_write: false,
+    adapter_install: false,
+    adapter_execution: false,
+    hook_execution: false,
+    state_directory_created: false,
+    command_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    repair_execution: false,
+    reviewer_invocation: 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,
+    business_source_write: false,
+  };
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function stringValue(value) {
+  return value === undefined || value === null ? '' : String(value);
+}

package/tools/vibe-runtime/runtime-interaction-command-domain-registry.mjs

@@ -0,0 +1,46 @@
+function names(text) {
+  return String(text).trim().split(/\s+/).filter(Boolean);
+}
+
+function interactionDomain(functions, surfaceExports = '') {
+  return Object.freeze({
+    functions: Object.freeze(names(functions)),
+    surfaceExports: Object.freeze(names(surfaceExports)),
+  });
+}
+
+export const runtimeInteractionCommandDomains = Object.freeze({
+  entryWorkflow: interactionDomain(`
+    workflowReadinessEnvelope workflowCockpitEnvelope workflowReceiptEnvelope workflowStartEnvelope
+    progressiveEntryUxEnvelope workflowSequenceEnvelope workflowLoopContractEnvelope closeLoopDashboardEnvelope
+    humanFriendlyCloseLoopEnvelope humanFriendlyNextEvidenceEnvelope entryTriggerDisciplineEnvelope bootstrapAcceptanceEnvelope
+    onboardingBriefEnvelope adviceHubEnvelope entryAdviceEnvelope entryContractEnvelope
+  `, `
+    runBootstrap runOnboarding runAdvice runEntry humanFriendlyCloseLoopEnvelope humanFriendlyNextEvidenceEnvelope
+    workflowReadinessEnvelope workflowCockpitEnvelope workflowReceiptEnvelope workflowStartEnvelope progressiveEntryUxEnvelope
+    workflowSequenceEnvelope workflowLoopContractEnvelope entryTriggerDisciplineEnvelope closeLoopDashboardEnvelope
+  `),
+  methodology: interactionDomain(`
+    methodologyRouteEnvelope methodologyGateFilePath listMethodologyGateFiles methodologyGateSnapshotPath
+    methodologyWorkflowSource methodologyAutomationEvidence methodologyGatePayload methodologyEnvelope
+    validateMethodologyGateArtifact writeMethodologyGate methodologyAuditEnvelope methodologyCoverageSourceBundle
+    methodologyCoverageEnvelope
+  `, 'runMethodology methodologyGateFilePath validateMethodologyGateArtifact'),
+  completion: interactionDomain('', 'runCompletion completionEvidenceBundleEnvelope'),
+  learning: interactionDomain(`
+    learningObservationPayload learningObservationEnvelope validateLearningObservationArtifact writeLearningObservation
+    learningRunObservationPreviewEnvelope learningCandidateInstinctPayload learningCandidateInstinctEnvelope validateLearningCandidateInstinctArtifact
+    writeLearningCandidateInstinct learningPromotionPayload learningPromotionEnvelope validateLearningPromotionArtifact
+    writeLearningPromotion learningArtifactSummary learningArtifactAuditEnvelope learningAuditEnvelope learningAdviceObservationRefs
+    learningAdviceEnvelope experienceLearningPatternObservationRefs experienceLearningPatternEnvelope runLearning
+  `, 'runLearning'),
+  tokens: interactionDomain(`
+    tokenCompactionSnapshotPath tokenMetricsSnapshotPath tokenCompactorCatalogSnapshot tokenRootRelativeOutputFilePath
+    tokenCompactionPayload tokenCompactionEnvelope validateTokenCompactionArtifact writeTokenCompaction tokenProfileSnapshot
+    tokenProfileEnvelope tokenMetricsPayload tokenMetricsEnvelope validateTokenMetricsArtifact writeTokenMetrics tokenAdviceEnvelope
+    tokenRewritePreview tokenRewritePreviewEnvelope tokenAuditEnvelope
+  `, `
+    tokenAdviceEnvelope tokenAuditEnvelope tokenCompactionEnvelope tokenMetricsEnvelope tokenProfileEnvelope
+    tokenRewritePreviewEnvelope writeTokenCompaction writeTokenMetrics
+  `),
+});