@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-experience-learning-pattern.mjs

@@ -0,0 +1,354 @@
+import crypto from 'node:crypto';
+
+const experiencePatternStage = 'Stage 129';
+const experiencePatternKind = 'ecc-learning-experience-pattern-gate';
+const requiredWorkflow = ['vibe-writing-skills', 'vibe-writing-plans', 'vibe-test-driven-development'];
+
+export function runtimeExperienceLearningPattern({ friction = null, observations = [], source = {} } = {}) {
+  const normalizedFriction = normalizeFriction(friction);
+  const normalizedObservations = normalizeObservations(observations);
+  const repeatSignal = repeatSignalFor(normalizedFriction, normalizedObservations);
+  const candidatePatterns = candidatePatternsFor(normalizedFriction, normalizedObservations, repeatSignal);
+  const trigger = suggestedTriggerFor(candidatePatterns, repeatSignal);
+  const action = suggestedActionFor(candidatePatterns, repeatSignal);
+  const core = {
+    version: 1,
+    stage: experiencePatternStage,
+    pattern_kind: experiencePatternKind,
+    source_bindings: sourceBindingSummary(source, normalizedFriction, normalizedObservations),
+    friction_summary: frictionSummary(normalizedFriction),
+    observation_summary: observationSummary(normalizedObservations),
+    candidate_experience_patterns: candidatePatterns,
+    repeat_signal: repeatSignal,
+    suggested_instinct_trigger: trigger,
+    suggested_instinct_action: action,
+    promotion_required: true,
+    required_workflow: requiredWorkflow,
+    promotion_boundary: {
+      promotion_target: 'manual-skill-authoring',
+      automatic_promotion: false,
+      writes_formal_skills: false,
+      writes_agents_md: false,
+      writes_claude_md: false,
+      hook_registration: false,
+      prompt_mutation: false,
+      skill_mutation: false,
+      human_approval_required: true,
+    },
+    ecc_learning_boundary: {
+      absorbed: ['repeat-signal detection', 'candidate pattern extraction', 'explicit trigger/action proposal'],
+      rejected: ['agent-first delegation', 'automatic hook workflow', 'automatic skill or prompt mutation', 'cross-project memory propagation'],
+    },
+    boundary_assertions: runtimeExperienceLearningPatternBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeExperienceLearningPatternInvariants(core);
+  const pattern = {
+    ...core,
+    ok: invariants.pass,
+    experience_pattern_invariants: invariants,
+  };
+  return {
+    ...pattern,
+    experience_pattern_digest: digestExperienceLearningPattern(runtimeExperienceLearningPatternDigestPayload(pattern)),
+  };
+}
+
+export function runtimeExperienceLearningPatternDigestPayload(pattern) {
+  return {
+    stage: pattern.stage,
+    pattern_kind: pattern.pattern_kind,
+    source_bindings: pattern.source_bindings,
+    friction_summary: pattern.friction_summary,
+    observation_summary: pattern.observation_summary,
+    candidate_experience_patterns: pattern.candidate_experience_patterns,
+    repeat_signal: pattern.repeat_signal,
+    suggested_instinct_trigger: pattern.suggested_instinct_trigger,
+    suggested_instinct_action: pattern.suggested_instinct_action,
+    promotion_required: pattern.promotion_required,
+    required_workflow: pattern.required_workflow,
+    promotion_boundary: pattern.promotion_boundary,
+    ecc_learning_boundary: pattern.ecc_learning_boundary,
+    boundary_assertions: pattern.boundary_assertions,
+    experience_pattern_invariants: pattern.experience_pattern_invariants,
+  };
+}
+
+export function runtimeExperienceLearningPatternBoundaryAssertions() {
+  return {
+    experience_pattern_artifact: false,
+    learning_observation_write: false,
+    candidate_instinct_write: false,
+    learning_promotion_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    source_write: false,
+    skill_write: false,
+    writes_formal_skills: false,
+    writes_agents_md: false,
+    writes_claude_md: false,
+    prompt_mutation: false,
+    hook_registration: false,
+    shell_interception: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    automatic_promotion: false,
+    agent_first_delegation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeExperienceLearningPatternInvariants(pattern) {
+  const unsafeBoundaries = Object.entries(pattern.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = ['experience_pattern_artifact', 'learning_observation_write', 'candidate_instinct_write', 'learning_promotion_write', 'skill_write', 'writes_formal_skills', 'writes_agents_md', 'writes_claude_md', 'prompt_mutation', 'hook_registration', 'command_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'automatic_promotion', 'agent_first_delegation', 'subagent', 'mcp', 'platform_api', 'external_network', 'model_invocation', 'git', 'git_write', 'commit', 'pr', 'push', 'merge', 'business_source_write']
+    .filter((key) => pattern.boundary_assertions?.[key] !== false);
+  const requiredWorkflowMissing = requiredWorkflow.filter((skill) => !pattern.required_workflow?.includes(skill));
+  const patternExecutors = (pattern.candidate_experience_patterns || [])
+    .filter((item) => item.promotion_required !== true || item.preview_only !== true || item.auto_apply !== false)
+    .map((item) => item.id);
+  const findings = [
+    ...(pattern.stage === experiencePatternStage ? [] : [`stage must be ${experiencePatternStage}`]),
+    ...(pattern.pattern_kind === experiencePatternKind ? [] : [`pattern_kind must be ${experiencePatternKind}`]),
+    ...(pattern.source_bindings?.friction_file ? [] : ['source friction file is required']),
+    ...(Array.isArray(pattern.candidate_experience_patterns) && pattern.candidate_experience_patterns.length > 0 ? [] : ['candidate_experience_patterns must contain at least one candidate']),
+    ...(pattern.repeat_signal && typeof pattern.repeat_signal.detected === 'boolean' ? [] : ['repeat_signal.detected must be boolean']),
+    ...(pattern.suggested_instinct_trigger ? [] : ['suggested_instinct_trigger is required']),
+    ...(pattern.suggested_instinct_action ? [] : ['suggested_instinct_action is required']),
+    ...(pattern.promotion_required === true ? [] : ['promotion_required must be true']),
+    ...requiredWorkflowMissing.map((skill) => `required_workflow missing ${skill}`),
+    ...(pattern.promotion_boundary?.automatic_promotion === false ? [] : ['promotion_boundary.automatic_promotion must be false']),
+    ...(pattern.promotion_boundary?.writes_formal_skills === false ? [] : ['promotion_boundary.writes_formal_skills must be false']),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingForbidden.map((key) => `forbidden boundary missing or not false: ${key}`),
+    ...patternExecutors.map((id) => `candidate pattern must remain preview-only and non-applying: ${id}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['friction_binding', 'observation_binding', 'candidate_pattern_shape', 'repeat_signal', 'manual_promotion_workflow', 'ecc_agent_first_rejection', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestExperienceLearningPattern(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function candidatePatternsFor(friction, observations, repeatSignal) {
+  const patterns = [];
+  const add = (candidate) => {
+    if (!patterns.some((item) => item.id === candidate.id)) patterns.push({
+      ...candidate,
+      promotion_required: true,
+      required_workflow: requiredWorkflow,
+      preview_only: true,
+      auto_apply: false,
+    });
+  };
+  if (hasFriction(friction, 'next_action_unclear') || hasFriction(friction, 'entry_confusion')) add({
+    id: 'visible-next-action-instinct',
+    trigger: 'When entry or next-action friction repeats in local Stage 126 evidence.',
+    action: 'Surface one visible next action with why-now, evidence-needed, and do-not-do-yet before broader workflow context.',
+    evidence: evidenceRefsFor(friction, observations, ['entry_confusion', 'next_action_unclear']),
+  });
+  if (hasFriction(friction, 'evidence_gap') || hasFriction(friction, 'completion_claim_risk')) add({
+    id: 'evidence-before-claim-instinct',
+    trigger: 'When completion or review claims appear before local validation evidence is bound.',
+    action: 'Require local evidence binding and verification summary before any completion or release wording.',
+    evidence: evidenceRefsFor(friction, observations, ['evidence_gap', 'completion_claim_risk']),
+  });
+  if (hasFriction(friction, 'token_overhead')) add({
+    id: 'token-budget-before-context-instinct',
+    trigger: 'When token_overhead friction is present before workflow execution.',
+    action: 'Run a deterministic Token Savior budget first and defer non-selected skills until the user chooses a lane.',
+    evidence: evidenceRefsFor(friction, observations, ['token_overhead']),
+  });
+  if (repeatSignal.repeated_workflow_count > 0 || observations.length > 0) add({
+    id: 'repeat-signal-learning-gate',
+    trigger: 'When multiple local observations repeat the same workflow, preference, correction, or project constraint.',
+    action: 'Create only a candidate experience pattern, then require manual skill-authoring workflow before promotion.',
+    evidence: evidenceRefsFor(friction, observations, []),
+  });
+  if (patterns.length === 0) add({
+    id: 'manual-learning-review-required',
+    trigger: 'When friction evidence does not yet show a repeatable learning pattern.',
+    action: 'Keep learning as manual review; collect more Stage 61 observations before proposing a formal instinct.',
+    evidence: evidenceRefsFor(friction, observations, []),
+  });
+  return patterns;
+}
+
+function repeatSignalFor(friction, observations) {
+  const repeatedWorkflowCount = observations.reduce((sum, item) => sum + numberValue(item.signals?.repeated_workflows?.length), 0);
+  const correctionCount = observations.reduce((sum, item) => sum + numberValue(item.signals?.user_corrections?.length), 0);
+  const preferenceCount = observations.reduce((sum, item) => sum + numberValue(item.signals?.preferences?.length), 0);
+  const projectConstraintCount = observations.reduce((sum, item) => sum + numberValue(item.signals?.project_constraints?.length), 0);
+  const topFriction = friction.top_friction || '';
+  const detected = repeatedWorkflowCount > 0 || correctionCount > 0 || preferenceCount > 0 || projectConstraintCount > 0 || friction.priority_fixes.length > 0;
+  return {
+    detected,
+    signal_source_count: observations.length + (friction.provided ? 1 : 0),
+    observation_count: observations.length,
+    repeated_workflow_count: repeatedWorkflowCount,
+    correction_count: correctionCount,
+    preference_count: preferenceCount,
+    project_constraint_count: projectConstraintCount,
+    top_friction: topFriction,
+    confidence: confidenceFor({ friction, repeatedWorkflowCount, correctionCount, preferenceCount, projectConstraintCount }),
+  };
+}
+
+function suggestedTriggerFor(patterns, repeatSignal) {
+  const first = patterns[0];
+  if (!first) return 'When a local repeated experience signal is confirmed by Stage 126 or Stage 61 evidence.';
+  return `${first.trigger} confidence=${repeatSignal.confidence}; top_friction=${repeatSignal.top_friction || 'none'}`;
+}
+
+function suggestedActionFor(patterns) {
+  const first = patterns[0];
+  if (!first) return 'Keep learning candidate-only and require manual workflow before any formal skill change.';
+  return `${first.action} Do not auto-promote; enter ${requiredWorkflow.join(' -> ')} before formalizing.`;
+}
+
+function evidenceRefsFor(friction, observations, frictionIds) {
+  return {
+    friction_ids: frictionIds.filter((id) => hasFriction(friction, id)),
+    friction_digest: friction.friction_digest,
+    observation_digests: observations.map((item) => item.observation_digest).filter(Boolean).sort(),
+  };
+}
+
+function normalizeFriction(input) {
+  if (!input) return { provided: false, friction_score: 0, friction_level: 'not_provided', priority_fixes: [], dimensions: [], top_friction: '', friction_digest: '' };
+  const matrix = objectValue(input.experience_friction_matrix || input);
+  const dimensions = listValue(matrix.dimensions).map((dimension) => ({
+    id: stringValue(dimension.id),
+    severity: stringValue(dimension.severity || 'low'),
+    score: numberValue(dimension.score),
+  })).filter((dimension) => dimension.id);
+  const priorityFixes = listValue(matrix.priority_fixes).map((fix) => ({
+    id: stringValue(fix.id),
+    severity: stringValue(fix.severity || 'low'),
+    score: numberValue(fix.score),
+    recommended_stage: stringValue(fix.recommended_stage),
+  })).filter((fix) => fix.id);
+  const top = priorityFixes[0]?.id || [...dimensions].sort((left, right) => right.score - left.score)[0]?.id || '';
+  return {
+    provided: true,
+    stage: stringValue(matrix.stage || 'Stage 126'),
+    friction_score: numberValue(matrix.friction_score),
+    friction_level: stringValue(matrix.friction_level || 'unknown'),
+    priority_fixes: priorityFixes,
+    dimensions,
+    top_friction: top,
+    friction_digest: stringValue(matrix.friction_digest || input.friction_digest),
+  };
+}
+
+function normalizeObservations(observations) {
+  return listValue(observations).map((item) => {
+    const observation = objectValue(item.observation || item.learning_observation || item);
+    return {
+      file: stringValue(item.file || observation.file),
+      file_digest: stringValue(item.file_digest),
+      observation_digest: stringValue(item.observation_digest || observation.learning_observation_digest),
+      project_id: stringValue(observation.project_id),
+      scope: stringValue(observation.scope),
+      domain: stringValue(observation.domain),
+      signal_count: numberValue(observation.signal_count),
+      signals: objectValue(observation.signals),
+    };
+  }).filter((item) => item.observation_digest || item.signal_count > 0 || item.file);
+}
+
+function sourceBindingSummary(source, friction, observations) {
+  return {
+    friction_file: stringValue(source.friction_file),
+    friction_file_digest: stringValue(source.friction_digest),
+    friction_matrix_digest: friction.friction_digest,
+    observation_files: listValue(source.observation_files),
+    observation_file_digests: listValue(source.observation_file_digests),
+    observation_digests: observations.map((item) => item.observation_digest).filter(Boolean).sort(),
+    source_kind: observations.length > 0 ? 'stage126-friction-plus-learning-observations' : 'stage126-friction-only',
+  };
+}
+
+function frictionSummary(friction) {
+  return {
+    provided: friction.provided,
+    stage: friction.stage || '',
+    friction_score: friction.friction_score,
+    friction_level: friction.friction_level,
+    top_friction: friction.top_friction,
+    priority_fix_count: friction.priority_fixes.length,
+    dimension_count: friction.dimensions.length,
+    friction_digest: friction.friction_digest,
+  };
+}
+
+function observationSummary(observations) {
+  return {
+    provided: observations.length > 0,
+    observation_count: observations.length,
+    signal_count: observations.reduce((sum, item) => sum + numberValue(item.signal_count), 0),
+    project_ids: [...new Set(observations.map((item) => item.project_id).filter(Boolean))].sort(),
+    domains: [...new Set(observations.map((item) => item.domain).filter(Boolean))].sort(),
+  };
+}
+
+function confidenceFor({ friction, repeatedWorkflowCount, correctionCount, preferenceCount, projectConstraintCount }) {
+  const signalScore = Math.min(0.35, (repeatedWorkflowCount + correctionCount + preferenceCount + projectConstraintCount) * 0.08);
+  const frictionScore = Math.min(0.45, friction.friction_score / 200);
+  const priorityScore = Math.min(0.2, friction.priority_fixes.length * 0.05);
+  return Number(Math.max(0.1, Math.min(0.95, 0.2 + signalScore + frictionScore + priorityScore)).toFixed(3));
+}
+
+function hasFriction(friction, id) {
+  return friction.priority_fixes.some((fix) => fix.id === id) || friction.dimensions.some((dimension) => dimension.id === id && dimension.score >= 50);
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function stringValue(value) {
+  return String(value || '').trim();
+}
+
+function numberValue(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : 0;
+}
+
+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);
+}