@jtf19/vibecoding-kit 0.1.0

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

@@ -0,0 +1,648 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import crypto from 'node:crypto';
+import {
+  hasProductCompletionEvidenceInputs,
+  runProductCompletionEvidenceBundleCommand,
+} from './runtime-completion-command.mjs';
+import { createRuntimeInteractionCompletionCommands } from './runtime-interaction-completion-command.mjs';
+import { createRuntimeInteractionEntryCommands } from './runtime-interaction-entry-command.mjs';
+import { createRuntimeMethodologyInteractionCommands } from './runtime-methodology-interaction-command.mjs';
+import { createRuntimeTokenInteractionCommands } from './runtime-token-interaction-command.mjs';
+import { createRuntimeLearningInteractionCommands } from './runtime-learning-interaction-command.mjs';
+import { createRuntimeWorkflowAliasInteractionCommands } from './runtime-workflow-alias-interaction-command.mjs';
+import { workflowAliasActionTextEnvelope } from './runtime-workflow-alias-boundary-text.mjs';
+import { createWorkflowPresentation } from './runtime-workflow-presentation.mjs';
+import { createCompletionPresentation } from './runtime-completion-presentation.mjs';
+import { createEntryPresentation } from './runtime-entry-presentation.mjs';
+import { createLearningPresentation } from './runtime-learning-presentation.mjs';
+import { createMethodologyCoveragePresentation } from './runtime-methodology-coverage-presentation.mjs';
+import { readonlyLocalJsonEnvelope } from './runtime-readonly-local-json-output-envelope.mjs';
+import { createRuntimeInteractionWorkflowEnvelopes } from './runtime-interaction-workflow-envelopes.mjs';
+import {
+  methodologyBoundaryAssertions,
+  methodologyGateCatalog,
+  methodologyRouteForIntent,
+  skillRouteRegistrySnapshot,
+} from './runtime-methodology-route-model.mjs';
+import {
+  buildMethodologyGatePayloadModel,
+  validateMethodologyGateArtifactModel,
+} from './runtime-methodology-gate-model.mjs';
+import { createRuntimeLearningAuditModel } from './runtime-learning-audit-model.mjs';
+import { createRuntimeLearningArtifactModel } from './runtime-learning-artifact-model.mjs';
+import { runtimeContractSyncOwner } from './runtime-contract-marker-registry.mjs';
+import {
+  methodologyCoverageMarkers,
+  methodologyCoverageSuperpowersFiles,
+  methodologyCoverageVibecodingFiles,
+} from './runtime-methodology-coverage-marker-specs.mjs';
+
+export const runtimeInteractionCommandContractSync = runtimeContractSyncOwner('runtime-interaction-command');
+
+export function createRuntimeInteractionCommands(deps) {
+  const {
+    jsonSchemaVersion,
+    stateDirectoryName,
+    methodologyGatesDirectoryName,
+    learningDirectoryName,
+    tokenEconomyDirectoryName,
+    methodologyGateKinds,
+  } = deps;
+  const {
+    ensureRoot,
+    localJsonFileWithinRoot,
+    safeStateArtifactFilePath,
+    readJsonArtifact,
+    listSubagentDispatchFiles,
+    listSubagentResultFiles,
+    listSubagentReviewFiles,
+    listHookRunFiles,
+    runtimeTracesDirectory,
+    listGovernanceFiles,
+    governanceAdviceEnvelope,
+    readinessEnvelope,
+    runtimeCapabilityRegistry,
+    planLintEnvelope,
+    planActionManifestEnvelope,
+    selfTestGateProfileEnvelope,
+    commitReadinessEnvelope,
+    confirmedOneShotPlanEnvelope,
+    evidenceIntakeEnvelope,
+    diffCoverageEnvelope,
+    reviewIntakeEnvelope,
+    tddTraceEnvelope,
+    learningObservationFilePath,
+    learningCandidateInstinctFilePath,
+    learningPromotionFilePath,
+    tokenCompactionFilePath,
+    tokenMetricsFilePath,
+    localTextEvidenceDescriptor,
+    localDirectoryWithinRoot,
+    sourceDescriptor,
+    stateDirectory,
+    workflowFileName,
+    workflowPath,
+    readWorkflow,
+    tasksFromState,
+    validateState,
+    workflowSummary,
+    asList,
+    listStateFiles,
+    fileDigest,
+    digestObject,
+    validateCommonArtifactSafety,
+    validateRuntimePolicyCatalogDigest,
+    runtimePolicyCatalogDigest,
+    writeStateArtifact,
+    writeJsonEnvelope,
+    printList,
+    stableStringify,
+    methodologyGatesDirectory,
+    learningDirectory,
+    tokenEconomyDirectory,
+    runtimeAutomationReadinessCommandEnvelope,
+    nextActionConsoleEnvelope,
+    digestTokenSaviorBudget, runtimeTokenSaviorBudget, runtimeTokenSaviorBudgetDigestPayload,
+    digestExperienceLearningPattern, runtimeExperienceLearningPattern, runtimeExperienceLearningPatternDigestPayload,
+    digestMethodologyCoverage,
+    runtimeMethodologyCoverageDigestPayload,
+    runtimeMethodologyCoverageMap,
+    digestCloseLoopDashboard, runtimeCloseLoopDashboard, runtimeCloseLoopDashboardDigestPayload,
+    digestHumanFriendlyAlias,
+    runtimeHumanFriendlyAliasDigestPayload,
+    runtimeHumanFriendlyCloseLoopAlias,
+    runtimeHumanFriendlyNextEvidenceAlias,
+    digestWorkflowLoopContract, runtimeWorkflowLoopContract, runtimeWorkflowLoopContractDigestPayload,
+    digestProgressiveEntryUx, runtimeProgressiveEntryUx, runtimeProgressiveEntryUxDigestPayload,
+    digestNextActionConsole, runtimeNextActionConsole, runtimeNextActionConsoleDigestPayload,
+    digestEntryTriggerDiscipline, runtimeEntryTriggerDiscipline, runtimeEntryTriggerDisciplineDigestPayload,
+    digestSelfTestGateProfile, runtimeSelfTestGateProfile, runtimeSelfTestGateProfileDigestPayload,
+    digestCommitReadiness,
+    runtimeCommitReadinessDigestPayload,
+    runtimeCommitReadinessEnvelope,
+    digestStagedCommitReadiness, runtimeStagedCommitReadiness, runtimeStagedCommitReadinessDigestPayload,
+    digestDiffCoverage,
+    runtimeDiffCoverageDigestPayload,
+    runtimeDiffCoverageEnvelope,
+  } = deps;
+
+function createInteractionPresentationOwners() {
+  return {
+    workflowPresentation: createWorkflowPresentation({ printList }),
+    completionPresentation: createCompletionPresentation({ printList }),
+    entryPresentation: createEntryPresentation({ printList }),
+    learningPresentation: createLearningPresentation({ printList }),
+    methodologyCoveragePresentation: createMethodologyCoveragePresentation({ printList }),
+  };
+}
+
+  const runtimeAutomationReadinessEnvelope = (root) => runtimeAutomationReadinessCommandEnvelope(root, { digestObject });
+  const {
+    workflowPresentation,
+    completionPresentation,
+    entryPresentation,
+    learningPresentation,
+    methodologyCoveragePresentation,
+  } = createInteractionPresentationOwners();
+
+function methodologyRouteEnvelope(root, intent) {
+  ensureRoot(root);
+  const selected = methodologyRouteForIntent(intent);
+  const catalog = methodologyGateCatalog(digestObject);
+  const registry = skillRouteRegistrySnapshot(digestObject);
+  const route = {
+    version: 1,
+    stage: 'Stage 60',
+    registry_stage: registry.stage,
+    registry_kind: registry.registry_kind,
+    registry_version: registry.version,
+    route_registry_id: selected.route_registry_id,
+    route_registry_digest: registry.route_registry_digest,
+    route_kind: 'workflow-methodology-route',
+    intent: selected.intent,
+    input_intent: intent,
+    selected_workflow: selected.workflow,
+    first_skill: selected.first_skill,
+    required_skill: selected.first_skill,
+    next_gate: selected.next_gate,
+    handoff_required: selected.handoff_required,
+    gate_kinds: selected.gate_kinds,
+    rationale: selected.rationale,
+    stop_condition: selected.stop_condition,
+    trigger_discipline: {
+      one_percent_rule: 'if a workflow might apply, first classify the workflow before acting',
+      user_rules_priority: true,
+      no_false_skill_claims: true,
+      handoff_required_between_workflow_steps: true,
+    },
+    catalog_digest: catalog.catalog_digest,
+    writes: false,
+    state_directory_created: false,
+    allowed_followup: ['manual_workflow_entry', 'methodology-gate-preview', 'methodology-gate-confirm'],
+    boundary_assertions: methodologyBoundaryAssertions(),
+    local_only: true,
+    no_execution: true,
+    no_external_delivery: true,
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'methodology-route',
+    ok: true,
+    payloadKey: 'methodology_route',
+    payload: { ...route, route_digest: digestObject(route) },
+    safety: { stage: 'Stage 60', writes: false, methodology_route_artifact: false, ...methodologyBoundaryAssertions() },
+    quality: selected.intent === 'unknown' ? ['unknown intent routed to using-vibecoding and brainstorming'] : [],
+    action: 'methodology route was computed read-only. No state directory, workflow skill execution, dispatch, subagent, platform API, external network, model, git, worktree, or business source write occurred.',
+  });
+}
+
+function methodologyGateFilePath(root, fileName) {
+  return safeStateArtifactFilePath(root, methodologyGatesDirectory, fileName, '.methodology-gate.json', 'Methodology gate');
+}
+
+function listMethodologyGateFiles(root) {
+  return listStateFiles(root, methodologyGatesDirectory, '.methodology-gate.json');
+}
+
+function methodologyGateSnapshotPath(root, kind) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return path.join(methodologyGatesDirectory(root), `${timestamp}.${kind}.methodology-gate.json`);
+}
+
+function methodologyWorkflowSource(root) {
+  const file = workflowPath(root);
+  if (!fs.existsSync(file)) return { root, workflow_file: '', workflow_digest: '', workflow_present: false, workflow_valid: false, workflow_failures: ['workflow state is not present'] };
+  try {
+    const state = readWorkflow(root);
+    validateState(state);
+    return { root, workflow_file: workflowFileName, workflow_digest: fileDigest(file), workflow_present: true, workflow_valid: true, workflow_failures: [] };
+  } catch (error) {
+    return { root, workflow_file: workflowFileName, workflow_digest: fileDigest(file), workflow_present: true, workflow_valid: false, workflow_failures: [error.message] };
+  }
+}
+
+function methodologyAutomationEvidence(root) {
+  return {
+    dispatch_files: listSubagentDispatchFiles(root),
+    result_files: listSubagentResultFiles(root),
+    review_files: listSubagentReviewFiles(root),
+    hook_run_files: listHookRunFiles(root),
+    trace_or_governance_files: [
+      ...listStateFiles(root, runtimeTracesDirectory, '.runtime-trace.json'),
+      ...listGovernanceFiles(root),
+    ],
+  };
+}
+
+function methodologyGatePayload(root, kind) {
+  const source = methodologyWorkflowSource(root);
+  const state = source.workflow_valid ? readWorkflow(root) : null;
+  const catalog = methodologyGateCatalog(digestObject);
+  return buildMethodologyGatePayloadModel({
+    kind,
+    source,
+    state,
+    catalog,
+    createdAt: new Date().toISOString(),
+    boundaryAssertions: methodologyBoundaryAssertions(),
+    digestObject,
+    methodologyGateKinds,
+    automationEvidence: methodologyAutomationEvidence(root),
+    asList,
+    tasksFromState,
+  });
+}
+
+function methodologyEnvelope(root, kind, { persist = false } = {}) {
+  const gate = methodologyGatePayload(root, kind);
+  return {
+    mode: 'methodology-gate',
+    ok: gate.outcome === 'passed',
+    state_present: fs.existsSync(stateDirectory(root)),
+    methodology_gate: { ...gate, writes: Boolean(persist) },
+    safety: { stage: 'Stage 32', writes: Boolean(persist), methodology_gate_artifact: Boolean(persist), ...methodologyBoundaryAssertions() },
+    quality: gate.blocked_reasons,
+    action: persist ? 'methodology gate was written locally. No workflow skill, runtime action, platform API, git, worktree, subagent, MCP, or external delivery occurred.' : 'methodology gate was previewed read-only. No files were written and no workflow skill was executed.',
+  };
+}
+
+function validateMethodologyGateArtifact(root, artifact) {
+  const failures = validateMethodologyGateArtifactModel({
+    artifact,
+    jsonSchemaVersion,
+    methodologyGateKinds,
+    expectedCatalogDigest: methodologyGateCatalog(digestObject).catalog_digest,
+    boundaryAssertions: methodologyBoundaryAssertions(),
+    digestObject,
+  });
+  const gate = artifact.methodology_gate || {};
+  if (gate.source?.workflow_file) {
+    try {
+      const workflow = workflowPath(root);
+      if (path.basename(workflow) !== gate.source.workflow_file) failures.push('methodology workflow file mismatch');
+      if (fileDigest(workflow) !== gate.source.workflow_digest) failures.push('methodology workflow digest mismatch');
+      const state = readWorkflow(root);
+      validateState(state);
+    } catch (error) {
+      failures.push(error.message);
+    }
+  } else if (gate.source?.workflow_present !== false) {
+    failures.push('methodology source workflow metadata is incomplete');
+  }
+  failures.push(...validateCommonArtifactSafety(artifact.safety, 'Stage 32'));
+  return { ok: failures.length === 0, failures };
+}
+
+function writeMethodologyGate(root, envelope) {
+  const file = methodologyGateSnapshotPath(root, envelope.methodology_gate.kind);
+  const payload = { schema_version: jsonSchemaVersion, command: 'methodology', ...envelope, safety: { ...envelope.safety, methodology_gate_artifact: true } };
+  const verification = validateMethodologyGateArtifact(root, payload);
+  if (!verification.ok) throw new Error(`methodology gate verification failed: ${verification.failures.join('; ')}`);
+  return writeStateArtifact(path.dirname(file), path.basename(file), payload);
+}
+
+function methodologyAuditEnvelope(root, mode, gateFile = '') {
+  if (mode === 'catalog') return { mode: 'methodology-catalog', ok: true, catalog: methodologyGateCatalog(digestObject), quality: [], action: 'read-only methodology catalog was shown. No files were written.' };
+  if (mode === 'list') {
+    const gates = listMethodologyGateFiles(root).map((fileName) => {
+      try {
+        const file = methodologyGateFilePath(root, fileName);
+        const artifact = readJsonArtifact(file, 'Methodology gate');
+        const verification = validateMethodologyGateArtifact(root, artifact);
+        return { file: fileName, kind: artifact.methodology_gate?.kind || '', outcome: artifact.methodology_gate?.outcome || '', ok: verification.ok, blocked_count: artifact.methodology_gate?.blocked_reasons?.length || 0 };
+      } catch (error) {
+        return { file: fileName, kind: '', outcome: 'invalid', ok: false, blocked_count: 1, error: error.message };
+      }
+    });
+    return { mode: 'methodology-list', ok: true, summary: { count: gates.length, failed_count: gates.filter((item) => !item.ok).length }, gates, quality: [], action: 'read-only methodology gate audit listed local gates. No workflow skill was executed.' };
+  }
+  const file = methodologyGateFilePath(root, gateFile);
+  const artifact = readJsonArtifact(file, 'Methodology gate');
+  const verification = validateMethodologyGateArtifact(root, artifact);
+  if (mode === 'verify' && !verification.ok) throw new Error(`methodology gate verification failed: ${verification.failures.join('; ')}`);
+  return { mode: mode === 'verify' ? 'methodology-verify' : 'methodology-show', ok: verification.ok, summary: { file: path.basename(file), kind: artifact.methodology_gate?.kind || '', outcome: artifact.methodology_gate?.outcome || '', blocked_count: artifact.methodology_gate?.blocked_reasons?.length || 0 }, verification, artifact, quality: verification.failures, action: 'read-only methodology gate audit inspected one gate. No workflow skill was executed.' };
+}
+
+function methodologyCoverageSourceBundle(root, superpowersDirectoryInput) {
+  const superpowersDirectory = localDirectoryWithinRoot(root, superpowersDirectoryInput, 'methodology --coverage-map --from-superpowers-root');
+  const allMarkers = methodologyCoverageMarkers;
+  const superpowersFiles = methodologyCoverageSuperpowersFiles;
+  const vibecodingFiles = methodologyCoverageVibecodingFiles;
+  const superpowersRootRelative = path.relative(root, superpowersDirectory).replace(/\\/g, '/');
+  return {
+    superpowers_root: superpowersRootRelative,
+    superpowers_root_digest: crypto.createHash('sha256').update(superpowersRootRelative).digest('hex'),
+    superpowers_sources: superpowersFiles.map((file) => sourceDescriptor(root, superpowersDirectory, file, allMarkers)),
+    vibecoding_sources: vibecodingFiles.map((file) => sourceDescriptor(root, root, file, allMarkers)),
+  };
+}
+
+function methodologyCoverageEnvelope(root, superpowersDirectoryInput) {
+  ensureRoot(root);
+  const sources = methodologyCoverageSourceBundle(root, superpowersDirectoryInput);
+  const registry = runtimeCapabilityRegistry();
+  const coverageBase = runtimeMethodologyCoverageMap({
+    superpowersSources: sources.superpowers_sources,
+    vibecodingSources: sources.vibecoding_sources,
+    registry,
+    source: {
+      superpowers_root: sources.superpowers_root,
+      superpowers_root_digest: sources.superpowers_root_digest,
+    },
+  });
+  const coverage = {
+    ...coverageBase,
+    coverage_digest: digestMethodologyCoverage(runtimeMethodologyCoverageDigestPayload(coverageBase)),
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'methodology-coverage-map',
+    ok: coverage.ok,
+    payloadKey: 'methodology_coverage_map',
+    payload: coverage,
+    safety: { stage: 'Stage 136', ...coverage.boundary_assertions },
+    quality: coverage.methodology_coverage_invariants.findings,
+    action: 'methodology coverage map was computed read-only from local fork/superpowers and Vibecoding source files. It only reports covered, partial, missing, and Vibecoding-specific methodology patterns; no coverage artifact, state directory, sidecar, command, check, smoke, test, hook, adapter, workflow skill execution, runtime action, repair, prompt or skill mutation, git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  });
+}
+
+function learningArtifactModelForInteraction() {
+  return createRuntimeLearningArtifactModel({
+    jsonSchemaVersion,
+    learningDirectory,
+    listStateFiles,
+    readJsonArtifact,
+    fileDigest,
+    digestObject,
+    stableStringify,
+    stateDirectory,
+    writeStateArtifact,
+    learningObservationFilePath,
+    learningCandidateInstinctFilePath,
+    learningPromotionFilePath,
+  });
+}
+
+function learningAuditModelForInteraction(learningArtifactModel) {
+  return createRuntimeLearningAuditModel({
+    readJsonArtifact,
+    learningObservationFilePath,
+    learningCandidateInstinctFilePath,
+    learningPromotionFilePath,
+    validateLearningObservationArtifact: learningArtifactModel.validateLearningObservationArtifact,
+    validateLearningCandidateInstinctArtifact: learningArtifactModel.validateLearningCandidateInstinctArtifact,
+    validateLearningPromotionArtifact: learningArtifactModel.validateLearningPromotionArtifact,
+  });
+}
+
+function createInteractionLearningCommandOwners() {
+  const learningArtifactModel = learningArtifactModelForInteraction();
+  const learningAuditModel = learningAuditModelForInteraction(learningArtifactModel);
+  const {
+    learningArtifactSummary,
+    learningArtifactAuditEnvelope,
+  } = learningAuditModel;
+  const {
+    listLearningObservationFiles,
+    listLearningCandidateInstinctFiles,
+    listLearningPromotionFiles,
+    learningObservationDescriptor,
+    learningCandidateInstinctDescriptor,
+    learningObservationEnvelope,
+    writeLearningObservation,
+    learningCandidateInstinctEnvelope,
+    writeLearningCandidateInstinct,
+    learningPromotionEnvelope,
+    writeLearningPromotion,
+  } = learningArtifactModel;
+  const tokenCommands = createRuntimeTokenInteractionCommands({
+    jsonSchemaVersion,
+    resolveLocalStateRoot: stateDirectory,
+    tokenEconomyDirectory,
+    tokenCompactionFilePath,
+    tokenMetricsFilePath,
+    readJsonArtifact,
+    fileDigest,
+    digestObject,
+    persistStateArtifact: writeStateArtifact,
+  });
+  const learningCommands = createRuntimeLearningInteractionCommands({
+    ensureRoot,
+    emitJsonEnvelope: writeJsonEnvelope,
+    learningPresentation,
+    localJsonFileWithinRoot,
+    resolveLocalStateRoot: stateDirectory,
+    digestObject,
+    stableStringify,
+    digestExperienceLearningPattern,
+    runtimeExperienceLearningPattern,
+    runtimeExperienceLearningPatternDigestPayload,
+    listLearningObservationFiles,
+    listLearningCandidateInstinctFiles,
+    listLearningPromotionFiles,
+    learningArtifactSummary,
+    learningArtifactAuditEnvelope,
+    learningObservationDescriptor,
+    learningCandidateInstinctDescriptor,
+    learningObservationEnvelope,
+    writeLearningObservation,
+    learningCandidateInstinctEnvelope,
+    writeLearningCandidateInstinct,
+    learningPromotionEnvelope,
+    writeLearningPromotion,
+  });
+  return { tokenCommands, learningCommands };
+}
+
+function createInteractionWorkflowEnvelopeOwners({ tokenCommands, learningCommands }) {
+  return createRuntimeInteractionWorkflowEnvelopes({
+    ensureRoot,
+    workflowPath,
+    stateDirectory,
+    localTextEvidenceDescriptor,
+    methodologyGateKinds,
+    methodologyRouteEnvelope,
+    methodologyEnvelope,
+    readinessEnvelope,
+    planLintEnvelope,
+    runtimeAutomationReadinessEnvelope,
+    runtimeCapabilityRegistry,
+    tokenAdviceEnvelope: tokenCommands.tokenAdviceEnvelope,
+    learningAdviceEnvelope: learningCommands.learningAdviceEnvelope,
+    governanceAdviceEnvelope,
+    digestObject,
+    digestWorkflowLoopContract,
+    runtimeWorkflowLoopContract,
+    runtimeWorkflowLoopContractDigestPayload,
+    digestProgressiveEntryUx,
+    runtimeProgressiveEntryUx,
+    runtimeProgressiveEntryUxDigestPayload,
+    digestEntryTriggerDiscipline,
+    runtimeEntryTriggerDiscipline,
+    runtimeEntryTriggerDisciplineDigestPayload,
+  });
+}
+
+  const { tokenCommands, learningCommands } = createInteractionLearningCommandOwners();
+
+  const workflowEnvelopes = createInteractionWorkflowEnvelopeOwners({ tokenCommands, learningCommands });
+
+  const {
+    adviceHubEnvelope,
+    bootstrapAcceptanceEnvelope,
+    entryAdviceEnvelope,
+    entryContractEnvelope,
+    entryTriggerDisciplineEnvelope,
+    onboardingBriefEnvelope,
+    progressiveEntryUxEnvelope,
+    workflowCockpitEnvelope,
+    workflowLoopContractEnvelope,
+    workflowReadinessBoundaryAssertions,
+    workflowReadinessEnvelope,
+    workflowReceiptEnvelope,
+    workflowSequenceEnvelope,
+    workflowStartEnvelope,
+  } = workflowEnvelopes;
+
+  const methodologyCommands = createRuntimeMethodologyInteractionCommands({
+    ensureRoot,
+    writeJsonEnvelope,
+    printList,
+    workflowPresentation,
+    methodologyCoveragePresentation,
+    methodologyAuditEnvelope,
+    methodologyRouteEnvelope,
+    workflowReadinessEnvelope,
+    methodologyCoverageEnvelope,
+    methodologyEnvelope,
+    writeMethodologyGate,
+  });
+
+  const completionCommands = createRuntimeInteractionCompletionCommands({
+    ensureRoot,
+    workflowPath,
+    fileExists: fs.existsSync,
+    localTextEvidenceDescriptor,
+    runtimeCapabilityRegistry,
+    digestObject,
+    writeJsonEnvelope,
+    printList,
+    completionPresentation,
+    hasProductCompletionEvidenceInputs,
+    runProductCompletionEvidenceBundleCommand,
+    localJsonFileWithinRoot,
+    stateDirectory,
+    writeStateArtifact,
+  });
+
+function interactionWorkflowAliasActionTextEnvelope() {
+  return workflowAliasActionTextEnvelope();
+}
+
+  const workflowAliasActionText = interactionWorkflowAliasActionTextEnvelope();
+
+  const workflowAliasCommands = createRuntimeWorkflowAliasInteractionCommands({
+    ensureRoot,
+    aliasActionText: workflowAliasActionText,
+    planActionManifestEnvelope,
+    selfTestGateProfileEnvelope,
+    commitReadinessEnvelope,
+    confirmedOneShotPlanEnvelope,
+    evidenceIntakeEnvelope,
+    diffCoverageEnvelope,
+    reviewIntakeEnvelope,
+    tddTraceEnvelope,
+    runtimeAutomationReadinessEnvelope,
+    runtimeCapabilityRegistry,
+    digestCloseLoopDashboard,
+    runtimeCloseLoopDashboard,
+    runtimeCloseLoopDashboardDigestPayload,
+    digestHumanFriendlyAlias,
+    runtimeHumanFriendlyAliasDigestPayload,
+    runtimeHumanFriendlyCloseLoopAlias,
+    runtimeHumanFriendlyNextEvidenceAlias,
+  });
+
+  const {
+    closeLoopDashboardEnvelope,
+    humanFriendlyCloseLoopEnvelope,
+    humanFriendlyNextEvidenceEnvelope,
+  } = workflowAliasCommands;
+
+  const entryCommands = createRuntimeInteractionEntryCommands({
+    ensureRoot,
+    writeJsonEnvelope,
+    entryPresentation,
+    bootstrapAcceptanceEnvelope,
+    onboardingBriefEnvelope,
+    adviceHubEnvelope,
+    entryAdviceEnvelope,
+    entryContractEnvelope,
+    humanFriendlyCloseLoopEnvelope,
+    humanFriendlyNextEvidenceEnvelope,
+    workflowReadinessEnvelope,
+    workflowCockpitEnvelope,
+    workflowReceiptEnvelope,
+    workflowStartEnvelope,
+    progressiveEntryUxEnvelope,
+    workflowSequenceEnvelope,
+    workflowLoopContractEnvelope,
+    entryTriggerDisciplineEnvelope,
+    closeLoopDashboardEnvelope,
+  });
+
+function interactionCommandExports() {
+  return {
+    runCompletion: completionCommands.runCompletion,
+    completionEvidenceBundleEnvelope: completionCommands.completionEvidenceBundleEnvelope,
+    runBootstrap: entryCommands.runBootstrap,
+    runOnboarding: entryCommands.runOnboarding,
+    runAdvice: entryCommands.runAdvice,
+    runEntry: entryCommands.runEntry,
+    runMethodology: methodologyCommands.runMethodology, methodologyGateFilePath, validateMethodologyGateArtifact,
+    runLearning: learningCommands.runLearning,
+    humanFriendlyCloseLoopEnvelope,
+    humanFriendlyNextEvidenceEnvelope,
+    workflowReadinessEnvelope,
+    workflowReadinessBoundaryAssertions,
+    workflowCockpitEnvelope,
+    workflowReceiptEnvelope,
+    workflowStartEnvelope,
+    progressiveEntryUxEnvelope,
+    workflowSequenceEnvelope,
+    workflowLoopContractEnvelope,
+    entryTriggerDisciplineEnvelope,
+    closeLoopDashboardEnvelope,
+    printHumanFriendlyAlias: workflowPresentation.printHumanFriendlyAlias,
+    printWorkflowReadiness: workflowPresentation.printWorkflowReadiness,
+    printWorkflowCockpit: workflowPresentation.printWorkflowCockpit,
+    printWorkflowReceipt: workflowPresentation.printWorkflowReceipt,
+    printWorkflowStart: workflowPresentation.printWorkflowStart,
+    printSessionStart: workflowPresentation.printSessionStart,
+    printSkillSelect: workflowPresentation.printSkillSelect,
+    printSessionCheckpoint: workflowPresentation.printSessionCheckpoint,
+    printSessionHandoff: workflowPresentation.printSessionHandoff,
+    printSessionResume: workflowPresentation.printSessionResume,
+    printSessionClose: completionPresentation.printSessionClose,
+    printWorkflowRunPlan: workflowPresentation.printWorkflowRunPlan,
+    printEntryRuntimeSummary: workflowPresentation.printEntryRuntimeSummary,
+    printProgressiveEntryUx: workflowPresentation.printProgressiveEntryUx,
+    printWorkflowSequence: workflowPresentation.printWorkflowSequence,
+    printWorkflowLoopContract: workflowPresentation.printWorkflowLoopContract,
+    printEntryTriggerDiscipline: workflowPresentation.printEntryTriggerDiscipline,
+    printCloseLoopDashboard: workflowPresentation.printCloseLoopDashboard,
+    printNextActionConsole: workflowPresentation.printNextActionConsole,
+    learningAdviceEnvelope: learningCommands.learningAdviceEnvelope,
+    tokenAdviceEnvelope: tokenCommands.tokenAdviceEnvelope,
+    tokenAuditEnvelope: tokenCommands.tokenAuditEnvelope,
+    tokenCompactionEnvelope: tokenCommands.tokenCompactionEnvelope,
+    tokenMetricsEnvelope: tokenCommands.tokenMetricsEnvelope,
+    tokenProfileEnvelope: tokenCommands.tokenProfileEnvelope,
+    tokenRewritePreviewEnvelope: tokenCommands.tokenRewritePreviewEnvelope,
+    writeTokenCompaction: tokenCommands.writeTokenCompaction,
+    writeTokenMetrics: tokenCommands.writeTokenMetrics,
+  };
+}
+
+  return interactionCommandExports();
+}