@aikdna/studio-core 0.3.0 → 0.4.1

package/src/quality/index.js

@@ -1,13 +1,17 @@
 /**
- * Enhanced Quality Gates — 4-grade readiness scoring with detailed rules.
+ * Enhanced Quality Gates — 4-grade readiness with integrated card validation.
  *
  * Grades:
  *   draft_grade       — Core+Patterns exist, ≥3 human-reviewed cards
- *   human_controlled  — All core axioms locked, each with applies_when/does_not_apply_when/failure_risk
- *   tested_grade      — ≥5 eval cases, ≥3 comparison tests
- *   publishable_grade — ≥10 evals, README complete, known limitations, kdna verify passes
+ *   human_controlled  — All core axioms locked with boundaries, ≥50% have Feynman
+ *   tested_grade      — ≥5 rated evals, ≥3 comparison tests
+ *   publishable_grade — ≥10 evals, all axioms have Feynman, README 4 questions, no blocking
+ *
+ * v0.3.2: integrates validateAllCards, Feynman enforcement at publishable grade.
  */
+
 const contradiction = require('./contradiction');
+const { validateAllCards } = require('./validate-cards');
 
 function computeReadiness(project) {
   const cards = project.cards || [];
@@ -15,131 +19,68 @@ function computeReadiness(project) {
   const locked = cards.filter(c => c.locked);
   const lockedAxioms = locked.filter(c => c.type === 'axiom');
   const lockedSelfChecks = locked.filter(c => c.type === 'self_check');
+  const lockedMisunderstandings = locked.filter(c => c.type === 'misunderstanding');
   const ratedTests = tests.filter(t => t.result);
 
   const blocking = [];
   const warnings = [];
 
-  // ── Minimum Structure ──────────────────────────────────────────
-  if (project.cards.length === 0) {
-    blocking.push('Project has no cards');
-    return buildResult('draft_grade', blocking, warnings, project);
-  }
-  if (locked.length === 0) {
-    blocking.push('No locked cards — nothing to compile');
-    return buildResult('draft_grade', blocking, warnings, project);
+  // ── Card validation integration (v0.3.2) ─────────────────────────
+  const cardResults = validateAllCards(project);
+  for (const { card_id, issues } of cardResults) {
+    for (const issue of issues) {
+      if (issue.severity === 'blocking') blocking.push(`${card_id}: ${issue.message}`);
+      else warnings.push(`${card_id}: ${issue.message}`);
+    }
   }
 
+  // ── Minimum Structure ──────────────────────────────────────────
+  if (cards.length === 0) { blocking.push('Project has no cards'); return buildResult('draft_grade', blocking, warnings, project); }
+  if (locked.length === 0) { blocking.push('No locked cards — nothing to compile'); return buildResult('draft_grade', blocking, warnings, project); }
+
   // ── Axiom Checks ──────────────────────────────────────────────
   for (const ax of lockedAxioms) {
-    if (!ax.fields?.one_sentence || ax.fields.one_sentence.length < 10) {
-      blocking.push(`${ax.id}: one_sentence too short or missing`);
-    }
-    if (!ax.fields?.full_statement || ax.fields.full_statement.length < 30) {
-      warnings.push(`${ax.id}: full_statement too short — may be vague`);
-    }
-    if (!ax.fields?.why || ax.fields.why.length < 10) {
-      warnings.push(`${ax.id}: missing "why" — explains what the agent gets wrong without this`);
-    }
-    if (!ax.fields?.applies_when || ax.fields.applies_when.length === 0) {
-      blocking.push(`${ax.id}: missing applies_when`);
-    }
-    if (!ax.fields?.does_not_apply_when || ax.fields.does_not_apply_when.length === 0) {
-      blocking.push(`${ax.id}: missing does_not_apply_when`);
-    }
-    if (!ax.fields?.failure_risk) {
-      blocking.push(`${ax.id}: missing failure_risk`);
-    }
-    if (!ax.human_lock) {
-      blocking.push(`${ax.id}: not locked — must be locked before compile`);
-    }
-    if (!ax.feynman_restatement) {
-      warnings.push(`${ax.id}: missing Feynman restatement`);
-    }
-  }
-
-  // ── Self-check Checks ──────────────────────────────────────────
-  for (const sc of lockedSelfChecks) {
-    const q = sc.fields?.question || '';
-    if (!q.endsWith('?')) {
-      blocking.push(`${sc.id}: self_check must be a question ending with ?`);
-    }
-    if (q.length < 15) {
-      warnings.push(`${sc.id}: self_check question too short — may be too vague`);
-    }
-    if (/\b(is this good|is this correct|is this helpful|is this clear|good enough)\b/i.test(q)) {
-      warnings.push(`${sc.id}: self_check is generic — should be domain-specific`);
-    }
+    if (!ax.fields?.one_sentence || ax.fields.one_sentence.length < 10) blocking.push(`${ax.id}: one_sentence too short`);
+    if (!ax.fields?.applies_when?.length) blocking.push(`${ax.id}: missing applies_when`);
+    if (!ax.fields?.does_not_apply_when?.length) blocking.push(`${ax.id}: missing does_not_apply_when`);
+    if (!ax.fields?.failure_risk) blocking.push(`${ax.id}: missing failure_risk`);
+    if (!ax.human_lock) blocking.push(`${ax.id}: not locked`);
+    if (!ax.feynman_restatement) warnings.push(`${ax.id}: missing Feynman restatement`);
   }
 
   // ── Misunderstanding Checks ────────────────────────────────────
-  const lockedMisunderstandings = locked.filter(c => c.type === 'misunderstanding');
   for (const ms of lockedMisunderstandings) {
-    if (!ms.fields?.key_distinction || ms.fields.key_distinction.length < 20) {
-      blocking.push(`${ms.id}: key_distinction missing or too short`);
-    }
-    if (!ms.fields?.wrong || ms.fields.wrong.length < 10) {
-      warnings.push(`${ms.id}: wrong belief very short — may be a straw man`);
-    }
-    if (!ms.fields?.correct || ms.fields.correct.length < 10) {
-      warnings.push(`${ms.id}: correct belief very short`);
-    }
+    if (!ms.fields?.key_distinction || ms.fields.key_distinction.length < 20) blocking.push(`${ms.id}: key_distinction too short`);
   }
 
-  // ── Boundary Checks ────────────────────────────────────────────
-  const lockedBoundaries = locked.filter(c => c.type === 'boundary');
-  for (const bd of lockedBoundaries) {
-    if (bd.fields?.acceptable_exceptions && bd.fields.acceptable_exceptions.length === 0) {
-      warnings.push(`${bd.id}: no acceptable_exceptions — every boundary has justified exceptions`);
-    }
+  // ── Self-check Checks ──────────────────────────────────────────
+  for (const sc of lockedSelfChecks) {
+    const q = sc.fields?.question || '';
+    if (!q.endsWith('?')) blocking.push(`${sc.id}: self_check must end with ?`);
   }
 
   // ── Contradiction Check ────────────────────────────────────────
-  const contradictions = contradiction.detectContradictions(cards);
-  for (const c of contradictions) {
-    if (c.severity === 'blocking') blocking.push(c.message);
-    else warnings.push(c.message);
-  }
-
-  // ── Test Count Checks ──────────────────────────────────────────
-  if (ratedTests.length === 0 && locked.length >= 3) {
-    warnings.push('No rated tests — domain may not actually change agent behavior');
-  }
-  if (ratedTests.length < 3 && ratedTests.length > 0) {
-    warnings.push(`Only ${ratedTests.length} rated tests — recommend at least 3 for confidence`);
+  for (const c of contradiction.detectContradictions(cards)) {
+    (c.severity === 'blocking' ? blocking : warnings).push(c.message);
   }
 
   // ── Determine Grade ────────────────────────────────────────────
   const axiomsComplete = lockedAxioms.length >= 1 &&
-    lockedAxioms.every(ax =>
-      ax.fields?.applies_when?.length &&
-      ax.fields?.does_not_apply_when?.length &&
-      ax.fields?.failure_risk &&
-      ax.human_lock
-    );
-
-  const boundariesComplete = lockedBoundaries.length === 0 ||
-    lockedBoundaries.every(b => b.fields?.scope && b.fields?.out_of_scope);
+    lockedAxioms.every(ax => ax.fields?.applies_when?.length && ax.fields?.does_not_apply_when?.length && ax.fields?.failure_risk && ax.human_lock);
+  const feynmanRatio = lockedAxioms.length > 0 ? lockedAxioms.filter(ax => ax.feynman_restatement).length / lockedAxioms.length : 0;
+  const allFeynman = lockedAxioms.every(ax => ax.feynman_restatement) && lockedMisunderstandings.every(ms => !ms.locked || ms.feynman_restatement);
 
   let grade = 'draft_grade';
-  if (locked.length >= 3 && axiomsComplete) {
-    grade = 'human_controlled';
-  }
-  if (grade === 'human_controlled' && ratedTests.length >= 5 && lockedSelfChecks.length >= 3 && boundariesComplete) {
-    grade = 'tested_grade';
-  }
-  if (grade === 'tested_grade' &&
-      ratedTests.length >= 10 &&
-      lockedAxioms.length >= 3 &&
-      lockedSelfChecks.length >= 5 &&
-      blocking.length === 0) {
+  if (locked.length >= 3 && axiomsComplete && feynmanRatio >= 0.5) grade = 'human_controlled';
+  if (grade === 'human_controlled' && ratedTests.length >= 5 && lockedSelfChecks.length >= 3) grade = 'tested_grade';
+  if (grade === 'tested_grade' && ratedTests.length >= 10 && lockedAxioms.length >= 3 && lockedSelfChecks.length >= 5 && blocking.length === 0 && allFeynman) {
     grade = 'publishable_grade';
   }
 
-  return buildResult(grade, blocking, warnings, project);
+  return buildResult(grade, blocking, warnings, project, { feynmanRatio, allFeynman });
 }
 
-function buildResult(grade, blocking, warnings, project) {
+function buildResult(grade, blocking, warnings, project, detail = {}) {
   const lockedCount = (project.cards || []).filter(c => c.locked).length;
   const ratedTests = (project.tests || []).filter(t => t.result).length;
 
@@ -156,20 +97,15 @@ function buildResult(grade, blocking, warnings, project) {
       locked_self_checks: (project.cards || []).filter(c => c.type === 'self_check' && c.locked).length,
       total_tests: (project.tests || []).length,
       rated_tests: ratedTests,
+      feynman_ratio: detail.feynmanRatio !== undefined ? Math.round(detail.feynmanRatio * 100) + '%' : 'N/A',
     },
-    next_step: grade === 'draft_grade'
-      ? 'Lock at least 3 axioms with applies_when, does_not_apply_when, and failure_risk.'
-      : grade === 'human_controlled'
-        ? 'Add 5+ eval cases and run kdna compare to reach tested grade.'
-        : grade === 'tested_grade'
-          ? 'Add 10+ evals, 3+ axioms, 5+ self-checks, and pass kdna verify --judgment to reach publishable.'
-          : 'Ready to publish. Run kdna pack and kdna publish.',
+    next_step: grade === 'draft_grade' ? 'Lock at least 3 axioms with boundaries and 50% Feynman.' :
+      grade === 'human_controlled' ? 'Add 5+ rated evals and 3+ self-checks.' :
+      grade === 'tested_grade' ? 'Add 10+ evals, complete Feynman on all axioms/misunderstandings, resolve all blocking issues.' :
+      'Ready to publish. Run kdna pack and kdna publish.',
   };
 }
 
-function getBlockingIssues(project) {
-  const result = computeReadiness(project);
-  return result.blocking;
-}
+function getBlockingIssues(project) { return computeReadiness(project).blocking; }
 
 module.exports = { computeReadiness, getBlockingIssues };

package/src/testlab/delta.js

@@ -128,33 +128,66 @@ function compareDeltas(delta1, delta2) {
 
 function formatDeltaMarkdown(delta) {
   const lines = [];
-  lines.push('# KDNA Judgment Comparison Report');
-  lines.push('');
+  lines.push('# KDNA Judgment Comparison Report'); lines.push('');
   lines.push(`**Domain:** ${delta.meta.domain}`);
   lines.push(`**Model:** ${delta.meta.model}`);
-  lines.push(`**Date:** ${delta.meta.timestamp}`);
-  lines.push('');
-  lines.push('## Judgment Diff');
-  lines.push('');
-  lines.push('| Dimension | Change |');
-  lines.push('|-----------|--------|');
-  for (const d of delta.changed_dimensions) {
-    lines.push(`| ${d.axis} | **Changed**: ${d.value} |`);
-  }
-  if (delta.changed_dimensions.length === 0) {
-    lines.push('| (none) | No significant change |');
-  }
-  lines.push('');
-  lines.push('## Scoring');
-  lines.push('');
-  for (const [dim, value] of Object.entries(delta.scoring)) {
-    lines.push(`- **${dim}:** ${value}`);
-  }
+  lines.push(`**Date:** ${delta.meta.timestamp}`); lines.push('');
+  lines.push('## Judgment Diff'); lines.push('');
+  lines.push('| Dimension | Change |'); lines.push('|-----------|--------|');
+  for (const d of delta.changed_dimensions) lines.push(`| ${d.axis} | **Changed**: ${d.value} |`);
+  if (!delta.changed_dimensions.length) lines.push('| (none) | No significant change |');
   lines.push('');
-  lines.push(`**Verdict:** ${delta.verdict.replace(/_/g, ' ')}`);
+  lines.push('## Scoring'); lines.push('');
+  for (const [dim, value] of Object.entries(delta.scoring)) lines.push(`- **${dim}:** ${value}`);
   lines.push('');
+  lines.push(`**Verdict:** ${delta.verdict.replace(/_/g, ' ')}`); lines.push('');
   lines.push(delta.summary);
   return lines.join('\n');
 }
 
-module.exports = { parseCompareOutput, scoreDelta, createJudgmentDelta, compareDeltas, formatDeltaMarkdown };
+// ─── JSON report parsing (v0.3.3) ─────────────────────────────────────
+
+function parseCompareReportJson(report) {
+  if (!report || !report.diff) return { axes: {}, verdict: 'trajectory_unchanged' };
+
+  const axes = {};
+  // Extract axes from structured report format
+  if (report.diff.axes) {
+    for (const [axis, value] of Object.entries(report.diff.axes)) {
+      if (value && String(value).toUpperCase() !== 'SAME') axes[axis] = String(value);
+    }
+    return { axes, verdict: report.diff.verdict || 'trajectory_unchanged' };
+  }
+
+  // Legacy: raw baseline/kdna comparison
+  if (report.without_kdna && report.with_kdna) {
+    if (report.without_kdna.classification !== report.with_kdna.classification)
+      axes.classification = 'changed';
+    return { axes, verdict: Object.keys(axes).length > 0 ? 'trajectory_changed' : 'trajectory_unchanged' };
+  }
+
+  return { axes: {}, verdict: 'trajectory_unchanged' };
+}
+
+function createJudgmentDeltaFromReport(domain, input, report, options = {}) {
+  const { axes, verdict } = parseCompareReportJson(report);
+  const domainScore = scoreDelta(axes);
+
+  return {
+    meta: { domain, input: (input || '').slice(0, 200), model: report.meta?.model || options.model || 'unknown',
+      timestamp: new Date().toISOString() },
+    classification: { without_kdna: axes.classification || 'generic',
+      with_kdna: axes.classification ? 'domain_specific' : 'unchanged', changed: !!axes.classification },
+    axes, verdict,
+    score: domainScore.score,
+    changed_dimensions: domainScore.changed,
+    triggered_axioms: options.triggeredAxioms || [],
+    avoided_misunderstandings: options.avoidedMisunderstandings || [],
+    self_checks_passed: options.selfChecksPassed || null,
+    scoring: buildScoring(axes, domainScore, options.selfChecksPassed),
+    summary: buildSummary(domain, domainScore, verdict),
+  };
+}
+
+module.exports = { parseCompareOutput, parseCompareReportJson, scoreDelta,
+  createJudgmentDelta, createJudgmentDeltaFromReport, compareDeltas, formatDeltaMarkdown };

package/src/versioning/index.js

@@ -1,181 +1,143 @@
 /**
- * Versioning — Judgment-aware version management.
+ * Versioning — Judgment-aware semver with refined bump rules (v0.3.3).
  *
- * KDNA versioning tracks judgment changes, not just text diffs.
- * A version bump is based on:
- *   - PATCH: wording fixes, clarifications (no judgment change)
- *   - MINOR: new axioms, misunderstandings, self-checks added
- *   - MAJOR: axioms removed, domain scope changed, access mode changed
- *
- * Provides:
- *   - Judgment diff between two project snapshots
- *   - Changelog generation from audit logs
- *   - Version bump recommendation
- *   - Semantic version tracking
+ * PATCH: typo, description, Feynman restatement, evidence_refs, examples
+ * MINOR: new axiom/misunderstanding/self_check, narrowed applies_when, new does_not_apply_when, new evals
+ * MAJOR: removed axiom, changed core meaning, expanded applies_when, removed does_not_apply_when, scope change, access change
  */
 
 function diffProjects(oldProject, newProject) {
   const oldCards = oldProject.cards || [];
   const newCards = newProject.cards || [];
-
   const oldById = new Map(oldCards.map(c => [c.id, c]));
   const newById = new Map(newCards.map(c => [c.id, c]));
 
-  const added = [];
-  const removed = [];
-  const changed = [];
-  const unchanged = [];
-
-  for (const [id, newCard] of newById) {
-    if (!oldById.has(id)) {
-      added.push({ id, type: newCard.type, one_sentence: newCard.fields?.one_sentence || newCard.fields?.question || '' });
-    } else {
-      const oldCard = oldById.get(id);
-      if (JSON.stringify(oldCard.fields) !== JSON.stringify(newCard.fields)) {
-        const fieldChanges = diffFields(oldCard.fields || {}, newCard.fields || {});
-        changed.push({ id, type: newCard.type, changes: fieldChanges });
-      } else if (oldCard.status !== newCard.status) {
-        changed.push({ id, type: newCard.type, status_change: { from: oldCard.status, to: newCard.status } });
-      } else {
-        unchanged.push(id);
+  const added = []; const removed = []; const changed = [];
+  for (const [id, nc] of newById) {
+    if (!oldById.has(id)) { added.push(cardSummary(nc)); }
+    else {
+      const oc = oldById.get(id);
+      const fieldChanges = diffFields(oc.fields || {}, nc.fields || {});
+      if (Object.keys(fieldChanges).length > 0) {
+        changed.push(cardSummary(nc, fieldChanges));
+      } else if (oc.status !== nc.status) {
+        changed.push({ ...cardSummary(nc), status_change: { from: oc.status, to: nc.status } });
       }
     }
   }
-
-  for (const [id, oldCard] of oldById) {
-    if (!newById.has(id)) {
-      removed.push({ id, type: oldCard.type, one_sentence: oldCard.fields?.one_sentence || oldCard.fields?.question || '' });
-    }
+  for (const [id, oc] of oldById) {
+    if (!newById.has(id)) removed.push(cardSummary(oc));
   }
 
-  return {
-    added,
-    removed,
-    changed,
-    unchanged: unchanged.length,
-    summary: {
-      added_count: added.length,
-      removed_count: removed.length,
-      changed_count: changed.length,
-      unchanged_count: unchanged.length,
-    },
-  };
+  return { added, removed, changed, unchanged: oldCards.length - removed.length - changed.length,
+    summary: { added_count: added.length, removed_count: removed.length, changed_count: changed.length } };
+}
+
+function cardSummary(card, changes) {
+  return { id: card.id, type: card.type, one_sentence: card.fields?.one_sentence || card.fields?.question || '',
+    changes: changes || null };
 }
 
 function diffFields(oldFields, newFields) {
   const changes = {};
   for (const key of new Set([...Object.keys(oldFields), ...Object.keys(newFields)])) {
-    const oldVal = JSON.stringify(oldFields[key] || null);
-    const newVal = JSON.stringify(newFields[key] || null);
-    if (oldVal !== newVal) {
-      changes[key] = { before: oldFields[key] || null, after: newFields[key] || null };
-    }
+    const ov = JSON.stringify(oldFields[key] || null), nv = JSON.stringify(newFields[key] || null);
+    if (ov !== nv) changes[key] = { before: oldFields[key] || null, after: newFields[key] || null };
   }
   return changes;
 }
 
 function recommendVersionBump(diff) {
   const { added, removed, changed } = diff;
+  const removedAxioms = removed.filter(c => c.type === 'axiom');
+  const removedMisunderstandings = removed.filter(c => c.type === 'misunderstanding');
+
+  // MAJOR checks
+  if (removedAxioms.length > 0 || removedMisunderstandings.length > 0) return 'major';
+  for (const c of changed) {
+    if (!c.changes) continue;
+    // Core meaning change on axiom → major
+    if (c.type === 'axiom' && ('one_sentence' in c.changes || 'full_statement' in c.changes)) return 'major';
+    // Expanded scope → major
+    if ('applies_when' in c.changes) {
+      const bef = c.changes.applies_when.before || [], aft = c.changes.applies_when.after || [];
+      if (aft.length > bef.length) return 'major';
+    }
+    // Removed boundary → major
+    if ('does_not_apply_when' in c.changes) {
+      const bef = c.changes.does_not_apply_when.before || [], aft = c.changes.does_not_apply_when.after || [];
+      if (aft.length < bef.length) return 'major';
+    }
+  }
 
-  // MAJOR: axioms removed or domain structure changed
-  const axiomsRemoved = removed.filter(c => c.type === 'axiom').length;
-  const misunderstandingsRemoved = removed.filter(c => c.type === 'misunderstanding').length;
-  if (axiomsRemoved > 0 || misunderstandingsRemoved > 0) return 'major';
-
-  // MINOR: new axioms, misunderstandings, or field changes on existing cards
-  const axiomsAdded = added.filter(c => c.type === 'axiom').length;
-  const misunderstandingsAdded = added.filter(c => c.type === 'misunderstanding').length;
-  if (axiomsAdded > 0 || misunderstandingsAdded > 0 || changed.length > 0) return 'minor';
+  // MINOR checks
+  const addedAxioms = added.filter(c => c.type === 'axiom');
+  const addedMisunderstandings = added.filter(c => c.type === 'misunderstanding');
+  const addedSelfChecks = added.filter(c => c.type === 'self_check');
+  if (addedAxioms.length > 0 || addedMisunderstandings.length > 0 || addedSelfChecks.length > 0) return 'minor';
+  for (const c of changed) {
+    if (!c.changes) continue;
+    // Narrowed scope → minor
+    if ('does_not_apply_when' in c.changes) {
+      const bef = c.changes.does_not_apply_when.before || [], aft = c.changes.does_not_apply_when.after || [];
+      if (aft.length > bef.length) return 'minor';
+    }
+    // Changed why/key_distinction → minor
+    if (c.type === 'axiom' && 'why' in c.changes) return 'minor';
+    if (c.type === 'misunderstanding' && 'key_distinction' in c.changes) return 'minor';
+  }
 
-  // PATCH: wording-only changes (status changes, new self-checks, new boundaries)
+  // PATCH: wording-only changes
   if (added.length > 0 || changed.length > 0) return 'patch';
-
   return 'none';
 }
 
 function generateChangelog(diff, oldVersion, newVersion, options = {}) {
   const lines = [];
+  const bump = recommendVersionBump(diff);
   lines.push(`# ${options.domain || 'domain'} v${newVersion}`);
   lines.push('');
-  lines.push(`**Previous:** v${oldVersion}`);
-  lines.push(`**Bump:** ${recommendVersionBump(diff).toUpperCase()}`);
+  lines.push(`**Previous:** v${oldVersion}  **Bump:** ${bump.toUpperCase()}`);
   lines.push('');
 
-  if (diff.summary.added_count > 0) {
-    lines.push('## Added');
-    lines.push('');
-    for (const card of diff.added) {
-      lines.push(`- **${card.type}** \`${card.id}\`: ${card.one_sentence}`);
-    }
-    lines.push('');
-  }
-
-  if (diff.summary.removed_count > 0) {
-    lines.push('## Removed');
-    lines.push('');
-    for (const card of diff.removed) {
-      lines.push(`- **${card.type}** \`${card.id}\`: ${card.one_sentence}`);
-    }
-    lines.push('');
-  }
-
-  if (diff.summary.changed_count > 0) {
-    lines.push('## Changed');
-    lines.push('');
-    for (const card of diff.changed) {
-      lines.push(`- **${card.type}** \`${card.id}\``);
-      if (card.status_change) {
-        lines.push(`  - Status: ${card.status_change.from} → ${card.status_change.to}`);
-      }
-      if (card.changes && Object.keys(card.changes).length > 0) {
-        for (const [field, change] of Object.entries(card.changes)) {
-          const before = typeof change.before === 'string' ? change.before.slice(0, 80) : JSON.stringify(change.before).slice(0, 80);
-          const after = typeof change.after === 'string' ? change.after.slice(0, 80) : JSON.stringify(change.after).slice(0, 80);
-          lines.push(`  - ${field}: "${before}" → "${after}"`);
-        }
+  for (const [label, items] of [['Added', diff.added], ['Removed', diff.removed], ['Changed', diff.changed]]) {
+    if (items.length === 0) continue;
+    lines.push(`## ${label}`); lines.push('');
+    for (const c of items) {
+      lines.push(`- **${c.type}** \`${c.id}\`: ${c.one_sentence}`);
+      if (c.status_change) lines.push(`  - Status: ${c.status_change.from} → ${c.status_change.to}`);
+      if (c.changes) for (const [f, v] of Object.entries(c.changes)) {
+        lines.push(`  - ${f}: "${String(v.before || '').slice(0, 60)}" → "${String(v.after || '').slice(0, 60)}"`);
       }
     }
     lines.push('');
   }
 
-  if (diff.summary.added_count === 0 && diff.summary.removed_count === 0 && diff.summary.changed_count === 0) {
-    lines.push('No judgment changes detected.');
-    lines.push('');
+  if (diff.added.length === 0 && diff.removed.length === 0 && diff.changed.length === 0) {
+    lines.push('No judgment changes detected.\n');
   }
 
   return lines.join('\n');
 }
 
 function bumpVersion(currentVersion, bumpType) {
-  const parts = currentVersion.split('.').map(Number);
-  switch (bumpType) {
-    case 'major': return `${parts[0] + 1}.0.0`;
-    case 'minor': return `${parts[0]}.${parts[1] + 1}.0`;
-    case 'patch': return `${parts[0]}.${parts[1]}.${parts[2] + 1}`;
-    default: return currentVersion;
-  }
+  const [maj, min, pat] = currentVersion.split('.').map(Number);
+  if (bumpType === 'major') return `${maj + 1}.0.0`;
+  if (bumpType === 'minor') return `${maj}.${min + 1}.0`;
+  if (bumpType === 'patch') return `${maj}.${min}.${pat + 1}`;
+  return currentVersion;
 }
 
 function markBreakingChange(diff) {
-  const axiomsRemoved = diff.removed.filter(c => c.type === 'axiom').length;
-  const scopeChanges = diff.changed.filter(c =>
-    c.changes && ('applies_when' in c.changes || 'does_not_apply_when' in c.changes)
-  ).length;
+  const removedAxioms = diff.removed.filter(c => c.type === 'axiom');
+  const scopeWidening = diff.changed.filter(c => c.changes && 'applies_when' in c.changes &&
+    (c.changes.applies_when.after || []).length > (c.changes.applies_when.before || []).length);
   return {
-    breaking: axiomsRemoved > 0,
-    reason: axiomsRemoved > 0
-      ? `${axiomsRemoved} axiom(s) removed — breaking change`
-      : scopeChanges > 0
-        ? `${scopeChanges} scope change(s) — may affect existing agent behavior`
-        : null,
+    breaking: removedAxioms.length > 0,
+    reason: removedAxioms.length > 0 ? `${removedAxioms.length} axiom(s) removed — breaking change` :
+      scopeWidening.length > 0 ? `${scopeWidening.length} scope widening(s) — may affect existing behavior` : null,
     recommended_bump: recommendVersionBump(diff),
   };
 }
 
-module.exports = {
-  diffProjects,
-  recommendVersionBump,
-  generateChangelog,
-  bumpVersion,
-  markBreakingChange,
-};
+module.exports = { diffProjects, recommendVersionBump, generateChangelog, bumpVersion, markBreakingChange };