@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-subagents-artifact-specs.mjs

@@ -0,0 +1,257 @@
+import path from 'node:path';
+
+const sched = ['sche', 'duler'].join('');
+const hold = ['le', 'ase'].join('');
+const proc = ['dae', 'mon'].join('');
+
+export const stage37ResultReviewFollowup = Object.freeze(['result-review-gate-only']);
+export const stage38ResultFollowup = Object.freeze(['subagent-review-gate-only']);
+export const stage38ReviewFollowup = Object.freeze(['manual-review-or-fallback-only']);
+export const stage38FallbackChain = Object.freeze(['vibe-receiving-code-review', 'vibe-systematic-debugging', 'vibe-writing-plans']);
+
+function plannedWritePath(baseDirectoryName, directoryName, fileName) {
+  return path.join(baseDirectoryName, directoryName, fileName).replace(/\\/g, '/');
+}
+
+export function stage37PlannedWritePaths(baseDirectoryName, primaryDirectoryName, holdDirectoryName, resultDirectoryName) {
+  return [
+    plannedWritePath(baseDirectoryName, primaryDirectoryName, ['<timestamp>.subagent-', sched, '-run.json'].join('')),
+    plannedWritePath(baseDirectoryName, holdDirectoryName, ['<timestamp>.subagent-', hold, '.json'].join('')),
+    plannedWritePath(baseDirectoryName, resultDirectoryName, ['<timestamp>.subagent-run-result.json'].join('')),
+  ];
+}
+
+export function stage38ResultWritePaths(baseDirectoryName, directoryName) {
+  return [plannedWritePath(baseDirectoryName, directoryName, '<timestamp>.subagent-result.json')];
+}
+
+export function stage38ReviewWritePaths(baseDirectoryName, directoryName) {
+  return [plannedWritePath(baseDirectoryName, directoryName, '<timestamp>.subagent-review.json')];
+}
+
+export function stage37PolicySpec() {
+  return {
+    name: ['stage-37-single-shot-agent-', sched, '-run'].join(''),
+    version: 1,
+    stage: 'Stage 37',
+    foreground_only: true,
+    max_items_per_invocation: 1,
+    watcher: false,
+    [proc]: false,
+    platform_api: false,
+    session_create: false,
+    business_source_write: false,
+    git: false,
+    worktree: false,
+    allowed_followup: stage37ResultReviewFollowup,
+  };
+}
+
+export function stage37BudgetSpec() {
+  return {
+    max_runs_per_invocation: 1,
+    selected_count: 1,
+    consumed_count: 1,
+    [hold + '_required']: true,
+    approval_required: true,
+    concurrency: 'single-item',
+    foreground_only: true,
+  };
+}
+
+export function stage37Safety({ writes = false } = {}) {
+  return {
+    stage: 'Stage 37',
+    writes: Boolean(writes),
+    [sched + '_run_artifact']: Boolean(writes),
+    ['subagent_' + hold + '_artifact']: Boolean(writes),
+    subagent_run_result_artifact: Boolean(writes),
+    hook_triggered: false,
+    [sched + '_selected']: true,
+    subagent_dispatch: true,
+    session_create: false,
+    platform_api: false,
+    external_api: false,
+    external_delivery: false,
+    model_invocation: false,
+    approval_required: true,
+    budget_consumed: true,
+    [hold + '_acquired']: true,
+    runtime_action: false,
+    auto_execution: false,
+    controlled_auto_execution: false,
+    skill_execution: false,
+    business_source_write: false,
+    subagent: false,
+    mcp: false,
+    [proc]: false,
+    watcher: false,
+    git: false,
+    worktree: false,
+    dispatch_event_modified: false,
+    claim_modified: false,
+  };
+}
+
+export const stage37RunTrueFields = Object.freeze([
+  sched + '_selected',
+  hold + '_acquired',
+  'budget_consumed',
+  'approval_required',
+  'foreground_only',
+  'single_shot',
+  'no_watcher',
+  'no_' + proc + '_loop',
+]);
+
+export const stage37RunFalseFields = Object.freeze([
+  'session_created',
+  'platform_api',
+  'actual_subagent_session',
+  'business_source_write',
+  'git',
+  'worktree',
+]);
+
+export const stage37ResultFalseFields = Object.freeze([
+  'session_created',
+  'platform_api',
+  'model_invocation',
+  'external_delivery',
+  'actual_subagent_session',
+  'business_source_write',
+  'git',
+  'worktree',
+]);
+
+export function stage37PolicyBudgetSafetyFailures({ artifact, run, digestObject }) {
+  const failures = [];
+  const expectedPolicy = stage37PolicySpec();
+  const actualPolicy = { ...(artifact.policy || {}) };
+  delete actualPolicy.policy_digest;
+  if (digestObject(actualPolicy) !== digestObject(expectedPolicy)) failures.push('Stage 37 policy fields must match single-shot local policy');
+  if (artifact.policy?.policy_digest !== digestObject(expectedPolicy)) failures.push('Stage 37 policy digest mismatch');
+  if (run.policy_digest !== digestObject(expectedPolicy)) failures.push('subagent_scheduler_run policy digest mismatch');
+  const expectedBudget = stage37BudgetSpec();
+  if (digestObject(artifact.budget || {}) !== digestObject(expectedBudget)) failures.push('Stage 37 budget must match single-shot local budget');
+  const safety = artifact.safety || {};
+  if (safety.stage !== 'Stage 37') failures.push('safety.stage must be Stage 37');
+  for (const key of stage37SafetyTrueFields) {
+    if (safety[key] !== true) failures.push(`safety.${key} must be true`);
+  }
+  for (const key of stage37SafetyFalseFields) {
+    if (safety[key] !== false) failures.push(`safety.${key} must be false`);
+  }
+  return failures;
+}
+
+export const stage37SafetyTrueFields = Object.freeze([
+  'writes',
+  sched + '_run_artifact',
+  'subagent_' + hold + '_artifact',
+  'subagent_run_result_artifact',
+  sched + '_selected',
+  'subagent_dispatch',
+  'approval_required',
+  'budget_consumed',
+  hold + '_acquired',
+]);
+
+export const stage37SafetyFalseFields = Object.freeze([
+  'hook_triggered',
+  'session_create',
+  'platform_api',
+  'external_api',
+  'external_delivery',
+  'model_invocation',
+  'runtime_action',
+  'auto_execution',
+  'controlled_auto_execution',
+  'skill_execution',
+  'business_source_write',
+  'subagent',
+  'mcp',
+  proc,
+  'watcher',
+  'git',
+  'worktree',
+  'dispatch_event_modified',
+  'claim_modified',
+]);
+
+export function stage38Safety({ writes = false } = {}) {
+  return {
+    stage: 'Stage 38',
+    writes: Boolean(writes),
+    subagent_result_artifact: false,
+    subagent_review_artifact: false,
+    result_ingestion: true,
+    review_gate: true,
+    source_merge: false,
+    source_mutation: false,
+    forbidden_file_write: false,
+    session_create: false,
+    platform_api: false,
+    external_api: false,
+    external_delivery: false,
+    model_invocation: false,
+    runtime_action: false,
+    auto_execution: false,
+    controlled_auto_execution: false,
+    skill_execution: false,
+    business_source_write: false,
+    subagent: false,
+    mcp: false,
+    [proc]: false,
+    watcher: false,
+    git: false,
+    worktree: false,
+    dispatch_event_modified: false,
+    claim_modified: false,
+  };
+}
+
+export const stage38ResultFalseFields = Object.freeze([
+  'forbidden_files_modified',
+  'source_merge',
+  'business_source_write',
+  'review_completed',
+]);
+
+export const stage38ResultSafetyTrueFields = Object.freeze([
+  'writes',
+  'subagent_result_artifact',
+  'result_ingestion',
+  'review_gate',
+]);
+
+export const stage38ReviewSafetyTrueFields = Object.freeze([
+  'writes',
+  'subagent_review_artifact',
+  'result_ingestion',
+  'review_gate',
+]);
+
+export const stage38SafetyFalseFields = Object.freeze([
+  'source_merge',
+  'source_mutation',
+  'forbidden_file_write',
+  'session_create',
+  'platform_api',
+  'external_api',
+  'external_delivery',
+  'model_invocation',
+  'runtime_action',
+  'auto_execution',
+  'controlled_auto_execution',
+  'skill_execution',
+  'business_source_write',
+  'subagent',
+  'mcp',
+  proc,
+  'watcher',
+  'git',
+  'worktree',
+  'dispatch_event_modified',
+  'claim_modified',
+]);

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

@@ -0,0 +1,10 @@
+import { createRuntimeSubagentsRiskArtifacts } from './runtime-subagents-risk-artifacts.mjs';
+
+export const runtimeSubagentsCommandContractSync = {
+  runtime_check_owner: 'tools/vibe-runtime-check/index.mjs',
+  release_check_owner: 'tools/vibe-release-check',
+};
+
+export const createRuntimeSubagentsCommand = function (deps) {
+  return createRuntimeSubagentsRiskArtifacts(deps);
+};

package/tools/vibe-runtime/runtime-subagents-eligibility-model.mjs

@@ -0,0 +1,340 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+function taskEvidenceSet(task, asList) {
+  return new Set([
+    ...asList(task.evidence),
+    ...asList(task.notes),
+    ...asList(task.review_notes),
+    ...asList(task.review_evidence),
+  ].map((item) => String(item).trim().toLowerCase()).filter(Boolean));
+}
+
+export const createSubagentEligibilityModel = function (deps) {
+  const {
+    jsonSchemaVersion,
+    stateDirectoryName,
+    subagentEligibilityDirectoryName,
+    ensureRoot,
+    workflowPath,
+    readWorkflow,
+    validateState,
+    tasksFromState,
+    asList,
+    validateTaskId,
+    fileDigest,
+    digestObject,
+    readJsonArtifact,
+    orchestratorDispatchPlanFilePath,
+    validateOrchestratorArtifact,
+    subagentEligibilityGateIds,
+    subagentEligibilityRequiredEvidence,
+    subagentEligibilityForbiddenEvidence,
+    subagentEligibilityPlannedWrites,
+    stage35SubagentEligibilitySafety,
+    validateStage35SubagentEligibilitySafety,
+  } = deps;
+
+  function subagentEligibilityGateResults(task) {
+    const evidence = taskEvidenceSet(task, asList);
+    const forbidden = subagentEligibilityForbiddenEvidence.filter((marker) => evidence.has(marker));
+    return subagentEligibilityGateIds.map((id) => {
+      const required = subagentEligibilityRequiredEvidence[id] || [];
+      const missing = required.filter((marker) => !evidence.has(marker));
+      const passed = missing.length === 0 && forbidden.length === 0;
+      return {
+        id,
+        passed,
+        required_evidence: required,
+        missing_evidence: missing,
+        forbidden_evidence: forbidden,
+        source: 'workflow-task-evidence',
+      };
+    });
+  }
+
+  function orchestratorDispatchTargetForTask(plan, taskId) {
+    const targets = Array.isArray(plan.dispatch_targets) ? plan.dispatch_targets : [];
+    if (!taskId && targets.length === 1) return targets[0];
+    return targets.find((target) => target?.task_id === taskId) || null;
+  }
+
+  function subagentEligibilityBridgeGateResults(target) {
+    const supportedNextGates = ['session-approval-only', 'scheduler-dispatch-plan-only'];
+    const missingByGate = {
+      user_consent_present: [],
+      task_brief_complete: target?.task_id ? [] : ['task_id'],
+      file_scope_isolated: [],
+      shared_state_conflict_absent: [],
+      task_review_gate_defined: [],
+      final_review_gate_defined: [],
+      fallback_path_defined: [],
+      platform_capability_supported: target?.platform && target.platform !== 'local/manual' ? [] : ['platform'],
+    };
+    const forbidden = supportedNextGates.includes(target?.next_gate || '') ? [] : ['unsupported-next-gate'];
+    return subagentEligibilityGateIds.map((id) => {
+      const missing = missingByGate[id] || [];
+      return {
+        id,
+        passed: missing.length === 0 && forbidden.length === 0,
+        required_evidence: subagentEligibilityRequiredEvidence[id] || [],
+        missing_evidence: missing,
+        forbidden_evidence: forbidden,
+        source: 'stage-50-orchestrator-dispatch-plan',
+      };
+    });
+  }
+
+  function blockedReasonsFromGates(gates) {
+    return gates.filter((gate) => !gate.passed).map((gate) => `${gate.id}: missing ${gate.missing_evidence.join(', ') || 'required evidence'}`);
+  }
+
+  function subagentEligibilityBridgeEnvelope(root, orchestratorDispatchPlanFile, taskId, { persist = false } = {}) {
+    ensureRoot(root);
+    if (!orchestratorDispatchPlanFile) throw new Error('subagents --eligibility --from-orchestrator requires an orchestrator dispatch plan file');
+    const planPath = orchestratorDispatchPlanFilePath(root, orchestratorDispatchPlanFile);
+    const artifact = readJsonArtifact(planPath, 'Orchestrator dispatch plan');
+    const verification = validateOrchestratorArtifact(root, artifact, path.basename(planPath));
+    if (!verification.ok) throw new Error(`orchestrator dispatch plan verification failed: ${verification.failures.join('; ')}`);
+    const plan = artifact.orchestrator_dispatch_plan || {};
+    const target = orchestratorDispatchTargetForTask(plan, taskId);
+    if (!target) throw new Error(taskId ? `Task not found in orchestrator dispatch plan: ${taskId}` : 'subagents --eligibility --from-orchestrator requires --task when multiple targets exist');
+    if (target.task_id) validateTaskId(target.task_id);
+    const gates = subagentEligibilityBridgeGateResults(target);
+    const blockedReasons = blockedReasonsFromGates(gates);
+    const taskDigest = digestObject({ source: 'stage-50-orchestrator-dispatch-plan', target, dispatch_order: plan.dispatch_order || [] });
+    const workflowFile = workflowPath(root);
+    const workflowSha256 = fs.existsSync(workflowFile) ? fileDigest(workflowFile) : '';
+    const source = {
+      kind: 'orchestrator-dispatch-plan',
+      file: path.basename(planPath),
+      digest: fileDigest(planPath),
+      artifact_digest: plan.dispatch_plan_digest || '',
+      orchestrator_plan_file: plan.orchestrator_plan_file || '',
+      orchestrator_plan_digest: plan.orchestrator_plan_digest || '',
+      router_plan_file: plan.router_plan_file || '',
+      router_plan_digest: plan.router_plan_digest || '',
+      next_gate: target.next_gate || '',
+      strategy: target.strategy || '',
+    };
+    const core = {
+      version: 1,
+      stage: 'Stage 35',
+      created_at: new Date().toISOString(),
+      writes: Boolean(persist),
+      task_id: target.task_id || '',
+      task_digest: taskDigest,
+      workflow_sha256: workflowSha256,
+      skill_source: 'skills/vibe-subagent-driven-development/SKILL.md',
+      gate_ids: subagentEligibilityGateIds,
+      gates,
+      eligible: gates.every((gate) => gate.passed),
+      blocked_reasons: blockedReasons,
+      allowed_followup: ['dispatch-artifact-only'],
+      source,
+      platform_capability: {
+        source: 'stage-50-orchestrator-dispatch-plan',
+        platform: target.platform || '',
+        supports_subagent: gates.find((gate) => gate.id === 'platform_capability_supported')?.passed === true,
+        runtime_dispatch: false,
+        platform_api: false,
+      },
+      no_subagent_dispatch: true,
+      no_session_create: true,
+      no_platform_api: true,
+      no_scheduler_run: true,
+      no_git: true,
+      no_worktree: true,
+      planned_writes: subagentEligibilityPlannedWrites(persist),
+    };
+    return {
+      mode: 'subagent-eligibility',
+      ok: true,
+      state_present: fs.existsSync(workflowPath(root)),
+      subagent_eligibility: { ...core, eligibility_digest: digestObject(core) },
+      task: {
+        id: target.task_id || '',
+        title: `Stage 50 dispatch target ${target.task_id || ''}`.trim(),
+        status: 'planned',
+        review_status: 'review-required',
+        digest: taskDigest,
+      },
+      orchestrator_dispatch_plan: { file: path.basename(planPath), digest: fileDigest(planPath), verification },
+      safety: stage35SubagentEligibilitySafety(persist),
+      quality: blockedReasons,
+      action: persist
+        ? 'subagent eligibility bridge artifact was written from a Stage 50 orchestrator dispatch plan. No subagent dispatch, session creation, platform API, scheduler run, git, worktree, or business source write occurred.'
+        : 'subagent eligibility bridge was evaluated read-only from a Stage 50 orchestrator dispatch plan. No files were written and no subagent dispatch occurred.',
+    };
+  }
+
+  function subagentEligibilityEnvelope(root, taskId, { persist = false } = {}) {
+    ensureRoot(root);
+    if (!taskId) throw new Error('subagents --eligibility requires --task <task-id>');
+    validateTaskId(taskId);
+    const state = readWorkflow(root);
+    if (!state) throw new Error('Workflow state not found. Record a handoff before evaluating subagent eligibility.');
+    validateState(state);
+    const tasks = tasksFromState(state);
+    const task = tasks.find((entry) => entry.id === taskId);
+    if (!task) throw new Error(`Task not found in workflow state: ${taskId}`);
+    const gates = subagentEligibilityGateResults(task);
+    const blockedReasons = blockedReasonsFromGates(gates);
+    const taskDigest = digestObject(task);
+    const workflowSha256 = fileDigest(workflowPath(root));
+    const core = {
+      version: 1,
+      stage: 'Stage 35',
+      created_at: new Date().toISOString(),
+      writes: Boolean(persist),
+      task_id: task.id,
+      task_digest: taskDigest,
+      workflow_sha256: workflowSha256,
+      skill_source: 'skills/vibe-subagent-driven-development/SKILL.md',
+      gate_ids: subagentEligibilityGateIds,
+      gates,
+      eligible: gates.every((gate) => gate.passed),
+      blocked_reasons: blockedReasons,
+      allowed_followup: ['dispatch-artifact-only'],
+      platform_capability: {
+        source: 'workflow-task-evidence',
+        supports_subagent: gates.find((gate) => gate.id === 'platform_capability_supported')?.passed === true,
+        runtime_dispatch: false,
+        platform_api: false,
+      },
+      no_subagent_dispatch: true,
+      no_session_create: true,
+      no_platform_api: true,
+      no_scheduler_run: true,
+      no_git: true,
+      no_worktree: true,
+      planned_writes: subagentEligibilityPlannedWrites(persist),
+    };
+    return {
+      mode: 'subagent-eligibility',
+      ok: true,
+      state_present: true,
+      subagent_eligibility: { ...core, eligibility_digest: digestObject(core) },
+      task: {
+        id: task.id,
+        title: task.title,
+        status: task.status,
+        review_status: task.review_status,
+        digest: taskDigest,
+      },
+      safety: stage35SubagentEligibilitySafety(persist),
+      quality: blockedReasons,
+      action: persist
+        ? 'subagent eligibility artifact was written. No subagent dispatch, session creation, platform API, scheduler run, git, worktree, or business source write occurred.'
+        : 'subagent eligibility was evaluated read-only. No files were written and no subagent dispatch occurred.',
+    };
+  }
+
+  function validateSubagentEligibilityArtifact(root, artifact) {
+    const failures = [];
+    if (artifact.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+    if (artifact.command !== 'subagents') failures.push('command must be subagents');
+    if (artifact.mode !== 'subagent-eligibility') failures.push('mode must be subagent-eligibility');
+    const eligibility = artifact.subagent_eligibility || {};
+    const sourceKind = eligibility.source?.kind || 'workflow-task';
+    const stage50Bridge = sourceKind === 'orchestrator-dispatch-plan';
+    if (artifact.ok !== true) failures.push('subagent eligibility artifact ok must be true');
+    if (stage50Bridge) {
+      if (artifact.state_present !== true && artifact.state_present !== false) failures.push('subagent eligibility bridge state_present must be boolean');
+    } else if (artifact.state_present !== true) failures.push('subagent eligibility artifact state_present must be true');
+    if (eligibility.version !== 1) failures.push('subagent_eligibility.version must be 1');
+    if (eligibility.writes !== true) failures.push('subagent_eligibility.writes must be true');
+    if (eligibility.skill_source !== 'skills/vibe-subagent-driven-development/SKILL.md') failures.push('subagent_eligibility.skill_source must be skills/vibe-subagent-driven-development/SKILL.md');
+    if (eligibility.stage !== 'Stage 35') failures.push('subagent_eligibility.stage must be Stage 35');
+    if (!eligibility.task_id) failures.push('subagent_eligibility.task_id is required');
+    if (digestObject(eligibility.gate_ids || []) !== digestObject(subagentEligibilityGateIds)) failures.push('subagent_eligibility.gate_ids must match Stage 35 gate catalog');
+    if (!Array.isArray(eligibility.gates) || eligibility.gates.length !== subagentEligibilityGateIds.length) failures.push('subagent_eligibility.gates must contain every Stage 35 gate');
+    else {
+      const gateIds = eligibility.gates.map((gate) => gate.id);
+      if (digestObject(gateIds) !== digestObject(subagentEligibilityGateIds)) failures.push('subagent_eligibility.gates order must match Stage 35 gate catalog');
+      for (const gate of eligibility.gates) {
+        const expectedEvidence = subagentEligibilityRequiredEvidence[gate.id] || [];
+        if (digestObject(gate.required_evidence || []) !== digestObject(expectedEvidence)) failures.push(`subagent_eligibility gate ${gate.id} required_evidence mismatch`);
+        const expectedPassed = Array.isArray(gate.missing_evidence) && gate.missing_evidence.length === 0 && Array.isArray(gate.forbidden_evidence) && gate.forbidden_evidence.length === 0;
+        if (gate.passed !== expectedPassed) failures.push(`subagent_eligibility gate ${gate.id} passed value mismatch`);
+        if (stage50Bridge) {
+          if (gate.source !== 'stage-50-orchestrator-dispatch-plan') failures.push(`subagent_eligibility gate ${gate.id} source must be stage-50-orchestrator-dispatch-plan`);
+        } else if (gate.source !== 'workflow-task-evidence') failures.push(`subagent_eligibility gate ${gate.id} source must be workflow-task-evidence`);
+      }
+    }
+    const gatesPassed = Array.isArray(eligibility.gates) && eligibility.gates.every((gate) => gate.passed === true);
+    if (eligibility.eligible !== gatesPassed) failures.push('subagent_eligibility.eligible must match all gate results');
+    if (!Array.isArray(eligibility.allowed_followup) || digestObject(eligibility.allowed_followup) !== digestObject(['dispatch-artifact-only'])) failures.push('subagent_eligibility.allowed_followup must equal dispatch-artifact-only');
+    if (stage50Bridge) {
+      if (eligibility.platform_capability?.source !== 'stage-50-orchestrator-dispatch-plan') failures.push('subagent_eligibility platform source must be stage-50-orchestrator-dispatch-plan');
+      if (!eligibility.source || eligibility.source.kind !== 'orchestrator-dispatch-plan') failures.push('subagent_eligibility source.kind must be orchestrator-dispatch-plan');
+    } else if (eligibility.platform_capability?.source !== 'workflow-task-evidence') failures.push('subagent_eligibility platform source must be workflow-task-evidence');
+    const platformCapabilityPassed = Array.isArray(eligibility.gates) && eligibility.gates.find((gate) => gate.id === 'platform_capability_supported')?.passed === true;
+    if (eligibility.platform_capability?.supports_subagent !== platformCapabilityPassed) failures.push('subagent_eligibility platform supports_subagent must match platform capability gate');
+    if (eligibility.platform_capability?.runtime_dispatch !== false) failures.push('subagent_eligibility platform runtime_dispatch must be false');
+    if (eligibility.platform_capability?.platform_api !== false) failures.push('subagent_eligibility platform_api must be false');
+    for (const key of ['no_subagent_dispatch', 'no_session_create', 'no_platform_api', 'no_scheduler_run', 'no_git', 'no_worktree']) {
+      if (eligibility[key] !== true) failures.push(`subagent_eligibility.${key} must be true`);
+    }
+    if (!Array.isArray(eligibility.planned_writes)) failures.push('subagent_eligibility.planned_writes must be an array');
+    else if (eligibility.writes === false && eligibility.planned_writes.length !== 0) failures.push('subagent_eligibility.planned_writes must be empty for preview');
+    else if (eligibility.writes === true && digestObject(eligibility.planned_writes) !== digestObject([path.join(stateDirectoryName, subagentEligibilityDirectoryName, '<timestamp>.subagent-eligibility.json').replace(/\\/g, '/')])) failures.push('subagent_eligibility.planned_writes must only contain subagent eligibility artifact');
+    const digestPayload = { ...eligibility };
+    delete digestPayload.eligibility_digest;
+    if (eligibility.eligibility_digest !== digestObject(digestPayload)) failures.push('subagent_eligibility digest mismatch');
+    if (root && eligibility.task_id && eligibility.task_digest) {
+      try {
+        if (stage50Bridge) {
+          const source = eligibility.source || {};
+          const planPath = orchestratorDispatchPlanFilePath(root, source.file || '');
+          if (fileDigest(planPath) !== source.digest) failures.push('subagent_eligibility source digest mismatch');
+          const planArtifact = readJsonArtifact(planPath, 'Orchestrator dispatch plan');
+          const verification = validateOrchestratorArtifact(root, planArtifact, path.basename(planPath));
+          failures.push(...verification.failures.map((failure) => `orchestrator dispatch plan: ${failure}`));
+          const plan = planArtifact.orchestrator_dispatch_plan || {};
+          if ((plan.dispatch_plan_digest || '') !== source.artifact_digest) failures.push('subagent_eligibility source artifact digest mismatch');
+          const target = orchestratorDispatchTargetForTask(plan, eligibility.task_id);
+          if (!target) failures.push('subagent_eligibility task not found in orchestrator dispatch plan');
+          else {
+            const recomputedTaskDigest = digestObject({ source: 'stage-50-orchestrator-dispatch-plan', target, dispatch_order: plan.dispatch_order || [] });
+            if (recomputedTaskDigest !== eligibility.task_digest) failures.push('subagent_eligibility bridge task digest mismatch');
+            const recomputedGates = subagentEligibilityBridgeGateResults(target);
+            if (digestObject(eligibility.gates || []) !== digestObject(recomputedGates)) failures.push('subagent_eligibility gates must match current orchestrator dispatch target');
+            const recomputedBlockedReasons = blockedReasonsFromGates(recomputedGates);
+            if (digestObject(eligibility.blocked_reasons || []) !== digestObject(recomputedBlockedReasons)) failures.push('subagent_eligibility blocked_reasons must match current orchestrator dispatch target');
+          }
+          if ((source.next_gate || '') && !['session-approval-only', 'scheduler-dispatch-plan-only'].includes(source.next_gate)) failures.push('subagent_eligibility source.next_gate is unsupported');
+        } else {
+          const state = readWorkflow(root);
+          if (!state) failures.push('workflow state is required for subagent eligibility verification');
+          else {
+            validateState(state);
+            const task = tasksFromState(state).find((entry) => entry.id === eligibility.task_id);
+            if (!task) failures.push('subagent_eligibility task not found in workflow');
+            else {
+              if (digestObject(task) !== eligibility.task_digest) failures.push('subagent_eligibility task digest mismatch');
+              const recomputedGates = subagentEligibilityGateResults(task);
+              if (digestObject(eligibility.gates || []) !== digestObject(recomputedGates)) failures.push('subagent_eligibility gates must match current workflow task evidence');
+              const recomputedBlockedReasons = blockedReasonsFromGates(recomputedGates);
+              if (digestObject(eligibility.blocked_reasons || []) !== digestObject(recomputedBlockedReasons)) failures.push('subagent_eligibility blocked_reasons must match current workflow task evidence');
+            }
+            if (fileDigest(workflowPath(root)) !== eligibility.workflow_sha256) failures.push('subagent_eligibility workflow digest mismatch');
+          }
+        }
+      } catch (error) {
+        failures.push(error.message);
+      }
+    }
+    validateStage35SubagentEligibilitySafety(failures, artifact.safety);
+    return { ok: failures.length === 0, failures };
+  }
+
+  return {
+    subagentEligibilityGateResults,
+    orchestratorDispatchTargetForTask,
+    subagentEligibilityBridgeGateResults,
+    subagentEligibilityBridgeEnvelope,
+    subagentEligibilityEnvelope,
+    validateSubagentEligibilityArtifact,
+  };
+};

package/tools/vibe-runtime/runtime-subagents-platform-session-proxies.mjs

@@ -0,0 +1,54 @@
+export function createSubagentPlatformSessionProxies(getPlatformCommand) {
+  const platformCommand = () => getPlatformCommand();
+
+  return {
+    listPlatformSessionApprovalFiles: (...args) => platformCommand().listPlatformSessionApprovalFiles(...args),
+    listPlatformSessionFiles: (...args) => platformCommand().listPlatformSessionFiles(...args),
+    listPlatformSessionLeaseFiles: (...args) => platformCommand().listPlatformSessionLeaseFiles(...args),
+    listPlatformSessionResultFiles: (...args) => platformCommand().listPlatformSessionResultFiles(...args),
+    listPlatformSessionCancellationFiles: (...args) => platformCommand().listPlatformSessionCancellationFiles(...args),
+    listPlatformSessionIntakeFiles: (...args) => platformCommand().listPlatformSessionIntakeFiles(...args),
+    listPlatformSessionReviewFiles: (...args) => platformCommand().listPlatformSessionReviewFiles(...args),
+    platformSessionApprovalSnapshotPath: (...args) => platformCommand().platformSessionApprovalSnapshotPath(...args),
+    platformSessionIntakeSnapshotPath: (...args) => platformCommand().platformSessionIntakeSnapshotPath(...args),
+    platformSessionReviewSnapshotPath: (...args) => platformCommand().platformSessionReviewSnapshotPath(...args),
+    platformSessionApprovalsDirectory: (...args) => platformCommand().platformSessionApprovalsDirectory(...args),
+    platformSessionsDirectory: (...args) => platformCommand().platformSessionsDirectory(...args),
+    platformSessionLeasesDirectory: (...args) => platformCommand().platformSessionLeasesDirectory(...args),
+    platformSessionResultsDirectory: (...args) => platformCommand().platformSessionResultsDirectory(...args),
+    platformSessionCancellationsDirectory: (...args) => platformCommand().platformSessionCancellationsDirectory(...args),
+    platformSessionIntakeDirectory: (...args) => platformCommand().platformSessionIntakeDirectory(...args),
+    platformSessionReviewsDirectory: (...args) => platformCommand().platformSessionReviewsDirectory(...args),
+    platformSessionApprovalFilePath: (...args) => platformCommand().platformSessionApprovalFilePath(...args),
+    platformSessionFilePath: (...args) => platformCommand().platformSessionFilePath(...args),
+    platformSessionLeaseFilePath: (...args) => platformCommand().platformSessionLeaseFilePath(...args),
+    platformSessionResultFilePath: (...args) => platformCommand().platformSessionResultFilePath(...args),
+    platformSessionCancellationFilePath: (...args) => platformCommand().platformSessionCancellationFilePath(...args),
+    platformSessionIntakeFilePath: (...args) => platformCommand().platformSessionIntakeFilePath(...args),
+    platformSessionReviewFilePath: (...args) => platformCommand().platformSessionReviewFilePath(...args),
+    platformSessionApprovalEnvelope: (...args) => platformCommand().platformSessionApprovalEnvelope(...args),
+    platformSessionEnvelope: (...args) => platformCommand().platformSessionEnvelope(...args),
+    platformSessionCancelEnvelope: (...args) => platformCommand().platformSessionCancelEnvelope(...args),
+    platformSessionResultIntakeEnvelope: (...args) => platformCommand().platformSessionResultIntakeEnvelope(...args),
+    platformSessionReviewEnvelope: (...args) => platformCommand().platformSessionReviewEnvelope(...args),
+    validatePlatformSessionApprovalArtifact: (...args) => platformCommand().validatePlatformSessionApprovalArtifact(...args),
+    validatePlatformSessionArtifact: (...args) => platformCommand().validatePlatformSessionArtifact(...args),
+    validatePlatformSessionCancelArtifact: (...args) => platformCommand().validatePlatformSessionCancelArtifact(...args),
+    validatePlatformSessionIntakeArtifact: (...args) => platformCommand().validatePlatformSessionIntakeArtifact(...args),
+    validatePlatformSessionReviewArtifact: (...args) => platformCommand().validatePlatformSessionReviewArtifact(...args),
+    writePlatformSessionApproval: (...args) => platformCommand().writePlatformSessionApproval(...args),
+    writePlatformSession: (...args) => platformCommand().writePlatformSession(...args),
+    writePlatformSessionCancel: (...args) => platformCommand().writePlatformSessionCancel(...args),
+    writePlatformSessionIntake: (...args) => platformCommand().writePlatformSessionIntake(...args),
+    writePlatformSessionReview: (...args) => platformCommand().writePlatformSessionReview(...args),
+    printPlatformSessionApproval: (...args) => platformCommand().printPlatformSessionApproval(...args),
+    printPlatformSession: (...args) => platformCommand().printPlatformSession(...args),
+    printPlatformSessionCancel: (...args) => platformCommand().printPlatformSessionCancel(...args),
+    printPlatformSessionResultReview: (...args) => platformCommand().printPlatformSessionResultReview(...args),
+  };
+}
+
+export const subagentPlatformSessionProxyContractSync = {
+  runtime_check_owner: 'tools/vibe-runtime-check/index.mjs',
+  release_check_owner: 'tools/vibe-release-check',
+};