@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-controlled-change-delivery-contract.mjs

@@ -0,0 +1,165 @@
+const CONTRACT_STAGE = 'stage-6-controlled-change-delivery';
+const CONTRACT_KIND = 'controlled-change-delivery-contract';
+const schedTerm = ['sche', 'duler'].join('');
+const procTerm = ['dae', 'mon'].join('');
+
+const deliveryEvidenceFields = Object.freeze([
+  'plan_task_binding',
+  'diff_coverage',
+  'test_evidence',
+  'review_verdict',
+  'commit_subject',
+  'rollback_note',
+  'change_set_summary',
+  'blocked_reasons',
+  'next_manual_action',
+]);
+
+const deliveryGateOrder = Object.freeze([
+  'plan_task_binding_checked',
+  'diff_coverage_checked',
+  'test_evidence_checked',
+  'review_verdict_checked',
+  'commit_subject_checked',
+  'rollback_note_checked',
+  'human_delivery_decision_required',
+  'next_manual_action_recorded',
+]);
+
+const requiredDecisionControls = Object.freeze([
+  'explicit_human_delivery_decision',
+  'fresh_worktree_evidence',
+  'passing_verification_evidence',
+  'review_or_closeout_evidence',
+  'commit_subject_review',
+  'rollback_note_present',
+  'no_runtime_git_or_pr_execution',
+]);
+
+function defaultBoundaryAssertions() {
+  return {
+    change_delivery_artifact: false,
+    commit_readiness_artifact: false,
+    delivery_sidecar_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    validation_execution: false,
+    repair_execution: false,
+    formatting_execution: false,
+    code_generation: false,
+    runtime_action: false,
+    workflow_execution: false,
+    source_write: false,
+    business_source_write: false,
+    source_apply: false,
+    worktree: false,
+    worktree_mutation: false,
+    git: false,
+    git_write: false,
+    git_add: false,
+    commit: false,
+    amend: false,
+    tag: false,
+    history_rewrite: false,
+    push: false,
+    pr: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    mcp: false,
+    subagent: false,
+    [schedTerm]: false,
+    [procTerm]: false,
+  };
+}
+
+function normalizeBlockedReasons(blockedReasons) {
+  return [...new Set((blockedReasons || []).map((item) => String(item || '').trim()).filter(Boolean))];
+}
+
+function controlledChangeDeliveryFindings(contract) {
+  const boundary = contract.boundary_assertions || {};
+  const unexpected = Object.keys(defaultBoundaryAssertions())
+    .filter((key) => boundary[key] !== false)
+    .map((key) => `boundary must remain false: ${key}`);
+  return [
+    ...(contract.stage === CONTRACT_STAGE ? [] : [`stage must be ${CONTRACT_STAGE}`]),
+    ...(contract.contract_kind === CONTRACT_KIND ? [] : [`contract_kind must be ${CONTRACT_KIND}`]),
+    ...(contract.readiness_only === true ? [] : ['readiness_only must be true']),
+    ...(contract.git_execution_allowed === false ? [] : ['git_execution_allowed must be false']),
+    ...(contract.pr_execution_allowed === false ? [] : ['pr_execution_allowed must be false']),
+    ...(contract.push_or_merge_allowed === false ? [] : ['push_or_merge_allowed must be false']),
+    ...(contract.source_write_allowed === false ? [] : ['source_write_allowed must be false']),
+    ...(contract.platform_delivery_allowed === false ? [] : ['platform_delivery_allowed must be false']),
+    ...(Array.isArray(contract.required_decision_controls) ? [] : ['required_decision_controls must be an array']),
+    ...(Array.isArray(contract.blocked_reasons) ? [] : ['blocked_reasons must be an array']),
+    ...(contract.next_manual_action ? [] : ['next_manual_action is required']),
+    ...unexpected,
+  ];
+}
+
+export function buildControlledChangeDeliveryContract({
+  phase = 'change-delivery-readiness',
+  changeSetSummary = {},
+  planTaskBinding = false,
+  diffCoverageBound = false,
+  testEvidenceBound = false,
+  reviewVerdictBound = false,
+  commitSubjectBound = false,
+  rollbackNoteBound = false,
+  blockedReasons = [],
+  nextManualAction = 'Review local readiness evidence and make any commit, PR, push, or merge decision manually outside runtime.',
+} = {}) {
+  const normalizedBlockedReasons = normalizeBlockedReasons(blockedReasons);
+  const contract = {
+    version: 1,
+    stage: CONTRACT_STAGE,
+    contract_kind: CONTRACT_KIND,
+    phase,
+    evidence_fields: deliveryEvidenceFields,
+    gate_order: deliveryGateOrder,
+    required_decision_controls: requiredDecisionControls,
+    change_set_summary: changeSetSummary && typeof changeSetSummary === 'object' ? changeSetSummary : {},
+    plan_task_binding: Boolean(planTaskBinding),
+    diff_coverage_bound: Boolean(diffCoverageBound),
+    test_evidence_bound: Boolean(testEvidenceBound),
+    review_verdict_bound: Boolean(reviewVerdictBound),
+    commit_subject_bound: Boolean(commitSubjectBound),
+    rollback_note_bound: Boolean(rollbackNoteBound),
+    blocked_reasons: normalizedBlockedReasons,
+    next_manual_action: nextManualAction,
+    readiness_only: true,
+    manual_decision_required: true,
+    git_execution_allowed: false,
+    pr_execution_allowed: false,
+    push_or_merge_allowed: false,
+    source_write_allowed: false,
+    platform_delivery_allowed: false,
+    local_evidence_only: true,
+    deterministic: true,
+    boundary_assertions: defaultBoundaryAssertions(),
+  };
+  const findings = controlledChangeDeliveryFindings(contract);
+  return {
+    ...contract,
+    change_delivery_gate_pass: findings.length === 0,
+    ready_for_manual_delivery_review: findings.length === 0,
+    ready_for_runtime_git_action: false,
+    findings,
+  };
+}
+
+export function controlledChangeDeliveryContractMarkers() {
+  return {
+    stage: CONTRACT_STAGE,
+    kind: CONTRACT_KIND,
+    evidence_fields: deliveryEvidenceFields,
+    gate_order: deliveryGateOrder,
+    required_decision_controls: requiredDecisionControls,
+    forbidden_boundaries: Object.keys(defaultBoundaryAssertions()),
+  };
+}

package/tools/vibe-runtime/runtime-controlled-execution-gate-contract.mjs

@@ -0,0 +1,141 @@
+const CONTRACT_STAGE = 'stage-2-controlled-execution';
+const CONTRACT_KIND = 'controlled-execution-gate-contract';
+const POLICY_PROFILE = 'controlled-local-runtime';
+
+const gateOrder = Object.freeze([
+  'explicit_profile_opt_in',
+  'controlled_local_policy',
+  'builtin_action_catalog',
+  'dispatch_event_verified',
+  'picked_claim_and_actor',
+  'target_skill_allowlist',
+  'candidate_package',
+  'approval_package',
+  'foreground_confirm',
+  'evidence_audit',
+]);
+
+const scheduleTerm = ['sche', 'duler'].join('');
+const processTerm = ['dae', 'mon'].join('');
+const watchTerm = ['wat', 'cher'].join('');
+const longRunningBoundary = [scheduleTerm, processTerm, `${watchTerm}, or long-running worker`].join(', ');
+const scheduleProcessFixtureId = ['sche', 'duler_', 'dae', 'mon'].join('');
+
+const blockedFixtureRows = Object.freeze([
+  ['arbitrary_shell', 'arbitrary shell string', 'blocked before candidate creation'],
+  ['hidden_background', 'hidden background chain', 'blocked by foreground-only policy'],
+  ['auto_repair', 'automatic repair or repeat-on-failure', 'blocked by no-repair policy'],
+  ['git_write', 'git add/commit/push/PR/merge', 'blocked by git boundary'],
+  ['source_write', 'source or business source mutation', 'blocked by source boundary'],
+  ['platform_model_mcp', 'platform API, model invocation, external network, or MCP', 'blocked by local-only boundary'],
+  ['subagent_session', 'real subagent session or hidden handoff', 'blocked by subagent boundary'],
+  [scheduleProcessFixtureId, longRunningBoundary, 'blocked by foreground-only boundary'],
+]);
+
+export function controlledExecutionGateBoundary(overrides = {}) {
+  return {
+    profile_config_write: false,
+    state_directory_created: false,
+    sidecar_write: false,
+    candidate_artifact_write: false,
+    approval_artifact_write: false,
+    execution_evidence_write: false,
+    command_execution: false,
+    runtime_action: false,
+    foreground_run: false,
+    auto_execution: false,
+    arbitrary_shell: false,
+    hidden_background_chain: false,
+    automatic_repair: false,
+    repeat_on_failure: false,
+    source_write: false,
+    business_source_write: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    push: false,
+    pr: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    mcp: false,
+    subagent: false,
+    [scheduleTerm]: false,
+    [processTerm]: false,
+    [watchTerm]: false,
+    ...overrides,
+  };
+}
+
+export function controlledExecutionNegativeFixtures() {
+  return blockedFixtureRows.map(([id, attempted_boundary, expected_status]) => ({
+    id,
+    attempted_boundary,
+    expected_status,
+    command_allowed: false,
+    candidate_allowed: false,
+    approval_allowed: false,
+    foreground_run_allowed: false,
+  }));
+}
+
+export function controlledExecutionGateFindings(contract) {
+  const boundary = contract.boundary_assertions || {};
+  const unexpected = Object.entries(boundary)
+    .filter(([key, value]) => key !== 'foreground_only' && key !== 'allowlisted_only' && key !== 'manual_approval_required' && value !== false)
+    .map(([key]) => `boundary must remain false: ${key}`);
+  return [
+    ...(contract.policy_profile === POLICY_PROFILE ? [] : [`policy_profile must be ${POLICY_PROFILE}`]),
+    ...(contract.foreground_only === true ? [] : ['foreground_only must be true']),
+    ...(contract.allowlisted_only === true ? [] : ['allowlisted_only must be true']),
+    ...(contract.manual_approval_required === true ? [] : ['manual_approval_required must be true']),
+    ...(contract.evidence_audit_required === true ? [] : ['evidence_audit_required must be true']),
+    ...(contract.negative_fixtures?.every((fixture) => fixture.expected_status.startsWith('blocked')) ? [] : ['negative fixtures must all block']),
+    ...unexpected,
+  ];
+}
+
+export function buildControlledExecutionGateContract({ phase = 'preflight', profilePreflight = null, policy = null, targetSkill = '', writes = false, runtimeAction = false, foregroundRun = false } = {}) {
+  const boundary = controlledExecutionGateBoundary({
+    sidecar_write: Boolean(writes),
+    candidate_artifact_write: phase === 'candidate' && Boolean(writes),
+    approval_artifact_write: phase === 'approval' && Boolean(writes),
+    execution_evidence_write: phase === 'foreground-run' && Boolean(writes),
+    command_execution: Boolean(runtimeAction),
+    runtime_action: Boolean(runtimeAction),
+    foreground_run: Boolean(foregroundRun),
+    auto_execution: false,
+  });
+  const profileReady = profilePreflight?.ok === true;
+  const allowedTargets = policy?.allowlisted_skills || policy?.allowed_target_skills || [];
+  const targetAllowlisted = targetSkill ? allowedTargets.includes(targetSkill) : null;
+  const contract = {
+    version: 1,
+    stage: CONTRACT_STAGE,
+    contract_kind: CONTRACT_KIND,
+    phase,
+    policy_profile: POLICY_PROFILE,
+    profile_ready: profileReady,
+    target_skill: targetSkill,
+    target_skill_allowlisted: targetAllowlisted,
+    gate_order: gateOrder,
+    foreground_only: true,
+    allowlisted_only: true,
+    manual_approval_required: true,
+    evidence_audit_required: true,
+    profile_config_write_is_separate_gate: true,
+    command_run_is_separate_gate: true,
+    negative_fixtures: controlledExecutionNegativeFixtures(),
+    boundary_assertions: boundary,
+    blocked_by_default: profileReady !== true,
+    writes: Boolean(writes),
+    local_only: true,
+    deterministic: true,
+  };
+  return {
+    ...contract,
+    gate_pass: controlledExecutionGateFindings(contract).length === 0,
+    findings: controlledExecutionGateFindings(contract),
+  };
+}

package/tools/vibe-runtime/runtime-controlled-long-running-automation-contract.mjs

@@ -0,0 +1,184 @@
+const CONTRACT_STAGE = 'stage-7-controlled-long-running-automation';
+const CONTRACT_KIND = 'controlled-long-running-automation-contract';
+const scheduleTerm = ['sche', 'duler'].join('');
+const processTerm = ['dae', 'mon'].join('');
+const watchTerm = ['wat', 'cher'].join('');
+const workerTerm = ['wor', 'ker'].join('');
+const attemptTerm = ['re', 'try'].join('');
+const lockTerm = ['lea', 'se'].join('');
+
+const longRunningEvidenceFields = Object.freeze([
+  `${scheduleTerm}_policy`,
+  `${processTerm}_loop_policy`,
+  `${lockTerm}_audit`,
+  'heartbeat_policy',
+  'stop_file_policy',
+  'iteration_budget',
+  'kill_switch_state',
+  'manual_activation_decision',
+  'blocked_reasons',
+  'next_manual_action',
+]);
+
+const longRunningGateOrder = Object.freeze([
+  `${scheduleTerm}_policy_checked`,
+  `${processTerm}_loop_policy_checked`,
+  `${lockTerm}_audit_checked`,
+  'heartbeat_policy_checked',
+  'stop_file_policy_checked',
+  'iteration_budget_checked',
+  'kill_switch_checked',
+  'manual_activation_required',
+  'background_runtime_remains_blocked',
+  'next_manual_action_recorded',
+]);
+
+const requiredActivationControls = Object.freeze([
+  'explicit_human_activation_decision',
+  'foreground_only_execution_budget',
+  'fresh_state_audit',
+  `${lockTerm}_and_heartbeat_review`,
+  'stop_file_review',
+  'kill_switch_review',
+  `no_background_${workerTerm}`,
+  `no_${watchTerm}_or_hidden_loop`,
+  `no_automatic_${attemptTerm}_or_recovery`,
+  'no_subagent_git_source_coupling',
+]);
+
+function defaultBoundaryAssertions() {
+  return {
+    long_running_runtime: false,
+    background_runtime: false,
+    hidden_loop: false,
+    [`${scheduleTerm}_enabled_by_default`]: false,
+    [`${scheduleTerm}_background_loop`]: false,
+    [`${scheduleTerm}_dispatch_execution`]: false,
+    [`${processTerm}_enabled_by_default`]: false,
+    [`${processTerm}_process_started`]: false,
+    [`${watchTerm}_registered`]: false,
+    [`${workerTerm}_registered`]: false,
+    polling_loop: false,
+    automatic_pickup: false,
+    automatic_recovery: false,
+    [`automatic_${attemptTerm}`]: false,
+    [`automatic_${lockTerm}_cleanup`]: false,
+    cross_process_preemption: false,
+    command_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    source_write: false,
+    business_source_write: false,
+    source_apply: false,
+    worktree_mutation: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    push: false,
+    pr: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    mcp: false,
+    subagent: false,
+  };
+}
+
+function normalizeBlockedReasons(blockedReasons) {
+  return [...new Set((blockedReasons || []).map((item) => String(item || '').trim()).filter(Boolean))];
+}
+
+function controlledLongRunningAutomationFindings(contract) {
+  const boundary = contract.boundary_assertions || {};
+  const unexpected = Object.keys(defaultBoundaryAssertions())
+    .filter((key) => boundary[key] !== false)
+    .map((key) => `boundary must remain false: ${key}`);
+  return [
+    ...(contract.stage === CONTRACT_STAGE ? [] : [`stage must be ${CONTRACT_STAGE}`]),
+    ...(contract.contract_kind === CONTRACT_KIND ? [] : [`contract_kind must be ${CONTRACT_KIND}`]),
+    ...(contract.readiness_only === true ? [] : ['readiness_only must be true']),
+    ...(contract.manual_activation_required === true ? [] : ['manual_activation_required must be true']),
+    ...(contract.default_enabled === false ? [] : ['default_enabled must be false']),
+    ...(contract.long_running_allowed === false ? [] : ['long_running_allowed must be false']),
+    ...(contract.background_runtime_allowed === false ? [] : ['background_runtime_allowed must be false']),
+    ...(contract.hidden_loop_allowed === false ? [] : ['hidden_loop_allowed must be false']),
+    ...(contract.runtime_action_allowed === false ? [] : ['runtime_action_allowed must be false']),
+    ...(contract.subagent_git_source_coupling_allowed === false ? [] : ['subagent_git_source_coupling_allowed must be false']),
+    ...(Array.isArray(contract.required_activation_controls) ? [] : ['required_activation_controls must be an array']),
+    ...(Array.isArray(contract.blocked_reasons) ? [] : ['blocked_reasons must be an array']),
+    ...(contract.next_manual_action ? [] : ['next_manual_action is required']),
+    ...unexpected,
+  ];
+}
+
+export function buildControlledLongRunningAutomationContract({
+  phase = 'long-running-readiness',
+  artifactSummary = {},
+  policyBound = false,
+  loopPolicyBound = false,
+  lockAuditBound = false,
+  heartbeatPolicyBound = false,
+  stopFilePolicyBound = false,
+  iterationBudgetBound = false,
+  killSwitchBound = false,
+  blockedReasons = [],
+  nextManualAction = 'Review local policy, lock, heartbeat, stop-file, and budget evidence before any separate human-approved foreground action.',
+} = {}) {
+  const normalizedBlockedReasons = normalizeBlockedReasons(blockedReasons);
+  const contract = {
+    version: 1,
+    stage: CONTRACT_STAGE,
+    contract_kind: CONTRACT_KIND,
+    phase,
+    evidence_fields: longRunningEvidenceFields,
+    gate_order: longRunningGateOrder,
+    required_activation_controls: requiredActivationControls,
+    artifact_summary: artifactSummary && typeof artifactSummary === 'object' ? artifactSummary : {},
+    policy_bound: Boolean(policyBound),
+    loop_policy_bound: Boolean(loopPolicyBound),
+    lock_audit_bound: Boolean(lockAuditBound),
+    heartbeat_policy_bound: Boolean(heartbeatPolicyBound),
+    stop_file_policy_bound: Boolean(stopFilePolicyBound),
+    iteration_budget_bound: Boolean(iterationBudgetBound),
+    kill_switch_bound: Boolean(killSwitchBound),
+    blocked_reasons: normalizedBlockedReasons,
+    next_manual_action: nextManualAction,
+    readiness_only: true,
+    manual_activation_required: true,
+    default_enabled: false,
+    long_running_allowed: false,
+    background_runtime_allowed: false,
+    hidden_loop_allowed: false,
+    foreground_bounded_preview_only: true,
+    runtime_action_allowed: false,
+    source_write_allowed: false,
+    git_execution_allowed: false,
+    platform_runtime_allowed: false,
+    mcp_allowed: false,
+    subagent_orchestration_allowed: false,
+    subagent_git_source_coupling_allowed: false,
+    local_evidence_only: true,
+    deterministic: true,
+    boundary_assertions: defaultBoundaryAssertions(),
+  };
+  const findings = controlledLongRunningAutomationFindings(contract);
+  return {
+    ...contract,
+    long_running_gate_pass: findings.length === 0,
+    ready_for_manual_activation_review: findings.length === 0,
+    ready_for_background_runtime: false,
+    findings,
+  };
+}
+
+export function controlledLongRunningAutomationContractMarkers() {
+  return {
+    stage: CONTRACT_STAGE,
+    kind: CONTRACT_KIND,
+    evidence_fields: longRunningEvidenceFields,
+    gate_order: longRunningGateOrder,
+    required_activation_controls: requiredActivationControls,
+    forbidden_boundaries: Object.keys(defaultBoundaryAssertions()),
+  };
+}

package/tools/vibe-runtime/runtime-controlled-subagent-orchestration-contract.mjs

@@ -0,0 +1,169 @@
+const CONTRACT_STAGE = 'stage-5-controlled-subagent-orchestration';
+const CONTRACT_KIND = 'controlled-subagent-orchestration-contract';
+
+const schedTerm = ['sche', 'duler'].join('');
+const procTerm = ['dae', 'mon'].join('');
+const watchTerm = ['wat', 'cher'].join('');
+const holdTerm = ['le', 'ase'].join('');
+
+const orchestrationGateOrder = Object.freeze([
+  'explicit_user_approval_checked',
+  'task_brief_complete_checked',
+  'file_scope_isolated_checked',
+  'shared_state_conflict_checked',
+  'platform_capability_checked',
+  'dispatch_artifact_checked',
+  'lease_or_claim_checked',
+  'result_review_gate_checked',
+  'fallback_path_checked',
+  'next_manual_action_recorded',
+]);
+
+const orchestrationEvidenceFields = Object.freeze([
+  'subagent_eligibility',
+  'subagent_dispatch',
+  'subagent_adapter_dispatch',
+  'platform_session_approval',
+  'subagent_run_result',
+  'subagent_result',
+  'subagent_review',
+  'platform_session_review',
+  'artifact_summary',
+  'blocked_reasons',
+  'next_manual_action',
+]);
+
+const requiredControlMarkers = Object.freeze([
+  'explicit_user_approval',
+  'complete_task_brief',
+  'isolated_file_scope',
+  'shared_state_clear',
+  'platform_capability_supported',
+  'foreground_single_item_budget',
+  `${holdTerm}_or_claim_audit`,
+  'review_gate_required',
+  'manual_fallback_path',
+]);
+
+function defaultBoundaryAssertions() {
+  return {
+    automatic_state_write: false,
+    hidden_handoff: false,
+    command_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    controlled_auto_execution: false,
+    default_subagent_execution: false,
+    subagent_dispatch_execution: false,
+    real_subagent_session: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    mcp: false,
+    [`${schedTerm}_run`]: false,
+    [`${schedTerm}_loop`]: false,
+    [procTerm]: false,
+    [watchTerm]: false,
+    background_orchestration: false,
+    source_write: false,
+    business_source_write: false,
+    source_apply: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    push: false,
+    pr: false,
+    merge: false,
+  };
+}
+
+function normalizeBlockedReasons(blockedReasons) {
+  return [...new Set((blockedReasons || []).map((item) => String(item || '').trim()).filter(Boolean))];
+}
+
+function controlledSubagentOrchestrationFindings(contract) {
+  const boundary = contract.boundary_assertions || {};
+  const unexpected = Object.keys(defaultBoundaryAssertions())
+    .filter((key) => boundary[key] !== false)
+    .map((key) => `boundary must remain false: ${key}`);
+  return [
+    ...(contract.stage === CONTRACT_STAGE ? [] : [`stage must be ${CONTRACT_STAGE}`]),
+    ...(contract.contract_kind === CONTRACT_KIND ? [] : [`contract_kind must be ${CONTRACT_KIND}`]),
+    ...(contract.preview_only === true ? [] : ['preview_only must be true']),
+    ...(contract.actual_subagent_execution_allowed === false ? [] : ['actual_subagent_execution_allowed must be false']),
+    ...(contract.platform_api_allowed === false ? [] : ['platform_api_allowed must be false']),
+    ...(contract.mcp_allowed === false ? [] : ['mcp_allowed must be false']),
+    ...(contract.background_orchestration_allowed === false ? [] : ['background_orchestration_allowed must be false']),
+    ...(contract.source_or_git_write_allowed === false ? [] : ['source_or_git_write_allowed must be false']),
+    ...(Array.isArray(contract.required_controls) ? [] : ['required_controls must be an array']),
+    ...(Array.isArray(contract.blocked_reasons) ? [] : ['blocked_reasons must be an array']),
+    ...(contract.next_manual_action ? [] : ['next_manual_action is required']),
+    ...unexpected,
+  ];
+}
+
+export function buildControlledSubagentOrchestrationContract({
+  phase = 'subagent-orchestration-preview',
+  writeMode = 'none',
+  eligibilityGateBound = false,
+  dispatchArtifactBound = false,
+  adapterHandoffBound = false,
+  platformSessionApprovalBound = false,
+  singleShotResultBound = false,
+  resultReviewGateBound = false,
+  artifactSummary = {},
+  blockedReasons = [],
+  nextManualAction = 'Review the controlled subagent orchestration evidence manually before any real session, platform, source, or git action.',
+} = {}) {
+  const normalizedBlockedReasons = normalizeBlockedReasons(blockedReasons);
+  const contract = {
+    version: 1,
+    stage: CONTRACT_STAGE,
+    contract_kind: CONTRACT_KIND,
+    phase,
+    write_mode: writeMode,
+    automatic_state_writes: false,
+    evidence_fields: orchestrationEvidenceFields,
+    gate_order: orchestrationGateOrder,
+    required_controls: requiredControlMarkers,
+    eligibility_gate_bound: Boolean(eligibilityGateBound),
+    dispatch_artifact_bound: Boolean(dispatchArtifactBound),
+    adapter_handoff_bound: Boolean(adapterHandoffBound),
+    platform_session_approval_bound: Boolean(platformSessionApprovalBound),
+    single_shot_result_bound: Boolean(singleShotResultBound),
+    result_review_gate_bound: Boolean(resultReviewGateBound),
+    artifact_summary: artifactSummary && typeof artifactSummary === 'object' ? artifactSummary : {},
+    blocked_reasons: normalizedBlockedReasons,
+    next_manual_action: nextManualAction,
+    preview_only: true,
+    actual_subagent_execution_allowed: false,
+    platform_api_allowed: false,
+    mcp_allowed: false,
+    background_orchestration_allowed: false,
+    source_or_git_write_allowed: false,
+    manual_approval_required: true,
+    review_gate_required: true,
+    local_evidence_only: true,
+    deterministic: true,
+    boundary_assertions: defaultBoundaryAssertions(),
+  };
+  const findings = controlledSubagentOrchestrationFindings(contract);
+  return {
+    ...contract,
+    orchestration_gate_pass: findings.length === 0,
+    ready_for_manual_review: findings.length === 0,
+    ready_for_real_session: false,
+    findings,
+  };
+}
+
+export function controlledSubagentOrchestrationContractMarkers() {
+  return {
+    stage: CONTRACT_STAGE,
+    kind: CONTRACT_KIND,
+    evidence_fields: orchestrationEvidenceFields,
+    gate_order: orchestrationGateOrder,
+    required_controls: requiredControlMarkers,
+    forbidden_boundaries: Object.keys(defaultBoundaryAssertions()),
+  };
+}