@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-adapter-bootstrap-matrix.mjs

@@ -0,0 +1,264 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const adapterBootstrapStage = 'Stage 122';
+const adapterBootstrapKind = 'adapter-bootstrap-conformance-matrix';
+const expectedAdapters = ['claude', 'cursor', 'codex'];
+
+const adapterSpecs = {
+  claude: {
+    required_files: ['plugin.json', 'install.md', 'settings.example.json'],
+    entry_file: 'CLAUDE.md',
+    install_markers: ['using-vibecoding', 'session-start.mjs --format claude', '不会注入完整 skill', '写 `.vibecoding-state/`', 'subagent', 'git', 'worktree'],
+  },
+  cursor: {
+    required_files: ['plugin.json', 'install.md', 'hooks.example.json'],
+    entry_file: 'AGENTS.md',
+    install_markers: ['using-vibecoding', 'session-start.mjs --format cursor', '不会注入完整 skill', '写 `.vibecoding-state/`', 'subagent', 'git', 'worktree'],
+  },
+  codex: {
+    required_files: ['plugin.json', 'install.md', 'hooks.example.json'],
+    entry_file: 'AGENTS.md',
+    install_markers: ['using-vibecoding', 'session-start.mjs --format codex', '不会注入完整 skill', '写 `.vibecoding-state/`', 'subagent', 'git', 'worktree'],
+  },
+};
+
+export function runtimeAdapterBootstrapMatrix(root) {
+  const rows = expectedAdapters.map((adapter) => adapterBootstrapRow(root, adapter));
+  const gateResults = adapterBootstrapGateResults(rows);
+  const boundaryAssertions = runtimeAdapterBootstrapBoundaryAssertions();
+  const matrixCore = {
+    version: 1,
+    stage: adapterBootstrapStage,
+    matrix_kind: adapterBootstrapKind,
+    source: 'local-adapter-manifests-and-install-docs',
+    expected_adapters: expectedAdapters,
+    adapter_rows: rows,
+    gate_results: gateResults,
+    blockers: gateResults.filter((gate) => !gate.pass).flatMap((gate) => gate.findings.map((finding) => `${gate.gate}: ${finding}`)),
+    digest_inputs: rows.map((row) => ({ adapter: row.adapter, manifest_digest: row.manifest_digest, install_digest: row.install_digest })),
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeAdapterBootstrapInvariants(matrixCore);
+  const matrix = {
+    ...matrixCore,
+    ok: matrixCore.blockers.length === 0 && invariants.pass,
+    adapter_bootstrap_invariants: invariants,
+  };
+  return {
+    ...matrix,
+    matrix_digest: digestAdapterBootstrapMatrix(runtimeAdapterBootstrapMatrixDigestPayload(matrix)),
+    manual_action: matrix.ok
+      ? 'Adapter bootstrap matrix passed. Keep adapter manifests and install docs in sync with the lightweight entry contract before changing bootstrap behavior.'
+      : 'Fix the listed adapter bootstrap blockers before claiming installed-entry parity or superiority.',
+  };
+}
+
+export function runtimeAdapterBootstrapMatrixDigestPayload(matrix) {
+  return {
+    stage: matrix.stage,
+    matrix_kind: matrix.matrix_kind,
+    source: matrix.source,
+    expected_adapters: matrix.expected_adapters,
+    adapter_rows: matrix.adapter_rows,
+    gate_results: matrix.gate_results,
+    blockers: matrix.blockers,
+    digest_inputs: matrix.digest_inputs,
+    boundary_assertions: matrix.boundary_assertions,
+    adapter_bootstrap_invariants: matrix.adapter_bootstrap_invariants,
+  };
+}
+
+export function runtimeAdapterBootstrapBoundaryAssertions() {
+  return {
+    bootstrap_matrix_artifact: false,
+    adapter_install: false,
+    manifest_write: false,
+    install_doc_write: false,
+    settings_write: false,
+    hook_write: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    hook_execution: false,
+    runtime_action: false,
+    workflow_execution: false,
+    skill_execution: false,
+    auto_execution: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    git_write: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeAdapterBootstrapInvariants(matrix) {
+  const findings = [];
+  const adapters = matrix.adapter_rows.map((row) => row.adapter);
+  const missingAdapters = expectedAdapters.filter((adapter) => !adapters.includes(adapter));
+  const duplicateAdapters = adapters.filter((adapter, index, items) => items.indexOf(adapter) !== index);
+  findings.push(...missingAdapters.map((adapter) => `missing adapter row: ${adapter}`));
+  findings.push(...duplicateAdapters.map((adapter) => `duplicate adapter row: ${adapter}`));
+
+  const unsafeBoundaries = Object.entries(matrix.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  findings.push(...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`));
+
+  for (const row of matrix.adapter_rows) {
+    if (row.stage !== adapterBootstrapStage) findings.push(`${row.adapter}: row stage must be ${adapterBootstrapStage}`);
+    if (row.bootstrap_policy.injectsFullSkill !== false) findings.push(`${row.adapter}: injectsFullSkill must be false`);
+    if (row.bootstrap_policy.writesRuntimeState !== false) findings.push(`${row.adapter}: writesRuntimeState must be false`);
+    if (row.bootstrap_policy.autoRunsNextSkill !== false) findings.push(`${row.adapter}: autoRunsNextSkill must be false`);
+    if (row.runtime_bridge.canAutoExecuteSkill !== false) findings.push(`${row.adapter}: canAutoExecuteSkill must be false`);
+    if (row.runtime_bridge.canCallSubagent !== false) findings.push(`${row.adapter}: canCallSubagent must be false`);
+    if (row.runtime_bridge.canTouchGit !== false) findings.push(`${row.adapter}: canTouchGit must be false`);
+  }
+
+  return {
+    pass: findings.length === 0,
+    checked: [
+      'adapter_row_coverage',
+      'required_adapter_files',
+      'manifest_bootstrap_policy',
+      'runtime_bridge_manual_boundary',
+      'install_doc_bootstrap_markers',
+      'entry_file_consistency',
+      'read_only_boundary_assertions',
+    ],
+    findings,
+  };
+}
+
+export function digestAdapterBootstrapMatrix(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function adapterBootstrapRow(root, adapter) {
+  const spec = adapterSpecs[adapter];
+  const adapterRoot = path.join(root, 'adapters', adapter);
+  const fileResults = spec.required_files.map((file) => ({ file, exists: fs.existsSync(path.join(adapterRoot, file)) }));
+  const manifestPath = path.join(adapterRoot, 'plugin.json');
+  const installPath = path.join(adapterRoot, 'install.md');
+  const manifest = readJsonIfPresent(manifestPath);
+  const installText = readTextIfPresent(installPath);
+  const manifestDigest = fs.existsSync(manifestPath) ? fileDigest(manifestPath) : '';
+  const installDigest = fs.existsSync(installPath) ? fileDigest(installPath) : '';
+  const gates = rowGateResults(adapter, spec, manifest, installText, fileResults);
+
+  return {
+    stage: adapterBootstrapStage,
+    adapter,
+    adapter_root: path.relative(root, adapterRoot).replace(/\\/g, '/'),
+    required_files: fileResults,
+    entry_file: manifest?.layout?.entryFile || '',
+    expected_entry_file: spec.entry_file,
+    runtime_bridge: {
+      supported: manifest?.runtimeBridge?.supported,
+      mode: manifest?.runtimeBridge?.mode || '',
+      canReadDispatchIntent: manifest?.runtimeBridge?.canReadDispatchIntent,
+      canAutoExecuteSkill: manifest?.runtimeBridge?.canAutoExecuteSkill,
+      canCallSubagent: manifest?.runtimeBridge?.canCallSubagent,
+      canTouchGit: manifest?.runtimeBridge?.canTouchGit,
+    },
+    bootstrap_policy: {
+      supported: manifest?.sessionStartBootstrap?.supported,
+      command: manifest?.sessionStartBootstrap?.command || '',
+      injectsFullSkill: manifest?.sessionStartBootstrap?.injectsFullSkill,
+      writesRuntimeState: manifest?.sessionStartBootstrap?.writesRuntimeState,
+      autoRunsNextSkill: manifest?.sessionStartBootstrap?.autoRunsNextSkill,
+    },
+    manifest_digest: manifestDigest,
+    install_digest: installDigest,
+    gates,
+    pass: gates.every((gate) => gate.pass),
+    blockers: gates.filter((gate) => !gate.pass).flatMap((gate) => gate.findings.map((finding) => `${gate.gate}: ${finding}`)),
+  };
+}
+
+function rowGateResults(adapter, spec, manifest, installText, fileResults) {
+  const missingFiles = fileResults.filter((entry) => !entry.exists).map((entry) => entry.file);
+  const manifestFindings = [];
+  if (!manifest) manifestFindings.push('plugin.json is missing or invalid JSON');
+  else {
+    if (manifest.name !== 'vibe-coding-kit') manifestFindings.push('manifest name must be vibe-coding-kit');
+    if (!manifest.version) manifestFindings.push('manifest version is required');
+    if (manifest.layout?.repoSkills !== '../../skills/') manifestFindings.push('layout.repoSkills must be ../../skills/');
+    if (manifest.layout?.installedSkills !== '.vibecoding/skills/') manifestFindings.push('layout.installedSkills must be .vibecoding/skills/');
+    if (manifest.layout?.installedAdapter !== `.vibecoding/adapters/${adapter}/`) manifestFindings.push(`layout.installedAdapter must target ${adapter}`);
+    if (manifest.layout?.entryFile !== spec.entry_file) manifestFindings.push(`layout.entryFile must be ${spec.entry_file}`);
+    if (manifest.runtimeBridge?.supported !== true) manifestFindings.push('runtimeBridge.supported must be true');
+    if (manifest.runtimeBridge?.mode !== 'manual') manifestFindings.push('runtimeBridge.mode must be manual');
+    if (manifest.runtimeBridge?.canReadDispatchIntent !== true) manifestFindings.push('runtimeBridge.canReadDispatchIntent must be true');
+    if (manifest.runtimeBridge?.canAutoExecuteSkill !== false) manifestFindings.push('runtimeBridge.canAutoExecuteSkill must be false');
+    if (manifest.runtimeBridge?.canCallSubagent !== false) manifestFindings.push('runtimeBridge.canCallSubagent must be false');
+    if (manifest.runtimeBridge?.canTouchGit !== false) manifestFindings.push('runtimeBridge.canTouchGit must be false');
+  }
+
+  const bootstrapFindings = [];
+  if (!manifest?.sessionStartBootstrap) bootstrapFindings.push('sessionStartBootstrap is required');
+  else {
+    if (manifest.sessionStartBootstrap.supported !== true) bootstrapFindings.push('sessionStartBootstrap.supported must be true');
+    if (!String(manifest.sessionStartBootstrap.command || '').includes(`--format ${adapter}`)) bootstrapFindings.push(`sessionStartBootstrap.command must use --format ${adapter}`);
+    if (manifest.sessionStartBootstrap.injectsFullSkill !== false) bootstrapFindings.push('sessionStartBootstrap.injectsFullSkill must be false');
+    if (manifest.sessionStartBootstrap.writesRuntimeState !== false) bootstrapFindings.push('sessionStartBootstrap.writesRuntimeState must be false');
+    if (manifest.sessionStartBootstrap.autoRunsNextSkill !== false) bootstrapFindings.push('sessionStartBootstrap.autoRunsNextSkill must be false');
+  }
+
+  const missingInstallMarkers = spec.install_markers.filter((marker) => !installText.includes(marker));
+  return [
+    { gate: 'required_adapter_files', pass: missingFiles.length === 0, findings: missingFiles.map((file) => `missing ${file}`) },
+    { gate: 'manifest_parity_gate', pass: manifestFindings.length === 0, findings: manifestFindings },
+    { gate: 'bootstrap_policy_gate', pass: bootstrapFindings.length === 0, findings: bootstrapFindings },
+    { gate: 'install_doc_bootstrap_gate', pass: missingInstallMarkers.length === 0, findings: missingInstallMarkers.map((marker) => `install.md missing marker: ${marker}`) },
+  ];
+}
+
+function adapterBootstrapGateResults(rows) {
+  const gateNames = ['required_adapter_files', 'manifest_parity_gate', 'bootstrap_policy_gate', 'install_doc_bootstrap_gate'];
+  return gateNames.map((gate) => {
+    const findings = rows.flatMap((row) => {
+      const result = row.gates.find((item) => item.gate === gate);
+      return result?.pass ? [] : result.findings.map((finding) => `${row.adapter}: ${finding}`);
+    });
+    return { gate, pass: findings.length === 0, findings };
+  });
+}
+
+function readJsonIfPresent(file) {
+  try {
+    if (!fs.existsSync(file)) return null;
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function readTextIfPresent(file) {
+  if (!fs.existsSync(file)) return '';
+  return fs.readFileSync(file, 'utf8');
+}
+
+function fileDigest(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).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-adapter-entry-acceptance.mjs

@@ -0,0 +1,310 @@
+import crypto from 'node:crypto';
+import {
+  installedMultiroundUxGateResults,
+  runtimeInstalledMultiroundUxAcceptance,
+} from './runtime-installed-multiround-ux-acceptance.mjs';
+
+const adapterEntryAcceptanceStage = 'Stage 131';
+const adapterEntryAcceptanceKind = 'adapter-entry-acceptance-contract';
+const supportedAdapters = ['claude', 'cursor', 'codex'];
+
+export function runtimeAdapterEntryAcceptance({ transcript = {}, adapter = '', source = {} } = {}) {
+  const normalized = normalizeTranscript(transcript, adapter);
+  const installedMultiroundUxAcceptance = runtimeInstalledMultiroundUxAcceptance(normalized);
+  const gateResults = [...adapterEntryGateResults(normalized), ...installedMultiroundUxGateResults(installedMultiroundUxAcceptance)];
+  const blockers = gateResults.filter((gate) => !gate.pass).flatMap((gate) => gate.findings.map((finding) => `${gate.gate}: ${finding}`));
+  const core = {
+    version: 1,
+    stage: adapterEntryAcceptanceStage,
+    acceptance_kind: adapterEntryAcceptanceKind,
+    adapter: normalized.adapter,
+    source_bindings: sourceBindingSummary(source, normalized),
+    transcript_summary: transcriptSummary(normalized),
+    installed_multiround_ux_acceptance: installedMultiroundUxAcceptance,
+    gate_results: gateResults,
+    acceptance_score: acceptanceScore(gateResults),
+    accepted: blockers.length === 0,
+    workflow_explanation: workflowExplanation(normalized, gateResults),
+    next_expected_user_visible_step: nextExpectedUserVisibleStep(normalized),
+    blockers,
+    boundary_assertions: runtimeAdapterEntryAcceptanceBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeAdapterEntryAcceptanceInvariants(core);
+  const contract = {
+    ...core,
+    ok: core.accepted && invariants.pass,
+    adapter_entry_acceptance_invariants: invariants,
+  };
+  return {
+    ...contract,
+    acceptance_digest: digestAdapterEntryAcceptance(runtimeAdapterEntryAcceptanceDigestPayload(contract)),
+  };
+}
+
+export function runtimeAdapterEntryAcceptanceDigestPayload(contract) {
+  return {
+    stage: contract.stage,
+    acceptance_kind: contract.acceptance_kind,
+    adapter: contract.adapter,
+    source_bindings: contract.source_bindings,
+    transcript_summary: contract.transcript_summary,
+    installed_multiround_ux_acceptance: contract.installed_multiround_ux_acceptance,
+    gate_results: contract.gate_results,
+    acceptance_score: contract.acceptance_score,
+    accepted: contract.accepted,
+    workflow_explanation: contract.workflow_explanation,
+    next_expected_user_visible_step: contract.next_expected_user_visible_step,
+    blockers: contract.blockers,
+    boundary_assertions: contract.boundary_assertions,
+    adapter_entry_acceptance_invariants: contract.adapter_entry_acceptance_invariants,
+  };
+}
+
+export function runtimeAdapterEntryAcceptanceBoundaryAssertions() {
+  return {
+    entry_acceptance_artifact: false,
+    transcript_write: false,
+    adapter_install: false,
+    adapter_execution: false,
+    hook_execution: false,
+    prompt_mutation: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    git_write: false,
+    git_add: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeAdapterEntryAcceptanceInvariants(contract) {
+  const unsafeBoundaries = Object.entries(contract.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = ['entry_acceptance_artifact', 'adapter_install', 'adapter_execution', 'hook_execution', 'sidecar_write', 'state_directory_created', 'command_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'auto_execution', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'git', 'git_write', 'git_add', 'commit', 'pr', 'push', 'merge', 'worktree', 'business_source_write']
+    .filter((key) => contract.boundary_assertions?.[key] !== false);
+  const gateNames = (contract.gate_results || []).map((gate) => gate.gate);
+  const requiredGates = ['using_vibecoding_first', 'lightweight_routing', 'visible_next_step', 'no_auto_execution', 'workflow_explained'];
+  const missingGates = requiredGates.filter((gate) => !gateNames.includes(gate));
+  const findings = [
+    ...(contract.stage === adapterEntryAcceptanceStage ? [] : [`stage must be ${adapterEntryAcceptanceStage}`]),
+    ...(contract.acceptance_kind === adapterEntryAcceptanceKind ? [] : [`acceptance_kind must be ${adapterEntryAcceptanceKind}`]),
+    ...(supportedAdapters.includes(contract.adapter) ? [] : ['adapter must be claude, cursor, or codex']),
+    ...(contract.source_bindings?.transcript_file ? [] : ['source transcript file is required']),
+    ...(contract.source_bindings?.transcript_digest ? [] : ['source transcript digest is required']),
+    ...(Array.isArray(contract.gate_results) && contract.gate_results.length >= requiredGates.length ? [] : ['gate_results must include all entry acceptance gates']),
+    ...missingGates.map((gate) => `missing gate result: ${gate}`),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingForbidden.map((key) => `forbidden boundary missing or not false: ${key}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['adapter_name', 'transcript_binding', 'using_vibecoding_first', 'lightweight_routing', 'visible_next_step', 'no_auto_execution', 'workflow_explained', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestAdapterEntryAcceptance(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function normalizeTranscript(input, adapterOverride) {
+  const transcript = objectValue(input.adapter_entry_transcript || input.transcript_contract || input.transcript || input);
+  const messages = normalizeMessages(transcript);
+  const rawText = messages.map((message) => `${message.role}: ${message.text}`).join('\n');
+  const adapter = stringValue(adapterOverride || transcript.adapter || input.adapter || inferAdapter(rawText)).toLowerCase();
+  return {
+    adapter,
+    transcript_kind: stringValue(transcript.transcript_kind || transcript.kind || 'adapter-entry-transcript'),
+    prompt: stringValue(transcript.prompt || input.prompt),
+    messages,
+    raw_text: rawText,
+    observed_workflow: stringValue(transcript.observed_workflow || transcript.workflow || input.observed_workflow),
+    next_action: stringValue(transcript.next_action || transcript.recommended_next_action || input.next_action),
+    entry_skill: stringValue(transcript.entry_skill || transcript.current_skill || input.entry_skill),
+    structured_flags: objectValue(transcript.flags || input.flags),
+    commands_run: listValue(transcript.commands_run || input.commands_run).map(stringValue).filter(Boolean),
+    actions: listValue(transcript.actions || input.actions).map(stringValue).filter(Boolean),
+  };
+}
+
+function normalizeMessages(transcript) {
+  const candidates = transcript.messages || transcript.turns || transcript.entries || [];
+  if (Array.isArray(candidates) && candidates.length > 0) {
+    return candidates.map((message, index) => ({
+      index,
+      role: stringValue(message.role || message.speaker || `entry-${index + 1}`).toLowerCase(),
+      text: stringValue(message.text || message.content || message.message || message.output),
+    })).filter((message) => message.text);
+  }
+  const fallback = [transcript.system, transcript.prompt, transcript.response, transcript.output, transcript.text, transcript.raw_text]
+    .map(stringValue)
+    .filter(Boolean)
+    .map((text, index) => ({ index, role: index === 0 ? 'input' : 'assistant', text }));
+  return fallback;
+}
+
+function adapterEntryGateResults(normalized) {
+  const lower = normalized.raw_text.toLowerCase();
+  const firstAssistant = normalized.messages.find((message) => ['assistant', 'agent', 'model'].includes(message.role)) || normalized.messages[0] || { text: '' };
+  const firstAssistantText = firstAssistant.text.toLowerCase();
+  const hasUsingVibecoding = includesAny(firstAssistantText, ['using-vibecoding']) || normalized.entry_skill === 'using-vibecoding';
+  const hasLightRouting = includesAny(lower, ['轻量分流', '轻量 workflow 判断', 'workflow 判断', '任务分流', 'routing', 'route', 'start contract']);
+  const injectsFullSkill = booleanFlag(normalized, 'injects_full_skill') || includesAny(lower, ['注入完整 skill', 'loaded full skill', '完整加载所有 skill']);
+  const hasVisibleNextStep = Boolean(normalized.next_action) || includesAny(lower, ['下一步', 'next step', 'recommended_next_action', 'recommended next action', '建议进入', '应进入']);
+  const forbiddenExecution = forbiddenExecutionSignals(normalized, lower);
+  const workflowExplained = Boolean(normalized.observed_workflow) || includesAny(lower, ['vibe-brainstorming', 'vibe-planning', 'vibe-writing-plans', 'vibe-test-driven-development', 'vibe-executing-plans', 'vibe-verification-before-completion', 'vibe-review', 'workflow']);
+  return [
+    gate('using_vibecoding_first', hasUsingVibecoding, hasUsingVibecoding ? [] : ['first visible adapter response must reference using-vibecoding or declare entry_skill=using-vibecoding']),
+    gate('lightweight_routing', hasLightRouting && !injectsFullSkill, [
+      ...(hasLightRouting ? [] : ['entry transcript must show lightweight routing instead of silent continuation']),
+      ...(injectsFullSkill ? ['entry transcript suggests full skill injection'] : []),
+    ]),
+    gate('visible_next_step', hasVisibleNextStep, hasVisibleNextStep ? [] : ['entry transcript must expose a visible next action']),
+    gate('no_auto_execution', forbiddenExecution.length === 0, forbiddenExecution),
+    gate('workflow_explained', workflowExplained, workflowExplained ? [] : ['entry transcript must explain which workflow should be entered or deferred']),
+  ];
+}
+
+function forbiddenExecutionSignals(normalized, lower) {
+  const flags = normalized.structured_flags;
+  const flagged = [
+    ['skill_executed', flags.skill_executed],
+    ['subagent_called', flags.subagent_called],
+    ['git_called', flags.git_called],
+    ['platform_api_called', flags.platform_api_called],
+    ['hook_executed', flags.hook_executed],
+    ['state_written', flags.state_written],
+  ].filter(([, value]) => value === true).map(([key]) => `structured flag must be false: ${key}`);
+  const actionText = [...normalized.actions, ...normalized.commands_run].join('\n').toLowerCase();
+  const actionFindings = forbiddenActionPatterns(actionText).map((finding) => `recorded action is forbidden at entry: ${finding.match}`);
+  const textualFindings = forbiddenActionPatterns(lower)
+    .filter((finding) => {
+      const matchIndex = finding.context.indexOf(finding.match);
+      const negationWindow = finding.context.slice(Math.max(0, matchIndex - 64), matchIndex + finding.match.length + 16);
+      return !/不|未|不会|无需|禁止|没有|no |without |does not|do not|must not/.test(negationWindow);
+    })
+    .map((finding) => `transcript suggests forbidden entry execution: ${finding.match}`)
+    .slice(0, 5);
+  return [...flagged, ...actionFindings, ...textualFindings];
+}
+
+function forbiddenActionPatterns(text) {
+  const source = stringValue(text);
+  const patterns = [/\bgit\s+(add|commit|push|merge|tag|reset|checkout)\b/i, /\bgh\s+pr\b/i, /subagent\s+(call|dispatch|run)/i, /platform api/i, /hook\s+execut/i, /skill\s+execut/i, /state\s+writ/i, /\b--confirm\b/i, /\b--write\b/i, /\b--dispatch\b/i, /\b--auto-run\b/i];
+  return patterns.flatMap((pattern) => {
+    const match = source.match(pattern);
+    if (!match) return [];
+    return [{ match: match[0], context: source.slice(Math.max(0, match.index - 40), match.index + match[0].length + 40) }];
+  });
+}
+
+function transcriptSummary(normalized) {
+  return {
+    transcript_kind: normalized.transcript_kind,
+    message_count: normalized.messages.length,
+    prompt_present: Boolean(normalized.prompt),
+    installed_multiround_close_loop: Boolean(runtimeInstalledMultiroundUxAcceptance(normalized)),
+    entry_skill: normalized.entry_skill,
+    observed_workflow: normalized.observed_workflow,
+    commands_run_count: normalized.commands_run.length,
+    actions_count: normalized.actions.length,
+  };
+}
+
+function workflowExplanation(normalized, gateResults) {
+  const failed = gateResults.filter((gateResult) => !gateResult.pass).map((gateResult) => gateResult.gate);
+  return {
+    status: failed.length === 0 ? 'entry-accepted' : 'entry-blocked',
+    adapter: normalized.adapter,
+    observed_workflow: normalized.observed_workflow || 'not_explicit',
+    why: failed.length === 0
+      ? 'Installed adapter entry preserved the lightweight using-vibecoding routing contract and exposed the next step without executing workflow, subagent, git, hook, or platform actions.'
+      : `Entry transcript is missing or violating gate(s): ${failed.join(', ')}`,
+  };
+}
+
+function nextExpectedUserVisibleStep(normalized) {
+  return normalized.next_action || normalized.observed_workflow || 'show the lightweight workflow recommendation and ask before any execution';
+}
+
+function acceptanceScore(gateResults) {
+  if (gateResults.length === 0) return 0;
+  const passed = gateResults.filter((gateResult) => gateResult.pass).length;
+  return Math.round((passed / gateResults.length) * 100);
+}
+
+function sourceBindingSummary(source, normalized) {
+  return {
+    transcript_file: stringValue(source.transcript_file),
+    transcript_digest: stringValue(source.transcript_digest),
+    requested_adapter: stringValue(source.requested_adapter),
+    transcript_adapter: normalized.adapter,
+  };
+}
+
+function gate(name, pass, findings) {
+  return { gate: name, pass: Boolean(pass), findings: pass ? [] : findings };
+}
+
+function includesAny(text, markers) {
+  return markers.some((marker) => stringValue(text).includes(marker.toLowerCase()));
+}
+
+function booleanFlag(normalized, key) {
+  return normalized.structured_flags?.[key] === true;
+}
+
+function inferAdapter(text) {
+  const lower = stringValue(text).toLowerCase();
+  if (lower.includes('claude')) return 'claude';
+  if (lower.includes('cursor')) return 'cursor';
+  if (lower.includes('codex')) return 'codex';
+  return '';
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function stringValue(value) {
+  return value === undefined || value === null ? '' : String(value);
+}
+
+function stableStringify(value) {
+  return JSON.stringify(sortForJson(value));
+}
+
+function sortForJson(value) {
+  if (Array.isArray(value)) return value.map(sortForJson);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, sortForJson(nested)]));
+  }
+  return value;
+}