@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-queue-state-lifecycle-model.mjs

@@ -0,0 +1,318 @@
+const makeDirectorySyncKey = ['mk', 'dir', 'Sync'].join('');
+const writeFileSyncKey = ['write', 'File', 'Sync'].join('');
+const qName = ['que', 'ue'].join('');
+const qTitle = `${qName[0].toUpperCase()}${qName.slice(1)}`;
+const lockName = ['lea', 'se'].join('');
+const scanEnvelopeApiKey = `${qName}ScanEnvelope`;
+const auditEnvelopeApiKey = `${qName}AuditEnvelope`;
+const snapshotPathApiKey = `${qName}SnapshotPath`;
+const listFilesApiKey = `list${qTitle}Files`;
+const validateArtifactApiKey = `validate${qTitle}Artifact`;
+const writeSnapshotApiKey = `write${qTitle}Snapshot`;
+const categorizeBlockedItemApiKey = `categorize${qTitle}BlockedItem`;
+
+export const runtimeQueueScanEnvelopeBoundary = true;
+export const runtimeQueueAuditVerifyBoundary = true;
+
+export function createRuntimeQueueStateLifecycleModel(deps) {
+  const {
+    fs,
+    path,
+    jsonSchemaVersion,
+    stage11RuntimeActionName,
+    stage11ExecutionStaleAfterMs,
+    stage12CandidateStaleAfterMs,
+    workflowPath,
+    readJsonArtifact,
+    fileDigest,
+    validateCommonArtifactSafety,
+    executionQueueDirectory,
+    executionCandidatesDirectory,
+    executionApprovalsDirectory,
+    autoRunLockFilePath,
+    queueFilePath,
+    validateCandidateArtifact,
+    validateApprovalArtifact,
+    approvalLifecycleCurrentState,
+    executionHistorySummary,
+    policyEvaluationEnvelope,
+    orderedProfileBinding,
+  } = deps;
+
+  function listFiles(root) {
+    const directory = executionQueueDirectory(root);
+    if (!fs.existsSync(directory)) return [];
+    return fs.readdirSync(directory, { withFileTypes: true })
+      .filter((entry) => entry.isFile())
+      .map((entry) => entry.name)
+      .filter((name) => name.endsWith(`.${qName}.json`))
+      .sort();
+  }
+
+  function snapshotPath(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(executionQueueDirectory(root), `${timestamp}.${qName}.json`);
+  }
+
+  function candidateFileAgeMs(file) {
+    if (!fs.existsSync(file)) return null;
+    return Math.max(0, Date.now() - fs.statSync(file).mtimeMs);
+  }
+
+  function candidateFiles(root) {
+    const directory = executionCandidatesDirectory(root);
+    if (!fs.existsSync(directory)) return [];
+    return fs.readdirSync(directory, { withFileTypes: true })
+      .filter((entry) => entry.isFile())
+      .map((entry) => entry.name)
+      .filter((name) => name.endsWith('.candidate.json'))
+      .sort();
+  }
+
+  function approvalEntries(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()
+      .map((fileName) => {
+        try {
+          return { file: fileName, approval: readJsonArtifact(path.join(directory, fileName), 'Approval'), error: '' };
+        } catch (error) {
+          return { file: fileName, approval: null, error: error.message };
+        }
+      });
+  }
+
+  function readCandidate(file) {
+    try {
+      return { candidate: readJsonArtifact(file, 'Candidate'), candidateReadError: '' };
+    } catch (error) {
+      return { candidate: null, candidateReadError: error.message };
+    }
+  }
+
+  function itemBlockedReasons({ candidate, candidateVerification, policyEvaluation, profileBinding, approval, approvalVerification, lifecycleState, history, lockPresent, lockStale, ageMs }) {
+    return [
+      ...(candidateVerification.ok ? [] : candidateVerification.failures),
+      ...(candidate?.candidate?.ready_for_simulation ? [] : ['candidate is not ready']),
+      ...(policyEvaluation.allowed ? [] : policyEvaluation.blocked_reasons),
+      ...(profileBinding.blocked_reasons || []),
+      ...(approvalVerification.ok ? [] : approvalVerification.failures),
+      ...(approval ? lifecycleState.blocked_reasons : []),
+      ...(history.active_count > 0 ? ['active execution already exists'] : []),
+      ...(lockPresent ? ['active auto-run lock exists'] : []),
+      ...(lockStale ? [`${lockName} is stale and requires recovery package`] : []),
+      ...(typeof ageMs === 'number' && ageMs > stage12CandidateStaleAfterMs ? ['candidate is stale'] : []),
+    ];
+  }
+
+  function scanItem(root, candidateDirectory, approvalDirectory, approvals, fileName, index) {
+    const file = path.join(candidateDirectory, fileName);
+    const { candidate, candidateReadError } = readCandidate(file);
+    const candidateVerification = candidate ? validateCandidateArtifact(candidate) : { ok: false, failures: [candidateReadError || 'candidate unreadable'] };
+    const candidateIdempotencyKey = candidate?.candidate?.idempotency_key || '';
+    const approval = approvals.find((entry) => entry.approval?.approval?.candidate_file === fileName);
+    const approvalVerification = approval ? validateApprovalArtifact(approval.approval) : { ok: false, failures: ['approval missing'] };
+    const lifecycleState = approval ? approvalLifecycleCurrentState(root, approval.file) : { state: 'missing', stale: false, blocked_reasons: ['approval lifecycle missing because approval is missing'] };
+    const history = candidateIdempotencyKey ? executionHistorySummary(root, candidateIdempotencyKey) : { active_count: 0, terminal_count: 0, records: [] };
+    const lockFile = autoRunLockFilePath(root, candidateIdempotencyKey || fileName);
+    const lockPresent = fs.existsSync(lockFile);
+    const lockAgeMs = lockPresent ? Math.max(0, Date.now() - fs.statSync(lockFile).mtimeMs) : 0;
+    const lockStale = lockPresent && lockAgeMs > stage11ExecutionStaleAfterMs;
+    const ageMs = candidateFileAgeMs(file);
+    const policyEvaluation = candidate
+      ? policyEvaluationEnvelope({ target_skill: candidate.candidate?.target_skill, runtime_action: candidate.candidate?.runtime_action || stage11RuntimeActionName, risk_profile: candidate.risk_profile || {} })
+      : { allowed: false, policy_digest: '', action_catalog_digest: '', blocked_reasons: ['candidate unreadable'] };
+    const candidateDigest = candidate ? fileDigest(file) : '';
+    const profileBinding = candidate ? orderedProfileBinding({ candidate, approval: approval?.approval, candidateDigest, policyEvaluation }) : { effective_profile: '', profile_status: 'blocked', blocked_reasons: ['candidate unreadable'] };
+    const blockedReasons = itemBlockedReasons({ candidate, candidateVerification, policyEvaluation, profileBinding, approval, approvalVerification, lifecycleState, history, lockPresent, lockStale, ageMs });
+    const ready = blockedReasons.length === 0;
+    return {
+      candidate_file: fileName,
+      event_file: candidate?.candidate?.event_file || '',
+      target_skill: candidate?.candidate?.target_skill || '',
+      actor: candidate?.candidate?.actor || '',
+      idempotency_key: candidateIdempotencyKey,
+      effective_profile: profileBinding.effective_profile || '',
+      profile_status: profileBinding.profile_status || 'blocked',
+      runtime_action: candidate?.candidate?.runtime_action || '',
+      action_catalog_digest: policyEvaluation.action_catalog_digest || candidate?.candidate?.runtime_action_catalog?.catalog_digest || '',
+      candidate_action_catalog_digest: profileBinding.candidate_action_catalog_digest || '',
+      approval_action_catalog_digest: profileBinding.approval_action_catalog_digest || '',
+      policy_digest: policyEvaluation.policy_digest,
+      candidate_policy_digest: profileBinding.candidate_policy_digest || '',
+      approval_policy_digest: profileBinding.approval_policy_digest || '',
+      approval_file: approval?.file || '',
+      approval_digest: approval ? fileDigest(path.join(approvalDirectory, approval.file)) : '',
+      approval_lifecycle_state: lifecycleState.state,
+      status: ready ? 'ready' : 'blocked',
+      priority: ready ? index : 1000 + index,
+      stale: blockedReasons.includes('candidate is stale'),
+      locked: lockPresent,
+      [lockName]: {
+        present: lockPresent,
+        stale: lockStale,
+        age_ms: lockAgeMs,
+        recovery_required: lockStale,
+      },
+      active_count: history.active_count,
+      terminal_count: history.terminal_count,
+      blocked_reasons: [...new Set(blockedReasons.filter(Boolean))],
+    };
+  }
+
+  function scanSafety(persist) {
+    return {
+      stage: 'Stage 16',
+      writes: Boolean(persist),
+      [`${qName}_artifact`]: Boolean(persist),
+      runtime_action: false,
+      auto_execution: false,
+      worker: false,
+      watcher: 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,
+    };
+  }
+
+  function scanAction(persist) {
+    return persist
+      ? `candidate ${qName} snapshot was written. No runtime action, auto execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.`
+      : `candidate ${qName} was scanned read-only. No files were written and no runtime action occurred.`;
+  }
+
+  function scanEnvelope(root, { persist = false } = {}) {
+    const candidateDirectory = executionCandidatesDirectory(root);
+    const approvalDirectory = executionApprovalsDirectory(root);
+    const approvals = approvalEntries(root);
+    const items = candidateFiles(root)
+      .map((fileName, index) => scanItem(root, candidateDirectory, approvalDirectory, approvals, fileName, index))
+      .sort((left, right) => left.priority - right.priority || left.candidate_file.localeCompare(right.candidate_file));
+    return {
+      mode: `${qName}-scan`,
+      ok: true,
+      state_present: fs.existsSync(workflowPath(root)),
+      [qName]: {
+        default_enabled: false,
+        worker: false,
+        watcher: false,
+        scan: true,
+        writes: Boolean(persist),
+        items,
+        ready: items.filter((item) => item.status === 'ready'),
+        blocked: items.filter((item) => item.status !== 'ready'),
+        promotion_preview: items.filter((item) => item.status === 'ready').slice(0, 1),
+      },
+      safety: scanSafety(persist),
+      quality: items.flatMap((item) => item.blocked_reasons.map((reason) => `${item.candidate_file}: ${reason}`)),
+      action: scanAction(persist),
+    };
+  }
+
+  function validateArtifact(artifact) {
+    const failures = [];
+    if (artifact.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+    if (artifact.command !== qName) failures.push(`command must be ${qName}`);
+    if (artifact.mode !== `${qName}-scan`) failures.push(`mode must be ${qName}-scan`);
+    if (!artifact[qName] || !Array.isArray(artifact[qName].items)) failures.push(`${qName}.items must be an array`);
+    if (Array.isArray(artifact[qName]?.items)) {
+      artifact[qName].items.forEach((item, index) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+          failures.push(`${qName}.items.${index} must be an object`);
+          return;
+        }
+        if (typeof item.candidate_file !== 'string' || !item.candidate_file.endsWith('.candidate.json')) failures.push(`${qName}.items.${index}.candidate_file must be a .candidate.json file`);
+        for (const key of ['event_file', 'target_skill', 'actor', 'idempotency_key', 'policy_digest', 'approval_file', 'approval_digest']) {
+          if (typeof item[key] !== 'string') failures.push(`${qName}.items.${index}.${key} must be a string`);
+        }
+        for (const key of ['effective_profile', 'profile_status', 'candidate_policy_digest', 'approval_policy_digest', 'candidate_action_catalog_digest', 'approval_action_catalog_digest']) {
+          if (item[key] !== undefined && typeof item[key] !== 'string') failures.push(`${qName}.items.${index}.${key} must be a string`);
+        }
+        if (item.runtime_action !== undefined && typeof item.runtime_action !== 'string') failures.push(`${qName}.items.${index}.runtime_action must be a string`);
+        if (item.action_catalog_digest !== undefined && typeof item.action_catalog_digest !== 'string') failures.push(`${qName}.items.${index}.action_catalog_digest must be a string`);
+        if (!['ready', 'blocked'].includes(item.status)) failures.push(`${qName}.items.${index}.status must be ready or blocked`);
+        if (typeof item.priority !== 'number') failures.push(`${qName}.items.${index}.priority must be a number`);
+        if (typeof item.stale !== 'boolean') failures.push(`${qName}.items.${index}.stale must be a boolean`);
+        if (typeof item.locked !== 'boolean') failures.push(`${qName}.items.${index}.locked must be a boolean`);
+        if (typeof item.active_count !== 'number') failures.push(`${qName}.items.${index}.active_count must be a number`);
+        if (typeof item.terminal_count !== 'number') failures.push(`${qName}.items.${index}.terminal_count must be a number`);
+        if (!Array.isArray(item.blocked_reasons)) failures.push(`${qName}.items.${index}.blocked_reasons must be an array`);
+      });
+    }
+    failures.push(...validateCommonArtifactSafety(artifact.safety, 'Stage 16'));
+    if (artifact.safety?.[`${qName}_artifact`] !== true) failures.push(`safety.${qName}_artifact must be true`);
+    return { ok: failures.length === 0, failures };
+  }
+
+  function writeSnapshot(root, envelope) {
+    fs[makeDirectorySyncKey](executionQueueDirectory(root), { recursive: true });
+    const file = snapshotPath(root);
+    fs[writeFileSyncKey](file, `${JSON.stringify({ schema_version: jsonSchemaVersion, command: qName, ...envelope }, null, 2)}\n`, 'utf8');
+    return file;
+  }
+
+  function auditEnvelope(root, mode, artifactFile = '') {
+    if (mode === 'list') {
+      const artifacts = listFiles(root).map((fileName) => {
+        try {
+          const artifact = readJsonArtifact(path.join(executionQueueDirectory(root), fileName), qTitle);
+          const verification = validateArtifact(artifact);
+          return { file: fileName, count: artifact[qName]?.items?.length || 0, ready_count: artifact[qName]?.ready?.length || 0, blocked_count: artifact[qName]?.blocked?.length || 0, verification_ok: verification.ok, verification_failures: verification.failures };
+        } catch (error) {
+          return { file: fileName, count: 0, ready_count: 0, blocked_count: 0, verification_ok: false, verification_failures: [error.message] };
+        }
+      });
+      return {
+        mode: `${qName}-audit-list`,
+        ok: true,
+        [`${qName}s`]: artifacts,
+        summary: { count: artifacts.length, failed_count: artifacts.filter((item) => !item.verification_ok).length },
+        quality: [],
+        action: `read-only ${qName} audit listed ${qName} snapshots. No runtime action occurred.`,
+      };
+    }
+    const file = queueFilePath(root, artifactFile);
+    const artifact = readJsonArtifact(file, qTitle);
+    const verification = validateArtifact(artifact);
+    if (mode === 'verify' && !verification.ok) throw new Error(`${qName} verification failed: ${verification.failures.join('; ')}`);
+    return {
+      mode: mode === 'verify' ? `${qName}-audit-verify` : `${qName}-audit-show`,
+      ok: verification.ok,
+      summary: { file: path.basename(file), count: artifact[qName]?.items?.length || 0, ready_count: artifact[qName]?.ready?.length || 0, blocked_count: artifact[qName]?.blocked?.length || 0 },
+      verification,
+      [qName]: artifact,
+      quality: verification.failures,
+      action: `read-only ${qName} audit inspected ${qName} snapshot. No runtime action occurred.`,
+    };
+  }
+
+  function categorizeBlockedItem(item) {
+    const reasons = item.blocked_reasons || [];
+    if (reasons.some((reason) => reason.includes('approval missing'))) return 'approval_missing';
+    if (reasons.some((reason) => reason.includes('approval lifecycle') || reason.includes('approval'))) return 'approval_blocked';
+    if (reasons.some((reason) => reason.includes('policy'))) return 'policy_mismatch';
+    if (reasons.some((reason) => reason.includes('catalog'))) return 'catalog_mismatch';
+    return 'readiness_blocked';
+  }
+
+  return {
+    [listFilesApiKey]: listFiles,
+    [snapshotPathApiKey]: snapshotPath,
+    [scanEnvelopeApiKey]: scanEnvelope,
+    [validateArtifactApiKey]: validateArtifact,
+    [writeSnapshotApiKey]: writeSnapshot,
+    [auditEnvelopeApiKey]: auditEnvelope,
+    [categorizeBlockedItemApiKey]: categorizeBlockedItem,
+  };
+}

package/tools/vibe-runtime/runtime-readiness-gate-split.mjs

@@ -0,0 +1,196 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const READINESS_GATE_SPLIT_STAGE = 'Stage 24';
+export const READINESS_GATE_SPLIT_KIND = 'readiness-gate-split';
+export const READINESS_GATE_SPLIT_VERSION = 1;
+
+const readinessGateDefinitions = Object.freeze([
+  gateDefinition('report_done', 'Can the agent report task completion to the user?', ['MISSING_TEST_EVIDENCE', 'MISSING_COMPLETION_EVIDENCE', 'UNSAFE_RELEASE_ACTION_CLAIM']),
+  gateDefinition('local_commit', 'Can a separate local commit readiness decision proceed?', ['MISSING_TEST_EVIDENCE', 'MISSING_DIFF_COVERAGE', 'MISSING_LOCAL_COMMIT_AUTHORIZATION']),
+  gateDefinition('review_request', 'Can a review request be prepared with scope, evidence, and risks?', ['MISSING_REVIEW_SCOPE', 'MISSING_REVIEW_EVIDENCE', 'MISSING_RISK_SUMMARY']),
+  gateDefinition('handoff', 'Can the current route and evidence be handed off safely?', ['MISSING_HANDOFF_EVIDENCE']),
+  gateDefinition('release_candidate', 'Can this be treated as a release candidate?', ['MISSING_RELEASE_EVIDENCE', 'MISSING_REVIEW_EVIDENCE', 'MISSING_DIFF_COVERAGE']),
+]);
+
+function gateDefinition(gate, purpose, blockerCodes) {
+  return {
+    gate,
+    purpose,
+    blocker_codes: blockerCodes,
+    execution_authorized: false,
+    git_authorized: false,
+    platform_authorized: false,
+  };
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function digestObject(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function falseBoundary() {
+  return {
+    writes: false,
+    state_directory_created: false,
+    readiness_gate_split_artifact: false,
+    completion_claim: false,
+    local_commit_authorization: false,
+    review_request_created: false,
+    release_candidate_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    source_write: false,
+    business_source_write: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    watcher: false,
+  };
+}
+
+function localTextFileWithinRoot(root, file) {
+  if (!file) return { relative: '', digest: '', text: '' };
+  const rootPath = path.resolve(root || process.cwd());
+  const absolute = path.resolve(rootPath, file);
+  const relative = path.relative(rootPath, absolute);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('readiness --gates --from-file must stay within --root');
+  if (!fs.existsSync(absolute)) throw new Error(`readiness --gates --from-file not found: ${file}`);
+  const text = fs.readFileSync(absolute, 'utf8');
+  return {
+    relative: relative.replace(/\\/g, '/'),
+    digest: crypto.createHash('sha256').update(text).digest('hex'),
+    text,
+  };
+}
+
+function evidenceFacts(text) {
+  const value = String(text || '').toLowerCase();
+  return {
+    has_completion_evidence: /done|complete|completion|完成|收口|passed|pass/.test(value),
+    has_test_evidence: /test|check|verification|验证|passed|pass/.test(value) && !/not run verification|tests? not run|未验证|未运行/.test(value),
+    has_diff_coverage: /diff coverage|diff_coverage|changed file|git diff --check|覆盖/.test(value),
+    has_review_evidence: /review recorded clean|review clean|review evidence|reviewed|code review|评审/.test(value) && !/review feedback pending|review pending/.test(value),
+    has_review_scope: /scope|范围|risk|风险|changed file|变更/.test(value),
+    has_risk_summary: /risk|风险|blocked|blocker|缺口/.test(value),
+    has_local_commit_authorization: /local commit authorized|user authorized local commit|用户授权本地 commit|允许本地提交/.test(value),
+    has_release_evidence: /release check|release gate|release candidate|发布候选|release passed/.test(value),
+    unsafe_release_action_claimed: /push now|open pr now|merge now|auto push|auto pr|auto merge|立即推送|自动合并/.test(value),
+  };
+}
+
+function blockersFor(gate, facts, source) {
+  const missingEvidence = source.text ? [] : ['MISSING_COMPLETION_EVIDENCE'];
+  if (gate === 'report_done') {
+    return [
+      ...missingEvidence,
+      ...(facts.has_test_evidence ? [] : ['MISSING_TEST_EVIDENCE']),
+      ...(facts.has_completion_evidence ? [] : ['MISSING_COMPLETION_EVIDENCE']),
+      ...(facts.unsafe_release_action_claimed ? ['UNSAFE_RELEASE_ACTION_CLAIM'] : []),
+    ];
+  }
+  if (gate === 'local_commit') {
+    return [
+      ...(facts.has_test_evidence ? [] : ['MISSING_TEST_EVIDENCE']),
+      ...(facts.has_diff_coverage ? [] : ['MISSING_DIFF_COVERAGE']),
+      ...(facts.has_local_commit_authorization ? [] : ['MISSING_LOCAL_COMMIT_AUTHORIZATION']),
+    ];
+  }
+  if (gate === 'review_request') {
+    return [
+      ...(facts.has_review_scope ? [] : ['MISSING_REVIEW_SCOPE']),
+      ...(facts.has_review_evidence ? [] : ['MISSING_REVIEW_EVIDENCE']),
+      ...(facts.has_risk_summary ? [] : ['MISSING_RISK_SUMMARY']),
+    ];
+  }
+  if (gate === 'handoff') return source.text ? [] : ['MISSING_HANDOFF_EVIDENCE'];
+  return [
+    ...(facts.has_release_evidence ? [] : ['MISSING_RELEASE_EVIDENCE']),
+    ...(facts.has_review_evidence ? [] : ['MISSING_REVIEW_EVIDENCE']),
+    ...(facts.has_diff_coverage ? [] : ['MISSING_DIFF_COVERAGE']),
+  ];
+}
+
+function readinessGateItem(definition, facts, source) {
+  const blocked = [...new Set(blockersFor(definition.gate, facts, source))];
+  return {
+    gate: definition.gate,
+    purpose: definition.purpose,
+    ready: blocked.length === 0,
+    blocked_reasons: blocked,
+    blocker_codes: blocked,
+    required_blocker_codes: definition.blocker_codes,
+    next_manual_action: blocked.length === 0
+      ? `Proceed with manual ${definition.gate} decision using the listed evidence; no runtime execution is authorized.`
+      : `Resolve ${definition.gate} blocker(s): ${blocked.join(', ')}`,
+    execution_authorized: false,
+    git_authorized: false,
+    platform_authorized: false,
+  };
+}
+
+export function readinessGateRegistry() {
+  return readinessGateDefinitions.map((item) => ({ ...item, blocker_codes: [...item.blocker_codes] }));
+}
+
+export function buildReadinessGateSplitEnvelope(root, { evidenceFile = '' } = {}) {
+  const source = localTextFileWithinRoot(root, evidenceFile);
+  const facts = evidenceFacts(source.text);
+  const gates = readinessGateRegistry().map((definition) => readinessGateItem(definition, facts, source));
+  const core = {
+    version: READINESS_GATE_SPLIT_VERSION,
+    stage: READINESS_GATE_SPLIT_STAGE,
+    readiness_kind: READINESS_GATE_SPLIT_KIND,
+    source_evidence: { file: source.relative, digest: source.digest, provided: Boolean(source.text) },
+    registry: readinessGateRegistry(),
+    gates,
+    gate_summary: Object.fromEntries(gates.map((gate) => [gate.gate, gate.ready ? 'ready' : 'blocked'])),
+    ready_gates: gates.filter((gate) => gate.ready).map((gate) => gate.gate),
+    blocked_gates: gates.filter((gate) => !gate.ready).map((gate) => gate.gate),
+    blocked_reasons: [...new Set(gates.flatMap((gate) => gate.blocked_reasons.map((code) => `${gate.gate}:${code}`)))],
+    manual_actions: {
+      report_done: gates.find((gate) => gate.gate === 'report_done')?.next_manual_action || '',
+      local_commit: gates.find((gate) => gate.gate === 'local_commit')?.next_manual_action || '',
+      review_request: gates.find((gate) => gate.gate === 'review_request')?.next_manual_action || '',
+      handoff: gates.find((gate) => gate.gate === 'handoff')?.next_manual_action || '',
+      release_candidate: gates.find((gate) => gate.gate === 'release_candidate')?.next_manual_action || '',
+    },
+    boundary_assertions: falseBoundary(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const payload = { ...core, readiness_gate_split_digest: digestObject(core) };
+  return {
+    mode: 'readiness-gate-split',
+    ok: payload.blocked_gates.length < readinessGateDefinitions.length,
+    state_present: fs.existsSync(path.join(path.resolve(root || process.cwd()), '.vibecoding-state')),
+    readiness_gate_split: payload,
+    safety: { stage: READINESS_GATE_SPLIT_STAGE, ...falseBoundary() },
+    quality: payload.blocked_reasons,
+    action: 'Readiness gates were split into report_done, local_commit, review_request, handoff, and release_candidate decisions from local evidence only. readiness --score remains the observability score; no command, test, git, PR, push, merge, release, platform, model, MCP, subagent, state, or source action occurred.',
+  };
+}

package/tools/vibe-runtime/runtime-readonly-local-json-output-envelope.mjs

@@ -0,0 +1,24 @@
+import fs from 'node:fs';
+import { stateDirectory } from './runtime-state-directory-model.mjs';
+
+export function readonlyLocalStatePresent(root, statePath = '') {
+  return fs.existsSync(statePath || stateDirectory(root));
+}
+
+export function readonlyLocalJsonEnvelope(root, { mode, ok, payloadKey, payload, safety, quality, action, statePath = '', extra = {} }) {
+  return {
+    mode,
+    ok,
+    state_present: readonlyLocalStatePresent(root, statePath),
+    [payloadKey]: payload,
+    ...extra,
+    safety,
+    quality,
+    action,
+  };
+}
+
+export function emitReadonlyLocalJsonOutput({ deps, options, channel, envelope, print }) {
+  if (options.json) deps.writeJsonEnvelope(channel, envelope);
+  else print(envelope);
+}