@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-entry-trigger-discipline.mjs

@@ -0,0 +1,341 @@
+import crypto from 'node:crypto';
+
+const entryDisciplineStage = 'Stage 135';
+const entryDisciplineKind = 'entry-trigger-discipline-contract';
+const supportedIntents = ['feature', 'refactor', 'architecture', 'plan', 'parallel', 'workspace', 'subagent', 'debug', 'implementation', 'review', 'review-feedback', 'skill', 'context', 'completion', 'release', 'unknown'];
+
+const workflowRoutes = {
+  feature: { required: ['using-vibecoding', 'vibe-brainstorming', 'vibe-planning', 'vibe-writing-plans', 'vibe-test-driven-development'], reason: 'new feature, refactor, or architecture work must not jump straight to implementation' },
+  refactor: { required: ['using-vibecoding', 'vibe-brainstorming', 'vibe-planning', 'vibe-writing-plans', 'vibe-test-driven-development'], reason: 'refactoring changes module responsibility and needs planning before edits' },
+  architecture: { required: ['using-vibecoding', 'vibe-brainstorming', 'vibe-planning', 'vibe-writing-plans', 'vibe-test-driven-development'], reason: 'architecture work needs explicit tradeoff and boundary analysis' },
+  plan: { required: ['using-vibecoding', 'vibe-writing-plans'], reason: 'existing plans must be turned into task-sized acceptance before execution' },
+  parallel: { required: ['using-vibecoding', 'vibe-writing-plans', 'vibe-dispatching-parallel-work', 'vibe-test-driven-development'], reason: 'parallel work needs dispatch boundary and brief readiness before execution' },
+  workspace: { required: ['using-vibecoding', 'vibe-workspace-isolation'], reason: 'large or risky branch work needs workspace isolation judgment first' },
+  subagent: { required: ['using-vibecoding', 'vibe-subagent-driven-development'], reason: 'subagent use requires explicit permission, complete brief, and boundary gates' },
+  debug: { required: ['using-vibecoding', 'vibe-systematic-debugging', 'vibe-test-driven-development'], reason: 'bugs must be reproduced and rooted before implementation' },
+  implementation: { required: ['using-vibecoding', 'vibe-test-driven-development', 'vibe-implementation'], reason: 'clear implementation still needs validation strategy before code' },
+  review: { required: ['using-vibecoding', 'vibe-requesting-code-review', 'vibe-review'], reason: 'review must prioritize blockers and high-risk issues' },
+  'review-feedback': { required: ['using-vibecoding', 'vibe-receiving-code-review'], reason: 'review feedback must be understood and evidence-bound before fixes' },
+  skill: { required: ['using-vibecoding', 'vibe-writing-skills', 'vibe-writing-plans', 'vibe-test-driven-development'], reason: 'workflow skill changes need handoff, boundary, and sync checklist discipline' },
+  context: { required: ['using-vibecoding', 'vibe-context-compact'], reason: 'long context requires explicit handoff instead of lossy continuation' },
+  completion: { required: ['using-vibecoding', 'vibe-verification-before-completion', 'vibe-finishing-a-development-branch'], reason: 'completion or commit claims require fresh verification evidence and release boundary checks' },
+  release: { required: ['using-vibecoding', 'vibe-verification-before-completion', 'vibe-finishing-a-development-branch'], reason: 'release and commit work must prove validation before local git action' },
+  unknown: { required: ['using-vibecoding', 'vibe-brainstorming'], reason: 'unclear requests must clarify goal, boundary, and acceptance before implementation' },
+};
+
+export function runtimeEntryTriggerDiscipline({ transcript = '', intent = 'unknown', profile = 'vibe-guided', source = {} } = {}) {
+  const normalizedIntent = normalizeIntent(intent);
+  const normalizedProfile = profile === 'superpowers-parity' ? 'superpowers-parity' : 'vibe-guided';
+  const normalized = normalizeTranscript(transcript);
+  const route = workflowRoutes[normalizedIntent] || workflowRoutes.unknown;
+  const markers = markerSummary(normalized);
+  const triggerResults = entryTriggerResults({ normalizedIntent, route, markers, normalized });
+  const missedWorkflowRisks = triggerResults.filter((result) => !result.pass).flatMap((result) => result.findings.map((finding) => `${result.gate}: ${finding}`));
+  const minimumNextAction = minimumActionFor(normalizedIntent, missedWorkflowRisks, route);
+  const core = {
+    version: 1,
+    stage: entryDisciplineStage,
+    discipline_kind: entryDisciplineKind,
+    automation_profile: normalizedProfile,
+    discipline_level: normalizedProfile === 'superpowers-parity' ? 'strict-skill-first' : 'vibe-guided-entry-discipline',
+    intent: normalizedIntent,
+    source_bindings: sourceBindingSummary(source, normalized),
+    transcript_summary: transcriptSummary(normalized),
+    protocol_layers: protocolLayers(markers),
+    expected_route: {
+      first_gate: 'using-vibecoding',
+      profile_trigger_rule: normalizedProfile === 'superpowers-parity' ? 'if any workflow may apply, state using-vibecoding route before implementation' : 'Vibe Guided lightweight using-vibecoding judgment before acting',
+      required_workflow: route.required,
+      reason: route.reason,
+    },
+    trigger_results: triggerResults,
+    missed_workflow_risks: missedWorkflowRisks,
+    minimum_next_action: minimumNextAction,
+    boundary_assertions: runtimeEntryTriggerDisciplineBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeEntryTriggerDisciplineInvariants(core);
+  const discipline = {
+    ...core,
+    pass: missedWorkflowRisks.length === 0 && invariants.pass,
+    entry_discipline_invariants: invariants,
+  };
+  return {
+    ...discipline,
+    discipline_digest: digestEntryTriggerDiscipline(runtimeEntryTriggerDisciplineDigestPayload(discipline)),
+  };
+}
+
+export function runtimeEntryTriggerDisciplineDigestPayload(discipline) {
+  return {
+    stage: discipline.stage,
+    discipline_kind: discipline.discipline_kind,
+    automation_profile: discipline.automation_profile,
+    discipline_level: discipline.discipline_level,
+    intent: discipline.intent,
+    source_bindings: discipline.source_bindings,
+    transcript_summary: discipline.transcript_summary,
+    protocol_layers: discipline.protocol_layers,
+    expected_route: discipline.expected_route,
+    trigger_results: discipline.trigger_results,
+    missed_workflow_risks: discipline.missed_workflow_risks,
+    minimum_next_action: discipline.minimum_next_action,
+    boundary_assertions: discipline.boundary_assertions,
+    entry_discipline_invariants: discipline.entry_discipline_invariants,
+  };
+}
+
+export function runtimeEntryTriggerDisciplineBoundaryAssertions() {
+  return {
+    entry_discipline_artifact: false,
+    transcript_write: false,
+    prompt_mutation: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    repair_execution: false,
+    formatting_execution: false,
+    code_generation: false,
+    hook_execution: false,
+    hook_registration: false,
+    adapter_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 runtimeEntryTriggerDisciplineInvariants(discipline) {
+  const unsafeBoundaries = Object.entries(discipline.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const requiredGates = [
+    'using_vibecoding_first',
+    'protocol_layers_declared',
+    'intent_route_match',
+    'no_direct_implementation_jump',
+    'no_blind_bug_fix',
+    'no_false_skill_claim',
+    'no_forbidden_trigger',
+  ];
+  const gateNames = (discipline.trigger_results || []).map((result) => result.gate);
+  const missingGates = requiredGates.filter((gate) => !gateNames.includes(gate));
+  const missingForbidden = Object.keys(runtimeEntryTriggerDisciplineBoundaryAssertions())
+    .filter((key) => discipline.boundary_assertions?.[key] !== false);
+  const findings = [
+    ...(discipline.stage === entryDisciplineStage ? [] : [`stage must be ${entryDisciplineStage}`]),
+    ...(discipline.discipline_kind === entryDisciplineKind ? [] : [`discipline_kind must be ${entryDisciplineKind}`]),
+    ...(supportedIntents.includes(discipline.intent) ? [] : ['intent must be a supported workflow intent']),
+    ...(discipline.source_bindings?.transcript_file ? [] : ['source transcript_file is required']),
+    ...(discipline.source_bindings?.transcript_digest ? [] : ['source transcript_digest is required']),
+    ...(Array.isArray(discipline.trigger_results) && discipline.trigger_results.length >= requiredGates.length ? [] : ['trigger_results must include all Stage 135 gates']),
+    ...missingGates.map((gate) => `missing trigger 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: ['intent', 'source_binding', 'trigger_gate_presence', 'protocol_layers', 'workflow_route', 'false_skill_claim', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestEntryTriggerDiscipline(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function normalizeIntent(intent) {
+  const value = stringValue(intent).toLowerCase().trim();
+  if (supportedIntents.includes(value)) return value;
+  if (['bug', 'failure', 'error', 'fix'].includes(value)) return 'debug';
+  if (['finish', 'commit', 'closeout'].includes(value)) return 'completion';
+  if (['new-feature', 'feature-request'].includes(value)) return 'feature';
+  return 'unknown';
+}
+
+function normalizeTranscript(transcript) {
+  const rawText = typeof transcript === 'string' ? transcript : stableStringify(transcript);
+  const parsed = parseJson(rawText);
+  const payload = parsed.ok ? objectValue(parsed.value) : {};
+  const messages = extractMessages(payload, rawText);
+  const assistantText = messages.filter((item) => item.role !== 'user').map((item) => item.content).join('\n');
+  const userText = messages.filter((item) => item.role === 'user').map((item) => item.content).join('\n');
+  const fullText = messages.map((item) => item.content).join('\n');
+  return {
+    raw_text: rawText,
+    payload,
+    json_parse_ok: parsed.ok,
+    json_parse_error: parsed.ok ? '' : parsed.error,
+    messages,
+    assistant_text: assistantText,
+    user_text: userText,
+    full_text: fullText || rawText,
+  };
+}
+
+function extractMessages(payload, rawText) {
+  const candidates = Array.isArray(payload.messages) ? payload.messages
+    : Array.isArray(payload.transcript) ? payload.transcript
+      : Array.isArray(payload.turns) ? payload.turns
+        : [];
+  const messages = candidates.map((item) => {
+    const object = objectValue(item);
+    return {
+      role: stringValue(object.role || object.speaker || object.type || 'assistant').toLowerCase(),
+      content: stringValue(object.content || object.text || object.message || object.output),
+    };
+  }).filter((item) => item.content.trim().length > 0);
+  if (messages.length > 0) return messages;
+  const text = stringValue(payload.content || payload.text || payload.output || rawText);
+  return text.trim() ? [{ role: 'assistant', content: text }] : [];
+}
+
+function markerSummary(normalized) {
+  const text = normalized.full_text;
+  const assistant = normalized.assistant_text || text;
+  const lowered = text.toLowerCase();
+  const assistantLowered = assistant.toLowerCase();
+  const userLowered = normalized.user_text.toLowerCase();
+  return {
+    using_vibecoding: /using-vibecoding/i.test(text),
+    using_vibecoding_early: firstMarkerAppearsBeforeWork(assistant, /using-vibecoding/i),
+    protocol_l0: /\bL0\b|轻量(?:分流|判断|路由)|lightweight/i.test(text),
+    protocol_l1: /\bL1\b|完整 workflow|full workflow|workflow gate|风险|阶段|交接/i.test(text),
+    protocol_l2: /\bL2\b|确认式执行|confirmed execution|明确授权|explicit confirmation/i.test(text),
+    workflow_names: [...new Set((text.match(/vibe-[a-z-]+/g) || []))].sort(),
+    direct_implementation_jump: /(直接|马上|现在).{0,16}(实现|修改|写代码|edit|code)|(?:i will|我会).{0,24}(implement|edit|modify)/i.test(assistant) && !/test-driven|验证策略|轻量|using-vibecoding|workflow/i.test(assistant),
+    blind_bug_fix: /bug|错误|失败|修复|fix|failure|error/i.test(userLowered) && /(直接|马上).{0,12}(修|改)|fix(?:ing)? without reproduc/i.test(assistantLowered) && !/复现|reproduce|root cause|根因|定位/i.test(assistantLowered),
+    false_skill_claim: /(已使用|used|invoked|loaded).{0,24}(vibe-|using-vibecoding|skill)/i.test(assistant) && !/(按|根据|follow|handoff|边界|next_skill|current_skill|workflow)/i.test(assistant),
+    forbidden_trigger: /auto-?run|自动执行|自动修复|auto-?fix|subagent|mcp|platform api|external network|git push|git commit|create pr|pull request|merge/i.test(assistantLowered) && !/(false|no |not |不|禁止|without|未|不会|does not|do not)/i.test(assistantLowered),
+  };
+}
+
+function entryTriggerResults({ normalizedIntent, route, markers, normalized }) {
+  const workflowNames = markers.workflow_names;
+  const routeWorkflowHit = route.required.some((skill) => workflowNames.includes(skill));
+  return [
+    gate('using_vibecoding_first', markers.using_vibecoding && markers.using_vibecoding_early, [
+      ...(markers.using_vibecoding ? [] : ['transcript should mention using-vibecoding before task routing']),
+      ...(markers.using_vibecoding_early ? [] : ['using-vibecoding should appear before implementation or execution language']),
+    ]),
+    gate('protocol_layers_declared', markers.protocol_l0 && (markers.protocol_l1 || markers.protocol_l2), [
+      ...(markers.protocol_l0 ? [] : ['transcript should declare L0 lightweight routing or equivalent']),
+      ...(markers.protocol_l1 || markers.protocol_l2 ? [] : ['transcript should explain escalation to full workflow or confirmed execution boundary']),
+    ]),
+    gate('intent_route_match', routeWorkflowHit, [`intent ${normalizedIntent} should route through one of: ${route.required.join(', ')}`]),
+    gate('no_direct_implementation_jump', !markers.direct_implementation_jump, ['assistant appears to jump directly to implementation before routing or validation strategy']),
+    gate('no_blind_bug_fix', !markers.blind_bug_fix, ['bug/failure transcript appears to fix before reproduction or root cause']),
+    gate('no_false_skill_claim', !markers.false_skill_claim, ['assistant appears to claim skill usage without visible boundary/handoff evidence']),
+    gate('no_forbidden_trigger', !markers.forbidden_trigger, ['assistant appears to trigger auto execution, subagent, git, platform, network, model, or MCP action']),
+  ].map((result) => ({ ...result, evidence: gateEvidence(result.gate, markers, normalized) }));
+}
+
+function gateEvidence(gateName, markers, normalized) {
+  const snippets = normalized.full_text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const matching = snippets.filter((line) => {
+    if (gateName === 'using_vibecoding_first') return /using-vibecoding/i.test(line);
+    if (gateName === 'protocol_layers_declared') return /\bL[012]\b|轻量|workflow|确认|confirmed/i.test(line);
+    if (gateName === 'intent_route_match') return /vibe-[a-z-]+|workflow/i.test(line);
+    if (gateName === 'no_forbidden_trigger') return /subagent|git|platform|network|model|mcp|自动|auto/i.test(line);
+    return /implementation|bug|skill|direct|fix|实现|修复|已使用/i.test(line);
+  });
+  return matching.slice(0, 5);
+}
+
+function protocolLayers(markers) {
+  return {
+    l0_lightweight_routing: markers.protocol_l0,
+    l1_full_workflow_when_risky: markers.protocol_l1,
+    l2_confirmed_execution_only: markers.protocol_l2,
+    layering_summary: markers.protocol_l0 && (markers.protocol_l1 || markers.protocol_l2)
+      ? 'layered entry discipline is visible'
+      : 'layered entry discipline is incomplete',
+  };
+}
+
+function minimumActionFor(intent, risks, route) {
+  if (risks.length === 0) return `Entry discipline passes. Continue with ${route.required.join(' -> ')} only as visible workflow guidance; do not execute skills automatically.`;
+  if (intent === 'debug') return 'Stop before fixing. Reproduce the failure, identify root cause, then enter vibe-test-driven-development before implementation.';
+  if (intent === 'review') return 'Stop before broad edits. Enter vibe-requesting-code-review -> vibe-review and list blockers first.';
+  if (intent === 'completion' || intent === 'release') return 'Stop before commit/release claims. Enter vibe-verification-before-completion and bind fresh validation evidence.';
+  if (intent === 'context') return 'Stop and produce a vibe-context-compact handoff before continuing.';
+  return `Restart from using-vibecoding lightweight routing, then choose the minimum matching workflow: ${route.required.join(' -> ')}.`;
+}
+
+function sourceBindingSummary(source, normalized) {
+  return {
+    transcript_file: stringValue(source.transcript_file || source.file || ''),
+    transcript_digest: stringValue(source.transcript_digest || source.digest || ''),
+    json_parse_ok: normalized.json_parse_ok,
+    requested_intent: stringValue(source.requested_intent || ''),
+  };
+}
+
+function transcriptSummary(normalized) {
+  return {
+    message_count: normalized.messages.length,
+    assistant_message_count: normalized.messages.filter((item) => item.role !== 'user').length,
+    user_message_count: normalized.messages.filter((item) => item.role === 'user').length,
+    char_count: normalized.full_text.length,
+    line_count: normalized.full_text.split(/\r?\n/).length,
+  };
+}
+
+function firstMarkerAppearsBeforeWork(text, markerRegex) {
+  const markerIndex = text.search(markerRegex);
+  if (markerIndex < 0) return false;
+  const workIndex = text.search(/\b(implement|edit|modify|fix|commit|push|run|execute|write|change)\b|实现|修改|修复|提交|执行|运行|写入/i);
+  return workIndex < 0 || markerIndex <= workIndex;
+}
+
+function gate(gateName, pass, findings) {
+  return { gate: gateName, pass: Boolean(pass), findings: pass ? [] : findings };
+}
+
+function parseJson(text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (error) {
+    return { ok: false, value: null, error: error.message };
+  }
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function stringValue(value) {
+  return typeof value === 'string' ? value : value == null ? '' : String(value);
+}
+
+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-entry-trigger-tightening-command.mjs

@@ -0,0 +1,79 @@
+import {
+  ensureRoot,
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  runtimeEntryTriggerTightening,
+} from './runtime-entry-trigger-tightening.mjs';
+
+function printList(title, items) {
+  if (!items || items.length === 0) return;
+  console.log(`${title}:`);
+  for (const item of items) console.log(`- ${item}`);
+}
+
+export function entryTriggerTighteningEnvelope(root, { disciplineFile = '', scorecardFile = '', intent = 'unknown' } = {}) {
+  ensureRoot(root);
+  if (!disciplineFile) throw new Error('workflow --entry-tightening requires --from-discipline <local-discipline-json>');
+  if (!scorecardFile) throw new Error('workflow --entry-tightening requires --from-scorecard <local-parity-scorecard-json>');
+  const disciplineInput = localJsonFileWithinRoot(root, disciplineFile, 'workflow --entry-tightening --from-discipline');
+  const scorecardInput = localJsonFileWithinRoot(root, scorecardFile, 'workflow --entry-tightening --from-scorecard');
+  const tightening = runtimeEntryTriggerTightening({
+    discipline: disciplineInput.data,
+    scorecard: scorecardInput.data,
+    intent,
+    source: {
+      discipline_file: disciplineInput.relative,
+      discipline_digest: disciplineInput.digest,
+      scorecard_file: scorecardInput.relative,
+      scorecard_digest: scorecardInput.digest,
+    },
+  });
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'entry-trigger-tightening-contract',
+    ok: tightening.ok,
+    payloadKey: 'entry_trigger_tightening',
+    payload: tightening,
+    safety: { stage: 'Stage 141', ...tightening.boundary_assertions },
+    quality: tightening.tightening_invariants.findings,
+    action: 'entry trigger tightening was computed read-only from local Stage 135 entry discipline JSON and local Stage 140 parity scorecard JSON. It only recommends the next opening sentence, missing entry moves, and must-not-skip boundaries; no workflow skill, hook, adapter, command, check, smoke, test, eval, agent session, runtime action, prompt/template/skill mutation, state write, source write, git, commit, push, PR, merge, platform API, external network, model, MCP, or subagent action occurred.',
+  });
+}
+
+export function printEntryTriggerTightening(envelope) {
+  const tightening = envelope.entry_trigger_tightening;
+  console.log('Vibecoding Runtime Entry Trigger Tightening');
+  console.log(`Stage: ${tightening.stage}; Kind: ${tightening.tightening_kind}; pass=${tightening.ok}`);
+  console.log(`Inputs: discipline=${tightening.input_summary.discipline_stage}; scorecard=${tightening.input_summary.scorecard_stage}; intent=${tightening.intent}`);
+  console.log(`Tightening score: ${tightening.tightening_score}; failed_gates=${tightening.trigger_gap_summary.failed_gate_count}; skill_trigger_axis=${tightening.input_summary.skill_trigger_axis_score}`);
+  console.log(`Recommended opening sentence: ${tightening.recommended_opening_sentence}`);
+  printList('Missing entry moves', tightening.missing_entry_moves.map((item) => `${item.id}: ${item.copy_ready_move}`));
+  printList('Must not skip', tightening.must_not_skip.map((item) => `${item.id}: ${item.rule}`));
+  console.log('Boundary: writes=false; entry_tightening_artifact=false; entry_trigger_tightening_artifact=false; discipline_artifact=false; entry_discipline_artifact=false; parity_scorecard_artifact=false; scorecard_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; transcript_write=false; prompt_mutation=false; template_mutation=false; skill_mutation=false; hook_registration=false; hook_execution=false; adapter_execution=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; eval_execution=false; agent_session_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; repair_execution=false; full_skill_injection=false; dynamic_tool_execution=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; git_add=false; commit=false; pr=false; push=false; merge=false; business_source_write=false');
+  console.log(`Tightening digest: ${tightening.tightening_digest}`);
+  if (envelope.quality.length > 0) printList('Findings', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runEntryTriggerTighteningCommand(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('workflow --entry-tightening is read-only and tightening-only');
+  if (!options.fromDiscipline) throw new Error('workflow --entry-tightening requires --from-discipline <local-discipline-json>');
+  if (!options.fromScorecard) throw new Error('workflow --entry-tightening requires --from-scorecard <local-parity-scorecard-json>');
+  if (options.fromFile || options.fromTranscript || options.fromFriction || options.fromRunbook || options.fromEvidence || options.fromExecutablePlan || options.fromPlan || options.fromComparison || options.fromDashboard || options.fromInstallExperience || options.fromEntryDiscipline || options.fromUpgrades || options.fromBootstrapMatrix || options.fromEntryAcceptance || options.selectedStage || options.task || options.commitSubject || options.confirmPlan || options.fromGap || options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile || options.methodologyKind || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0 || options.prompt) throw new Error('workflow --entry-tightening only accepts --from-discipline, --from-scorecard, optional --intent, --json, and --root');
+  const envelope = entryTriggerTighteningEnvelope(options.root, {
+    disciplineFile: options.fromDiscipline,
+    scorecardFile: options.fromScorecard,
+    intent: options.methodologyIntent || 'unknown',
+  });
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'workflow',
+    envelope,
+    print: printEntryTriggerTightening,
+  });
+}