@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-close-loop-dashboard.mjs

@@ -0,0 +1,283 @@
+import crypto from 'node:crypto';
+
+const closeLoopDashboardStage = 'Stage 109';
+const closeLoopDashboardKind = 'close-loop-dashboard';
+
+export function runtimeCloseLoopDashboard({
+  planActionManifest = {},
+  selfTestGateProfile = {},
+  commitReadiness = {},
+  confirmedOneShotPlan = null,
+  automationReadiness = {},
+  registry = {},
+  registryDigest = '',
+  confirmation = {},
+} = {}) {
+  const boundaryAssertions = runtimeCloseLoopDashboardBoundaryAssertions();
+  const dashboard = {
+    version: 1,
+    stage: closeLoopDashboardStage,
+    dashboard_kind: closeLoopDashboardKind,
+    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_readiness_stage: commitReadiness.stage || '',
+      commit_readiness_digest: commitReadiness.commit_readiness_digest || '',
+      confirmed_one_shot_plan_stage: confirmedOneShotPlan?.stage || '',
+      confirmed_one_shot_plan_digest: confirmedOneShotPlan?.confirmed_one_shot_plan_digest || '',
+      automation_readiness_stage: automationReadiness.stage || '',
+      automation_readiness_kind: automationReadiness.readiness_kind || '',
+      automation_readiness_digest: automationReadiness.readiness_digest || '',
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+      registry_digest: registryDigest,
+    },
+    plan_status: planStatus(planActionManifest),
+    docs_status: docsStatus(planActionManifest),
+    code_status: codeStatus(planActionManifest),
+    self_test_status: selfTestStatus(selfTestGateProfile),
+    commit_status: commitStatus(commitReadiness),
+    one_shot_status: oneShotStatus(confirmedOneShotPlan, confirmation),
+    dashboard_sections: ['plan', 'docs', 'code', 'self_test', 'commit', 'one_shot', 'next_manual_action'],
+    next_manual_action: nextManualAction({ commitReadiness, confirmedOneShotPlan, confirmation }),
+    allowed_followup: [
+      'manual evidence collection outside Stage 109',
+      'Stage 110 evidence intake envelope from a local evidence file',
+      'Stage 111 diff coverage envelope from a local diff file',
+      'manual commit only after fresh human-reviewed evidence and explicit git action',
+    ],
+    forbidden_actions: [
+      'executing plan action items from Stage 109',
+      'running checks, tests, repair, formatting, or code generation',
+      'git command, commit, push, PR, merge, tag, reset, checkout, or history rewrite',
+      'sidecar or .vibecoding-state write',
+      'scheduler, daemon, retry, platform API, external network, model, MCP, or subagent invocation',
+      'treating dashboard pass as runtime execution permission',
+    ],
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeCloseLoopDashboardInvariants(dashboard);
+  return {
+    ...dashboard,
+    dashboard_invariants: invariants,
+    manual_action: invariants.pass
+      ? dashboard.next_manual_action
+      : 'Resolve the listed dashboard binding or boundary gaps before using this close-loop overview.',
+  };
+}
+
+export function runtimeCloseLoopDashboardInvariants(dashboard) {
+  const missingSourceBindings = ['plan_action_manifest_digest', 'self_test_gate_profile_digest', 'commit_readiness_digest', 'automation_readiness_digest', 'registry_digest']
+    .filter((key) => !dashboard.source_bindings?.[key]);
+  const expectedStages = [
+    ['plan_action_manifest_stage', 'Stage 105'],
+    ['self_test_gate_profile_stage', 'Stage 106'],
+    ['commit_readiness_stage', 'Stage 107'],
+    ['automation_readiness_stage', 'Stage 103'],
+    ['registry_stage', 'Stage 101'],
+  ];
+  const stageMismatches = expectedStages
+    .filter(([key, expected]) => dashboard.source_bindings?.[key] !== expected)
+    .map(([key, expected]) => `${key} must be ${expected}`);
+  const writableBoundaries = Object.entries(dashboard.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const forbiddenMissing = ['close_loop_dashboard_artifact', 'command_execution', 'test_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write']
+    .filter((key) => dashboard.boundary_assertions?.[key] !== false);
+  const executableStatus = [
+    dashboard.plan_status?.execution_authorized,
+    dashboard.self_test_status?.test_execution_authorized,
+    dashboard.commit_status?.commit_execution_authorized,
+    dashboard.one_shot_status?.execution_authorized,
+    dashboard.one_shot_status?.actions_executed,
+    dashboard.one_shot_status?.ready_for_runtime_execution,
+  ].filter((value) => value !== false);
+  const findings = [
+    ...(dashboard.plan_status?.pass !== true ? ['Stage 105 plan status must pass before dashboard pass'] : []),
+    ...(dashboard.self_test_status?.all_gates_planned_not_run !== true ? ['Stage 106 gates must remain planned_not_run'] : []),
+    ...(dashboard.commit_status?.commit_ready !== false ? ['dashboard must not mark commit_ready=true'] : []),
+    ...(dashboard.one_shot_status?.ready_for_runtime_execution !== false ? ['dashboard must not mark ready_for_runtime_execution=true'] : []),
+    ...missingSourceBindings.map((item) => `missing source binding: ${item}`),
+    ...stageMismatches,
+    ...executableStatus.map((item) => `execution boundary must remain false: ${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: [
+      'stage_105_manifest_binding',
+      'stage_106_self_test_binding',
+      'stage_107_commit_readiness_binding',
+      'stage_108_optional_confirmation_status',
+      'dashboard_only_no_execution',
+      'read_only_boundary_assertions',
+    ],
+    findings,
+  };
+}
+
+export function runtimeCloseLoopDashboardBoundaryAssertions() {
+  return {
+    close_loop_dashboard_artifact: false,
+    plan_action_manifest_artifact: false,
+    self_test_gate_profile_artifact: false,
+    commit_readiness_artifact: false,
+    confirmed_one_shot_plan_artifact: false,
+    one_shot_execution_artifact: false,
+    test_result_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    test_execution: false,
+    check_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 runtimeCloseLoopDashboardDigestPayload(dashboard) {
+  return {
+    stage: dashboard.stage,
+    dashboard_kind: dashboard.dashboard_kind,
+    source_bindings: dashboard.source_bindings,
+    plan_status: dashboard.plan_status,
+    docs_status: dashboard.docs_status,
+    code_status: dashboard.code_status,
+    self_test_status: dashboard.self_test_status,
+    commit_status: dashboard.commit_status,
+    one_shot_status: dashboard.one_shot_status,
+    dashboard_sections: dashboard.dashboard_sections,
+    next_manual_action: dashboard.next_manual_action,
+    allowed_followup: dashboard.allowed_followup,
+    forbidden_actions: dashboard.forbidden_actions,
+    boundary_assertions: dashboard.boundary_assertions,
+    dashboard_invariants: dashboard.dashboard_invariants,
+  };
+}
+
+export function digestCloseLoopDashboard(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function planStatus(manifest) {
+  const actions = manifest.action_items || [];
+  return {
+    stage: manifest.stage || '',
+    pass: manifest.manifest_invariants?.pass === true,
+    action_item_count: actions.length,
+    blocked_findings: manifest.manifest_invariants?.findings || [],
+    execution_authorized: false,
+  };
+}
+
+function docsStatus(manifest) {
+  const expectations = manifest.docs_expectations || [];
+  return {
+    expectation_count: expectations.length,
+    expected_files: unique(expectations.flatMap((item) => item.files || item.target_files || [])),
+    gaps: expectations.length === 0 ? ['no docs expectations were derived from the local plan'] : [],
+    execution_authorized: false,
+  };
+}
+
+function codeStatus(manifest) {
+  const expectations = manifest.code_expectations || [];
+  return {
+    expectation_count: expectations.length,
+    expected_files: unique(expectations.flatMap((item) => item.files || item.target_files || [])),
+    gaps: expectations.length === 0 ? ['no code expectations were derived from the local plan'] : [],
+    execution_authorized: false,
+  };
+}
+
+function selfTestStatus(profile) {
+  const gates = profile.gate_items || [];
+  const planned = gates.filter((item) => item.status === 'planned_not_run');
+  return {
+    stage: profile.stage || '',
+    pass: profile.profile_invariants?.pass === true,
+    gate_count: gates.length,
+    planned_not_run_count: planned.length,
+    all_gates_planned_not_run: gates.length > 0 && planned.length === gates.length,
+    categories: profile.coverage?.categories || {},
+    recommended_order_count: profile.recommended_order?.length || 0,
+    test_execution_authorized: false,
+  };
+}
+
+function commitStatus(readiness) {
+  const gates = readiness.readiness_gates || [];
+  return {
+    stage: readiness.stage || '',
+    pass: readiness.readiness_invariants?.pass === true,
+    readiness_gate_count: gates.length,
+    ready_gate_count: gates.filter((item) => item.status === 'ready').length,
+    evidence_required_gate_count: gates.filter((item) => item.status === 'evidence_required').length,
+    blocked_gate_ids: readiness.readiness_state?.blocked_gate_ids || [],
+    subject_guard_pass: readiness.commit_subject?.guard_pass === true,
+    commit_ready: false,
+    commit_execution_authorized: false,
+  };
+}
+
+function oneShotStatus(plan, confirmation) {
+  const phrase = String(confirmation.confirmPlan || '').trim();
+  return {
+    stage: plan?.stage || 'Stage 108',
+    confirmation_provided: phrase.length > 0,
+    plan_confirmed: plan?.confirmation_gate?.plan_confirmed === true,
+    planned_step_count: plan?.planned_steps?.length || 0,
+    ready_for_runtime_execution: false,
+    actions_executed: false,
+    execution_authorized: false,
+    status: phrase ? 'confirmed_plan_contract_available' : 'not_confirmed_plan_contract_optional',
+  };
+}
+
+function nextManualAction({ commitReadiness, confirmedOneShotPlan, confirmation }) {
+  const blocked = commitReadiness.readiness_state?.blocked_gate_ids || [];
+  if (blocked.length > 0) return 'Fix blocked readiness gates before collecting evidence for closeout.';
+  if (!String(confirmation.confirmPlan || '').trim()) return 'Review the dashboard, then optionally add --confirm-plan to include the Stage 108 confirmed plan contract without executing it.';
+  if (confirmedOneShotPlan?.plan_invariants?.pass !== true) return 'Fix the confirmed plan contract gaps before any separate manual execution discussion.';
+  return 'Collect fresh manual evidence, review diff and checks, then commit only through an explicit human-approved git action outside Stage 109.';
+}
+
+function unique(items) {
+  return [...new Set(items.filter((item) => typeof item === 'string' && item.trim()).map((item) => item.trim()))].sort();
+}
+
+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-closeout-parity-contract.mjs

@@ -0,0 +1,214 @@
+import { buildControlledChangeDeliveryContract } from './runtime-controlled-change-delivery-contract.mjs';
+import { executionEnabledCloseoutIsolation } from './runtime-execution-enabled-closeout-boundary.mjs';
+
+export const closeoutParityStage = 'P13';
+export const closeoutParityKind = 'superpowers-parity-closeout-readiness';
+
+export function closeoutParityEnvelope({ ledgerSource, testSource, diffSource, readinessSource, digestObject, statePresent }) {
+  const ledger = ledgerSnapshot(ledgerSource.data);
+  const tests = testSnapshot(testSource.data);
+  const diff = diffSnapshot(diffSource.data);
+  const readiness = readinessSnapshot(readinessSource.data);
+  const findings = closeoutFindings({ ledger, tests, diff, readiness });
+  const isolation = executionEnabledCloseoutIsolation({ digestObject });
+  const ready = findings.length === 0;
+  const core = {
+    version: 1,
+    stage: closeoutParityStage,
+    closeout_kind: closeoutParityKind,
+    automation_profile: 'superpowers-parity',
+    sources: {
+      ledger: sourceRef(ledgerSource),
+      test_evidence: sourceRef(testSource),
+      diff_evidence: sourceRef(diffSource),
+      task_commit_readiness: sourceRef(readinessSource),
+    },
+    gates: [
+      gate('sdd-ledger-complete', ledger.ready, ledger.reason),
+      gate('final-review-clean', ledger.reviewClean, ledger.reviewReason),
+      gate('test-evidence-present', tests.ready, tests.reason),
+      gate('diff-evidence-present', diff.ready, diff.reason),
+      gate('task-commit-readiness-pass', readiness.ready, readiness.reason),
+    ],
+    closeout_ready: ready,
+    manual_next_action: ready ? 'commit' : 'stop',
+    manual_action_options: ready ? ['commit', 'no commit', 'PR after manual push decision'] : ['stop'],
+    blocker_count: findings.length,
+    blocked_reasons: findings,
+    evidence_summary: {
+      completed_task_ids: ledger.completedTaskIds,
+      active_task_id: ledger.activeTaskId,
+      review_statuses: ledger.reviewStatuses,
+      test_status: tests.status,
+      diff_changed_file_count: diff.changedFileCount,
+      task_commit_gate_pass: readiness.gatePass,
+      execution_evidence_verification_only: true,
+    },
+    controlled_change_delivery: buildControlledChangeDeliveryContract({
+      phase: 'closeout-readiness',
+      changeSetSummary: {
+        source_stage: closeoutParityStage,
+        completed_task_count: ledger.completedTaskIds.length,
+        diff_changed_file_count: diff.changedFileCount,
+        task_commit_gate_pass: readiness.gatePass,
+        closeout_ready: ready,
+      },
+      planTaskBinding: ledger.completedTaskIds.length > 0,
+      diffCoverageBound: diff.ready,
+      testEvidenceBound: tests.ready,
+      reviewVerdictBound: ledger.reviewClean,
+      commitSubjectBound: readiness.ready,
+      rollbackNoteBound: false,
+      blockedReasons: findings,
+      nextManualAction: ready
+        ? 'Make any commit, PR, push, or merge decision manually outside runtime after reviewing the local evidence bundle.'
+        : 'Resolve closeout evidence blockers before any delivery decision.',
+    }),
+    policy: {
+      final_review_required: true,
+      critical_or_important_blockers_allowed: false,
+      test_evidence_required: true,
+      diff_evidence_required: true,
+      task_commit_readiness_required: true,
+      execution_evidence_authorizes_source_write: false,
+      execution_evidence_authorizes_git: false,
+      execution_evidence_authorizes_subagent: false,
+      execution_evidence_authorizes_platform_or_model: false,
+      runtime_git_execution_authorized: false,
+      push_allowed_by_runtime: false,
+      pr_allowed_by_runtime: false,
+      merge_allowed_by_runtime: false,
+    },
+    allowed_followup: ready
+      ? ['manual commit decision outside runtime', 'manual PR decision outside runtime after human review']
+      : ['resolve closeout blockers and rerun local closeout readiness'],
+    execution_enabled_isolation: isolation,
+    forbidden_actions: ['runtime git add/commit/push/PR/merge/tag/reset/checkout', 'platform API call', 'external network call', 'model invocation', 'subagent invocation', 'source write', 'worktree write'],
+    boundary_assertions: closeoutBoundary(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const closeout = { ...core, closeout_readiness_digest: digestObject(core) };
+  return {
+    mode: closeoutParityKind,
+    ok: ready,
+    state_present: statePresent,
+    closeout_readiness: closeout,
+    safety: { stage: closeoutParityStage, ...closeoutBoundary() },
+    quality: findings,
+    action: ready
+      ? 'closeout readiness passed from local ledger, review, test, diff, and task commit readiness evidence. The runtime did not run git, create a commit, push, open a PR, merge, call platform APIs, invoke models or subagents, write source, or create worktrees.'
+      : 'closeout readiness is blocked by local evidence gates. The runtime did not run git, create a commit, push, open a PR, merge, call platform APIs, invoke models or subagents, write source, or create worktrees.',
+  };
+}
+
+export function closeoutBoundary() {
+  return {
+    closeout_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    source_write: false,
+    business_source_write: false,
+    worktree: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    push: false,
+    pr: false,
+    merge: false,
+    tag: false,
+    history_rewrite: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+  };
+}
+
+export function printCloseoutReadiness(envelope) {
+  const readiness = envelope.closeout_readiness;
+  console.log('Vibecoding Runtime Closeout Readiness');
+  console.log(`Mode: ${envelope.mode}; ok=${envelope.ok}; next=${readiness.manual_next_action}`);
+  console.log(`Completed tasks: ${readiness.evidence_summary.completed_task_ids.join(', ') || 'none'}`);
+  if (envelope.quality?.length > 0) console.log(`Blocked: ${envelope.quality.join('; ')}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+function sourceRef(source) {
+  return { file: source.relative, digest: source.digest };
+}
+
+function gate(id, pass, reason) {
+  return { id, status: pass ? 'ready' : 'blocked', reason: pass ? '' : reason, runtime_action_authorized: false };
+}
+
+function closeoutFindings({ ledger, tests, diff, readiness }) {
+  return [
+    ...(ledger.ready ? [] : [`sdd-ledger-complete: ${ledger.reason}`]),
+    ...(ledger.reviewClean ? [] : [`final-review-clean: ${ledger.reviewReason}`]),
+    ...(tests.ready ? [] : [`test-evidence-present: ${tests.reason}`]),
+    ...(diff.ready ? [] : [`diff-evidence-present: ${diff.reason}`]),
+    ...(readiness.ready ? [] : [`task-commit-readiness-pass: ${readiness.reason}`]),
+  ];
+}
+
+function ledgerSnapshot(data) {
+  const ledger = data.progress_ledger || data.sdd_progress_ledger || data;
+  const completedTaskIds = asArray(ledger.completed_task_ids).filter(Boolean);
+  const activeTaskId = ledger.active_task_id || null;
+  const records = [...asArray(ledger.adapter_consumption_records), ...asArray(ledger.task_records)];
+  const reviewStatuses = unique(records.map((item) => String(item?.review_status || item?.status || '').toLowerCase()).filter(Boolean));
+  const blockerCount = records.reduce((total, item) => total + Number(item?.blocker_count || 0), 0);
+  const blockedStatus = reviewStatuses.some((status) => status.includes('blocked') || status.includes('needs_fix'));
+  const reviewClean = records.length > 0 && blockerCount === 0 && !blockedStatus && records.some((item) => String(item?.review_status || '').toLowerCase() === 'clean' || String(item?.status || '').toLowerCase().includes('clean'));
+  const ready = completedTaskIds.length > 0 && !activeTaskId && reviewClean;
+  return {
+    ready,
+    reason: ready ? '' : 'ledger must have at least one completed task, no active task, and clean review consumption',
+    reviewClean,
+    reviewReason: reviewClean ? '' : 'final clean review verdict is required and Critical/Important blockers must be resolved',
+    completedTaskIds,
+    activeTaskId,
+    reviewStatuses,
+  };
+}
+
+function testSnapshot(data) {
+  const evidence = data.test_evidence || data.sdd_evidence_chain?.test_evidence || data.runtime_test_run || data;
+  const run = evidence.runtime_test_run || evidence;
+  const status = String(run.status || evidence.status || '').toLowerCase();
+  const ready = data.ok === true || evidence.ok === true || ['pass', 'passed', 'success', 'ok'].includes(status);
+  return { ready, status: status || (ready ? 'ok' : ''), reason: ready ? '' : 'passing local test evidence is required' };
+}
+
+function diffSnapshot(data) {
+  const diff = data.diff_coverage || data.sdd_evidence_chain?.diff_evidence || data.diff_evidence || data;
+  const invariants = data.diff_coverage_invariants || {};
+  const changedFileCount = Number(diff.changed_file_count ?? data.changed_file_count ?? asArray(data.changed_files).length ?? 0);
+  const blocked = asArray(data.blocked_reasons);
+  const ready = diff.coverage_complete === true || invariants.pass === true || (changedFileCount > 0 && blocked.length === 0);
+  return { ready, changedFileCount, reason: ready ? '' : 'diff evidence must be present, non-empty, and unblocked' };
+}
+
+function readinessSnapshot(data) {
+  const readiness = data.task_commit_readiness || data.release_task_commit_readiness || data;
+  const gatePass = readiness.gate_pass === true;
+  const allGatesReady = asArray(readiness.gates).length > 0 && asArray(readiness.gates).every((item) => item?.status === 'ready');
+  const runtimeGitOff = readiness.commit_policy?.runtime_git_execution_authorized === false || readiness.runtime_git_execution_authorized === false;
+  const ready = gatePass && allGatesReady && runtimeGitOff;
+  return { ready, gatePass, reason: ready ? '' : 'passing task commit readiness with runtime git execution disabled is required' };
+}
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function unique(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}

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

@@ -0,0 +1,26 @@
+import { runtimeCommandHandlers } from './runtime-cli-dispatch.mjs';
+import { runReleaseCommand } from './runtime-release-command.mjs';
+import { runTestRunCommand } from './runtime-test-run-command.mjs';
+import { runTokensCommand } from './runtime-tokens-command.mjs';
+import { runSessionCommand, runSkillCommand } from './runtime-session-skill-command.mjs';
+import { runWorkflowCommand } from './runtime-workflow-command.mjs';
+
+function resolveWrapperDeps(wrapper) {
+  return typeof wrapper === 'function' ? wrapper() : wrapper;
+}
+
+export function createRuntimeCliHandlerDeps({ commands, wrappers }) {
+  return { commands, wrappers };
+}
+
+export function createRuntimeCommandHandlers({ commands, wrappers }) {
+  return runtimeCommandHandlers({
+    ...commands,
+    runRelease: (releaseOptions) => runReleaseCommand(resolveWrapperDeps(wrappers.release), releaseOptions),
+    runTests: (testOptions) => runTestRunCommand(resolveWrapperDeps(wrappers.tests), testOptions),
+    runWorkflow: (workflowOptions) => runWorkflowCommand(resolveWrapperDeps(wrappers.workflow), workflowOptions),
+    runSession: (sessionOptions) => runSessionCommand(resolveWrapperDeps(wrappers.workflow), sessionOptions),
+    runSkill: (skillOptions) => runSkillCommand(resolveWrapperDeps(wrappers.workflow), skillOptions),
+    runTokens: (tokensOptions) => runTokensCommand(resolveWrapperDeps(wrappers.tokens), tokensOptions),
+  });
+}