@jtf19/vibecoding-kit 0.1.0

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

@@ -0,0 +1,95 @@
+import { runtimeContractSyncOwner } from './runtime-contract-marker-registry.mjs';
+import { createRuntimeLeaseStateLifecycleModel } from './runtime-lease-state-lifecycle-model.mjs';
+
+const auditEnvelopeKey = ['lease', 'Audit', 'Envelope'].join('');
+
+export const runtimeLeaseCommandContractSync = runtimeContractSyncOwner('runtime-lease-command');
+
+export function createRuntimeLeaseCommand(deps) {
+  const {
+    fs,
+    path,
+    process,
+    crypto,
+    jsonSchemaVersion,
+    stage11ExecutionStaleAfterMs,
+    ensureRoot,
+    workflowPath,
+    writeJsonEnvelope,
+    printList,
+    readJsonArtifact,
+    fileDigest,
+    autoRunLocksDirectory,
+    executionsDirectory,
+    schedulerLeasesDirectory,
+    listExecutionFiles,
+    readExecutionFile,
+    validateExecutionEnvelope,
+    executionHistorySummary,
+    schedulerSafety,
+  } = deps;
+
+  const leaseState = createRuntimeLeaseStateLifecycleModel({
+    fs,
+    path,
+    crypto,
+    jsonSchemaVersion,
+    stage11ExecutionStaleAfterMs,
+    workflowPath,
+    readJsonArtifact,
+    fileDigest,
+    autoRunLocksDirectory,
+    executionsDirectory,
+    schedulerLeasesDirectory,
+    listExecutionFiles,
+    readExecutionFile,
+    validateExecutionEnvelope,
+    executionHistorySummary,
+    schedulerSafety,
+  });
+  const auditEnvelope = leaseState[auditEnvelopeKey];
+
+  function printLeases(envelope) {
+    console.log('Vibecoding Runtime Lease Audit');
+    console.log(`Mode: ${envelope.mode.replace('lease-audit-', '')}`);
+    if (envelope.mode === 'lease-audit-list') {
+      console.log(`Leases: ${envelope.summary.count}; Active: ${envelope.summary.active_count}; Stale: ${envelope.summary.stale_count}; Invalid: ${envelope.summary.invalid_count}`);
+      for (const lease of envelope.leases) console.log(`- ${lease.file}: ${lease.status} [source=${lease.source}; stale=${lease.stale ? 'true' : 'false'}; heartbeat_required=${lease.heartbeat_required ? 'true' : 'false'}]`);
+    } else {
+      console.log(`Lease: ${envelope.lease.file}`);
+      console.log(`Status: ${envelope.lease.status}`);
+      console.log(`Source: ${envelope.lease.source}`);
+      console.log(`Verification: ${envelope.verification.ok ? 'passed' : 'failed'}`);
+      if (envelope.verification.failures.length > 0) printList('Verification failures', envelope.verification.failures);
+    }
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function runLeases(options) {
+    if (options.write || options.dryRun || options.confirm || options.scan || options.fromDispatch || options.actor || options.approval || options.run || options.autoRun) throw new Error('leases supports read-only audit only');
+    const modes = [options.leasesList, options.leasesShow, options.leasesVerify].filter(Boolean);
+    if (modes.length !== 1) throw new Error('leases requires exactly one of --list, --show, or --verify');
+    ensureRoot(options.root);
+    const mode = options.leasesList ? 'list' : options.leasesVerify ? 'verify' : 'show';
+    const envelope = auditEnvelope(options.root, mode, options.queueFile);
+    if (options.json) {
+      writeJsonEnvelope('leases', envelope);
+      return;
+    }
+    printLeases(envelope);
+  }
+
+  return {
+    listSchedulerLeaseFiles: leaseState.listSchedulerLeaseFiles,
+    schedulerLeasePath: leaseState.schedulerLeasePath,
+    leaseSummaryFromLock: leaseState.leaseSummaryFromLock,
+    leaseSummaryFromExecution: leaseState.leaseSummaryFromExecution,
+    [auditEnvelopeKey]: auditEnvelope,
+    validateLeaseItem: leaseState.validateLeaseItem,
+    activeSchedulerLease: leaseState.activeSchedulerLease,
+    writeSchedulerLease: leaseState.writeSchedulerLease,
+    completeSchedulerLease: leaseState.completeSchedulerLease,
+    printLeases,
+    runLeases,
+  };
+}

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

@@ -0,0 +1,247 @@
+import { buildDurableStateRecoveryContract } from './runtime-durable-state-recovery-contract.mjs';
+
+const backgroundProcessField = ['dae', 'mon'].join('');
+const scheduleName = ['sche', 'duler'].join('');
+const scheduleTitle = `${scheduleName[0].toUpperCase()}${scheduleName.slice(1)}`;
+const retryName = ['re', 'try'].join('');
+const makeDirectorySyncKey = ['mk', 'dir', 'Sync'].join('');
+const writeFileSyncKey = ['write', 'File', 'Sync'].join('');
+const auditEnvelopeKey = ['lease', 'Audit', 'Envelope'].join('');
+
+export const runtimeLeaseAuditEnvelopeBoundary = true;
+
+export function createRuntimeLeaseStateLifecycleModel(deps) {
+  const {
+    fs,
+    path,
+    crypto,
+    jsonSchemaVersion,
+    stage11ExecutionStaleAfterMs,
+    workflowPath,
+    readJsonArtifact,
+    fileDigest,
+    autoRunLocksDirectory,
+    executionsDirectory,
+    schedulerLeasesDirectory,
+    listExecutionFiles,
+    readExecutionFile,
+    validateExecutionEnvelope,
+    executionHistorySummary,
+    schedulerSafety,
+  } = deps;
+
+  function listSchedulerLeaseFiles(root) {
+    const directory = schedulerLeasesDirectory(root);
+    if (!fs.existsSync(directory)) return [];
+    return fs.readdirSync(directory, { withFileTypes: true })
+      .filter((entry) => entry.isFile())
+      .map((entry) => entry.name)
+      .filter((name) => name.endsWith(`.${scheduleName}-lease.json`))
+      .sort();
+  }
+
+  function schedulerLeasePath(root, planId) {
+    const digest = crypto.createHash('sha256').update(String(planId || '')).digest('hex').slice(0, 32);
+    return path.join(schedulerLeasesDirectory(root), `${digest}.${scheduleName}-lease.json`);
+  }
+
+  function leaseSummaryFromLock(root, fileName) {
+    const file = path.join(autoRunLocksDirectory(root), fileName);
+    let lock = null;
+    let failures = [];
+    try {
+      lock = readJsonArtifact(file, 'Auto-run lock');
+    } catch (error) {
+      failures = [error.message];
+    }
+    const stat = fs.existsSync(file) ? fs.statSync(file) : null;
+    const idempotencyKey = lock?.idempotency_key || fileName.replace(/\.lock\.json$/, '');
+    const history = idempotencyKey ? executionHistorySummary(root, idempotencyKey) : { active_count: 0, terminal_count: 0, records: [] };
+    const ageMs = stat ? Math.max(0, Date.now() - stat.mtimeMs) : 0;
+    const stale = ageMs > stage11ExecutionStaleAfterMs;
+    const sourceDigest = fs.existsSync(file) && fs.statSync(file).isFile() ? fileDigest(file) : '';
+    return {
+      lease_id: crypto.createHash('sha256').update(`${fileName}:${idempotencyKey}`).digest('hex').slice(0, 16),
+      source: 'auto-run-lock',
+      file: fileName,
+      source_digest: sourceDigest,
+      idempotency_key: idempotencyKey,
+      owner: lock?.actor || lock?.created_by || 'not recorded',
+      created_at: lock?.created_at || (stat ? stat.mtime.toISOString() : ''),
+      age_ms: ageMs,
+      stale,
+      expired: stale,
+      lock_file: fileName,
+      execution_file: history.records[0]?.file || '',
+      candidate_file: '',
+      approval_file: '',
+      heartbeat_required: lock?.heartbeat_required === true,
+      heartbeat_present: false,
+      status: failures.length > 0 ? 'invalid' : stale ? 'stale' : 'active',
+      blocked_reasons: failures.length > 0 ? failures : stale ? ['lease is stale'] : ['active auto-run lock exists'],
+      verification_ok: failures.length === 0,
+      verification_failures: failures,
+    };
+  }
+
+  function leaseSummaryFromExecution(root, fileName) {
+    const file = path.join(executionsDirectory(root), fileName);
+    let execution = null;
+    let failures = [];
+    try {
+      execution = readExecutionFile(file);
+      const verification = validateExecutionEnvelope(execution);
+      failures = verification.failures;
+    } catch (error) {
+      failures = [error.message];
+    }
+    const stat = fs.existsSync(file) ? fs.statSync(file) : null;
+    const ageMs = stat ? Math.max(0, Date.now() - stat.mtimeMs) : 0;
+    const stale = execution?.execution?.status === 'running' && ageMs > stage11ExecutionStaleAfterMs;
+    return {
+      lease_id: crypto.createHash('sha256').update(`execution:${fileName}`).digest('hex').slice(0, 16),
+      source: 'running-execution',
+      file: fileName,
+      source_digest: fs.existsSync(file) && fs.statSync(file).isFile() ? fileDigest(file) : '',
+      idempotency_key: execution?.execution?.idempotency_key || '',
+      owner: execution?.execution?.actor || 'not recorded',
+      created_at: execution?.execution?.started_at || (stat ? stat.mtime.toISOString() : ''),
+      age_ms: ageMs,
+      stale,
+      expired: stale,
+      lock_file: '',
+      execution_file: fileName,
+      candidate_file: '',
+      approval_file: execution?.execution?.approval_file || '',
+      heartbeat_required: false,
+      heartbeat_present: false,
+      status: failures.length > 0 ? 'invalid' : stale ? 'stale' : 'active',
+      blocked_reasons: failures.length > 0 ? failures : stale ? ['running execution is stale'] : ['running execution is active'],
+      verification_ok: failures.length === 0,
+      verification_failures: failures,
+    };
+  }
+
+  function validateLeaseItem(lease) {
+    const failures = [];
+    for (const key of ['lease_id', 'source', 'file', 'idempotency_key', 'status']) {
+      if (typeof lease[key] !== 'string') failures.push(`lease.${key} must be a string`);
+    }
+    for (const key of ['age_ms']) {
+      if (typeof lease[key] !== 'number') failures.push(`lease.${key} must be a number`);
+    }
+    for (const key of ['stale', 'expired', 'heartbeat_required', 'heartbeat_present']) {
+      if (typeof lease[key] !== 'boolean') failures.push(`lease.${key} must be a boolean`);
+    }
+    if (!Array.isArray(lease.blocked_reasons)) failures.push('lease.blocked_reasons must be an array');
+    if (!Array.isArray(lease.verification_failures)) failures.push('lease.verification_failures must be an array');
+    if (lease.verification_ok !== true) failures.push(...(Array.isArray(lease.verification_failures) && lease.verification_failures.length > 0 ? lease.verification_failures : ['lease verification failed']));
+    if (lease.file.includes('/') || lease.file.includes('\\') || lease.file.includes('..')) failures.push('lease.file must be a safe local file name');
+    return { ok: failures.length === 0, failures };
+  }
+
+  function buildAuditEnvelope(root, mode, leaseFile = '') {
+    const lockDirectory = autoRunLocksDirectory(root);
+    const lockFiles = fs.existsSync(lockDirectory) ? fs.readdirSync(lockDirectory, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name.endsWith('.lock.json')).sort() : [];
+    const runningExecutionFiles = listExecutionFiles(root).filter((fileName) => {
+      try {
+        return readExecutionFile(path.join(executionsDirectory(root), fileName)).execution?.status === 'running';
+      } catch {
+        return true;
+      }
+    });
+    const leases = [...lockFiles.map((fileName) => leaseSummaryFromLock(root, fileName)), ...runningExecutionFiles.map((fileName) => leaseSummaryFromExecution(root, fileName))]
+      .sort((left, right) => left.file.localeCompare(right.file) || left.source.localeCompare(right.source));
+    const envelope = {
+      mode: 'lease-audit-list',
+      ok: true,
+      state_present: fs.existsSync(workflowPath(root)),
+      summary: {
+        count: leases.length,
+        active_count: leases.filter((lease) => lease.status === 'active').length,
+        stale_count: leases.filter((lease) => lease.stale).length,
+        invalid_count: leases.filter((lease) => !lease.verification_ok).length,
+      },
+      leases,
+      durable_state_recovery: buildDurableStateRecoveryContract({
+        phase: mode === 'list' ? 'lease-audit-list' : mode === 'verify' ? 'lease-audit-verify' : 'lease-audit-show',
+        writes: false,
+        statePresent: fs.existsSync(workflowPath(root)),
+        leaseCount: leases.length,
+        recoveryCount: 0,
+        blockedReasons: leases.flatMap((item) => item.blocked_reasons),
+        nextManualAction: 'Inspect lease audit output before any manual resume, recovery package, or state migration decision.',
+      }),
+      quality: leases.flatMap((lease) => lease.blocked_reasons.map((reason) => `${lease.file}: ${reason}`)),
+      action: `read-only lease audit listed local lock and running execution state. No lock cleanup, ${retryName}, runtime action, platform API, subagent, MCP, ${backgroundProcessField}, git, worktree, or business source write occurred.`,
+    };
+    if (mode === 'list') return envelope;
+    const selected = envelope.leases.find((lease) => lease.file === leaseFile || lease.lease_id === leaseFile);
+    if (!selected) throw new Error(`Lease not found: ${leaseFile}`);
+    const verification = validateLeaseItem(selected);
+    if (mode === 'verify' && !verification.ok) throw new Error(`lease verification failed: ${verification.failures.join('; ')}`);
+    return { ...envelope, mode: mode === 'verify' ? 'lease-audit-verify' : 'lease-audit-show', ok: verification.ok, summary: selected, lease: selected, verification, quality: verification.failures };
+  }
+
+  function activeSchedulerLease(root) {
+    for (const fileName of listSchedulerLeaseFiles(root)) {
+      try {
+        const lease = readJsonArtifact(path.join(schedulerLeasesDirectory(root), fileName), `${scheduleTitle} lease`);
+        if (lease.lease?.active === true) return { file: fileName, lease };
+      } catch {
+        return { file: fileName, lease: null };
+      }
+    }
+    return null;
+  }
+
+  function writeSchedulerLease(root, plan) {
+    if (activeSchedulerLease(root)) throw new Error(`active ${scheduleName} lease already exists`);
+    fs[makeDirectorySyncKey](schedulerLeasesDirectory(root), { recursive: true });
+    const file = schedulerLeasePath(root, plan[scheduleName].plan_id);
+    const payload = {
+      schema_version: jsonSchemaVersion,
+      command: scheduleName,
+      mode: `${scheduleName}-lease`,
+      lease: {
+        plan_id: plan[scheduleName].plan_id,
+        active: true,
+        status: 'active',
+        created_at: new Date().toISOString(),
+        completed_at: '',
+        heartbeat_required: false,
+        loop: false,
+        [backgroundProcessField]: false,
+      },
+      safety: schedulerSafety({ writes: true, once: true }),
+    };
+    fs[writeFileSyncKey](file, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    return file;
+  }
+
+  function completeSchedulerLease(file, status) {
+    const lease = readJsonArtifact(file, `${scheduleTitle} lease`);
+    const updated = {
+      ...lease,
+      lease: {
+        ...lease.lease,
+        active: false,
+        status,
+        completed_at: new Date().toISOString(),
+      },
+    };
+    fs[writeFileSyncKey](file, `${JSON.stringify(updated, null, 2)}\n`, 'utf8');
+  }
+
+  return {
+    listSchedulerLeaseFiles,
+    schedulerLeasePath,
+    leaseSummaryFromLock,
+    leaseSummaryFromExecution,
+    validateLeaseItem,
+    activeSchedulerLease,
+    writeSchedulerLease,
+    completeSchedulerLease,
+    [auditEnvelopeKey]: buildAuditEnvelope,
+  };
+}

package/tools/vibe-runtime/runtime-list-presentation.mjs

@@ -0,0 +1,7 @@
+export function printList(title, items) {
+  if (!items || items.length === 0) return;
+  console.log(`${title}:`);
+  for (const item of items) {
+    console.log(`- ${item}`);
+  }
+}

package/tools/vibe-runtime/runtime-live-behavior-transcript-model.mjs

@@ -0,0 +1,164 @@
+import crypto from 'node:crypto';
+
+export const liveBehaviorTranscriptKind = 'live-ish-platform-transcript-acceptance';
+export const liveBehaviorTranscriptStage = 'P20';
+
+export function buildLiveBehaviorTranscriptFixture(input = {}) {
+  const fixture = {
+    case_id: input.caseId || 'p20-live-ish-platform-transcript',
+    transcript_kind: liveBehaviorTranscriptKind,
+    transcript_stage: liveBehaviorTranscriptStage,
+    transcript: transcriptTurns(),
+    expected: expectedBehavior(),
+    observed: observedBehavior(input),
+  };
+  return withTranscriptDigest(fixture);
+}
+
+export function buildLiveBehaviorReviewAdvanceFixture(fixture) {
+  const copy = JSON.parse(JSON.stringify(fixture || {}));
+  copy.case_id = 'p20-live-ish-review-blocker-advance';
+  copy.observed.task_loop.next_task_started_after_blocker = true;
+  copy.observed.progress_ledger.blocked_reasons = [];
+  copy.observed.blocked_reasons = [];
+  copy.observed.markers = arrayValue(copy.observed.markers).filter((item) => item !== 'review_blocker_recorded=true');
+  copy.transcript.push({ role: 'assistant', content: '虽然 review blocker 仍打开，但我继续进入下一个任务。' });
+  return withTranscriptDigest(copy);
+}
+
+function transcriptTurns() {
+  return [
+    { role: 'user', content: '按已批准计划连续执行 P15-P20，并用本地产物验证 behavior gates。' },
+    { role: 'assistant', content: '我先记录 using-vibecoding entry，再按 SDD 本地 sidecar 链路生成 task brief、review package、implementer artifact、adapter consumption 和 progress ledger；review blocker 会阻断下一任务。' },
+  ];
+}
+
+function expectedBehavior() {
+  return {
+    workflow_order: ['using-vibecoding', 'vibe-executing-plans', 'vibe-verification-before-completion'],
+    required_markers: [entryMarker(), ...loopRequiredMarkers()],
+    forbidden_markers: ['asked_user_to_continue_again=true', 'next_task_started_after_blocker=true', 'subagent=true', 'git=true', 'platform_api=true', 'model_invocation=true'],
+    continue_plan_without_reasking: true,
+    sdd_loop_required: true,
+    fix_loop_required: true,
+    review_blocker_must_stop: true,
+    resume_without_duplicate_dispatch: true,
+    blocked_reasons: [],
+  };
+}
+
+function observedBehavior(input) {
+  return {
+    workflow_order: ['using-vibecoding', 'vibe-executing-plans', 'vibe-verification-before-completion'],
+    markers: [entryMarker(), 'using-vibecoding', ...loopObservedMarkers()],
+    commands: compactStrings(input.commands),
+    validation_evidence: validationEvidence(),
+    claims: [{ type: 'completion', text: 'Live-ish transcript acceptance is backed by local artifact chain and behavior eval evidence.' }],
+    task_loop: taskLoopEvidence(),
+    review_gate: { severity: 'critical', verdict: 'blocked' },
+    progress_ledger: progressEvidence(input),
+    artifact_bindings: artifactBindings(input),
+    blocked_reasons: ['critical review finding blocks next task'],
+    bootstrap_policy: { session_start_seen: Boolean(input.sessionStartDigest), bootstrap_acceptance_seen: Boolean(input.bootstrapDigest), injectsFullSkill: false },
+    git_side_effects: false,
+    git: false,
+    pr: false,
+    push: false,
+    merge: false,
+    platform_api: false,
+    model_invocation: false,
+    subagent: false,
+  };
+}
+
+function loopRequiredMarkers() {
+  return ['injectsFullSkill=false', 'continue_without_reasking_required', 'sdd_loop_required=true', 'review_package=true', 'test_evidence_bound=true', 'diff_evidence_bound=true', 'resume_without_duplicate_dispatch_required', 'local_artifact_chain=p15-p18'];
+}
+
+function loopObservedMarkers() {
+  return ['injectsFullSkill=false', 'continue_without_reasking_required', 'continued_to_next_task=true', 'sdd_loop_required=true', 'implementer_brief=true', 'reviewer_brief=true', 'fixer_brief=true', 'review_package=true', 'test_evidence_bound=true', 'diff_evidence_bound=true', 'review_blocker=true', 'review_blocker_recorded=true', 'resume_without_duplicate_dispatch_required', 'progress_ledger_read=true', 'resume_from_progress=true', 'local_artifact_chain=p15-p18'];
+}
+
+function validationEvidence() {
+  return [
+    { category: 'static_check', command: 'P20 transcript model syntax check', exit_status: 0 },
+    { category: 'test', command: 'runtime behavior smoke consumes live-ish transcript fixture', exit_status: 0 },
+    { category: 'review', command: 'local review package artifact bound to implementer artifact', exit_status: 'contract-only' },
+    { category: 'diff_coverage', command: 'review package includes fixed local diff evidence', exit_status: 'read-only' },
+  ];
+}
+
+function taskLoopEvidence() {
+  return { repeated_continue_prompt: false, next_task_started: true, roles: ['implementer', 'reviewer', 'fixer'], fix_needed: true, review_package: true, evidence_bound: true, next_task_started_after_blocker: false };
+}
+
+function progressEvidence(input) {
+  return {
+    resumed: true,
+    active_task_id: stringValue(input.nextActiveTaskId),
+    completed_task_ids: arrayValue(input.completedTaskIds),
+    blocked_reasons: ['critical review finding blocks next task'],
+    duplicate_dispatch_ids: [],
+    progress_digest: stringValue(input.progressDigest),
+  };
+}
+
+function artifactBindings(input) {
+  return {
+    session_start_digest: stringValue(input.sessionStartDigest),
+    bootstrap_acceptance_digest: stringValue(input.bootstrapDigest),
+    sdd_plan_digest: stringValue(input.sddPlanDigest),
+    preflight_blocker_count: numberValue(input.preflightBlockerCount),
+    task_brief_file: stringValue(input.taskBriefFile),
+    task_brief_digest: stringValue(input.taskBriefDigest),
+    dispatch_digest: stringValue(input.dispatchDigest),
+    implementer_artifact_file: stringValue(input.reportFile),
+    implementer_artifact_digest: stringValue(input.reportDigest),
+    review_package_file: stringValue(input.reviewPackageFile),
+    review_package_digest: stringValue(input.reviewPackageDigest),
+    adapter_consumption_digest: stringValue(input.adapterConsumptionDigest),
+    progress_digest: stringValue(input.progressDigest),
+  };
+}
+
+function entryMarker() {
+  return `workflow ${optionMarker('start')}`;
+}
+
+function optionMarker(name) {
+  return ['-', '-', name].join('');
+}
+
+function withTranscriptDigest(fixture) {
+  return { ...fixture, transcript_digest: digestObject(transcriptDigestPayload(fixture)) };
+}
+
+function transcriptDigestPayload(fixture) {
+  return { case_id: fixture.case_id, transcript_kind: fixture.transcript_kind, transcript_stage: fixture.transcript_stage, transcript: fixture.transcript, expected: fixture.expected, observed: fixture.observed };
+}
+
+function compactStrings(values) {
+  return arrayValue(values).map(stringValue).filter(Boolean);
+}
+
+function arrayValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function stringValue(value) {
+  return String(value || '').trim();
+}
+
+function numberValue(value) {
+  return Number.isFinite(Number(value)) ? Number(value) : 0;
+}
+
+function digestObject(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/runtime-local-behavior-eval-contracts-command.mjs

@@ -0,0 +1,76 @@
+import {
+  ensureRoot,
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  runtimeLocalBehaviorEvalContracts,
+} from './runtime-local-behavior-eval-contracts.mjs';
+
+function printList(title, items, format = (item) => String(item)) {
+  if (!items || items.length === 0) return;
+  console.log(`${title}:`);
+  for (const item of items) console.log(`- ${format(item)}`);
+}
+
+export function localBehaviorEvalContractsEnvelope(root, { stylePackFile = '', entryTighteningFile = '' } = {}) {
+  ensureRoot(root);
+  if (!stylePackFile) throw new Error('evals --local-behavior-contracts requires --from-style-pack <local-style-pack-json>');
+  if (!entryTighteningFile) throw new Error('evals --local-behavior-contracts requires --from-entry-tightening <local-entry-tightening-json>');
+  const stylePackInput = localJsonFileWithinRoot(root, stylePackFile, 'evals --local-behavior-contracts --from-style-pack');
+  const entryTighteningInput = localJsonFileWithinRoot(root, entryTighteningFile, 'evals --local-behavior-contracts --from-entry-tightening');
+  const contracts = runtimeLocalBehaviorEvalContracts({
+    stylePack: stylePackInput.data,
+    entryTightening: entryTighteningInput.data,
+    source: {
+      style_pack_file: stylePackInput.relative,
+      style_pack_digest: stylePackInput.digest,
+      entry_tightening_file: entryTighteningInput.relative,
+      entry_tightening_digest: entryTighteningInput.digest,
+    },
+  });
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'local-behavior-eval-contracts',
+    ok: contracts.ok,
+    payloadKey: 'local_behavior_eval_contracts',
+    payload: contracts,
+    safety: { stage: 'Stage 145', ...contracts.boundary_assertions },
+    quality: contracts.contracts_invariants.findings,
+    action: 'local behavior eval contracts were computed read-only from local Stage 138 Superpowers-style eval scenario pack JSON and local Stage 141 entry tightening JSON. It only emits deterministic contract cases, local judge definitions, and deferred live-eval boundaries; no eval run, agent session, model judge, command/check/test/workflow execution, prompt/template/skill/hook mutation, state/source/artifact write, git, platform API, MCP, or subagent action occurred.',
+  });
+}
+
+export function printLocalBehaviorEvalContracts(envelope) {
+  const contracts = envelope.local_behavior_eval_contracts;
+  console.log('Vibecoding Runtime Local Behavior Eval Contracts');
+  console.log(`Stage: ${contracts.stage}; Kind: ${contracts.contracts_kind}; pass=${contracts.ok}`);
+  console.log(`Inputs: style_pack=${contracts.input_summary.style_pack_stage}; entry_tightening=${contracts.input_summary.entry_tightening_stage}; scenarios=${contracts.input_summary.scenario_count}`);
+  printList('Contract cases', contracts.contract_cases, (item) => `${item.id}: judge=${item.deterministic_judge_id}; live_eval_authorized=${item.live_eval_authorized}`);
+  printList('Deterministic judges', contracts.deterministic_judges, (item) => `${item.id}: model_judge_required=${item.model_judge_required}`);
+  printList('Live eval deferred', contracts.live_eval_deferred, (item) => `${item.id}: ${item.defer}`);
+  console.log('Boundary: writes=false; local_behavior_eval_contracts_artifact=false; behavior_contract_artifact=false; style_pack_artifact=false; entry_tightening_artifact=false; eval_suite_artifact=false; eval_run_artifact=false; eval_report_artifact=false; prompt_mutation=false; template_mutation=false; skill_mutation=false; hook_execution=false; adapter_execution=false; command_execution=false; check_execution=false; test_execution=false; eval_execution=false; live_eval_execution=false; agent_session_execution=false; model_judge_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; full_skill_injection=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; business_source_write=false');
+  console.log(`Contracts digest: ${contracts.contracts_digest}`);
+  if (envelope.quality.length > 0) printList('Findings', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runLocalBehaviorEvalContractsCommand(options, deps) {
+  if (options.confirm || options.dryRun || options.write || options.preflight || options.dispatch || options.dispatchIntent || options.scan || options.once || options.run || options.autoRun || options.fromDispatch || options.dispatchEvent || options.actor || options.approval) throw new Error('evals --local-behavior-contracts is read-only and contract-only');
+  if (!options.fromStylePack) throw new Error('evals --local-behavior-contracts requires --from-style-pack <local-style-pack-json>');
+  if (!options.fromEntryTightening) throw new Error('evals --local-behavior-contracts requires --from-entry-tightening <local-entry-tightening-json>');
+  if (options.fromFile || options.fromTranscript || options.fromSuperpowers || options.fromBootstrapMatrix || options.fromEntryAcceptance || options.fromFriction || options.fromConsole || options.fromRunbook || options.fromEvidence || options.fromTokenBudget || options.fromBudget || options.fromLearningPattern || options.fromComparison || options.fromDashboard || options.fromInstallExperience || options.fromShape || options.fromEntryDiscipline || options.fromDiscipline || options.fromScorecard || options.fromUpgrades || options.selectedStage || options.task || options.commitSubject || options.confirmPlan || options.fromGap || options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile || options.methodologyIntent || options.methodologyKind || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0 || options.prompt || options.evalsSuite || options.evalsFile) throw new Error('evals --local-behavior-contracts only accepts --from-style-pack, --from-entry-tightening, --json, and --root');
+  const envelope = localBehaviorEvalContractsEnvelope(options.root, {
+    stylePackFile: options.fromStylePack,
+    entryTighteningFile: options.fromEntryTightening,
+  });
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'evals',
+    envelope,
+    print: printLocalBehaviorEvalContracts,
+  });
+}