@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-commit-readiness-envelope.mjs

@@ -0,0 +1,281 @@
+import { buildControlledChangeDeliveryContract } from './runtime-controlled-change-delivery-contract.mjs';
+import crypto from 'node:crypto';
+
+const commitReadinessStage = 'Stage 107';
+const commitReadinessKind = 'commit-readiness-envelope';
+
+export function runtimeCommitReadinessEnvelope({ planActionManifest = {}, selfTestGateProfile = {}, commitGuard = {}, registry = {}, registryDigest = '' } = {}) {
+  const boundaryAssertions = runtimeCommitReadinessBoundaryAssertions();
+  const readinessGates = readinessGateItems({ planActionManifest, selfTestGateProfile, commitGuard });
+  const evidenceBundle = evidenceBundleRequirements({ planActionManifest, selfTestGateProfile, commitGuard });
+  const envelope = {
+    version: 1,
+    stage: commitReadinessStage,
+    readiness_kind: commitReadinessKind,
+    source_bindings: {
+      plan_action_manifest_stage: planActionManifest.stage || '',
+      plan_action_manifest_digest: planActionManifest.plan_action_manifest_digest || '',
+      self_test_gate_profile_stage: selfTestGateProfile.stage || '',
+      self_test_gate_profile_digest: selfTestGateProfile.self_test_gate_profile_digest || '',
+      commit_guard_stage: commitGuard.stage || '',
+      commit_guard_digest: commitGuard.commit_guard_digest || '',
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+      registry_digest: registryDigest,
+    },
+    commit_subject: {
+      subject_count: commitGuard.subject_count || 0,
+      guard_pass: commitGuard.guard_pass === true,
+      blocked_reasons: commitGuard.blocked_reasons || [],
+      commit_execution_authorized: false,
+    },
+    worktree_snapshot_requirements: {
+      git_status_short_required: true,
+      git_diff_stat_required: true,
+      git_diff_check_required: true,
+      git_command_execution: false,
+      collected_by_stage_107: false,
+      source: 'manual-evidence-required',
+    },
+    readiness_gates: readinessGates,
+    evidence_bundle_requirements: evidenceBundle,
+    controlled_change_delivery: buildControlledChangeDeliveryContract({
+      phase: 'commit-readiness-envelope',
+      changeSetSummary: {
+        source_stage: commitReadinessStage,
+        commit_subject_count: commitGuard.subject_count || 0,
+        readiness_gate_count: readinessGates.length,
+        evidence_requirement_count: evidenceBundle.gate_evidence.length,
+      },
+      planTaskBinding: Boolean(planActionManifest.plan_action_manifest_digest),
+      diffCoverageBound: false,
+      testEvidenceBound: false,
+      reviewVerdictBound: false,
+      commitSubjectBound: commitGuard.guard_pass === true,
+      rollbackNoteBound: false,
+      blockedReasons: readinessGates.filter((item) => item.status === 'blocked').map((item) => `${item.id}: ${item.required_evidence}`),
+      nextManualAction: 'Collect fresh manual worktree, test, diff, review, and rollback evidence before any human-approved git or PR action.',
+    }),
+    readiness_order: readinessGates.map((item) => item.id),
+    readiness_state: readinessState(readinessGates),
+    next_manual_action: nextManualAction(readinessGates),
+    allowed_followup: ['manual commit after evidence review', 'Stage 108 confirmed one-shot execution plan'],
+    forbidden_actions: [
+      'git commit/push/PR/merge/tag/reset/checkout',
+      'check execution or test execution',
+      'repair, formatting, or code generation',
+      'sidecar or .vibecoding-state write',
+      'platform API, external network, model, MCP, or subagent invocation',
+      'treating missing worktree evidence as commit-ready',
+    ],
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeCommitReadinessInvariants(envelope);
+  return {
+    ...envelope,
+    readiness_invariants: invariants,
+    manual_action: invariants.pass
+      ? 'Commit readiness envelope is valid. Collect manual evidence before any real commit; Stage 107 did not run checks or git.'
+      : 'Fix the listed commit readiness envelope gaps before using this envelope for commit review.',
+  };
+}
+
+export function runtimeCommitReadinessInvariants(envelope) {
+  const gates = envelope.readiness_gates || [];
+  const missingSourceBindings = ['plan_action_manifest_digest', 'self_test_gate_profile_digest', 'commit_guard_digest', 'registry_digest']
+    .filter((key) => !envelope.source_bindings?.[key]);
+  const executableGates = gates
+    .filter((item) => item.execution_authorized !== false || item.commit_execution_authorized !== false)
+    .map((item) => item.id || item.gate_kind || 'unknown');
+  const incompleteGates = gates
+    .filter((item) => !item.id || !item.gate_kind || !item.status)
+    .map((item) => item.id || item.gate_kind || 'unknown');
+  const writableBoundaries = Object.entries(envelope.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const forbiddenMissing = ['command_execution', 'test_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write']
+    .filter((key) => envelope.boundary_assertions?.[key] !== false);
+  const findings = [
+    ...(gates.length === 0 ? ['readiness_gates must not be empty'] : []),
+    ...(envelope.commit_subject?.commit_execution_authorized !== false ? ['commit subject must not authorize commit execution'] : []),
+    ...(envelope.worktree_snapshot_requirements?.git_command_execution !== false ? ['worktree snapshot must not execute git'] : []),
+    ...(envelope.worktree_snapshot_requirements?.collected_by_stage_107 !== false ? ['worktree snapshot must be manual evidence only'] : []),
+    ...missingSourceBindings.map((item) => `missing source binding: ${item}`),
+    ...executableGates.map((item) => `gate must not authorize execution: ${item}`),
+    ...incompleteGates.map((item) => `incomplete readiness gate: ${item}`),
+    ...writableBoundaries.map((item) => `boundary assertion must remain false: ${item}`),
+    ...forbiddenMissing.map((item) => `forbidden boundary missing or not false: ${item}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: [
+      'plan_action_manifest_binding',
+      'self_test_gate_profile_binding',
+      'commit_guard_binding',
+      'manual_worktree_evidence_required',
+      'execution_authorized_false',
+      'commit_execution_authorized_false',
+      'read_only_boundary_assertions',
+    ],
+    findings,
+  };
+}
+
+export function runtimeCommitReadinessBoundaryAssertions() {
+  return {
+    commit_readiness_artifact: false,
+    commit_artifact: false,
+    test_result_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    repair_execution: false,
+    formatting_execution: false,
+    code_generation: false,
+    runtime_action: false,
+    workflow_execution: false,
+    scheduler: false,
+    daemon: false,
+    retry: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    history_rewrite: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeCommitReadinessDigestPayload(envelope) {
+  return {
+    stage: envelope.stage,
+    readiness_kind: envelope.readiness_kind,
+    source_bindings: envelope.source_bindings,
+    commit_subject: envelope.commit_subject,
+    worktree_snapshot_requirements: envelope.worktree_snapshot_requirements,
+    readiness_gates: envelope.readiness_gates,
+    evidence_bundle_requirements: envelope.evidence_bundle_requirements,
+    controlled_change_delivery: envelope.controlled_change_delivery,
+    readiness_order: envelope.readiness_order,
+    readiness_state: envelope.readiness_state,
+    allowed_followup: envelope.allowed_followup,
+    forbidden_actions: envelope.forbidden_actions,
+    boundary_assertions: envelope.boundary_assertions,
+    readiness_invariants: envelope.readiness_invariants,
+  };
+}
+
+export function digestCommitReadiness(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function readinessGateItems({ planActionManifest, selfTestGateProfile, commitGuard }) {
+  return [
+    {
+      id: 'stage107-gate-01-plan-action-manifest',
+      gate_kind: 'plan-action-manifest-bound',
+      status: planActionManifest.manifest_invariants?.pass === true ? 'ready' : 'blocked',
+      required_evidence: 'Stage 105 plan_action_manifest_digest and passing manifest_invariants',
+      source_digest: planActionManifest.plan_action_manifest_digest || '',
+      execution_authorized: false,
+      commit_execution_authorized: false,
+    },
+    {
+      id: 'stage107-gate-02-self-test-profile',
+      gate_kind: 'self-test-profile-bound',
+      status: selfTestGateProfile.profile_invariants?.pass === true ? 'ready' : 'blocked',
+      required_evidence: 'Stage 106 self_test_gate_profile_digest and planned_not_run gate_items',
+      source_digest: selfTestGateProfile.self_test_gate_profile_digest || '',
+      execution_authorized: false,
+      commit_execution_authorized: false,
+    },
+    {
+      id: 'stage107-gate-03-commit-subject',
+      gate_kind: 'commit-subject-guard',
+      status: commitGuard.guard_pass === true ? 'ready' : 'blocked',
+      required_evidence: 'Stage 98 commit_guard_digest with no blocking subject findings',
+      source_digest: commitGuard.commit_guard_digest || '',
+      execution_authorized: false,
+      commit_execution_authorized: false,
+    },
+    {
+      id: 'stage107-gate-04-worktree-evidence',
+      gate_kind: 'manual-worktree-evidence',
+      status: 'evidence_required',
+      required_evidence: 'fresh git status --short, git diff --stat, and git diff --check output captured manually outside Stage 107',
+      source_digest: '',
+      execution_authorized: false,
+      commit_execution_authorized: false,
+    },
+    {
+      id: 'stage107-gate-05-check-evidence',
+      gate_kind: 'manual-check-evidence',
+      status: 'evidence_required',
+      required_evidence: 'fresh syntax/runtime/release check outputs corresponding to Stage 106 recommended_order',
+      source_digest: selfTestGateProfile.self_test_gate_profile_digest || '',
+      execution_authorized: false,
+      commit_execution_authorized: false,
+    },
+  ];
+}
+
+function evidenceBundleRequirements({ planActionManifest, selfTestGateProfile, commitGuard }) {
+  const gateEvidence = (selfTestGateProfile.evidence_requirements || []).map((item) => ({
+    gate_id: item.gate_id,
+    category: item.category,
+    required_evidence: item.required_evidence,
+    completion_claim_allowed_without_evidence: false,
+  }));
+  return {
+    plan_digest_required: Boolean(planActionManifest.plan_action_manifest_digest),
+    self_test_profile_digest_required: Boolean(selfTestGateProfile.self_test_gate_profile_digest),
+    commit_guard_digest_required: Boolean(commitGuard.commit_guard_digest),
+    worktree_status_required: true,
+    diff_stat_required: true,
+    diff_check_required: true,
+    gate_evidence: gateEvidence,
+    evidence_bundle_complete: false,
+    completion_claim_allowed_without_evidence: false,
+  };
+}
+
+function readinessState(gates) {
+  const blocked = gates.filter((item) => item.status === 'blocked');
+  const evidenceRequired = gates.filter((item) => item.status === 'evidence_required');
+  return {
+    envelope_valid: blocked.length === 0,
+    commit_ready: false,
+    manual_evidence_required: evidenceRequired.length > 0,
+    blocked_gate_ids: blocked.map((item) => item.id),
+    evidence_required_gate_ids: evidenceRequired.map((item) => item.id),
+    commit_execution_authorized: false,
+  };
+}
+
+function nextManualAction(gates) {
+  const blocked = gates.filter((item) => item.status === 'blocked');
+  if (blocked.length > 0) return 'Resolve blocked readiness gates before collecting commit evidence.';
+  return 'Collect fresh manual worktree/check evidence, review the envelope, then commit only by explicit human-approved git action.';
+}
+
+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-completion-boundary-text.mjs

@@ -0,0 +1,7 @@
+export function completionReadinessActionText() {
+  return 'completion readiness was computed read-only from optional local completion evidence. No state directory, sidecar, workflow skill execution, command execution, runtime action, git, PR, push, merge, tag, platform API, external network, model, worktree, subagent, MCP, daemon, shell interception, or business source mutation occurred.';
+}
+
+export function completionEvidenceBundleActionText() {
+  return 'completion --evidence-bundle was computed read-only from optional local completion evidence and existing completion readiness rules. Stage 124 adds a human one-screen completion evidence bundle without executing verification commands or creating artifacts. No state directory, sidecar, workflow skill execution, runtime action, git, PR, push, merge, tag, platform API, external network, model, worktree, subagent, MCP, daemon, shell interception, release gate, release notes, commit guard artifact, or business source mutation occurred.';
+}

package/tools/vibe-runtime/runtime-completion-bundle-contract.mjs

@@ -0,0 +1,71 @@
+import crypto from 'node:crypto';
+import {
+  productMethodologyBoundaryAssertions,
+} from './runtime-product-methodology-gates.mjs';
+
+export function completionEvidenceBundleBoundaryAssertions() {
+  return {
+    ...productMethodologyBoundaryAssertions(),
+    completion_bundle_artifact: false,
+    completion_evidence_bundle_artifact: false,
+    architecture_artifact_write: false,
+    traceability_artifact_write: false,
+    plan_artifact_write: false,
+    engineering_evidence_write: false,
+    test_result_artifact: false,
+    diff_coverage_artifact: false,
+    commit_readiness_artifact: false,
+    verification_execution: false,
+    release_gate_artifact: false,
+    release_notes_artifact: false,
+    commit_guard_artifact: false,
+    git_add: false,
+    history_rewrite: false,
+  };
+}
+
+export function bundleInvariants(bundle, { expandedMode }) {
+  const findings = [];
+  if (bundle.bundle_kind !== 'product-completion-evidence-bundle') findings.push('bundle_kind must be product-completion-evidence-bundle');
+  if (!['Stage 152', 'Stage 155'].includes(bundle.stage)) findings.push('stage must be Stage 152 or Stage 155');
+  if (!bundle.requirements_chain?.product_spec?.digest) findings.push('product spec digest binding is required');
+  if (!bundle.requirements_chain?.ui_design?.digest) findings.push('UI design digest binding is required');
+  if (!bundle.requirements_chain?.scenarios?.digest) findings.push('scenario acceptance digest binding is required');
+  if (!bundle.requirements_chain?.product_acceptance?.digest) findings.push('product acceptance digest binding is required');
+  if (expandedMode) {
+    if (!bundle.architecture_chain?.architecture?.digest) findings.push('architecture digest binding is required in expanded delivery chain');
+    if (!bundle.traceability_chain?.traceability?.digest) findings.push('traceability digest binding is required in expanded delivery chain');
+    if (!bundle.implementation_chain?.plan?.digest) findings.push('implementation plan digest binding is required in expanded delivery chain');
+    if (!bundle.source_bindings?.implementation_task_registry_digest) findings.push('implementation task registry digest binding is required in expanded delivery chain');
+    if (bundle.implementation_chain?.implementation_alignment_readiness?.implementation_plan_gate_ok !== true) findings.push('implementation plan gate must pass in expanded delivery chain');
+    if (bundle.implementation_chain?.implementation_alignment_readiness?.implementation_alignment_ok !== true) findings.push('implementation alignment gate must pass in expanded delivery chain');
+    if (!bundle.implementation_chain?.test_evidence?.digest) findings.push('test evidence digest binding is required in expanded delivery chain');
+    if (!bundle.implementation_chain?.diff_coverage?.digest) findings.push('diff coverage digest binding is required in expanded delivery chain');
+    if (!bundle.release_readiness_chain?.commit_readiness?.digest) findings.push('commit readiness digest binding is required in expanded delivery chain');
+  }
+  if (bundle.engineering_readiness?.evidence_status !== 'provided') findings.push('engineering evidence is required before completion handoff');
+  if (bundle.release_readiness_chain?.commit_execution_authorized !== false) findings.push('completion bundle must not authorize commit execution');
+  if (bundle.release_readiness_chain?.git_write !== false) findings.push('completion bundle must not authorize git write');
+  for (const key of ['git', 'git_write', 'commit', 'push', 'pr', 'merge', 'git_add', 'history_rewrite']) {
+    if (bundle.boundary_assertions?.[key] !== false) findings.push(`boundary assertion must remain false: ${key}`);
+  }
+  const unsafeBoundaries = Object.entries(bundle.boundary_assertions || {}).filter(([, value]) => value !== false).map(([key]) => key);
+  findings.push(...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`));
+  return {
+    pass: findings.length === 0 && bundle.blocked_reasons.length === 0,
+    checked: ['requirements_chain', 'architecture_chain', 'traceability_chain', 'implementation_chain', 'release_readiness_chain', 'engineering_readiness', 'source_bindings', 'boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestObject(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).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-completion-chain-assembly.mjs

@@ -0,0 +1,48 @@
+export function gateChainItem(result) {
+  if (!result) return { status: 'missing', file: '', digest: '', gate_digest: '', gate_ok: false };
+  return {
+    status: result.status,
+    file: result.file,
+    digest: result.digest,
+    gate_digest: result.gate_digest,
+    gate_ok: result.gate_ok,
+  };
+}
+
+export function evidenceChainItem(result) {
+  if (!result) return { status: 'missing', file: '', digest: '', summary: '' };
+  return {
+    status: result.status,
+    file: result.file,
+    digest: result.digest,
+    summary: result.summary,
+  };
+}
+
+export function requirementsChainFromGateResults(productGateResults) {
+  return Object.fromEntries(productGateResults.map((result) => [result.slot, gateChainItem(result)]));
+}
+
+export function sourceBindingsFromCompletionInputs({
+  productGateResults,
+  architecture,
+  traceability,
+  implementationPlan,
+  implementationPlanGate,
+  testEvidence,
+  diffCoverage,
+  commitReadiness,
+  engineeringEvidence,
+}) {
+  return {
+    ...Object.fromEntries(productGateResults.map((result) => [`${result.slot}_digest`, result.digest])),
+    architecture_digest: architecture?.digest || '',
+    traceability_digest: traceability?.digest || '',
+    implementation_plan_digest: implementationPlan?.digest || '',
+    implementation_task_registry_digest: implementationPlanGate.registry?.registry_digest || '',
+    test_evidence_digest: testEvidence?.digest || '',
+    diff_coverage_digest: diffCoverage?.digest || '',
+    commit_readiness_digest: commitReadiness?.digest || '',
+    engineering_evidence_digest: engineeringEvidence.digest,
+  };
+}

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

@@ -0,0 +1,50 @@
+import { productCompletionEvidenceBundleEnvelope } from './runtime-completion-evidence-bundle.mjs';
+
+export function hasProductCompletionEvidenceInputs(options) {
+  return Boolean(options.fromProductDiscovery || options.fromProductSpec || options.fromUiDesign || options.fromArchitecture || options.fromTraceability || options.fromPlan || options.fromScenarios || options.fromProductAcceptance || options.fromTestEvidence || options.fromDiffCoverage || options.fromCommitReadiness || options.fromEvidence);
+}
+
+export function runProductCompletionEvidenceBundleCommand(deps, options) {
+  const { writeJsonEnvelope, printList } = deps;
+  const envelope = productCompletionEvidenceBundleEnvelope(options.root, {
+    fromProductDiscovery: options.fromProductDiscovery,
+    fromProductSpec: options.fromProductSpec,
+    fromUiDesign: options.fromUiDesign,
+    fromArchitecture: options.fromArchitecture,
+    fromTraceability: options.fromTraceability,
+    fromPlan: options.fromPlan,
+    fromScenarios: options.fromScenarios,
+    fromProductAcceptance: options.fromProductAcceptance,
+    fromTestEvidence: options.fromTestEvidence,
+    fromDiffCoverage: options.fromDiffCoverage,
+    fromCommitReadiness: options.fromCommitReadiness,
+    fromEvidence: options.fromEvidence,
+  });
+  if (options.json) writeJsonEnvelope('completion', envelope);
+  else printProductCompletionEvidenceBundle(envelope, { printList });
+}
+
+export function printProductCompletionEvidenceBundle(envelope, { printList }) {
+  const bundle = envelope.completion_evidence_bundle;
+  console.log('Vibecoding Runtime Product Completion Evidence Bundle');
+  console.log(`Stage: ${bundle.stage}; Kind: ${bundle.bundle_kind}; pass=${bundle.invariants.pass}`);
+  console.log(`Product readiness: closed_loop=${bundle.product_readiness.closed_loop}`);
+  console.log(`UI readiness: closed_loop=${bundle.ui_readiness.closed_loop}`);
+  console.log(`Architecture readiness: closed_loop=${bundle.architecture_readiness.closed_loop}; required=${bundle.architecture_readiness.required}`);
+  console.log(`Traceability readiness: closed_loop=${bundle.traceability_readiness.closed_loop}; required=${bundle.traceability_readiness.required}`);
+  console.log(`Implementation evidence: plan=${bundle.implementation_chain.plan.status}; test=${bundle.implementation_chain.test_evidence.status}; diff=${bundle.implementation_chain.diff_coverage.status}`);
+  console.log(`Commit readiness: ${bundle.release_readiness_chain.commit_readiness.status}; git_write=${bundle.release_readiness_chain.git_write}; commit=${bundle.release_readiness_chain.commit}`);
+  console.log(`Engineering evidence: ${bundle.engineering_readiness.evidence_status}; ${bundle.engineering_readiness.evidence_file || 'not provided'}`);
+  if (bundle.verification_gate_chain) console.log(`Verification gate: ready_for_closeout=${bundle.verification_gate_chain.ready_for_closeout}; can_claim_verified=${bundle.verification_gate_chain.can_claim_verified}; blockers=${bundle.verification_gate_chain.blocked_reasons.length}`);
+  if (bundle.task_completion_summary) {
+    console.log(`Completion focus: classification=${bundle.task_completion_summary.readiness_classification}; local_task_ready=${bundle.task_completion_summary.local_task_ready}`);
+    console.log(`Missing local evidence: ${bundle.task_completion_summary.minimum_local_evidence_missing.length}; full compliance gaps: ${bundle.task_completion_summary.full_compliance_evidence_missing.length}; unsafe release actions: ${bundle.task_completion_summary.unsafe_release_actions_detected.length}`);
+  }
+  for (const [slot, item] of Object.entries(bundle.requirements_chain)) console.log(`- ${slot}: status=${item.status}; gate_ok=${item.gate_ok}; file=${item.file || 'not provided'}`);
+  if (bundle.evidence_gaps.length > 0) printList('Evidence gaps', bundle.evidence_gaps);
+  if (bundle.blocked_reasons.length > 0) printList('Blocked reasons', bundle.blocked_reasons);
+  console.log('Boundary: writes=false; completion_evidence_bundle_artifact=false; command_execution=false; check_execution=false; test_execution=false; browser_execution=false; skill_execution=false; workflow_execution=false; git=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+  console.log(`Bundle digest: ${bundle.bundle_digest}`);
+  console.log(`Manual action: ${bundle.next_manual_action}`);
+  console.log(`Action: ${envelope.action}`);
+}