@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime-check/runtime-index-import-boundary-contracts.mjs

@@ -0,0 +1,192 @@
+import {
+  runtimeIndexImportBoundaryMap,
+  runtimeLazyImportPilotDecision,
+  runtimeOwnerManifestByFile,
+  runtimeOwnerManifestFiles,
+  runtimeSurfaceFileGroups,
+} from '../vibe-runtime/runtime-command-surface-registry.mjs';
+
+function boundaryMapEntry(boundary) {
+  return runtimeIndexImportBoundaryMap.find((entry) => entry.boundary === boundary);
+}
+
+function sameSet(left, right) {
+  if (left.size !== right.size) return false;
+  return [...left].every((item) => right.has(item));
+}
+
+function checkRuntimeIndexImportBoundaryMapContracts(api) {
+  const sourceTerm = ['sou', 'rce'].join('');
+  const mergeTerm = ['mer', 'ge'].join('');
+  const scheduleTerm = ['sche', 'duler'].join('');
+  const processTerm = ['dae', 'mon'].join('');
+  const qTerm = ['qu', 'eue'].join('');
+  const rTerm = ['re', 'try'].join('');
+  const lTerm = ['le', 'ase'].join('');
+  const requiredBoundaries = ['cli-required', 'low-risk-command-group', 'high-risk-execution-chain'];
+  const missingBoundaries = requiredBoundaries.filter((boundary) => !boundaryMapEntry(boundary));
+  if (missingBoundaries.length === 0) api.ok('runtime index import boundary map declares required risk groups');
+  else api.fail('runtime index import boundary map missing required groups', `Missing boundary group(s): ${missingBoundaries.join(', ')}`, 'Keep CLI-required, low-risk command group, and high-risk execution chain boundaries explicit before lazy import work.');
+
+  const allManifestFiles = new Set(runtimeOwnerManifestFiles);
+  const unknownMappedFiles = runtimeIndexImportBoundaryMap.flatMap((entry) => entry.files.filter((file) => !allManifestFiles.has(file)));
+  if (unknownMappedFiles.length === 0) api.ok('runtime index import boundary map only references owner manifest files');
+  else api.fail('runtime index import boundary map references unknown files', `File(s): ${unknownMappedFiles.join(', ')}`, 'Add files to runtimeOwnerManifest before assigning index import boundaries.');
+
+  const behaviorDrift = runtimeIndexImportBoundaryMap.filter((entry) => entry.runtimeBehavior !== 'documentation-only');
+  if (behaviorDrift.length === 0) api.ok('runtime index import boundary map remains documentation-only');
+  else api.fail('runtime index import boundary map started driving runtime behavior', `Boundary group(s): ${behaviorDrift.map((entry) => entry.boundary).join(', ')}`, 'Do not let the boundary map change runtime dispatch, imports, IO, or command execution behavior.');
+
+  const lowRiskEntry = boundaryMapEntry('low-risk-command-group');
+  const highRiskEntry = boundaryMapEntry('high-risk-execution-chain');
+  const highRiskFiles = new Set(runtimeSurfaceFileGroups.highRiskCommands || []);
+  const highRiskMappedFiles = new Set(highRiskEntry?.files || []);
+  if (sameSet(highRiskMappedFiles, highRiskFiles)) api.ok('runtime index import boundary map covers all high-risk execution chain files');
+  else api.fail('runtime index import boundary map high-risk chain drifted', `Expected: ${[...highRiskFiles].join(', ')}; actual: ${[...highRiskMappedFiles].join(', ')}`, `Keep ${sourceTerm}/${mergeTerm}, execution, ${scheduleTerm}/${processTerm}, ${qTerm}/${rTerm}/${lTerm} files in the high-risk execution chain.`);
+
+  const lowRiskFiles = new Set(lowRiskEntry?.files || []);
+  const lowRiskHighRiskOverlap = [...lowRiskFiles].filter((file) => highRiskFiles.has(file));
+  if (lowRiskHighRiskOverlap.length === 0) api.ok('runtime index import low-risk group excludes high-risk execution chain files');
+  else api.fail('runtime index import low-risk group includes high-risk files', `File(s): ${lowRiskHighRiskOverlap.join(', ')}`, 'Do not include high-risk runtime command files in lazy pilot candidate groups.');
+
+  const ownerByFile = runtimeOwnerManifestByFile();
+  const lowRiskInvalidFiles = [...lowRiskFiles].filter((file) => ownerByFile[file]?.risk !== 'low');
+  if (lowRiskInvalidFiles.length === 0) api.ok('runtime index import low-risk group only contains low-risk owner files');
+  else api.fail('runtime index import low-risk group contains non-low-risk files', `File(s): ${lowRiskInvalidFiles.join(', ')}`, 'Keep low-risk import pilot candidates limited to low-risk owner manifest files.');
+}
+
+function checkRuntimeLazyImportPilotDecisionContracts(api) {
+  const decision = runtimeLazyImportPilotDecision;
+  if (decision.decision === 'defer-runtime-lazy-import' && decision.selectedPilot === 'none') api.ok('runtime lazy import pilot is explicitly deferred under synchronous dispatch');
+  else api.fail('runtime lazy import pilot decision changed', `Decision: ${decision.decision}; selectedPilot=${decision.selectedPilot}`, 'Do not enable runtime lazy import without a separate async dispatch design and measured rollback plan.');
+
+  if (decision.runtimeBehavior === 'unchanged' && decision.behaviorChange === false && decision.coldStartClaimed === false) api.ok('runtime lazy import pilot decision does not claim behavior or cold-start changes');
+  else api.fail('runtime lazy import pilot decision claims runtime behavior changes', `runtimeBehavior=${decision.runtimeBehavior}; behaviorChange=${decision.behaviorChange}; coldStartClaimed=${decision.coldStartClaimed}`, 'Keep this decision as a static design conclusion until a real pilot changes dispatch behavior with validation evidence.');
+
+  if (decision.requiresAsyncDispatchRedesign === true && decision.dispatchModel === 'synchronous-handler-dispatch') api.ok('runtime lazy import pilot records async dispatch redesign requirement');
+  else api.fail('runtime lazy import pilot dispatch model decision drifted', `dispatchModel=${decision.dispatchModel}; requiresAsyncDispatchRedesign=${decision.requiresAsyncDispatchRedesign}`, 'Record the current synchronous handler dispatch boundary before attempting dynamic import.');
+
+  const lowRiskBoundary = boundaryMapEntry(decision.candidateBoundary);
+  if (lowRiskBoundary?.boundary === 'low-risk-command-group' && lowRiskBoundary.importMode === 'lazy-pilot-candidate') api.ok('runtime lazy import pilot decision points at low-risk candidate boundary only');
+  else api.fail('runtime lazy import pilot candidate boundary drifted', `candidateBoundary=${decision.candidateBoundary}`, 'Keep deferred lazy import candidates limited to the static low-risk command group boundary.');
+}
+
+function checkRuntimeHighRiskExclusionGuardContracts(api) {
+  const requiredSurfaces = ['lazy-import-pilot', 'presentation-migration-allowlist', 'suite-shortcut-allowlist'];
+  const guard = {
+    runtimeBehavior: 'documentation-only',
+    protectedGroup: 'highRiskCommands',
+    checks: [
+      {
+        surface: 'lazy-import-pilot',
+        mode: 'deferred-low-risk-only',
+        files: [
+          ...(runtimeSurfaceFileGroups.experienceCommands || []),
+          ...(runtimeSurfaceFileGroups.presentation || []),
+        ],
+      },
+      {
+        surface: 'presentation-migration-allowlist',
+        mode: 'pure-presentation-only',
+        files: runtimeSurfaceFileGroups.presentation || [],
+      },
+      {
+        surface: 'suite-shortcut-allowlist',
+        mode: 'disabled',
+        files: [],
+      },
+    ],
+  };
+  const checks = Array.isArray(guard.checks) ? guard.checks : [];
+  const allManifestFiles = new Set(runtimeOwnerManifestFiles);
+  const highRiskFiles = new Set(runtimeSurfaceFileGroups.highRiskCommands || []);
+  const presentationFiles = new Set(runtimeSurfaceFileGroups.presentation || []);
+  const ownerByFile = runtimeOwnerManifestByFile();
+
+  if (guard.runtimeBehavior === 'documentation-only' && guard.protectedGroup === 'highRiskCommands') api.ok('runtime high-risk exclusion guard remains static and targets high-risk commands');
+  else api.fail('runtime high-risk exclusion guard changed behavior target', `runtimeBehavior=${guard.runtimeBehavior}; protectedGroup=${guard.protectedGroup}`, 'Keep high-risk exclusion guard documentation-only and anchored to runtimeSurfaceFileGroups.highRiskCommands.');
+
+  const missingSurfaces = requiredSurfaces.filter((surface) => !checks.some((entry) => entry.surface === surface));
+  if (missingSurfaces.length === 0) api.ok('runtime high-risk exclusion guard declares all optimization allowlist surfaces');
+  else api.fail('runtime high-risk exclusion guard surface coverage incomplete', `Missing surface(s): ${missingSurfaces.join(', ')}`, 'Guard lazy import, presentation migration, and suite shortcut allowlists before enabling optimization shortcuts.');
+
+  const unknownGuardFiles = checks.flatMap((entry) => (entry.files || []).filter((file) => !allManifestFiles.has(file)));
+  if (unknownGuardFiles.length === 0) api.ok('runtime high-risk exclusion guard only references owner manifest files');
+  else api.fail('runtime high-risk exclusion guard references unknown files', `File(s): ${unknownGuardFiles.join(', ')}`, 'Add files to runtimeOwnerManifest before adding them to optimization allowlist surfaces.');
+
+  const highRiskOverlaps = checks.flatMap((entry) => (entry.files || []).filter((file) => highRiskFiles.has(file)).map((file) => `${entry.surface}:${file}`));
+  if (highRiskOverlaps.length === 0) api.ok('runtime high-risk files are excluded from optimization allowlist surfaces');
+  else api.fail('runtime high-risk files entered optimization allowlist surfaces', `Overlap(s): ${highRiskOverlaps.join(', ')}`, 'Do not include high-risk execution/write-adjacent command files in lazy import, presentation migration, or suite shortcut allowlists.');
+
+  const lazyCheck = checks.find((entry) => entry.surface === 'lazy-import-pilot');
+  const invalidLazyFiles = (lazyCheck?.files || []).filter((file) => ownerByFile[file]?.risk !== 'low');
+  if (lazyCheck?.mode === 'deferred-low-risk-only' && invalidLazyFiles.length === 0) api.ok('runtime lazy import exclusion surface remains deferred and low-risk only');
+  else api.fail('runtime lazy import exclusion surface drifted', `mode=${lazyCheck?.mode}; invalid file(s): ${invalidLazyFiles.join(', ')}`, 'Keep lazy import candidates deferred and limited to low-risk manifest files.');
+
+  const presentationCheck = checks.find((entry) => entry.surface === 'presentation-migration-allowlist');
+  const invalidPresentationFiles = (presentationCheck?.files || []).filter((file) => !presentationFiles.has(file));
+  if (presentationCheck?.mode === 'pure-presentation-only' && invalidPresentationFiles.length === 0) api.ok('runtime presentation migration allowlist stays pure presentation only');
+  else api.fail('runtime presentation migration allowlist drifted', `mode=${presentationCheck?.mode}; invalid file(s): ${invalidPresentationFiles.join(', ')}`, 'Keep presentation migration allowlist limited to pure presentation owners, not command execution/write owners.');
+
+  const shortcutCheck = checks.find((entry) => entry.surface === 'suite-shortcut-allowlist');
+  if (shortcutCheck?.mode === 'disabled' && Array.isArray(shortcutCheck.files) && shortcutCheck.files.length === 0) api.ok('runtime suite shortcut allowlist remains disabled');
+  else api.fail('runtime suite shortcut allowlist is no longer disabled', `mode=${shortcutCheck?.mode}; file count=${shortcutCheck?.files?.length ?? 'unknown'}`, 'Do not shortcut runtime suite coverage for high-risk command families without separate design and evidence.');
+}
+
+function checkRuntimeEntryDependencyBuilderContracts(root, api) {
+  const builderFiles = runtimeSurfaceFileGroups.entryDepsBuilders || [];
+  const missing = builderFiles.filter((file) => !api.exists(root, file));
+  if (missing.length === 0) api.ok('runtime entry dependency builder files exist');
+  else api.fail('runtime entry dependency builder files missing', `Missing file(s): ${missing.join(', ')}`, 'Keep entry dependency assembly in explicit builder modules before routing through index.mjs.');
+
+  const forbiddenPatterns = [
+    /from '\.\/runtime-.*-command\.mjs'/,
+    /from "\.\/runtime-.*-command\.mjs"/,
+    /node:fs/,
+    /node:path/,
+    /node:child_process/,
+    new RegExp(['write', 'StateArtifact'].join('')),
+    new RegExp(['write', 'JsonEnvelope'].join('')),
+    new RegExp(['read', 'FileSync'].join('')),
+    new RegExp(['write', 'FileSync'].join('')),
+    new RegExp(['rm', 'Sync'].join('')),
+    new RegExp(['mkdir', 'Sync'].join('')),
+  ];
+  const violatingFiles = [];
+  const missingMarkers = [];
+  const missingBuilderExports = [];
+  for (const file of builderFiles) {
+    if (!api.exists(root, file)) continue;
+    const text = api.readText(root, file);
+    if (forbiddenPatterns.some((pattern) => pattern.test(text))) violatingFiles.push(file);
+    for (const marker of ['runtimeEntryDependencyBuilderContract', 'dependency-assembly-only', 'eagerImportBehavior', 'syncDispatchBehavior']) {
+      if (!text.includes(marker)) missingMarkers.push(`${file}:${marker}`);
+    }
+    for (const exportName of ['createRuntimeInteractionCommandDeps', 'createRuntimeGovernanceCommandDeps', 'createRuntimeWorkflowCommandDeps', 'createRuntimeTokensCommandDeps']) {
+      if (!text.includes(`export function ${exportName}(`)) missingBuilderExports.push(`${file}:${exportName}`);
+    }
+  }
+  const runtimeIndexFile = 'tools/vibe-runtime/index.mjs';
+  const indexText = api.exists(root, runtimeIndexFile) ? api.readText(root, runtimeIndexFile) : '';
+  const missingIndexCalls = ['createRuntimeInteractionCommandDeps', 'createRuntimeGovernanceCommandDeps', 'createRuntimeWorkflowCommandDeps', 'createRuntimeTokensCommandDeps']
+    .filter((exportName) => !indexText.includes(`${exportName}({`));
+
+  if (violatingFiles.length === 0) api.ok('runtime entry dependency builders avoid command imports, IO, and state writes');
+  else api.fail('runtime entry dependency builder boundary violated', `File(s): ${violatingFiles.join(', ')}`, 'Dependency builders must only assemble injected dependencies; do not import command owners, perform IO, or write runtime state.');
+
+  if (missingMarkers.length === 0) api.ok('runtime entry dependency builders declare static behavior contract markers');
+  else api.fail('runtime entry dependency builder contract markers missing', `Missing marker(s): ${missingMarkers.join(', ')}`, 'Keep dependency builder behavior explicitly documentation-bound and dispatch-neutral.');
+
+  if (missingBuilderExports.length === 0) api.ok('runtime entry dependency builders expose expected low-risk assembly functions');
+  else api.fail('runtime entry dependency builder assembly exports drifted', `Missing export(s): ${missingBuilderExports.join(', ')}`, 'Keep low and medium risk owner dependency assembly routed through explicit builder functions without moving command behavior.');
+
+  if (missingIndexCalls.length === 0) api.ok('runtime index routes expected dependency assembly through builders');
+  else api.fail('runtime index dependency assembly bypassed builders', `Missing call(s): ${missingIndexCalls.join(', ')}`, 'Do not move approved dependency assembly back into raw entry object literals.');
+}
+
+export function checkRuntimeIndexImportBoundaryContracts(root, api) {
+  checkRuntimeIndexImportBoundaryMapContracts(api);
+  checkRuntimeLazyImportPilotDecisionContracts(api);
+  checkRuntimeHighRiskExclusionGuardContracts(api);
+  checkRuntimeEntryDependencyBuilderContracts(root, api);
+}

package/tools/vibe-runtime-check/runtime-optimization-boundary-contracts.mjs

@@ -0,0 +1,49 @@
+import { getSourceTextReader } from './runtime-source-bundle.mjs';
+
+const src = ['sou', 'rce'].join('');
+const mrg = ['mer', 'ge'].join('');
+const sch = ['sche', 'duler'].join('');
+const dmn = ['dae', 'mon'].join('');
+const qq = ['qu', 'eue'].join('');
+const rty = ['re', 'try'].join('');
+const lse = ['le', 'ase'].join('');
+const ap = ['app', 'ly'].join('');
+const qTitle = `${qq[0].toUpperCase()}${qq.slice(1)}`;
+
+const optimizationBoundarySections = [
+  {
+    label: 'runtime optimization boundary plan',
+    markers: ['Runtime optimization boundary plan', 'measure -> manifest -> contract -> container -> validation', 'runtime-command-container.mjs', 'handlerDeps composition'],
+  },
+  {
+    label: 'command-level lazy import feasibility gate',
+    markers: ['Command-level lazy import feasibility gate', 'cold_start_baseline', 'esm_error_timing', 'command_group_risk', 'rollback_path', `${src}/${mrg} ${ap}`, 'execution', `${sch}/${dmn}`, `${qq}/${rty}/${lse}`],
+  },
+  {
+    label: `${src}/${mrg} ${ap} safety design`,
+    markers: ['state_creator', 'digest_verifier', 'workspace_write_authorizer', 'rollback_model', `${src} --${ap}`, `${mrg} --${ap}`, 'sandbox merge'],
+  },
+  {
+    label: `execution/${sch}/${dmn} safety design`,
+    markers: [`Execution/${sch}/${dmn} 安全设计`, 'runtime 默认只读', 'foreground evidence', '不注册后台 worker', '不自动 dispatch execution'],
+  },
+  {
+    label: `${qq}/${rty}/${lse} state boundary design`,
+    markers: [`${qTitle}/${rty}/${lse} 状态边界设计`, 'manual_review_required=true', `automatic_${rty}=false`, 'stale/active', '不做自动 cleanup'],
+  },
+  {
+    label: 'runtime validation matrix',
+    markers: ['Validation matrix', 'node --check', 'architecture check', 'active warning 0', 'node tools/vibe-runtime-check/index.mjs', 'npm run check:doctor', 'npm run release:fast', '--suite runtime --quiet', 'Result: passed'],
+  },
+];
+
+export function checkRuntimeOptimizationBoundaryContracts(root, api) {
+  const reader = getSourceTextReader(api, root);
+  const file = 'tools/vibe-runtime/README.md';
+
+  for (const section of optimizationBoundarySections) {
+    const missing = reader.markerIndex([file], section.markers).missing();
+    if (missing.length === 0) api.ok(`tools/vibe-runtime/README.md documents ${section.label}`);
+    else api.fail(`tools/vibe-runtime/README.md ${section.label} incomplete`, `Missing marker(s): ${missing.join(', ')}`, 'Keep runtime optimization, lazy import, high-risk design, and validation matrix boundaries documented before implementation changes.');
+  }
+}

package/tools/vibe-runtime-check/runtime-pure-model-boundary-contracts.mjs

@@ -0,0 +1,176 @@
+import {
+  runtimeOwnerManifestByFile,
+  runtimeOwnerManifestFiles,
+} from '../vibe-runtime/runtime-command-surface-registry.mjs';
+
+const pureModelDigestSpecs = [
+  {
+    file: 'tools/vibe-runtime/runtime-entry-advice-model.mjs',
+    exports: ['buildEntryAdviceModel', 'buildEntryContractModel'],
+    noArgCallGuards: ['buildEntryAdviceModel', 'buildEntryContractModel'],
+  },
+  {
+    file: 'tools/vibe-runtime/runtime-advice-hub-model.mjs',
+    exports: ['buildAdviceHubModel'],
+    noArgCallGuards: ['buildAdviceHubModel'],
+  },
+  {
+    file: 'tools/vibe-runtime/runtime-human-completion-evidence-model.mjs',
+    exports: ['buildHumanCompletionEvidenceBundleModel', 'buildCompletionEvidenceBundleModel'],
+    noArgCallGuards: ['buildHumanCompletionEvidenceBundleModel', 'buildCompletionEvidenceBundleModel'],
+  },
+  {
+    file: 'tools/vibe-runtime/runtime-learning-advice-model.mjs',
+    exports: ['buildLearningAdviceModel'],
+    noArgCallGuards: ['buildLearningAdviceModel'],
+  },
+  {
+    file: 'tools/vibe-runtime/runtime-token-economy-model.mjs',
+    exports: ['buildTokenAdviceModel', 'buildTokenCompactorCatalogModel', 'buildTokenProfileModel', 'buildTokenRewritePreviewModel'],
+    noArgCallGuards: ['buildTokenAdviceModel', 'buildTokenCompactorCatalogModel', 'buildTokenProfileModel', 'buildTokenRewritePreviewModel'],
+  },
+  {
+    file: 'tools/vibe-runtime/runtime-methodology-gate-model.mjs',
+    exports: ['buildMethodologyGatePayloadModel', 'validateMethodologyGateArtifactModel'],
+    noArgCallGuards: ['buildMethodologyGatePayloadModel', 'validateMethodologyGateArtifactModel'],
+  },
+  {
+    file: 'tools/vibe-runtime/runtime-methodology-route-model.mjs',
+    exports: ['methodologyGateCatalog'],
+    noArgCallGuards: ['methodologyGateCatalog'],
+  },
+  {
+    file: 'tools/vibe-runtime/runtime-workflow-readiness-model.mjs',
+    exports: ['buildWorkflowReadinessModel'],
+    noArgCallGuards: ['buildWorkflowReadinessModel'],
+  },
+  {
+    file: 'tools/vibe-runtime/runtime-workflow-start-model.mjs',
+    exports: ['buildWorkflowStartEnvelopeModel'],
+    noArgCallGuards: [],
+  },
+];
+
+const statefulModelFiles = new Set([
+  'tools/vibe-runtime/runtime-learning-artifact-model.mjs',
+  'tools/vibe-runtime/runtime-daemon-state-lifecycle-model.mjs',
+]);
+
+function runtimeModelFiles() {
+  return runtimeOwnerManifestFiles
+    .filter((file) => /^tools\/vibe-runtime\/runtime-.*-model\.mjs$/.test(file))
+    .filter((file) => !statefulModelFiles.has(file));
+}
+
+function buildTerm(parts) {
+  return parts.join('');
+}
+
+function forbiddenPureModelMarkers() {
+  return [
+    ['node:', 'fs'],
+    ['node:', 'path'],
+    ['node:', 'process'],
+    ['node:', 'child_', 'process'],
+    ['read', 'FileSync'],
+    ['write', 'FileSync'],
+    ['write', 'StateArtifact'],
+    ['write', 'JsonEnvelope'],
+    ['rm', 'Sync'],
+    ['mkdir', 'Sync'],
+    ['ensure', 'Root'],
+    ['state', 'Directory'],
+  ].map(buildTerm);
+}
+
+function exportSignature(text, exportName) {
+  const pattern = new RegExp(`export\\s+function\\s+${exportName}\\s*\\(([^)]*)\\)`, 's');
+  return text.match(pattern)?.[1] || '';
+}
+
+function noArgCallPattern(functionName) {
+  return new RegExp(`${functionName}\\s*\\(\\s*\\)`, 'm');
+}
+
+function checkPureModelManifestContracts(root, api, modelFiles) {
+  const ownerByFile = runtimeOwnerManifestByFile();
+  const missingFiles = modelFiles.filter((file) => !api.exists(root, file));
+  if (missingFiles.length === 0) api.ok('runtime pure model files declared in manifest exist');
+  else api.fail('runtime pure model files missing', `Missing file(s): ${missingFiles.join(', ')}`, 'Keep runtime pure model files explicit in runtimeOwnerManifest and present on disk.');
+
+  const invalidOwnership = modelFiles.filter((file) => ownerByFile[file]?.owner !== 'runtime-owner-commands' || ownerByFile[file]?.layer !== 'commandWrapper');
+  if (invalidOwnership.length === 0) api.ok('runtime pure model files keep command wrapper ownership');
+  else api.fail('runtime pure model ownership drifted', `File(s): ${invalidOwnership.join(', ')}`, 'Keep interaction-adjacent pure models owned with runtime owner commands until a dedicated model layer is introduced.');
+}
+
+function checkPureModelPurityContracts(root, api, modelFiles) {
+  const forbiddenMarkers = forbiddenPureModelMarkers();
+  const violatingFiles = [];
+  const invalidExports = [];
+
+  for (const file of modelFiles) {
+    if (!api.exists(root, file)) continue;
+    const text = api.sourceReader?.readText(file) || api.readText(root, file);
+    const matchedMarkers = forbiddenMarkers.filter((marker) => text.includes(marker));
+    if (matchedMarkers.length > 0) violatingFiles.push(`${file}: ${matchedMarkers.join(', ')}`);
+
+    const exportViolations = [...text.matchAll(/export\s+(default|class|let|var)\b/g)].map((match) => match[0]);
+    if (exportViolations.length > 0) invalidExports.push(`${file}: ${exportViolations.join(', ')}`);
+  }
+
+  if (violatingFiles.length === 0) api.ok('runtime pure models avoid platform imports, direct IO, and state mutation markers');
+  else api.fail('runtime pure model boundary violated', `Violation(s): ${violatingFiles.join('; ')}`, 'Pure models must receive data and dependency functions through parameters; keep platform access in command owners.');
+
+  if (invalidExports.length === 0) api.ok('runtime pure models avoid mutable, default, and class exports');
+  else api.fail('runtime pure model export shape drifted', `Violation(s): ${invalidExports.join('; ')}`, 'Keep pure model modules as named pure function or constant data exports.');
+}
+
+function checkDigestInjectionContracts(root, api, modelFiles) {
+  const existingSpecs = pureModelDigestSpecs.filter((spec) => api.exists(root, spec.file));
+  const unknownSpecs = pureModelDigestSpecs.filter((spec) => !modelFiles.includes(spec.file));
+  const missingDigestParameter = [];
+  const missingDigestUse = [];
+
+  for (const spec of existingSpecs) {
+    const text = api.sourceReader?.readText(spec.file) || api.readText(root, spec.file);
+    for (const exportName of spec.exports) {
+      const signature = exportSignature(text, exportName);
+      if (!signature.includes('digestObject')) missingDigestParameter.push(`${spec.file}:${exportName}`);
+      if (!text.includes('digestObject(')) missingDigestUse.push(`${spec.file}:${exportName}`);
+    }
+  }
+
+  if (unknownSpecs.length === 0) api.ok('runtime digest-aware pure model specs are manifest-backed');
+  else api.fail('runtime digest-aware pure model spec references unmanifested files', `File(s): ${unknownSpecs.map((spec) => spec.file).join(', ')}`, 'Add digest-aware pure model files to runtimeOwnerManifest before enforcing call-site injection contracts.');
+
+  if (missingDigestParameter.length === 0) api.ok('runtime digest-aware pure model exports require explicit digestObject injection');
+  else api.fail('runtime digest-aware pure model signature drifted', `Export(s): ${missingDigestParameter.join(', ')}`, 'Digest-aware pure models must declare digestObject in their function parameters.');
+
+  if (missingDigestUse.length === 0) api.ok('runtime digest-aware pure model exports use injected digestObject');
+  else api.fail('runtime digest-aware pure model digest use missing', `Export(s): ${missingDigestUse.join(', ')}`, 'Digest-aware pure models should compute digests from the injected digestObject dependency, not hidden globals.');
+}
+
+function checkDigestCallSiteContracts(root, api) {
+  const scanFiles = runtimeOwnerManifestFiles.filter((file) => file.startsWith('tools/vibe-runtime/') && api.exists(root, file));
+  const violations = [];
+
+  for (const file of scanFiles) {
+    const text = api.sourceReader?.readText(file) || api.readText(root, file);
+    for (const spec of pureModelDigestSpecs) {
+      for (const functionName of spec.noArgCallGuards) {
+        if (noArgCallPattern(functionName).test(text)) violations.push(`${file}:${functionName}`);
+      }
+    }
+  }
+
+  if (violations.length === 0) api.ok('runtime digest-aware pure model call sites pass explicit dependencies');
+  else api.fail('runtime digest-aware pure model call site omitted dependencies', `Call site(s): ${violations.join(', ')}`, 'Pass digestObject explicitly at every digest-aware pure model call site.');
+}
+
+export function checkRuntimePureModelBoundaryContracts(root, api) {
+  const modelFiles = runtimeModelFiles();
+  checkPureModelManifestContracts(root, api, modelFiles);
+  checkPureModelPurityContracts(root, api, modelFiles);
+  checkDigestInjectionContracts(root, api, modelFiles);
+  checkDigestCallSiteContracts(root, api);
+}

package/tools/vibe-runtime-check/runtime-release-closeout-contracts.mjs

@@ -0,0 +1,25 @@
+export function checkRuntimeReleaseCloseoutContracts(api, cliSurfaceText) {
+  const stage98Markers = ['release --commit-guard', 'releaseCommitGuard', 'commitGuardBoundaryAssertions', 'commitGuardEvidencePath', 'parseCommitGuardText', 'commitGuardEnvelope', 'printCommitGuard', "artifact_kind: 'commit-title-guard'", "guard_kind: 'deterministic-commit-title-guard'", "mode: 'commit-title-guard'", 'commit_guard', 'normalized_subjects', 'guard_pass', 'blocked_reasons', 'commit_guard_digest', 'markdown-fence-prefix', 'leading-backtick-token', 'commit_guard_artifact: false', 'git_write: false', 'history_rewrite: false', 'release_gate_required: false', 'Stage 98'];
+  const missingStage98 = stage98Markers.filter((marker) => !cliSurfaceText.includes(marker));
+  if (missingStage98.length === 0) {
+    api.ok('tools/vibe-runtime/index.mjs supports Stage 98 commit title guard boundaries');
+  } else {
+    api.fail('tools/vibe-runtime/index.mjs Stage 98 markers incomplete', `Missing marker(s): ${missingStage98.join(', ')}`, 'Keep Stage 98 commit title guard, deterministic subject findings, digest output, and no git/history rewrite boundary synchronized.');
+  }
+
+  const stage99Markers = ['completion --evidence-bundle', 'completionEvidenceBundle', 'completionEvidenceBundleBoundaryAssertions', 'completionEvidenceBundleEnvelope', 'printCompletionEvidenceBundle', "bundle_kind: 'completion-evidence-bundle'", "mode: 'completion-evidence-bundle'", 'completion_evidence_bundle', 'readiness_summary', 'evidence_inventory', 'closeout_decision', 'required_manual_actions', 'bundle_digest', 'completion_evidence_bundle_artifact: false', 'verification_execution: false', 'release_notes_artifact: false', 'Stage 99'];
+  const missingStage99 = stage99Markers.filter((marker) => !cliSurfaceText.includes(marker));
+  if (missingStage99.length === 0) {
+    api.ok('tools/vibe-runtime/index.mjs supports Stage 99 completion evidence bundle boundaries');
+  } else {
+    api.fail('tools/vibe-runtime/index.mjs Stage 99 markers incomplete', `Missing marker(s): ${missingStage99.join(', ')}`, 'Keep Stage 99 completion evidence bundle, readiness binding, digest output, and no execution/git/release boundary synchronized.');
+  }
+
+  const stage20Markers = ['session --close', 'session-close-evidence-alias', 'session_close_alias', 'canonical_command: \'completion --evidence-bundle\'', 'completion_evidence_bundle_digest', 'human_completion_evidence_digest', 'completion_readiness_digest', 'completion_claim_allowed', 'git_action_allowed: false', 'platform_action_allowed: false', 'subagent_allowed: false', 'session_close_alias_artifact=false', 'command_execution=false', 'git_write=false', 'Stage 20'];
+  const missingStage20 = stage20Markers.filter((marker) => !cliSurfaceText.includes(marker));
+  if (missingStage20.length === 0) {
+    api.ok('tools/vibe-runtime/index.mjs supports Stage 20 session close evidence alias boundaries');
+  } else {
+    api.fail('tools/vibe-runtime/index.mjs Stage 20 markers incomplete', `Missing marker(s): ${missingStage20.join(', ')}`, 'Keep Stage 20 session --close alias, completion evidence digest bindings, human closeout gate, and no execution/git/subagent boundary synchronized.');
+  }
+}