@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-session-start-example-pack.mjs

@@ -0,0 +1,290 @@
+import crypto from 'node:crypto';
+
+const sessionStartExampleStage = 'Stage 142';
+const sessionStartExampleKind = 'session-start-example-pack';
+const baselineAdapters = ['claude', 'cursor', 'codex', 'cursor-sdk'];
+const sdkAdapters = ['cursor-sdk'];
+
+export function runtimeSessionStartExamplePack({ shapeAcceptance = {}, installExperience = {}, source = {} } = {}) {
+  const shape = unwrapShapeAcceptance(shapeAcceptance);
+  const install = unwrapInstallExperience(installExperience);
+  const adapters = adapterExampleOrder(shape, install);
+  const adapterExamples = adapters.map((adapter) => adapterExample(adapter, shape, install));
+  const copyReadyContextShapes = adapters.map((adapter) => copyReadyContextShape(adapter));
+  const formatWarnings = formatWarningList(shape, install, adapterExamples);
+  const core = {
+    version: 1,
+    stage: sessionStartExampleStage,
+    pack_kind: sessionStartExampleKind,
+    source_bindings: sourceBindingSummary(source, shape, install),
+    input_summary: inputSummary(shape, install, adapterExamples),
+    adapter_examples: adapterExamples,
+    copy_ready_context_shapes: copyReadyContextShapes,
+    format_warnings: formatWarnings,
+    example_pack_digest_basis: {
+      shape_digest: shape.shape_digest || '',
+      install_experience_digest: install.install_experience_digest || '',
+    },
+    boundary_assertions: runtimeSessionStartExamplePackBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeSessionStartExamplePackInvariants(core);
+  const pack = {
+    ...core,
+    ok: invariants.pass,
+    example_pack_invariants: invariants,
+  };
+  return {
+    ...pack,
+    example_pack_digest: digestSessionStartExamplePack(runtimeSessionStartExamplePackDigestPayload(pack)),
+  };
+}
+
+export function runtimeSessionStartExamplePackDigestPayload(pack) {
+  return {
+    stage: pack.stage,
+    pack_kind: pack.pack_kind,
+    source_bindings: pack.source_bindings,
+    input_summary: pack.input_summary,
+    adapter_examples: pack.adapter_examples,
+    copy_ready_context_shapes: pack.copy_ready_context_shapes,
+    format_warnings: pack.format_warnings,
+    example_pack_digest_basis: pack.example_pack_digest_basis,
+    boundary_assertions: pack.boundary_assertions,
+    example_pack_invariants: pack.example_pack_invariants,
+  };
+}
+
+export function runtimeSessionStartExamplePackBoundaryAssertions() {
+  return {
+    session_start_example_pack_artifact: false,
+    session_start_shape_artifact: false,
+    install_experience_artifact: false,
+    adapter_example_artifact: false,
+    adapter_install: false,
+    adapter_execution: false,
+    hook_execution: false,
+    hook_registration: false,
+    manifest_write: false,
+    install_doc_write: false,
+    settings_write: false,
+    prompt_mutation: false,
+    template_mutation: false,
+    skill_mutation: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_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,
+    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 runtimeSessionStartExamplePackInvariants(pack) {
+  const unsafeBoundaries = Object.entries(pack.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = Object.keys(runtimeSessionStartExamplePackBoundaryAssertions())
+    .filter((key) => pack.boundary_assertions?.[key] !== false);
+  const adapters = (pack.adapter_examples || []).map((example) => example.adapter);
+  const duplicateAdapters = adapters.filter((adapter, index, items) => items.indexOf(adapter) !== index);
+  const findings = [
+    ...(pack.stage === sessionStartExampleStage ? [] : [`stage must be ${sessionStartExampleStage}`]),
+    ...(pack.pack_kind === sessionStartExampleKind ? [] : [`pack_kind must be ${sessionStartExampleKind}`]),
+    ...(pack.source_bindings?.shape_file ? [] : ['shape file binding is required']),
+    ...(pack.source_bindings?.shape_digest ? [] : ['shape digest binding is required']),
+    ...(pack.source_bindings?.install_experience_file ? [] : ['install experience file binding is required']),
+    ...(pack.source_bindings?.install_experience_digest ? [] : ['install experience digest binding is required']),
+    ...(pack.input_summary?.shape_stage === 'Stage 134' ? [] : ['shape input must be Stage 134 evidence']),
+    ...(pack.input_summary?.install_experience_stage === 'Stage 137' ? [] : ['install experience input must be Stage 137 evidence']),
+    ...(Array.isArray(pack.adapter_examples) && pack.adapter_examples.length >= 4 ? [] : ['adapter_examples must include claude, cursor, codex, and cursor-sdk examples']),
+    ...(Array.isArray(pack.copy_ready_context_shapes) && pack.copy_ready_context_shapes.length >= 4 ? [] : ['copy_ready_context_shapes must include claude, cursor, codex, and cursor-sdk shapes']),
+    ...(Array.isArray(pack.format_warnings) ? [] : ['format_warnings must be a list']),
+    ...baselineAdapters.filter((adapter) => !adapters.includes(adapter)).map((adapter) => `missing baseline adapter example: ${adapter}`),
+    ...duplicateAdapters.map((adapter) => `duplicate adapter example: ${adapter}`),
+    ...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: ['source_bindings', 'stage_134_shape_acceptance', 'stage_137_install_experience', 'adapter_examples', 'copy_ready_context_shapes', 'format_warnings', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestSessionStartExamplePack(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function unwrapShapeAcceptance(input) {
+  return objectValue(input.session_start_shape_acceptance || input.shape_acceptance || input);
+}
+
+function unwrapInstallExperience(input) {
+  return objectValue(input.install_experience_score || input.install_experience || input);
+}
+
+function sourceBindingSummary(source, shape, install) {
+  return {
+    shape_file: stringValue(source.shape_file),
+    shape_digest: stringValue(source.shape_digest),
+    install_experience_file: stringValue(source.install_experience_file),
+    install_experience_digest: stringValue(source.install_experience_digest),
+    shape_stage: stringValue(shape.stage),
+    install_experience_stage: stringValue(install.stage),
+    shape_artifact_digest: stringValue(shape.shape_digest),
+    install_experience_artifact_digest: stringValue(install.install_experience_digest),
+  };
+}
+
+function inputSummary(shape, install, adapterExamples) {
+  return {
+    shape_stage: stringValue(shape.stage),
+    shape_kind: stringValue(shape.acceptance_kind),
+    shape_adapter: stringValue(shape.adapter),
+    shape_accepted: shape.ok === true || shape.accepted === true,
+    shape_context_path: stringValue(shape.output_summary?.context_path),
+    install_experience_stage: stringValue(install.stage),
+    install_experience_kind: stringValue(install.score_kind),
+    install_experience_ok: install.ok === true,
+    install_experience_score: numberValue(install.install_experience_score),
+    adapter_example_count: adapterExamples.length,
+  };
+}
+
+function adapterExampleOrder(shape, install) {
+  const installAdapters = listValue(install.adapter_scores).map((row) => stringValue(row.adapter)).filter(Boolean);
+  const shapeAdapter = stringValue(shape.adapter);
+  return unique([...baselineAdapters, ...installAdapters, ...(shapeAdapter ? [shapeAdapter] : []), ...sdkAdapters.filter((adapter) => shapeAdapter === adapter)]);
+}
+
+function adapterExample(adapter, shape, install) {
+  const context = contextForAdapter(adapter);
+  const installRow = listValue(install.adapter_scores).find((row) => stringValue(row.adapter) === adapter) || {};
+  const shapeMatch = stringValue(shape.adapter) === adapter;
+  const contextPath = contextPathForAdapter(adapter);
+  return {
+    adapter,
+    context_path: contextPath,
+    output_shape: outputShapeName(adapter),
+    copy_ready_json: JSON.stringify(examplePayload(adapter, context), null, 2),
+    source_status: {
+      shape_acceptance_matched: shapeMatch,
+      shape_acceptance_ok: shapeMatch ? (shape.ok === true || shape.accepted === true) : false,
+      install_experience_present: Object.keys(installRow).length > 0,
+      install_experience_ok: installRow.entry_acceptance_ok === true || installRow.bootstrap_pass === true,
+    },
+    format_notes: formatNotesForAdapter(adapter, contextPath),
+  };
+}
+
+function copyReadyContextShape(adapter) {
+  return {
+    adapter,
+    context_path: contextPathForAdapter(adapter),
+    additional_context: contextForAdapter(adapter),
+    boundary_summary: 'Lightweight session-start routing context only; do not inject the full skill, create or modify runtime state directories, auto-run workflow skills, call subagents/MCP/platform APIs, or touch git.',
+  };
+}
+
+function contextForAdapter(adapter) {
+  return [
+    'using-vibecoding: start with lightweight routing context only.',
+    `adapter=${adapter}; expose this text at ${contextPathForAdapter(adapter)}.`,
+    'selected_skill=using-vibecoding; visible_route=lightweight route; next_manual_action=read .vibecoding/skills/using-vibecoding/SKILL.md and state route plus evidence gap.',
+    'context_policy=tiny_context by default; balanced_context only when implementation, debugging, or completion evidence needs it.',
+    'Do not inject the full skill; do not create or modify runtime state directories; do not auto-run workflow skills.',
+    'hidden_execution=false; command_execution=false; skill_execution_claimed=false; subagent_dispatch_claimed=false; git_write_claimed=false; platform_api=false; model_invocation=false; business_source_write=false.',
+    'No hook execution, adapter execution, command execution, git, platform API, model, MCP, or subagent action is authorized by session-start.',
+  ].join(' ');
+}
+
+function contextPathForAdapter(adapter) {
+  if (adapter === 'claude') return 'hookSpecificOutput.additionalContext';
+  if (adapter === 'cursor') return 'additional_context';
+  return 'additionalContext';
+}
+
+function outputShapeName(adapter) {
+  if (adapter === 'claude') return 'claude-session-start-hookSpecificOutput';
+  if (adapter === 'cursor') return 'cursor-session-start-additional_context';
+  return 'sdk-session-start-additionalContext';
+}
+
+function examplePayload(adapter, context) {
+  if (adapter === 'claude') return {
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext: context,
+    },
+  };
+  if (adapter === 'cursor') return { additional_context: context };
+  return { additionalContext: context };
+}
+
+function formatNotesForAdapter(adapter, contextPath) {
+  return [
+    `copy ${contextPath} exactly for ${adapter}`,
+    'keep the payload as a report/example shape; do not execute hooks while generating this pack',
+    'keep context lightweight and boundary-first',
+  ];
+}
+
+function formatWarningList(shape, install, examples) {
+  return [
+    ...((shape.ok === true || shape.accepted === true) ? [] : ['Stage 134 shape acceptance was not accepted; examples are still generated as corrective copy-ready shapes']),
+    ...(install.ok === true ? [] : ['Stage 137 install experience was not fully passing; examples may need adapter-specific install follow-up']),
+    ...examples.filter((example) => !example.source_status.install_experience_present).map((example) => `${example.adapter} is not present in Stage 137 install experience rows`),
+    ...examples.filter((example) => example.source_status.shape_acceptance_matched && !example.source_status.shape_acceptance_ok).map((example) => `${example.adapter} Stage 134 shape acceptance did not pass`),
+  ];
+}
+
+function unique(items) {
+  return [...new Set(items.filter(Boolean))];
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function stringValue(value) {
+  return typeof value === 'string' ? value : value == null ? '' : String(value);
+}
+
+function numberValue(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+
+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);
+}

package/tools/vibe-runtime/runtime-session-start-shape-acceptance.mjs

@@ -0,0 +1,344 @@
+import crypto from 'node:crypto';
+
+const sessionStartShapeStage = 'Stage 134';
+const sessionStartShapeKind = 'session-start-shape-acceptance';
+const supportedAdapters = ['claude', 'cursor', 'codex', 'cursor-sdk'];
+
+export function runtimeSessionStartShapeAcceptance({ capturedOutput = '', adapter = '', source = {} } = {}) {
+  const normalized = normalizeCapturedOutput(capturedOutput, adapter);
+  const shapeResults = sessionStartShapeResults(normalized);
+  const contextMarkers = contextMarkerSummary(normalized.context);
+  const markerResults = contextMarkerResults(contextMarkers);
+  const boundaryResults = boundaryShapeResults(normalized);
+  const allResults = [...shapeResults, ...markerResults, ...boundaryResults];
+  const blockers = allResults.filter((result) => !result.pass).flatMap((result) => result.findings.map((finding) => `${result.gate}: ${finding}`));
+  const core = {
+    version: 1,
+    stage: sessionStartShapeStage,
+    acceptance_kind: sessionStartShapeKind,
+    adapter: normalized.adapter,
+    source_bindings: sourceBindingSummary(source, normalized),
+    output_summary: outputSummary(normalized),
+    shape_results: allResults,
+    context_markers: contextMarkers,
+    accepted: blockers.length === 0,
+    blockers,
+    boundary_assertions: runtimeSessionStartShapeAcceptanceBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeSessionStartShapeAcceptanceInvariants(core);
+  const acceptance = {
+    ...core,
+    ok: core.accepted && invariants.pass,
+    session_start_shape_invariants: invariants,
+  };
+  return {
+    ...acceptance,
+    shape_digest: digestSessionStartShapeAcceptance(runtimeSessionStartShapeAcceptanceDigestPayload(acceptance)),
+  };
+}
+
+export function runtimeSessionStartShapeAcceptanceDigestPayload(acceptance) {
+  return {
+    stage: acceptance.stage,
+    acceptance_kind: acceptance.acceptance_kind,
+    adapter: acceptance.adapter,
+    source_bindings: acceptance.source_bindings,
+    output_summary: acceptance.output_summary,
+    shape_results: acceptance.shape_results,
+    context_markers: acceptance.context_markers,
+    accepted: acceptance.accepted,
+    blockers: acceptance.blockers,
+    boundary_assertions: acceptance.boundary_assertions,
+    session_start_shape_invariants: acceptance.session_start_shape_invariants,
+  };
+}
+
+export function runtimeSessionStartShapeAcceptanceBoundaryAssertions() {
+  return {
+    session_start_shape_artifact: false,
+    captured_output_write: false,
+    adapter_install: false,
+    adapter_execution: false,
+    hook_execution: false,
+    hook_registration: false,
+    prompt_mutation: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_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 runtimeSessionStartShapeAcceptanceInvariants(acceptance) {
+  const unsafeBoundaries = Object.entries(acceptance.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const requiredGates = [
+    'adapter_output_shape',
+    'context_present',
+    'using_vibecoding_marker',
+    'lightweight_routing_marker',
+    'semantic_field_markers',
+    'context_policy_marker',
+    'boundary_declaration_marker',
+    'no_full_skill_injection',
+    'no_execution_claims',
+    'no_forbidden_trigger',
+  ];
+  const gateNames = (acceptance.shape_results || []).map((result) => result.gate);
+  const missingGates = requiredGates.filter((gate) => !gateNames.includes(gate));
+  const missingForbidden = Object.keys(runtimeSessionStartShapeAcceptanceBoundaryAssertions())
+    .filter((key) => acceptance.boundary_assertions?.[key] !== false);
+  const findings = [
+    ...(acceptance.stage === sessionStartShapeStage ? [] : [`stage must be ${sessionStartShapeStage}`]),
+    ...(acceptance.acceptance_kind === sessionStartShapeKind ? [] : [`acceptance_kind must be ${sessionStartShapeKind}`]),
+    ...(supportedAdapters.includes(acceptance.adapter) ? [] : ['adapter must be claude, cursor, codex, or cursor-sdk']),
+    ...(acceptance.source_bindings?.captured_output_file ? [] : ['source captured_output_file is required']),
+    ...(acceptance.source_bindings?.captured_output_digest ? [] : ['source captured_output_digest is required']),
+    ...(Array.isArray(acceptance.shape_results) && acceptance.shape_results.length >= requiredGates.length ? [] : ['shape_results must include all Stage 134 gates']),
+    ...missingGates.map((gate) => `missing shape 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', 'captured_output_binding', 'platform_output_shape', 'context_markers', 'no_full_skill_injection', 'no_forbidden_trigger', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestSessionStartShapeAcceptance(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function normalizeCapturedOutput(capturedOutput, adapterOverride) {
+  const rawText = typeof capturedOutput === 'string' ? capturedOutput : stableStringify(capturedOutput);
+  const parsed = parseJson(rawText);
+  const payload = parsed.ok ? objectValue(parsed.value) : {};
+  const adapter = stringValue(adapterOverride || payload.adapter || payload.platform).toLowerCase();
+  const shape = extractContextShape(payload, adapter);
+  return {
+    adapter,
+    raw_text: rawText,
+    payload,
+    json_parse_ok: parsed.ok,
+    json_parse_error: parsed.ok ? '' : parsed.error,
+    context: shape.context,
+    context_path: shape.context_path,
+    shape_findings: shape.findings,
+    unexpected_fields: shape.unexpected_fields,
+  };
+}
+
+function extractContextShape(payload, adapter) {
+  if (adapter === 'claude') return claudeContextShape(payload);
+  if (adapter === 'cursor') return cursorContextShape(payload);
+  if (adapter === 'codex' || adapter === 'cursor-sdk') return sdkContextShape(payload, adapter);
+  return { context: '', context_path: '', findings: ['unsupported adapter'], unexpected_fields: [] };
+}
+
+function claudeContextShape(payload) {
+  const hookOutput = objectValue(payload.hookSpecificOutput);
+  const findings = [];
+  if (!payload.hookSpecificOutput || typeof payload.hookSpecificOutput !== 'object' || Array.isArray(payload.hookSpecificOutput)) findings.push('claude output must include hookSpecificOutput object');
+  if (hookOutput.hookEventName !== 'SessionStart') findings.push('claude hookSpecificOutput.hookEventName must be SessionStart');
+  if (typeof hookOutput.additionalContext !== 'string') findings.push('claude hookSpecificOutput.additionalContext must be a string');
+  const unexpectedFields = ['additional_context', 'additionalContext'].filter((key) => hasOwn(payload, key));
+  for (const field of unexpectedFields) findings.push(`claude output must not include top-level ${field}`);
+  return { context: stringValue(hookOutput.additionalContext), context_path: 'hookSpecificOutput.additionalContext', findings, unexpected_fields: unexpectedFields };
+}
+
+function cursorContextShape(payload) {
+  const findings = [];
+  if (typeof payload.additional_context !== 'string') findings.push('cursor output must include top-level additional_context string');
+  const unexpectedFields = ['hookSpecificOutput', 'additionalContext'].filter((key) => hasOwn(payload, key));
+  for (const field of unexpectedFields) findings.push(`cursor output must not include ${field}`);
+  return { context: stringValue(payload.additional_context), context_path: 'additional_context', findings, unexpected_fields: unexpectedFields };
+}
+
+function sdkContextShape(payload, adapter) {
+  const findings = [];
+  const hookOutput = objectValue(payload.hookSpecificOutput);
+  let context = '';
+  let contextPath = '';
+  if (typeof payload.additionalContext === 'string') {
+    context = payload.additionalContext;
+    contextPath = 'additionalContext';
+    if (hasOwn(payload, 'additional_context')) findings.push(`${adapter} output must not include additional_context when additionalContext is present`);
+    if (hasOwn(payload, 'hookSpecificOutput')) findings.push(`${adapter} output must not include hookSpecificOutput when additionalContext is present`);
+  } else if (typeof hookOutput.additionalContext === 'string' && hookOutput.hookEventName === 'SessionStart') {
+    context = hookOutput.additionalContext;
+    contextPath = 'hookSpecificOutput.additionalContext';
+    if (hasOwn(payload, 'additional_context')) findings.push(`${adapter} output must not include additional_context with nested SessionStart shape`);
+  } else {
+    findings.push(`${adapter} output must include additionalContext string or nested hookSpecificOutput.additionalContext SessionStart string`);
+  }
+  return { context, context_path: contextPath, findings, unexpected_fields: [] };
+}
+
+function sessionStartShapeResults(normalized) {
+  return [
+    gate('adapter_output_shape', normalized.json_parse_ok && normalized.shape_findings.length === 0, [
+      ...(normalized.json_parse_ok ? [] : [`captured output must be valid JSON: ${normalized.json_parse_error}`]),
+      ...normalized.shape_findings,
+    ]),
+    gate('context_present', typeof normalized.context === 'string' && normalized.context.trim().length > 0, ['captured output context must be a non-empty string']),
+  ];
+}
+
+function contextMarkerResults(markers) {
+  return [
+    gate('using_vibecoding_marker', markers.using_vibecoding, ['context must mention using-vibecoding']),
+    gate('lightweight_routing_marker', markers.lightweight_routing, ['context must mention lightweight routing or task routing']),
+    gate('semantic_field_markers', markers.selected_skill && markers.visible_route && markers.next_manual_action, [
+      ...(markers.selected_skill ? [] : ['context must expose selected skill']),
+      ...(markers.visible_route ? [] : ['context must expose visible route']),
+      ...(markers.next_manual_action ? [] : ['context must expose next manual action']),
+    ]),
+    gate('context_policy_marker', markers.context_policy, ['context must expose tiny_context, balanced_context, or equivalent context policy']),
+    gate('boundary_declaration_marker', markers.boundary_declaration, ['context must declare no full skill injection, state write, auto execution, subagent/git/platform actions, or equivalent boundaries']),
+    gate('no_full_skill_injection', !markers.full_skill_injection, ['context appears to contain full skill or workflow handoff content instead of lightweight bootstrap']),
+    gate('no_execution_claims', markers.no_execution_claims, ['context must explicitly keep hidden execution, command execution, skill execution, subagent dispatch, git writes, platform API, model invocation, and business source writes false']),
+  ];
+}
+
+function boundaryShapeResults(normalized) {
+  const forbidden = forbiddenTriggerSignals(normalized.context);
+  return [
+    gate('no_forbidden_trigger', forbidden.length === 0, forbidden),
+  ];
+}
+
+function contextMarkerSummary(context) {
+  const text = stringValue(context);
+  const lower = text.toLowerCase();
+  const falseMarkers = ['hidden_execution=false', 'command_execution=false', 'skill_execution_claimed=false', 'subagent_dispatch_claimed=false', 'git_write_claimed=false', 'platform_api=false', 'model_invocation=false', 'business_source_write=false'];
+  return {
+    using_vibecoding: lower.includes('using-vibecoding'),
+    lightweight_routing: includesAny(lower, ['lightweight routing', '轻量 routing', '轻量分流', '轻量 workflow 判断', 'default routing', '任务分流', 'routing context']),
+    selected_skill: includesAny(lower, ['selected_skill', 'selected skill', '选中 skill', '当前 skill']),
+    visible_route: includesAny(lower, ['visible_route', 'visible route', 'lightweight route', 'strict skill-first visible route', 'route=']),
+    next_manual_action: includesAny(lower, ['next_manual_action', 'next manual action', '下一步人工动作', 'manual next action']),
+    context_policy: includesAny(lower, ['context_policy', 'tiny_context', 'balanced_context', 'lightweight session-start routing context only']),
+    boundary_declaration: includesAny(lower, ['do not inject the full skill', '不注入完整', 'do not create or modify .vibecoding-state', 'do not auto-run', 'no auto execution'])
+      && includesAny(lower, ['subagent', 'git', 'platform api', 'platform apis', 'mcp']),
+    no_execution_claims: falseMarkers.every((marker) => lower.includes(marker)),
+    full_skill_injection: includesAny(text, ['## Workflow Handoff', '## 下一步调用', 'current_skill:', 'next_skill:', 'handoff:', 'stop_condition:']),
+    context_length: text.length,
+  };
+}
+
+function forbiddenTriggerSignals(context) {
+  const text = stringValue(context);
+  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,
+    /auto-run\s+next_skill/i,
+    /hidden_execution\s*=\s*true/i,
+    /command_execution\s*=\s*true/i,
+    /skill_execution_claimed\s*=\s*true/i,
+    /subagent_dispatch_claimed\s*=\s*true/i,
+    /git_write_claimed\s*=\s*true/i,
+    /platform_api\s*=\s*true/i,
+    /model_invocation\s*=\s*true/i,
+    /business_source_write\s*=\s*true/i,
+    /\b--confirm\b/i,
+    /\b--dispatch\b/i,
+  ];
+  return patterns.flatMap((pattern) => {
+    const match = text.match(pattern);
+    if (!match) return [];
+    const contextWindow = text.slice(Math.max(0, match.index - 80), match.index + match[0].length + 32);
+    if (/do not|does not|without|no |must not|禁止|不|未|不会|不要|无需/.test(contextWindow.toLowerCase())) return [];
+    return [`context suggests forbidden session-start trigger: ${match[0]}`];
+  });
+}
+
+function outputSummary(normalized) {
+  return {
+    json_parse_ok: normalized.json_parse_ok,
+    context_path: normalized.context_path,
+    context_length: normalized.context.length,
+    unexpected_fields: normalized.unexpected_fields,
+  };
+}
+
+function sourceBindingSummary(source, normalized) {
+  return {
+    captured_output_file: stringValue(source.captured_output_file),
+    captured_output_digest: stringValue(source.captured_output_digest),
+    requested_adapter: stringValue(source.requested_adapter),
+    output_adapter: normalized.adapter,
+  };
+}
+
+function gate(name, pass, findings) {
+  return { gate: name, pass: Boolean(pass), findings: pass ? [] : findings };
+}
+
+function parseJson(text) {
+  try {
+    return { ok: true, value: JSON.parse(text), error: '' };
+  } catch (error) {
+    return { ok: false, value: null, error: error.message };
+  }
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(objectValue(object), key);
+}
+
+function includesAny(text, markers) {
+  return markers.some((marker) => stringValue(text).toLowerCase().includes(marker.toLowerCase()));
+}
+
+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;
+}