@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-patch-queue-contract.mjs

@@ -0,0 +1,151 @@
+const defaultPatchQueueBudget = Object.freeze({
+  max_files: 5,
+  max_patch_bytes: 20000,
+  foreground_required: true,
+  approval_required: true,
+});
+
+const forbiddenApplySignals = Object.freeze([
+  'auto_apply',
+  'business_source_write',
+  'direct_worktree_mutation',
+  'runbook_executor_apply',
+  'repair_loop_apply',
+]);
+
+const highRiskPathPrefixes = Object.freeze([
+  'tools/vibe-runtime/index.mjs',
+  'tools/vibe-runtime/runtime-source-merge-apply-boundary-model.mjs',
+  'tools/vibe-runtime/runtime-source-merge-entry-command.mjs',
+  'tools/vibe-runtime/runtime-daemon-command.mjs',
+  'tools/vibe-runtime/runtime-scheduler-command.mjs',
+  'tools/vibe-runtime/runtime-retry-command.mjs',
+]);
+
+function normalizeRelativePath(value) {
+  const normalized = String(value || '').trim().replace(/\\/g, '/');
+  if (!normalized || normalized.startsWith('/') || normalized.includes('..')) return '';
+  return normalized.replace(/^\.\//, '');
+}
+
+function normalizePathList(values) {
+  return [...new Set((Array.isArray(values) ? values : [])
+    .map((item) => normalizeRelativePath(typeof item === 'string' ? item : item?.path))
+    .filter(Boolean))];
+}
+
+function firstArray(...values) {
+  return values.find((value) => Array.isArray(value)) || [];
+}
+
+function firstString(...values) {
+  return values.find((value) => typeof value === 'string' && value.trim()) || '';
+}
+
+function isWithinAllowedPath(file, allowedPath) {
+  return file === allowedPath || file.startsWith(`${allowedPath.replace(/\/$/, '')}/`);
+}
+
+function isHighRiskPath(file) {
+  return highRiskPathPrefixes.some((prefix) => file === prefix || file.startsWith(`${prefix.replace(/\/$/, '')}/`));
+}
+
+function normalizedBudget(rawBudget = {}) {
+  const maxFiles = Number(rawBudget.max_files ?? rawBudget.maxFiles ?? defaultPatchQueueBudget.max_files);
+  const maxPatchBytes = Number(rawBudget.max_patch_bytes ?? rawBudget.maxPatchBytes ?? defaultPatchQueueBudget.max_patch_bytes);
+  return {
+    ...defaultPatchQueueBudget,
+    max_files: Number.isFinite(maxFiles) && maxFiles > 0 ? Math.floor(maxFiles) : defaultPatchQueueBudget.max_files,
+    max_patch_bytes: Number.isFinite(maxPatchBytes) && maxPatchBytes > 0 ? Math.floor(maxPatchBytes) : defaultPatchQueueBudget.max_patch_bytes,
+  };
+}
+
+function blockedReasonsForItem({ allowedPaths, estimatedFiles, patchBytes, rollbackPatch, riskClass, budget, task }) {
+  const blocked = [];
+  if (allowedPaths.length === 0) blocked.push('path allowlist is required before patch queue apply');
+  if (estimatedFiles.length === 0) blocked.push('estimated changed files are required before patch queue apply');
+  for (const file of estimatedFiles) {
+    if (!allowedPaths.some((allowedPath) => isWithinAllowedPath(file, allowedPath))) blocked.push(`estimated file outside allowlist: ${file}`);
+    if (isHighRiskPath(file)) blocked.push(`high-risk runtime path requires separate source apply plan: ${file}`);
+  }
+  if (estimatedFiles.length > budget.max_files) blocked.push(`patch queue budget exceeded: files ${estimatedFiles.length}/${budget.max_files}`);
+  if (patchBytes > budget.max_patch_bytes) blocked.push(`patch queue budget exceeded: patch bytes ${patchBytes}/${budget.max_patch_bytes}`);
+  if (!String(rollbackPatch || '').trim()) blocked.push('rollback patch is required before patch queue apply');
+  if (['high', 'critical'].includes(String(riskClass || '').toLowerCase())) blocked.push(`risk classification ${riskClass} requires separate source apply approval`);
+  for (const signal of forbiddenApplySignals) {
+    if (task?.[signal] === true) blocked.push(`${signal} is forbidden in patch queue preview`);
+  }
+  return [...new Set(blocked)];
+}
+
+export function createPatchQueuePreviewContract({ task, taskFile, fileDigest, digestObject }) {
+  const parsed = task.parsed || {};
+  const taskId = firstString(parsed.task_id, parsed.id, parsed.task?.id, task.summary, 'manual-task').slice(0, 120);
+  const allowedPaths = normalizePathList(firstArray(parsed.allowed_paths, parsed.allowedFiles, parsed.path_allowlist, parsed.files, parsed.task?.files));
+  const estimatedFiles = normalizePathList(firstArray(parsed.estimated_changed_files, parsed.changed_files, parsed.files_touched, parsed.files, parsed.task?.files));
+  const verificationCommands = firstArray(parsed.verification_commands, parsed.validation_commands).map((item) => String(item || '').trim()).filter(Boolean);
+  const rollbackPatch = firstString(parsed.rollback_patch, parsed.rollbackPatch, parsed.rollback?.patch);
+  const patchText = firstString(parsed.patch, parsed.diff);
+  const patchBytes = Number.isFinite(Number(parsed.patch_bytes)) ? Number(parsed.patch_bytes) : patchText.length;
+  const riskClass = firstString(parsed.risk_classification, parsed.risk_class, parsed.risk, 'standard');
+  const budget = normalizedBudget(parsed.budget || parsed.patch_budget || {});
+  const diffDigest = firstString(parsed.diff_digest, parsed.patch_digest) || digestObject({ task_id: taskId, patch: patchText, estimated_files: estimatedFiles });
+  const blockedReasons = blockedReasonsForItem({ allowedPaths, estimatedFiles, patchBytes, rollbackPatch, riskClass, budget, task: parsed });
+  const status = blockedReasons.length === 0 ? 'ready-for-approval' : 'blocked';
+  const core = {
+    version: 1,
+    stage: 'Stage 11',
+    queue_item_kind: 'source-patch-queue-item',
+    task_id: taskId,
+    task_file: taskFile,
+    task_digest: fileDigest,
+    allowed_paths: allowedPaths,
+    diff_digest: diffDigest,
+    estimated_changed_files: estimatedFiles,
+    risk_classification: riskClass,
+    rollback_patch: rollbackPatch,
+    rollback_digest: rollbackPatch ? digestObject({ rollback_patch: rollbackPatch }) : '',
+    verification_commands: verificationCommands,
+    patch_budget: budget,
+    patch_bytes: patchBytes,
+    source_apply_gate: {
+      status,
+      approval_required: true,
+      separate_approval_required: true,
+      foreground_required: true,
+      scope_enforced: true,
+      budget_enforced: true,
+      digest_required: true,
+      rollback_required: true,
+      runbook_executor_apply: false,
+      repair_loop_apply: false,
+      direct_worktree_mutation: false,
+    },
+    forbidden_actions: ['business source write by default', 'no rollback apply', 'cross scope apply', 'direct worktree mutation', 'hidden runbook executor apply', 'hidden repair loop apply'],
+    blocked_reasons: blockedReasons,
+    status,
+  };
+  return {
+    default_enabled: false,
+    preview_only: true,
+    apply_requires_explicit_approval: true,
+    real_apply_allowed: false,
+    items: [{ ...core, queue_item_digest: digestObject(core) }],
+    ready: status === 'ready-for-approval' ? [taskId] : [],
+    blocked: status === 'blocked' ? [{ task_id: taskId, blocked_reasons: blockedReasons }] : [],
+    safety: {
+      writes: false,
+      patch_plan: true,
+      queue_preview: true,
+      source_apply: false,
+      foreground_apply_required: true,
+      approval_required: true,
+      rollback_required: true,
+      git: false,
+      worktree: false,
+      daemon: false,
+      repair_loop: false,
+      runbook_executor: false,
+    },
+  };
+}

package/tools/vibe-runtime/runtime-plan-action-manifest.mjs

@@ -0,0 +1,334 @@
+import crypto from 'node:crypto';
+
+const planActionManifestStage = 'Stage 105';
+const planActionManifestKind = 'plan-to-action-manifest';
+const defaultPhases = ['plan', 'docs', 'code', 'self_test', 'commit_readiness'];
+
+export function runtimePlanActionManifest({
+  sourcePlan = {},
+  planLint = {},
+  workflowLoopContract = {},
+  automationReadiness = {},
+  registry = {},
+  registryDigest = '',
+  intent = 'implementation',
+} = {}) {
+  const text = String(sourcePlan.text || '');
+  const boundaryAssertions = runtimePlanActionManifestBoundaryAssertions();
+  const actionItems = extractActionItems(text).map((item, index) => actionItemContract(item, index, text));
+  const docsExpectations = extractDocsExpectations(text, actionItems);
+  const codeExpectations = extractCodeExpectations(text, actionItems);
+  const checkExpectations = extractCheckExpectations(text, actionItems);
+  const sourceBindings = {
+    plan_lint_stage: planLint.stage || '',
+    plan_lint_digest: planLint.lint_digest || '',
+    workflow_loop_contract_stage: workflowLoopContract.stage || '',
+    workflow_loop_contract_digest: workflowLoopContract.loop_contract_digest || '',
+    automation_readiness_stage: automationReadiness.stage || '',
+    automation_readiness_digest: automationReadiness.readiness_digest || '',
+    registry_stage: registry.registry_stage || '',
+    registry_kind: registry.registry_kind || '',
+    registry_version: registry.registry_version || 0,
+    registry_digest: registryDigest,
+  };
+  const manifest = {
+    version: 1,
+    stage: planActionManifestStage,
+    manifest_kind: planActionManifestKind,
+    input_intent: String(intent || '').trim() || 'implementation',
+    normalized_intent: String(intent || '').trim() || 'implementation',
+    source_plan: {
+      file: sourcePlan.file || '',
+      digest: sourcePlan.digest || '',
+      line_count: Number(sourcePlan.line_count || 0),
+    },
+    source_bindings: sourceBindings,
+    action_items: actionItems,
+    docs_expectations: docsExpectations,
+    code_expectations: codeExpectations,
+    check_expectations: checkExpectations,
+    handoff_order: defaultPhases,
+    next_manual_action: nextManualAction(actionItems, checkExpectations),
+    allowed_followup: ['Stage 106 self-test gate profile', 'Stage 107 commit readiness envelope', 'Stage 108 confirmed one-shot execution plan'],
+    forbidden_actions: [
+      'automation --plan creation from Stage 105',
+      'action item execution',
+      'test/check/repair execution',
+      'formatting or code generation',
+      'sidecar or .vibecoding-state write',
+      'business source mutation',
+      'git commit/push/PR/merge/tag',
+      'platform API, external network, model, MCP, or subagent invocation',
+    ],
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimePlanActionManifestInvariants(manifest);
+  return {
+    ...manifest,
+    manifest_invariants: invariants,
+    manual_action: invariants.pass
+      ? 'Plan-to-action manifest is ready. Use it as deterministic local expectations for implementation; do not execute action items or checks from Stage 105.'
+      : 'Fix the listed plan-to-action manifest gaps before using this manifest for later gate profiling.',
+  };
+}
+
+export function runtimePlanActionManifestInvariants(manifest) {
+  const actionItems = manifest.action_items || [];
+  const missingSourceBindings = ['plan_lint_digest', 'workflow_loop_contract_digest', 'automation_readiness_digest', 'registry_digest']
+    .filter((key) => !manifest.source_bindings?.[key]);
+  const incompleteActions = actionItems
+    .filter((item) => !item.id || !item.phase || !item.title
+      || !Array.isArray(item.target_files)
+      || !Array.isArray(item.required_evidence) || item.required_evidence.length === 0
+      || !Array.isArray(item.recommended_checks)
+      || !Array.isArray(item.stop_conditions) || item.stop_conditions.length === 0
+      || item.execution_authorized !== false)
+    .map((item) => item.id || item.title || 'unknown');
+  const executableExpectations = [
+    ...actionItems.filter((item) => item.execution_authorized !== false).map((item) => `action:${item.id}`),
+    ...(manifest.check_expectations || []).filter((item) => item.execution_authorized !== false).map((item) => `check:${item.command || item.id}`),
+  ];
+  const writableBoundaries = Object.entries(manifest.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const forbiddenMissing = ['command_execution', 'test_execution', 'git', 'push', 'pr', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write']
+    .filter((key) => manifest.boundary_assertions?.[key] !== false);
+  const expectationGaps = [
+    ...(actionItems.length === 0 ? ['action_items must not be empty'] : []),
+    ...((manifest.check_expectations || []).length === 0 ? ['check_expectations must not be empty'] : []),
+  ];
+  const executionLeak = (manifest.allowed_followup || [])
+    .filter((item) => /execute|\brun\b|git commit|push|merge|\bpr\b|automation --plan/i.test(item));
+
+  const findings = [
+    ...expectationGaps,
+    ...missingSourceBindings.map((item) => `missing source binding: ${item}`),
+    ...incompleteActions.map((item) => `incomplete or executable action item: ${item}`),
+    ...executableExpectations.map((item) => `execution must not be authorized: ${item}`),
+    ...writableBoundaries.map((item) => `boundary assertion must remain false: ${item}`),
+    ...forbiddenMissing.map((item) => `forbidden boundary missing or not false: ${item}`),
+    ...executionLeak.map((item) => `allowed followup must not grant execution: ${item}`),
+  ];
+
+  return {
+    pass: findings.length === 0,
+    checked: [
+      'source_digest_bindings',
+      'action_item_schema',
+      'docs_code_check_expectations',
+      'execution_authorized_false',
+      'read_only_boundary_assertions',
+      'no_execution_followup',
+    ],
+    findings,
+  };
+}
+
+export function runtimePlanActionManifestBoundaryAssertions() {
+  return {
+    plan_action_manifest_artifact: false,
+    automation_plan_artifact: false,
+    one_shot_execution_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    runtime_action: false,
+    workflow_execution: false,
+    verification_execution: false,
+    test_execution: false,
+    repair_execution: false,
+    formatting_execution: false,
+    code_generation: false,
+    scheduler: false,
+    daemon: false,
+    retry: false,
+    git: false,
+    git_write: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    worktree: false,
+    business_source_write: false,
+    source_merge: false,
+  };
+}
+
+export function runtimePlanActionManifestDigestPayload(manifest) {
+  return {
+    stage: manifest.stage,
+    manifest_kind: manifest.manifest_kind,
+    input_intent: manifest.input_intent,
+    normalized_intent: manifest.normalized_intent,
+    source_plan: manifest.source_plan,
+    source_bindings: manifest.source_bindings,
+    action_items: manifest.action_items,
+    docs_expectations: manifest.docs_expectations,
+    code_expectations: manifest.code_expectations,
+    check_expectations: manifest.check_expectations,
+    handoff_order: manifest.handoff_order,
+    next_manual_action: manifest.next_manual_action,
+    allowed_followup: manifest.allowed_followup,
+    forbidden_actions: manifest.forbidden_actions,
+    boundary_assertions: manifest.boundary_assertions,
+    manifest_invariants: manifest.manifest_invariants,
+  };
+}
+
+export function digestPlanActionManifest(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function extractActionItems(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  const candidates = [];
+  for (const [index, raw] of lines.entries()) {
+    const line = raw.trim();
+    if (!line) continue;
+    const checkbox = line.match(/^- \[[ xX]\]\s+(.+)$/);
+    const numbered = line.match(/^\d+[.)]\s+(.+)$/);
+    const heading = line.match(/^#{2,4}\s+(.+)$/);
+    const bullet = line.match(/^-\s+(Stage\s+\d+|Task\b|Add\b|Update\b|Run\b|Validate\b|Implement\b|Create\b|Sync\b|Reject\b|任务|阶段|修改|新增|验证|检查|文档|实现).+/i);
+    const title = checkbox?.[1] || numbered?.[1] || heading?.[1] || bullet?.[0]?.replace(/^[-#\s]+/, '') || '';
+    if (title) candidates.push({ title: title.trim(), line: index + 1 });
+  }
+  return dedupeByTitle(candidates).slice(0, 30);
+}
+
+function actionItemContract(item, index, planText) {
+  const phase = classifyPhase(item.title);
+  return {
+    id: `stage105-action-${String(index + 1).padStart(2, '0')}-${slugify(item.title)}`,
+    phase,
+    title: item.title,
+    source_line: item.line,
+    target_files: extractPaths(item.title).length > 0 ? extractPaths(item.title) : phase === 'code' ? extractPaths(planText).filter((file) => !isDocsPath(file)).slice(0, 12) : [],
+    required_evidence: evidenceForPhase(phase),
+    recommended_checks: checksForPhase(phase, planText),
+    stop_conditions: stopConditionsForPhase(phase),
+    execution_authorized: false,
+  };
+}
+
+function extractDocsExpectations(text, actionItems) {
+  const docFiles = extractPaths(text).filter(isDocsPath);
+  const docActions = actionItems.filter((item) => item.phase === 'docs').map((item) => item.title);
+  return [...new Set([...docFiles, ...docActions])].slice(0, 20).map((item, index) => ({
+    id: `docs-${String(index + 1).padStart(2, '0')}`,
+    expectation: item,
+    evidence_required: 'documentation sync evidence or explicit docs-not-needed reason',
+    execution_authorized: false,
+  }));
+}
+
+function extractCodeExpectations(text, actionItems) {
+  const codeFiles = extractPaths(text).filter((file) => !isDocsPath(file));
+  const codeActions = actionItems.filter((item) => item.phase === 'code').map((item) => item.title);
+  return [...new Set([...codeFiles, ...codeActions])].slice(0, 30).map((item, index) => ({
+    id: `code-${String(index + 1).padStart(2, '0')}`,
+    expectation: item,
+    evidence_required: 'bounded implementation diff with no unrelated rewrite',
+    execution_authorized: false,
+  }));
+}
+
+function extractCheckExpectations(text, actionItems) {
+  const commandMatches = [...new Set((String(text || '').match(/\b(?:node|npm|pnpm|yarn|git|pytest|python|tsc|eslint|vitest|jest)\s+[^\n`]+/gi) || []).map((item) => item.trim()))];
+  const phaseChecks = actionItems.flatMap((item) => item.recommended_checks || []);
+  return [...new Set([...commandMatches, ...phaseChecks])].slice(0, 30).map((command, index) => ({
+    id: `check-${String(index + 1).padStart(2, '0')}`,
+    command,
+    evidence_required: 'fresh check output or explicit blocked verification reason',
+    execution_authorized: false,
+  }));
+}
+
+function classifyPhase(title) {
+  if (/docs?|readme|roadmap|marker|文档|路线/i.test(title)) return 'docs';
+  if (/check|test|smoke|verify|verification|runtime-check|release-check|验证|自测|检查/i.test(title)) return 'self_test';
+  if (/commit|release|evidence|收口|提交/i.test(title)) return 'commit_readiness';
+  if (/plan|manifest|lint|计划/i.test(title)) return 'plan';
+  return 'code';
+}
+
+function evidenceForPhase(phase) {
+  const table = {
+    plan: ['plan lint result', 'manifest action item mapping'],
+    docs: ['documentation marker or docs-not-needed reason'],
+    code: ['changed file scope', 'task-level acceptance target'],
+    self_test: ['syntax/check output or manual verification evidence'],
+    commit_readiness: ['status/stat review', 'explicit no-push boundary'],
+  };
+  return table[phase] || table.code;
+}
+
+function checksForPhase(phase, text) {
+  if (phase === 'self_test') {
+    const commands = [...new Set((String(text || '').match(/\b(?:node|git)\s+[^\n`]+/gi) || []).map((item) => item.trim()))];
+    return commands.length > 0 ? commands.slice(0, 8) : ['node --check <changed-runtime-files>', 'node tools/vibe-runtime-check/index.mjs --root <root>'];
+  }
+  if (phase === 'docs') return ['node tools/vibe-runtime-check/index.mjs --root <root>'];
+  if (phase === 'commit_readiness') return ['git diff --check', 'git status --short; git diff --stat'];
+  if (phase === 'plan') return ['planner --lint --from-file <local-plan-file> --json'];
+  return ['node --check <changed-runtime-files>'];
+}
+
+function stopConditionsForPhase(phase) {
+  const common = ['request to execute without explicit user confirmation', 'scope expands beyond accepted plan'];
+  const table = {
+    plan: ['missing task-level acceptance', 'plan source cannot be read', ...common],
+    docs: ['docs claim runtime behavior not backed by code/check marker', ...common],
+    code: ['source mutation outside accepted scope', 'unrelated working tree changes are not understood', ...common],
+    self_test: ['failed check without root-cause follow-up', 'test would write outside sandbox', ...common],
+    commit_readiness: ['commit requested without status/stat review', 'push/PR/merge requested without explicit authorization', ...common],
+  };
+  return table[phase] || table.code;
+}
+
+function nextManualAction(actionItems, checkExpectations) {
+  if (actionItems.length === 0) return 'Fix the source plan so it contains task-sized action items before Stage 106.';
+  if (checkExpectations.length === 0) return 'Add explicit verification/check expectations before Stage 106.';
+  return 'Use this manifest as the local task/evidence contract for implementation, then derive a Stage 106 self-test gate profile.';
+}
+
+function extractPaths(text) {
+  const backtickPathMatches = (String(text || '').match(/`[^`]+\.(?:mjs|js|ts|tsx|json|md|yml|yaml|py|go|rs|java|css|scss|html)`/g) || []).map((item) => item.slice(1, -1));
+  const barePathMatches = String(text || '').match(/\b(?:[\w.-]+[\\/])+[\w.-]+\.(?:mjs|js|ts|tsx|json|md|yml|yaml|py|go|rs|java|css|scss|html)\b/g) || [];
+  return [...new Set([...backtickPathMatches, ...barePathMatches].map((item) => item.replace(/\\/g, '/')))].sort();
+}
+
+function isDocsPath(file) {
+  return /(^|\/)(docs|README|readme)|\.md$/i.test(file);
+}
+
+function dedupeByTitle(items) {
+  const seen = new Set();
+  return items.filter((item) => {
+    const key = item.title.toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function slugify(value) {
+  const slug = String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 32);
+  return slug || 'item';
+}
+
+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-planner-route-model.mjs

@@ -0,0 +1,75 @@
+export function plannerAllowedWorkflows() {
+  return {
+    ambiguous: ['vibe-brainstorming', 'vibe-planning', 'vibe-writing-plans'],
+    feature: ['vibe-brainstorming', 'vibe-planning', 'vibe-writing-plans', 'vibe-test-driven-development', 'vibe-executing-plans', 'vibe-verification-before-completion', 'vibe-finishing-a-development-branch'],
+    bug: ['vibe-systematic-debugging', 'vibe-test-driven-development', 'vibe-implementation', 'vibe-verification-before-completion'],
+    refactor: ['vibe-brainstorming', 'vibe-planning', 'vibe-writing-plans', 'vibe-test-driven-development', 'vibe-executing-plans', 'vibe-verification-before-completion'],
+    review: ['vibe-requesting-code-review', 'vibe-review'],
+    docs: ['vibe-writing-plans', 'vibe-test-driven-development', 'vibe-executing-plans'],
+  };
+}
+
+export function plannerRiskLevel(score) {
+  if (score >= 7) return 'high';
+  if (score >= 4) return 'medium';
+  return 'low';
+}
+
+export function plannerIntentType(text) {
+  const value = String(text || '').toLowerCase();
+  if (!value.trim()) return 'ambiguous';
+  if (/(review|code review|审查|review feedback)/.test(value)) return 'review';
+  if (/(bug|error|failure|异常|报错|失败|debug)/.test(value)) return 'bug';
+  if (/(refactor|restructure|重构|架构调整)/.test(value)) return 'refactor';
+  if (/(feature|新增|实现|implement|new feature|workflow|skill)/.test(value)) return 'feature';
+  if (/(doc|docs|readme|文档)/.test(value)) return 'docs';
+  return 'ambiguous';
+}
+
+export function plannerRouteDecision(input, { policyCatalogDigest = '' } = {}) {
+  const text = input.raw_text || '';
+  const intentType = plannerIntentType(text);
+  const lower = text.toLowerCase();
+  const taskLikeCount = (text.match(/(^|\n)\s*[-*\d]+[.)]?\s+/g) || []).length;
+  const multiTask = taskLikeCount >= 2 || /并行|parallel|multiple tasks|multi-task/.test(lower);
+  const highRisk = /workspace isolation|大改动|并行任务|risk|高风险|subagent|merge|apply/.test(lower);
+  const ambiguous = intentType === 'ambiguous' || /模糊|unclear|uncertain|brainstorm/.test(lower);
+  const workflows = plannerAllowedWorkflows();
+  let selectedWorkflow = workflows[intentType] || workflows.ambiguous;
+  const blockedReasons = [];
+  let riskScore = 1;
+  if (ambiguous) {
+    selectedWorkflow = workflows.ambiguous;
+    blockedReasons.push('ambiguous requirement requires brainstorming first');
+    riskScore += 2;
+  }
+  if (multiTask) riskScore += 2;
+  if (highRisk) riskScore += 4;
+  if (intentType === 'bug') riskScore += 2;
+  if (intentType === 'refactor') riskScore += 3;
+  const riskLevel = plannerRiskLevel(riskScore);
+  if (riskLevel === 'high' && !selectedWorkflow.includes('vibe-workspace-isolation')) {
+    selectedWorkflow = ['vibe-workspace-isolation', ...selectedWorkflow];
+  }
+  if (multiTask && !selectedWorkflow.includes('vibe-dispatching-parallel-work')) {
+    const insertAfter = selectedWorkflow.includes('vibe-writing-plans') ? selectedWorkflow.indexOf('vibe-writing-plans') + 1 : 1;
+    selectedWorkflow = [...selectedWorkflow.slice(0, insertAfter), 'vibe-dispatching-parallel-work', ...selectedWorkflow.slice(insertAfter)];
+  }
+  if (riskLevel === 'high' && !selectedWorkflow.includes('vibe-verification-before-completion')) {
+    selectedWorkflow = [...selectedWorkflow, 'vibe-verification-before-completion'];
+  }
+  return {
+    intent_type: intentType,
+    selected_workflow: selectedWorkflow,
+    workflow_candidates: [selectedWorkflow, workflows[intentType] || workflows.ambiguous],
+    risk_level: riskLevel,
+    risk_score: riskScore,
+    blocked_reasons: [...new Set(blockedReasons)],
+    policy_catalog_digest: policyCatalogDigest,
+    characteristics: {
+      ambiguous,
+      multi_task: multiTask,
+      high_risk: highRisk,
+    },
+  };
+}