@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-execution-readonly-artifacts.mjs

@@ -0,0 +1,228 @@
+export const createRuntimeExecutionReadonlyArtifacts = function (deps) {
+  const { fs, path, jsonSchemaVersion, stage11RuntimeActionName, stage11ExecutionStaleAfterMs, stage11AllowedExecutionSkills, allowedExecutionStatuses, stage11TerminalStatuses, forbiddenDispatchActions, executionPolicy, autoRunPolicyProfiles, digestObject, parseIsoTimestamp, validatePolicySnapshot, controlledForegroundEnvelopeFailures, executionsDirectory, executionCandidatesDirectory, executionApprovalsDirectory } = deps;
+const listApprovalFiles = function (root) {
+  const directory = executionApprovalsDirectory(root);
+  if (!fs.existsSync(directory)) return [];
+  return fs.readdirSync(directory, { withFileTypes: true })
+    .filter((entry) => entry.isFile())
+    .map((entry) => entry.name)
+    .filter((name) => name.endsWith('.approval.json'))
+    .sort();
+}
+
+const executionFilePath = function (root, executionFile) {
+  const raw = String(executionFile || '').trim();
+  if (!raw) throw new Error('Execution audit file is required');
+  if (path.isAbsolute(raw)) throw new Error('Execution audit file must be relative to a runtime execution state directory');
+  if (raw.includes('/') || raw.includes('\\')) throw new Error('Execution audit file must not include path separators');
+  if (raw === '.' || raw === '..' || raw.includes('..')) throw new Error('Execution audit file must not include traversal');
+  if (raw.endsWith('.execution.json')) return path.join(executionsDirectory(root), raw);
+  if (raw.endsWith('.candidate.json')) return path.join(executionCandidatesDirectory(root), raw);
+  if (raw.endsWith('.approval.json')) return path.join(executionApprovalsDirectory(root), raw);
+  throw new Error('Execution audit file must be .execution.json, .candidate.json, or .approval.json');
+}
+
+const listExecutionFiles = function (root) {
+  const directory = executionsDirectory(root);
+  if (!fs.existsSync(directory)) return [];
+  return fs.readdirSync(directory, { withFileTypes: true })
+    .filter((entry) => entry.isFile())
+    .map((entry) => entry.name)
+    .filter((name) => name.endsWith('.execution.json'))
+    .sort();
+}
+
+const readExecutionFile = function (file) {
+  if (!fs.existsSync(file)) throw new Error(`Execution file not found: ${path.basename(file)}`);
+  if (!fs.statSync(file).isFile()) throw new Error(`Execution file is not a file: ${path.basename(file)}`);
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (error) {
+    throw new Error(`Execution JSON is invalid: ${path.basename(file)}`);
+  }
+}
+
+const lifecycleSummary = function (lifecycle) {
+  if (!Array.isArray(lifecycle) || lifecycle.length === 0) return 'not recorded';
+  return lifecycle.map((entry) => entry?.status || 'unknown').join(' -> ');
+}
+
+const executionAgeMs = function (execution, now = Date.now()) {
+  const startedAt = parseIsoTimestamp(execution?.execution?.started_at || execution?.execution?.lifecycle?.[0]?.at || '');
+  if (Number.isNaN(startedAt)) return null;
+  return Math.max(0, now - startedAt);
+}
+
+const executionAuditState = function (execution, now = Date.now()) {
+  const status = execution?.execution?.status || execution?.status || (execution?.mode === 'execute-confirm' ? 'planned' : 'unknown');
+  const ageMs = executionAgeMs(execution, now);
+  const active = status === 'running';
+  const terminal = stage11TerminalStatuses.has(status);
+  return {
+    active,
+    terminal,
+    age_ms: ageMs,
+    stale: active && typeof ageMs === 'number' && ageMs > stage11ExecutionStaleAfterMs,
+  };
+}
+
+const validateExecutionPolicySnapshot = function (details) {
+  const failures = [];
+  const policy = details.policy || {};
+  if (policy.name !== executionPolicy.name) failures.push(`execution.policy.name must be ${executionPolicy.name}`);
+  if (policy.version !== executionPolicy.version) failures.push(`execution.policy.version must be ${executionPolicy.version}`);
+  const allowlisted = Array.isArray(policy.allowlisted_skills) ? policy.allowlisted_skills : [];
+  const expectedAllowlisted = [...stage11AllowedExecutionSkills].sort();
+  if (JSON.stringify([...allowlisted].sort()) !== JSON.stringify(expectedAllowlisted)) failures.push('execution.policy.allowlisted_skills must match current Stage 11 allowlist snapshot');
+  const forbidden = Array.isArray(policy.forbidden_actions) ? policy.forbidden_actions : [];
+  if (JSON.stringify(forbidden) !== JSON.stringify(forbiddenDispatchActions)) failures.push('execution.policy.forbidden_actions must match forbidden action snapshot');
+  if (!policy.policy_digest) {
+    failures.push('execution.policy.policy_digest is required');
+  } else {
+    failures.push(...validatePolicySnapshot({
+      name: policy.name,
+      version: policy.version,
+      stage: policy.stage,
+      profile: policy.profile,
+      mode: autoRunPolicyProfiles[policy.profile]?.mode,
+      default_enabled: policy.default_enabled,
+      allowed_target_skills: policy.allowlisted_skills,
+      allowed_runtime_actions: policy.allowed_runtime_actions,
+      forbidden_actions: policy.forbidden_actions,
+      expected_writes: autoRunPolicyProfiles[policy.profile]?.expected_writes || [],
+      risk_ceiling: autoRunPolicyProfiles[policy.profile]?.risk_ceiling,
+      approval: policy.approval,
+      limits: policy.limits,
+      source: 'builtin-data-only',
+      dynamic_code: false,
+      remote_config: false,
+      policy_digest: policy.policy_digest,
+    }).map((failure) => `execution.${failure}`));
+  }
+  return failures;
+}
+
+const validateRuntimeActionContract = function (details) {
+  const failures = [];
+  if (details.runtime_action !== stage11RuntimeActionName) failures.push(`execution.runtime_action must be ${stage11RuntimeActionName}`);
+  const contract = details.runtime_action_contract || {};
+  if (contract.name !== stage11RuntimeActionName) failures.push(`execution.runtime_action_contract.name must be ${stage11RuntimeActionName}`);
+  if (contract.skill_execution !== false) failures.push('execution.runtime_action_contract.skill_execution must be false');
+  if (contract.business_source_write !== false) failures.push('execution.runtime_action_contract.business_source_write must be false');
+  if (!contract.input_summary || typeof contract.input_summary !== 'object') failures.push('execution.runtime_action_contract.input_summary is required');
+  if (!contract.output_summary || typeof contract.output_summary !== 'object') failures.push('execution.runtime_action_contract.output_summary is required');
+  return failures;
+}
+
+const validateTerminalEvidence = function (execution, status) {
+  const failures = [];
+  if (status === 'running') return failures;
+  if (!execution.evidence?.stdout_excerpt) failures.push('evidence.stdout_excerpt is required');
+  if (['failed', 'timed_out', 'cancelled'].includes(status) && !execution.evidence?.stderr_excerpt) failures.push('evidence.stderr_excerpt is required for failed, timed_out, or cancelled supervised-run records');
+  return failures;
+}
+
+const validateExecutionEnvelope = function (execution) {
+  const failures = [];
+  if (execution.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+  if (execution.command !== 'execute') failures.push('command must be execute');
+  if (!['execute-confirm', 'supervised-run', 'controlled-auto-run'].includes(execution.mode)) failures.push('mode must be execute-confirm, supervised-run, or controlled-auto-run');
+  if (execution.ok !== true) failures.push('ok must be true');
+  const details = execution.execution || {};
+  const status = details.status || execution.status || (execution.mode === 'execute-confirm' ? 'planned' : '');
+  if (!allowedExecutionStatuses.has(status)) failures.push('execution status is invalid');
+  if (!details.event_file) failures.push('execution.event_file is required');
+  if (!details.target_skill) failures.push('execution.target_skill is required');
+  if (execution.safety?.platform_api !== false) failures.push('safety.platform_api must be false');
+  if (execution.safety?.subagent !== false) failures.push('safety.subagent must be false');
+  if (execution.safety?.mcp !== false) failures.push('safety.mcp must be false');
+  if (execution.safety?.daemon !== false) failures.push('safety.daemon must be false');
+  if (execution.safety?.git !== false) failures.push('safety.git must be false');
+  if (execution.safety?.worktree !== false) failures.push('safety.worktree must be false');
+  if (execution.safety?.business_source_write !== false) failures.push('safety.business_source_write must be false');
+  if (execution.safety?.skill_execution !== false) failures.push('safety.skill_execution must be false');
+  if (execution.mode !== 'controlled-auto-run' && execution.safety?.auto_execution !== false) failures.push('safety.auto_execution must be false');
+
+  if (execution.mode === 'execute-confirm') {
+    if (execution.safety?.runtime_action !== false) failures.push('safety.runtime_action must be false');
+  }
+
+  if (execution.mode === 'controlled-auto-run') failures.push(...controlledForegroundEnvelopeFailures({ execution, status, digestObject }));
+
+  if (execution.mode === 'supervised-run' || execution.mode === 'controlled-auto-run') {
+    if (status === 'planned') failures.push('supervised-run status must not be planned');
+    if (!['running', 'succeeded', 'failed', 'timed_out', 'cancelled'].includes(status)) failures.push('supervised-run status is invalid');
+    if (details.allowlisted !== true) failures.push('execution.allowlisted must be true');
+    failures.push(...validateRuntimeActionContract(details));
+    failures.push(...validateExecutionPolicySnapshot(details));
+    if (execution.safety?.supervised_execution !== true) failures.push('safety.supervised_execution must be true');
+    if (execution.safety?.runtime_action !== true) failures.push('safety.runtime_action must be true');
+    if (execution.safety?.skill_execution !== false) failures.push('safety.skill_execution must be false');
+    if (execution.mode === 'supervised-run' && execution.safety?.auto_execution !== false) failures.push('safety.auto_execution must be false for supervised-run');
+
+    const lifecycle = details.lifecycle;
+    if (!Array.isArray(lifecycle) || lifecycle.length === 0) {
+      failures.push('execution.lifecycle is required');
+    } else {
+      if (lifecycle[0]?.status !== 'running') failures.push('execution.lifecycle must start with running');
+      if (lifecycle[lifecycle.length - 1]?.status !== status) failures.push('execution.lifecycle terminal status must match execution.status');
+      let previousTime = null;
+      for (const [index, entry] of lifecycle.entries()) {
+        if (!entry || typeof entry !== 'object') {
+          failures.push(`execution.lifecycle.${index} must be an object`);
+          continue;
+        }
+        if (!allowedExecutionStatuses.has(entry.status)) failures.push(`execution.lifecycle.${index}.status is invalid`);
+        const currentTime = parseIsoTimestamp(entry.at);
+        if (Number.isNaN(currentTime)) {
+          failures.push(`execution.lifecycle.${index}.at must be a valid timestamp`);
+          continue;
+        }
+        if (previousTime !== null && currentTime < previousTime) failures.push('execution.lifecycle timestamps must be monotonic');
+        previousTime = currentTime;
+      }
+    }
+
+    const startedAt = parseIsoTimestamp(details.started_at);
+    if (Number.isNaN(startedAt)) failures.push('execution.started_at must be a valid timestamp');
+    if (status === 'running') {
+      if (details.ended_at) failures.push('execution.ended_at must be empty while running');
+    } else {
+      const endedAt = parseIsoTimestamp(details.ended_at);
+      if (Number.isNaN(endedAt)) failures.push('execution.ended_at must be a valid timestamp');
+      if (!Number.isNaN(startedAt) && !Number.isNaN(endedAt) && endedAt < startedAt) failures.push('execution.ended_at must not be before execution.started_at');
+      failures.push(...validateTerminalEvidence(execution, status));
+    }
+  }
+
+  return { ok: failures.length === 0, failures };
+}
+
+const executionSummary = function (fileName, execution, verification = null) {
+  const verified = verification || validateExecutionEnvelope(execution);
+  const audit = executionAuditState(execution);
+  return {
+    file: fileName,
+    mode: execution.mode || '',
+    ok: Boolean(execution.ok),
+    status: execution.execution?.status || execution.status || (execution.mode === 'execute-confirm' ? 'planned' : 'unknown'),
+    event_file: execution.execution?.event_file || '',
+    target_skill: execution.execution?.target_skill || '',
+    actor: execution.claim?.actor || execution.execution?.actor || '',
+    supervised_run: execution.mode === 'supervised-run',
+    controlled_auto_run: execution.mode === 'controlled-auto-run',
+    lifecycle: lifecycleSummary(execution.execution?.lifecycle),
+    runtime_action: Boolean(execution.safety?.runtime_action),
+    auto_execution: Boolean(execution.safety?.auto_execution),
+    skill_execution: Boolean(execution.safety?.skill_execution),
+    active: audit.active,
+    terminal: audit.terminal,
+    age_ms: audit.age_ms,
+    stale: audit.stale,
+    verification_ok: verified.ok,
+    verification_failures: verified.failures,
+  };
+}
+
+  return { listApprovalFiles, executionFilePath, listExecutionFiles, readExecutionFile, lifecycleSummary, executionAgeMs, executionAuditState, validateExecutionPolicySnapshot, validateRuntimeActionContract, validateTerminalEvidence, validateExecutionEnvelope, executionSummary };
+};

package/tools/vibe-runtime/runtime-execution-run-preflight-artifacts.mjs

@@ -0,0 +1,265 @@
+export const createRuntimeExecutionRunPreflightArtifacts = function (deps) {
+  const { fs, path, stage11RuntimeActionName, runtimeActionCatalogStage, runtimeActionCatalogVersion, stage11AllowedExecutionSkills, forbiddenDispatchActions, dispatchEventFilePath, dispatchClaimFilePath, readDispatchEventFile, verifyDispatchEvent, validateDispatchEventOrThrow, dispatchEventSummary, readDispatchClaimFile, validateDispatchActor, claimSummary, workflowPath, readWorkflow, tasksFromState, readinessCounts, reviewSummaryStatus, hasActualStopCondition, executionPolicySnapshot, runtimeActionCatalogDigest, buildExecutionProfilePreflightEnvelope, foregroundPreflightGates, foregroundPreflightFailures, executionSafety, parseIsoTimestamp, digestObject, foregroundEvidenceDigestPayload, executionPlan, assertNoActiveExecution, executionEnabledPreflight } = deps;
+function assertExecutionClaimReady(root, eventFile, actor, event, eventPath, options = {}) {
+  const requireActor = options.requireActor !== false;
+  const normalizedActor = actor ? validateDispatchActor(actor) : '';
+  const claim = readDispatchClaimFile(dispatchClaimFilePath(root, eventFile));
+  if (!claim) throw new Error(`Dispatch claim not found: ${eventFile}`);
+  if (requireActor && !actor) throw new Error('execute --confirm requires --actor');
+  if (normalizedActor && claim.actor !== normalizedActor) throw new Error(`Dispatch claim actor mismatch: ${claim.actor}`);
+  if (claim.status !== 'picked') throw new Error(`Dispatch claim must be picked before execution: ${claim.status || 'unknown'}`);
+
+  const targetSkill = event.dispatch?.target_skill || '';
+  if (!stage11AllowedExecutionSkills.has(targetSkill)) {
+    throw new Error(`Execution target skill is not allowlisted for supervised run: ${targetSkill || 'none'}`);
+  }
+
+  const workflow = readWorkflow(root);
+  if (workflow && hasActualStopCondition(workflow.stop_condition)) {
+    throw new Error('execute --run gate failed: stop_condition is set');
+  }
+  const tasks = tasksFromState(workflow);
+  const readiness = readinessCounts(tasks);
+  if (readiness.waiting > 0 || readiness.blocked > 0) {
+    throw new Error('execute --run gate failed: task readiness has waiting or blocked items');
+  }
+  const review = reviewSummaryStatus(tasks);
+  if (review === 'needs_fix' && targetSkill !== 'vibe-receiving-code-review') {
+    throw new Error('execute --run gate failed: review_status needs_fix is present');
+  }
+
+  const plan = executionPlan(eventFile, event, claim, eventPath);
+  if (options.guardActiveRun) assertNoActiveExecution(root, plan);
+
+  return { claim, normalizedActor, workflow, plan };
+}
+
+function executionPreflightEnvelope(root, eventFile, actor = '') {
+  const eventPath = dispatchEventFilePath(root, eventFile);
+  const event = readDispatchEventFile(eventPath);
+  const verification = verifyDispatchEvent(event);
+  const claim = readDispatchClaimFile(dispatchClaimFilePath(root, eventFile));
+  const normalizedActor = actor ? validateDispatchActor(actor) : '';
+  const targetSkill = event.dispatch?.target_skill || '';
+  const workflow = readWorkflow(root);
+  const tasks = tasksFromState(workflow);
+  const readiness = readinessCounts(tasks);
+  const review = reviewSummaryStatus(tasks);
+  const stopConditionSet = Boolean(workflow && hasActualStopCondition(workflow.stop_condition));
+  const profilePreflight = executionEnabledPreflight(root);
+  const gates = foregroundPreflightGates({ verification, claim, normalizedActor, targetSkill, stopConditionSet, readiness, review, profilePreflight, allowedTargetSkills: stage11AllowedExecutionSkills, reviewBypassSkill: 'vibe-receiving-code-review' });
+  const gateValues = Object.values(gates);
+  const ok = verification.ok && profilePreflight.ok && gateValues.every((value) => value === 'passed' || value === 'not-required');
+  const plan = executionPlan(eventFile, event, claim || {}, eventPath);
+  const failures = foregroundPreflightFailures(gates, profilePreflight);
+  return {
+    mode: 'execute-preflight',
+    ok,
+    state_present: fs.existsSync(workflowPath(root)),
+    execution: plan,
+    dispatch: dispatchEventSummary(String(eventFile), event),
+    claim: claim ? claimSummary(claim, root) : null,
+    verification,
+    gates,
+    controlled_execution_gate: profilePreflight.controlled_execution_gate,
+    execution_enabled_preflight: profilePreflight,
+    policy: executionPolicySnapshot(),
+    write_boundary: {
+      expected_writes: plan.writes,
+      forbidden_actions: forbiddenDispatchActions,
+      state_write_requires_confirm: true,
+      business_source_write: false,
+      git: false,
+      worktree: false,
+    },
+    safety: executionSafety({ dryRun: true, writes: false }),
+    quality: failures,
+    action: 'execution preflight was audited. No execution envelope, skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.',
+  };
+}
+
+function executionEnvelope(root, eventFile, actor, mode) {
+  const eventPath = dispatchEventFilePath(root, eventFile);
+  const event = readDispatchEventFile(eventPath);
+  validateDispatchEventOrThrow(event);
+
+  const dryRun = mode === 'dry-run';
+  const { claim } = assertExecutionClaimReady(root, eventFile, actor, event, eventPath, { requireActor: !dryRun });
+
+  return {
+    mode: dryRun ? 'execute-dry-run' : 'execute-confirm',
+    ok: true,
+    state_present: fs.existsSync(workflowPath(root)),
+    execution: executionPlan(eventFile, event, claim, eventPath),
+    dispatch: dispatchEventSummary(String(eventFile), event),
+    claim: claim ? claimSummary(claim) : null,
+    verification: verifyDispatchEvent(event),
+    safety: executionSafety({ dryRun, writes: !dryRun }),
+    quality: claim ? [] : ['dispatch event has no claim state; confirm execution will be rejected until it is claimed and picked'],
+    action: dryRun
+      ? 'supervised execution plan was previewed. No execution envelope, skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'
+      : 'supervised execution envelope was written. No target workflow skill, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.',
+  };
+}
+
+function supervisedRunBaseEnvelope(root, eventFile, actor) {
+  const eventPath = dispatchEventFilePath(root, eventFile);
+  const event = readDispatchEventFile(eventPath);
+  validateDispatchEventOrThrow(event);
+  const { claim, normalizedActor, plan } = assertExecutionClaimReady(root, eventFile, actor, event, eventPath, { guardActiveRun: true });
+  const preflight = executionPreflightEnvelope(root, eventFile, actor);
+  const startedAt = new Date().toISOString();
+
+  return {
+    mode: 'supervised-run',
+    ok: true,
+    state_present: fs.existsSync(workflowPath(root)),
+    execution: {
+      ...plan,
+      status: 'running',
+      lifecycle: [{ status: 'running', at: startedAt }],
+      started_at: startedAt,
+      ended_at: '',
+      timeout_ms: 30000,
+      exit_code: null,
+    },
+    dispatch: dispatchEventSummary(String(eventFile), event),
+    claim: claimSummary(claim),
+    verification: verifyDispatchEvent(event),
+    gates: preflight.gates,
+    write_boundary: preflight.write_boundary,
+    policy: executionPolicySnapshot(),
+    evidence: {
+      stdout_excerpt: '',
+      stderr_excerpt: '',
+      artifacts: [],
+    },
+    safety: executionSafety({ dryRun: false, writes: true, run: true }),
+    quality: [],
+    action: 'supervised runtime action is running. A running execution record was written before the runtime action completed.',
+    runtime_context: {
+      actor: normalizedActor,
+    },
+  };
+}
+
+function terminalSupervisedRunEnvelope(envelope, status, terminal) {
+  const endedAt = new Date().toISOString();
+  const boundedResult = terminal?.result || null;
+  const successOutput = boundedResult?.stdout_excerpt || [
+    'Vibecoding Supervised Runtime Action',
+    `Target skill: ${envelope.execution.target_skill}`,
+    `Source skill: ${envelope.execution.from_skill}`,
+    `Actor: ${envelope.runtime_context?.actor || envelope.claim?.actor || ''}`,
+    'Action: generated supervised handoff package only; no platform API, subagent, MCP, git, worktree, or business source write occurred.',
+  ].join('\n');
+  const terminalMessages = {
+    succeeded: {
+      stdout: successOutput,
+      stderr: boundedResult?.stderr_excerpt || '',
+      exitCode: boundedResult?.exit_code ?? 0,
+      action: boundedResult
+        ? 'bounded foreground command completed and execution lifecycle evidence was written. No platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'
+        : 'supervised runtime action completed and execution lifecycle was written. No platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.',
+    },
+    failed: {
+      stdout: boundedResult?.stdout_excerpt || 'Vibecoding Supervised Runtime Action failed before producing a package.',
+      stderr: boundedResult?.stderr_excerpt || terminal?.message || 'supervised runtime action failed',
+      exitCode: boundedResult?.exit_code ?? 1,
+      action: boundedResult
+        ? 'bounded foreground command failed and execution lifecycle evidence was written. No automatic repair, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'
+        : 'supervised runtime action failed and execution lifecycle was written. No platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.',
+    },
+    timed_out: {
+      stdout: boundedResult?.stdout_excerpt || 'Vibecoding Supervised Runtime Action timed out before producing a package.',
+      stderr: boundedResult?.stderr_excerpt || terminal?.message || 'supervised runtime action timed out',
+      exitCode: boundedResult?.exit_code ?? null,
+      action: boundedResult
+        ? 'bounded foreground command timed out and execution lifecycle evidence was written. No automatic repair, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'
+        : 'supervised runtime action timed out and execution lifecycle was written. No platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.',
+    },
+    cancelled: {
+      stdout: 'Vibecoding Supervised Runtime Action was cancelled before producing a package.',
+      stderr: terminal?.message || 'supervised runtime action cancelled',
+      exitCode: null,
+      action: 'supervised runtime action was cancelled and execution lifecycle was written. No platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.',
+    },
+  };
+  const terminalMessage = terminalMessages[status];
+  if (!terminalMessage) throw new Error(`Unsupported supervised run terminal status: ${status}`);
+
+  const { runtime_context: _runtimeContext, ...publicEnvelope } = envelope;
+  const startedAt = parseIsoTimestamp(publicEnvelope.execution.started_at || '');
+  const endedAtMs = parseIsoTimestamp(endedAt);
+  const durationMs = Number.isNaN(startedAt) || Number.isNaN(endedAtMs) ? 0 : Math.max(0, endedAtMs - startedAt);
+  const commandDetails = boundedResult
+    ? {
+        command_profile_id: boundedResult.command_profile_id,
+        command_digest: boundedResult.command_digest,
+        bounded_foreground_command: {
+          argv: boundedResult.command_argv,
+          timeout_ms: boundedResult.timeout_ms,
+          max_buffer_bytes: boundedResult.max_buffer_bytes,
+          shell: boundedResult.shell,
+          foreground_only: boundedResult.foreground_only,
+          one_shot: boundedResult.one_shot,
+        },
+      }
+    : {};
+  const completed = {
+    ...publicEnvelope,
+    execution: {
+      ...publicEnvelope.execution,
+      ...commandDetails,
+      status,
+      lifecycle: [
+        ...publicEnvelope.execution.lifecycle,
+        { status, at: endedAt },
+      ],
+      ended_at: endedAt,
+      duration_ms: durationMs,
+      exit_code: terminalMessage.exitCode,
+    },
+    evidence: {
+      stdout_excerpt: terminalMessage.stdout,
+      stderr_excerpt: terminalMessage.stderr,
+      artifacts: [],
+      ...(boundedResult
+        ? {
+            command_profile_id: boundedResult.command_profile_id,
+            command_digest: boundedResult.command_digest,
+            budget_consumption: boundedResult.budget_consumption,
+          }
+        : {}),
+    },
+    ...(terminal?.executor_contract ? { bounded_foreground_command_executor: terminal.executor_contract } : {}),
+    action: terminalMessage.action,
+  };
+  return {
+    ...completed,
+    evidence: {
+      ...completed.evidence,
+      evidence_digest: digestObject(foregroundEvidenceDigestPayload(completed)),
+    },
+  };
+}
+
+function completeSupervisedRunEnvelope(envelope, terminal = null) {
+  return terminal?.status ? terminalSupervisedRunEnvelope(envelope, terminal.status, terminal) : terminalSupervisedRunEnvelope(envelope, 'succeeded');
+}
+
+function executeProfilePreflightEnvelope(root) {
+  return buildExecutionProfilePreflightEnvelope({
+    profilePreflight: executionEnabledPreflight(root),
+    policy: executionPolicySnapshot(),
+    actionName: stage11RuntimeActionName,
+    catalogDigest: runtimeActionCatalogDigest(),
+    catalogStage: runtimeActionCatalogStage,
+    catalogVersion: runtimeActionCatalogVersion,
+    forbiddenActions: forbiddenDispatchActions,
+    safety: executionSafety({ dryRun: true, writes: false }),
+  });
+};
+
+  return { assertExecutionClaimReady, executionPreflightEnvelope, executionEnvelope, supervisedRunBaseEnvelope, terminalSupervisedRunEnvelope, completeSupervisedRunEnvelope, executeProfilePreflightEnvelope };
+};

package/tools/vibe-runtime/runtime-execution-safety-artifacts.mjs

@@ -0,0 +1,131 @@
+export const createRuntimeExecutionSafetyArtifacts = function (deps) {
+  const { jsonSchemaVersion, stage11RuntimeActionName, runtimeActionCatalogStage, runtimeActionCatalogVersion, executionPolicy, validateCommonArtifactSafety, runtimeActionCatalogDigest, evaluateRuntimeActionCatalog, policyProfileSnapshot, executionPolicySnapshot, validateExecutionPolicySnapshot, candidateProfileBindingFailures, approvalProfileBindingFailures } = deps;
+const executionSafety = function ({ dryRun, writes, run = false, autoRun = false }) {
+  return {
+    supervised: true,
+    supervised_execution: Boolean(run),
+    confirmed: !dryRun,
+    dry_run: Boolean(dryRun),
+    writes: Boolean(writes),
+    execution_envelope: Boolean(writes),
+    dispatch_event_modified: false,
+    claim_modified: false,
+    auto_execution: Boolean(autoRun),
+    controlled_auto_execution: Boolean(autoRun),
+    command_execution: Boolean(run && autoRun),
+    bounded_foreground_command_execution: Boolean(run && autoRun),
+    runtime_action: Boolean(run),
+    platform_api: false,
+    skill_execution: false,
+    business_source_write: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    worktree: false,
+  };
+}
+
+const candidateSafety = function ({ writes = false } = {}) {
+  return {
+    stage: 'Stage 12',
+    writes: Boolean(writes),
+    candidate_artifact: Boolean(writes),
+    runtime_action: false,
+    auto_execution: false,
+    controlled_auto_execution: false,
+    platform_api: false,
+    skill_execution: false,
+    business_source_write: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    worktree: false,
+    dispatch_event_modified: false,
+    claim_modified: false,
+  };
+}
+
+const approvalSafety = function ({ writes = false } = {}) {
+  return {
+    stage: 'Stage 13',
+    writes: Boolean(writes),
+    approval_artifact: Boolean(writes),
+    runtime_action: false,
+    auto_execution: false,
+    controlled_auto_execution: false,
+    platform_api: false,
+    skill_execution: false,
+    business_source_write: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    worktree: false,
+    dispatch_event_modified: false,
+    claim_modified: false,
+  };
+}
+
+const autoRunSafety = function () {
+  return executionSafety({ dryRun: false, writes: true, run: true, autoRun: true });
+}
+
+const validateCandidateArtifact = function (candidate) {
+  const failures = [];
+  if (candidate.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+  if (candidate.command !== 'execute') failures.push('command must be execute');
+  if (candidate.mode !== 'execution-candidate') failures.push('mode must be execution-candidate');
+  if (!candidate.candidate?.idempotency_key) failures.push('candidate.idempotency_key is required');
+  if (!candidate.candidate?.event_sha256) failures.push('candidate.event_sha256 is required');
+  const candidateAction = candidate.candidate?.runtime_action || candidate.execution?.runtime_action || stage11RuntimeActionName;
+  const candidateCatalog = candidate.candidate?.runtime_action_catalog || candidate.runtime_action_catalog;
+  const catalogEvaluation = evaluateRuntimeActionCatalog(candidateAction, policyProfileSnapshot('controlled-local-runtime'));
+  if (!catalogEvaluation.known) failures.push('candidate runtime action is not in catalog');
+  if (!catalogEvaluation.allowed) failures.push(...catalogEvaluation.blocked_reasons.map((failure) => `candidate ${failure}`));
+  if (!candidateCatalog?.catalog_digest) failures.push('candidate.runtime_action_catalog.catalog_digest is required');
+  else if (candidateCatalog.catalog_digest !== runtimeActionCatalogDigest()) failures.push('candidate runtime action catalog digest mismatch');
+  if (candidateCatalog?.action_id && candidateCatalog.action_id !== candidateAction) failures.push('candidate runtime action catalog action mismatch');
+  if (!candidate.policy || candidate.policy.name !== executionPolicy.name || candidate.policy.version !== executionPolicy.version) failures.push('candidate policy snapshot is invalid');
+  failures.push(...validateExecutionPolicySnapshot({ policy: candidate.policy }).map((failure) => failure.replace('execution.policy', 'candidate.policy')));
+  if (!candidate.policy_evaluation?.policy_digest) failures.push('candidate.policy_evaluation.policy_digest is required');
+  else if (candidate.policy?.policy_digest !== candidate.policy_evaluation.policy_digest) failures.push('candidate policy digest mismatch');
+  if (candidate.policy_evaluation?.policy_digest && candidate.policy_evaluation.policy_digest !== executionPolicySnapshot().policy_digest) failures.push('candidate policy digest must match current policy');
+  if (candidate.policy_evaluation?.action_catalog_digest && candidate.policy_evaluation.action_catalog_digest !== runtimeActionCatalogDigest()) failures.push('candidate policy action catalog digest mismatch');
+  failures.push(...candidateProfileBindingFailures(candidate));
+  failures.push(...validateCommonArtifactSafety(candidate.safety, 'Stage 12'));
+  return { ok: failures.length === 0, failures };
+}
+
+const validateApprovalArtifact = function (approval) {
+  const failures = [];
+  if (approval.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+  if (approval.command !== 'execute') failures.push('command must be execute');
+  if (approval.mode !== 'execution-approval') failures.push('mode must be execution-approval');
+  if (!approval.approval?.candidate_digest) failures.push('approval.candidate_digest is required');
+  if (!approval.approval?.idempotency_key) failures.push('approval.idempotency_key is required');
+  const approvalAction = approval.simulation?.runtime_action || stage11RuntimeActionName;
+  const approvalCatalog = approval.approval?.runtime_action_catalog || approval.runtime_action_catalog;
+  const catalogEvaluation = evaluateRuntimeActionCatalog(approvalAction, policyProfileSnapshot('controlled-local-runtime'));
+  if (!catalogEvaluation.known) failures.push('approval runtime action is not in catalog');
+  if (!catalogEvaluation.allowed) failures.push(...catalogEvaluation.blocked_reasons.map((failure) => `approval ${failure}`));
+  if (!approvalCatalog?.catalog_digest) failures.push('approval.runtime_action_catalog.catalog_digest is required');
+  else if (approvalCatalog.catalog_digest !== runtimeActionCatalogDigest()) failures.push('approval runtime action catalog digest mismatch');
+  if (approvalCatalog?.action_id && approvalCatalog.action_id !== approvalAction) failures.push('approval runtime action catalog action mismatch');
+  if (!approval.simulation?.runtime_action || approval.simulation.runtime_action !== stage11RuntimeActionName) failures.push(`simulation.runtime_action must be ${stage11RuntimeActionName}`);
+  if (!approval.policy || approval.policy.name !== executionPolicy.name || approval.policy.version !== executionPolicy.version) failures.push('approval policy snapshot is invalid');
+  failures.push(...validateExecutionPolicySnapshot({ policy: approval.policy }).map((failure) => failure.replace('execution.policy', 'approval.policy')));
+  if (!approval.approval?.policy_digest) failures.push('approval.policy_digest is required');
+  else if (approval.policy?.policy_digest !== approval.approval.policy_digest) failures.push('approval policy digest mismatch');
+  if (!approval.policy_evaluation?.policy_digest) failures.push('approval.policy_evaluation.policy_digest is required');
+  else if (approval.policy_evaluation.policy_digest !== approval.approval?.policy_digest) failures.push('approval policy evaluation digest mismatch');
+  if (approval.approval?.policy_digest && approval.approval.policy_digest !== executionPolicySnapshot().policy_digest) failures.push('approval policy digest must match current policy');
+  if (approval.policy_evaluation?.action_catalog_digest && approval.policy_evaluation.action_catalog_digest !== runtimeActionCatalogDigest()) failures.push('approval policy action catalog digest mismatch');
+  failures.push(...approvalProfileBindingFailures(approval));
+  failures.push(...validateCommonArtifactSafety(approval.safety, 'Stage 13'));
+  return { ok: failures.length === 0, failures };
+}
+
+  return { executionSafety, candidateSafety, approvalSafety, autoRunSafety, validateCandidateArtifact, validateApprovalArtifact };
+};