@orcalang/orca-lang 0.1.18 → 0.1.21

package/src/health-check.ts

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+// Health Check Runner - Dogfooding Orca to check itself
+// Uses sequential execution pattern modeled after Orca state machine semantics
+
+import { execSync } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(__dirname, '../../..');
+
+interface StepResult {
+  name: string;
+  status: 'pending' | 'success' | 'failed';
+  output: string;
+  duration: number;
+  passed?: number;
+  skipped?: number;
+}
+
+interface HealthReport {
+  steps: StepResult[];
+  startTime: number;
+  endTime: number;
+  totalPassed: number;
+  totalFailed: number;
+}
+
+function runCommand(cmd: string, cwd: string, timeout = 120000): { status: number; stdout: string; stderr: string } {
+  try {
+    const stdout = execSync(cmd, { cwd, encoding: 'utf-8', timeout, maxBuffer: 10 * 1024 * 1024 });
+    return { status: 0, stdout: stdout as string, stderr: '' };
+  } catch (e: any) {
+    return {
+      status: e.status || 1,
+      stdout: e.stdout?.toString() || '',
+      stderr: e.stderr?.toString() || e.message || ''
+    };
+  }
+}
+
+async function runHealthCheck(): Promise<HealthReport> {
+  const report: HealthReport = {
+    steps: [],
+    startTime: Date.now(),
+    endTime: 0,
+    totalPassed: 0,
+    totalFailed: 0
+  };
+
+  // ── Step 1: Build ──────────────────────────────────────────────
+  {
+    const step: StepResult = { name: 'build', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Building TypeScript packages ━━━');
+    const result = runCommand('pnpm run build', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Build succeeded' : result.stderr || result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} Build ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 2: orca-lang tests ─────────────────────────────────────
+  {
+    const step: StepResult = { name: 'test:lang', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running orca-lang tests ━━━');
+    const result = runCommand('cd packages/orca-lang && pnpm test 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    const match = result.stdout.match(/(\d+) passed.*?(\d+) skipped/);
+    step.passed = match ? parseInt(match[1]) : 0;
+    step.skipped = match ? parseInt(match[2]) : 0;
+    step.status = result.status === 0 && step.passed >= 180 ? 'success' : 'failed';
+    step.output = `${step.passed} passed, ${step.skipped} skipped`;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} ${step.passed} tests passed, ${step.skipped} skipped (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 3: demo-ts smoke test ─────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-ts:test', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-ts smoke test ━━━');
+    const result = runCommand('pnpm --filter orca-demo-ts run test 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Tests passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-ts tests ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 4: demo-ts ticket demo ─────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-ts:ticket', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-ts ticket demo ━━━');
+    const result = runCommand('pnpm -w run run:demo-ts:ticket 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Demo passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} Support Ticket demo ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 5: demo-python ─────────────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-python', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-python ━━━');
+    const result = runCommand('.venv/bin/python packages/demo-python/demo.py 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Demo passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-python ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 6: demo-go ─────────────────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-go (trip)', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-go (trip) ━━━');
+    const result = runCommand('pnpm run test:demo-go 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Demo passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-go (trip) ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 6b: demo-go:loan ──────────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-go:loan', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+
+    // Build the loan binary first (not pre-built like 'trip')
+    console.log('━━━ Building demo-go:loan binary ━━━');
+    const buildResult = runCommand('cd packages/demo-go && go build -o loan ./cmd/loan 2>&1', REPO_ROOT);
+    if (buildResult.status !== 0) {
+      step.duration = Date.now() - start;
+      step.status = 'failed';
+      step.output = buildResult.stderr || buildResult.stdout;
+      report.steps.push(step);
+      console.log(`  ✗ Build failed (${step.duration}ms): ${step.output}\n`);
+      report.endTime = Date.now();
+      return report;
+    }
+    console.log(`  ✓ Build succeeded (${Date.now() - start}ms)\n`);
+
+    console.log('━━━ Running demo-go:loan (loan application) ━━━');
+    const runStart = Date.now();
+    const result = runCommand('cd packages/demo-go && ./loan 2>&1', REPO_ROOT);
+    step.duration = Date.now() - runStart;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Demo passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-go:loan (loan) ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 8: demo-nanolab tests ─────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-nanolab:test', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-nanolab tests ━━━');
+    const result = runCommand('pnpm run test:demo-nanolab 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Tests passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-nanolab tests ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 8: Example verification ────────────────────────────────
+  {
+    const step: StepResult = { name: 'examples:verify', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Verifying example files ━━━');
+    const result = runCommand('cd packages/orca-lang && pnpm exec tsx src/index.ts verify examples/simple-toggle.orca.md examples/payment-processor.orca.md 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Examples verified' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} Examples verified ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  report.endTime = Date.now();
+  return report;
+}
+
+function printReport(report: HealthReport) {
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║                    HEALTH CHECK REPORT                     ║');
+  console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+  for (const step of report.steps) {
+    const icon = step.status === 'success' ? '✓' : step.status === 'failed' ? '✗' : '○';
+    const label = step.status === 'success' ? 'PASS' : step.status === 'failed' ? 'FAIL' : 'SKIP';
+    console.log(`  ${icon} ${step.name.padEnd(20)} ${label.padEnd(6)} ${step.duration}ms${step.passed !== undefined ? ` (${step.passed} tests)` : ''}`);
+  }
+
+  const totalDuration = report.endTime - report.startTime;
+  report.totalPassed = report.steps.filter(s => s.status === 'success').length;
+  report.totalFailed = report.steps.filter(s => s.status === 'failed').length;
+
+  console.log(`\n  Total time: ${totalDuration}ms`);
+  console.log(`  Passed: ${report.totalPassed}/${report.totalPassed + report.totalFailed}\n`);
+
+  if (report.totalFailed === 0) {
+    console.log('  ✓ ALL CHECKS PASSED - Project is healthy\n');
+  } else {
+    console.log(`  ✗ ${report.totalFailed} CHECK(S) FAILED\n`);
+    // Print failed step outputs
+    for (const step of report.steps.filter(s => s.status === 'failed')) {
+      console.log(`  ── ${step.name} output ──`);
+      console.log(`  ${step.output.split('\n').slice(0, 10).join('\n  ')}`);
+      if (step.output.split('\n').length > 10) console.log('  ... (truncated)');
+      console.log();
+    }
+  }
+}
+
+async function main() {
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║           ORCA HEALTH CHECK - SELF-HOSTED RUNNER           ║');
+  console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+  const report = await runHealthCheck();
+  printReport(report);
+
+  process.exit(report.totalFailed > 0 ? 1 : 0);
+}
+
+main().catch(err => {
+  console.error('Health check failed with error:', err);
+  process.exit(1);
+});

package/src/index.ts

@@ -22,6 +22,7 @@ import { checkStructural, analyzeFile } from './verifier/structural.js';
 import { checkCompleteness } from './verifier/completeness.js';
 import { checkDeterminism } from './verifier/determinism.js';
 import { checkProperties } from './verifier/properties.js';
+import { computeAlignedDTOutputDomain } from './verifier/dt-verifier.js';
 import { compileToXState, compileToXStateMachine } from './compiler/xstate.js';
 import { compileToMermaid } from './compiler/mermaid.js';
 import { verifySkill, compileSkill, generateActionsSkill, refineSkill, generateOrcaSkill, generateOrcaMultiSkill, parseSkill, type SkillInput } from './skills.js';
@@ -232,7 +233,10 @@ async function verify(input: SkillInput, json: boolean = false): Promise<void> {
   const structural = checkStructural(machine);
   const completeness = checkCompleteness(machine);
   const determinism = checkDeterminism(machine);
-  const properties = checkProperties(machine);
+  const dtOutputDomain = file.decisionTables.length > 0
+    ? computeAlignedDTOutputDomain({ machines: [machine], decisionTables: file.decisionTables })
+    : undefined;
+  const properties = checkProperties(machine, { dtOutputDomain });
 
   const allErrors = [
     ...structural.errors,

package/src/parser/ast-to-markdown.ts

@@ -101,7 +101,8 @@ function emitStates(states: StateDef[], level: number): string[] {
     if (state.onEntry) lines.push(`- on_entry: ${state.onEntry}`);
     if (state.onExit) lines.push(`- on_exit: ${state.onExit}`);
     if (state.timeout) lines.push(`- timeout: ${state.timeout.duration} -> ${state.timeout.target}`);
-    if (state.ignoredEvents?.length) lines.push(`- ignore: ${state.ignoredEvents.join(', ')}`);
+    if (state.ignoredAll) lines.push(`- ignore: *`);
+    else if (state.ignoredEvents?.length) lines.push(`- ignore: ${state.ignoredEvents.join(', ')}`);
     if (state.onDone) lines.push(`- on_done: -> ${state.onDone}`);
 
     if (state.parallel) {

package/src/parser/ast.ts

@@ -1,5 +1,7 @@
 // Orca AST Type Definitions
 
+import { DecisionTableDef } from './dt-ast.js';
+
 export interface Position {
   line: number;
   column: number;
@@ -118,6 +120,7 @@ export interface StateDef {
   parent?: string;  // Parent state name for hierarchical states
   transitions?: Transition[];
   ignoredEvents?: string[];
+  ignoredAll?: boolean;     // true when "- ignore: *" — all unhandled events discarded
 }
 
 export interface Transition {
@@ -228,6 +231,7 @@ export interface MachineDef {
 // Multi-machine file (for machine invocation)
 export interface OrcaFile {
   machines: MachineDef[];
+  decisionTables: DecisionTableDef[];  // NEW
 }
 
 export interface ParseResult {

package/src/parser/dt-ast.ts

@@ -0,0 +1,40 @@
+// Decision Table AST Types
+
+export type ConditionType = 'bool' | 'enum' | 'int_range' | 'string';
+
+export interface ConditionDef {
+  name: string;
+  type: ConditionType;
+  values: string[];         // enum values, or ['true','false'] for bool
+  range?: { min: number; max: number };  // for int_range
+}
+
+export type ActionType = 'bool' | 'enum' | 'string';
+
+export interface ActionOutputDef {
+  name: string;
+  type: ActionType;
+  description?: string;
+  values?: string[];        // valid values for enum type
+}
+
+export type CellValue =
+  | { kind: 'any' }                           // "-" wildcard
+  | { kind: 'exact'; value: string }          // exact match
+  | { kind: 'negated'; value: string }        // "!value"
+  | { kind: 'set'; values: string[] };        // "a,b" (match any in set)
+
+export interface Rule {
+  number?: number;           // optional rule # from the # column
+  conditions: Map<string, CellValue>;   // condition name → cell value
+  actions: Map<string, string>;          // action name → output value
+}
+
+export interface DecisionTableDef {
+  name: string;
+  description?: string;
+  conditions: ConditionDef[];
+  actions: ActionOutputDef[];
+  rules: Rule[];
+  policy: 'first-match' | 'all-match';  // default: first-match
+}

package/src/parser/dt-parser.ts

@@ -0,0 +1,289 @@
+// Decision Table Parser
+// Parses ## conditions, ## actions, ## rules sections from markdown elements
+
+import {
+  ConditionDef, ConditionType, ActionOutputDef, ActionType,
+  CellValue, Rule, DecisionTableDef,
+} from './dt-ast.js';
+
+interface MdHeading { kind: 'heading'; level: number; text: string; line: number }
+interface MdTable { kind: 'table'; headers: string[]; rows: string[][]; line: number }
+interface MdBulletList { kind: 'bullets'; items: string[]; line: number }
+interface MdBlockquote { kind: 'blockquote'; text: string; line: number }
+interface MdParagraph { kind: 'paragraph'; text: string; line: number }
+interface MdSeparator { kind: 'separator'; line: number }
+
+type MdElement = MdHeading | MdTable | MdBulletList | MdBlockquote | MdParagraph | MdSeparator;
+
+function findColumnIndex(headers: string[], name: string): number {
+  return headers.findIndex(h => h.toLowerCase() === name.toLowerCase());
+}
+
+// --- Cell Value Parsing ---
+
+function parseCellValue(text: string | undefined): CellValue {
+  if (!text || text.trim() === '' || text.trim() === '-') {
+    return { kind: 'any' };
+  }
+
+  const trimmed = text.trim();
+
+  // Negated: !value (bare '!' with no value falls through to exact match)
+  if (trimmed.startsWith('!')) {
+    const negatedValue = trimmed.slice(1);
+    if (negatedValue) {
+      return { kind: 'negated', value: negatedValue };
+    }
+  }
+
+  // Set: a,b,c
+  if (trimmed.includes(',')) {
+    return { kind: 'set', values: trimmed.split(',').map(v => v.trim()).filter(Boolean) };
+  }
+
+  // Exact match
+  return { kind: 'exact', value: trimmed };
+}
+
+// --- Section Parsers ---
+
+function parseConditionsTable(table: MdTable): ConditionDef[] {
+  const nameIdx = findColumnIndex(table.headers, 'name');
+  const typeIdx = findColumnIndex(table.headers, 'type');
+  const valuesIdx = findColumnIndex(table.headers, 'values');
+
+  return table.rows.map(row => {
+    const name = (nameIdx >= 0 ? row[nameIdx] : '') || '';
+    const typeStr = (typeIdx >= 0 ? row[typeIdx] : '') || 'string';
+    const valuesStr = (valuesIdx >= 0 ? row[valuesIdx] : '') || '';
+
+    const type: ConditionType = typeStr.trim() as ConditionType;
+
+    // Bool conditions auto-populate values ['true', 'false'] when Values column is empty
+    let values: string[];
+    let range: { min: number; max: number } | undefined;
+
+    if (type === 'bool') {
+      values = valuesStr.trim() ? valuesStr.split(',').map(v => v.trim()) : ['true', 'false'];
+    } else if (type === 'int_range') {
+      // Parse min..max format
+      const rangeMatch = valuesStr.match(/(\d+)\s*\.\.\s*(\d+)/);
+      if (rangeMatch) {
+        range = { min: parseInt(rangeMatch[1], 10), max: parseInt(rangeMatch[2], 10) };
+        values = [];
+      } else {
+        values = [];
+      }
+    } else {
+      // enum or string - comma-separated values
+      values = valuesStr ? valuesStr.split(',').map(v => v.trim()).filter(Boolean) : [];
+    }
+
+    const condition: ConditionDef = { name: name.trim(), type, values };
+    if (range) condition.range = range;
+
+    return condition;
+  }).filter(c => c.name !== '');
+}
+
+function parseActionsTable(table: MdTable): ActionOutputDef[] {
+  const nameIdx = findColumnIndex(table.headers, 'name');
+  const typeIdx = findColumnIndex(table.headers, 'type');
+  const descIdx = findColumnIndex(table.headers, 'description');
+  const valuesIdx = findColumnIndex(table.headers, 'values');
+
+  return table.rows.map(row => {
+    const name = (nameIdx >= 0 ? row[nameIdx] : '') || '';
+    const typeStr = (typeIdx >= 0 ? row[typeIdx] : '') || 'string';
+    const desc = descIdx >= 0 ? (row[descIdx] || '').trim() : '';
+    const valuesStr = valuesIdx >= 0 ? (row[valuesIdx] || '').trim() : '';
+
+    const type: ActionType = typeStr.trim() as ActionType;
+    const action: ActionOutputDef = {
+      name: name.trim(),
+      type,
+      description: desc || undefined,
+    };
+
+    if (valuesStr && type === 'enum') {
+      action.values = valuesStr.split(',').map(v => v.trim()).filter(Boolean);
+    }
+
+    return action;
+  }).filter(a => a.name !== '');
+}
+
+function parseRulesTable(
+  table: MdTable,
+  conditionNames: Set<string>,
+  actionNames: Set<string>
+): { rules: Rule[]; warnings: string[] } {
+  const warnings: string[] = [];
+  const rules: Rule[] = [];
+
+  // Determine column types from headers
+  const columnTypes: Array<{ name: string; type: 'condition' | 'action' | 'skip' }> = [];
+
+  for (const header of table.headers) {
+    const trimmed = header.trim();
+    const lower = trimmed.toLowerCase();
+
+    if (lower === '#') {
+      columnTypes.push({ name: '#', type: 'skip' });
+    } else if (trimmed.startsWith('→ ') || trimmed.startsWith('-> ')) {
+      // Action column - strip prefix
+      const actionName = trimmed.replace(/^→\s*/, '').replace(/^->\s*/, '');
+      columnTypes.push({ name: actionName, type: 'action' });
+
+      if (!actionNames.has(actionName)) {
+        warnings.push(`Unknown action column: "${actionName}" (not declared in ## actions)`);
+      }
+    } else {
+      // Condition column
+      columnTypes.push({ name: trimmed, type: 'condition' });
+
+      if (!conditionNames.has(trimmed)) {
+        warnings.push(`Unknown condition column: "${trimmed}" (not declared in ## conditions)`);
+      }
+    }
+  }
+
+  // Parse each row
+  for (let rowIdx = 0; rowIdx < table.rows.length; rowIdx++) {
+    const row = table.rows[rowIdx];
+    const rule: Rule = {
+      conditions: new Map(),
+      actions: new Map(),
+    };
+
+    for (let colIdx = 0; colIdx < columnTypes.length && colIdx < row.length; colIdx++) {
+      const col = columnTypes[colIdx];
+      const cell = row[colIdx];
+
+      if (col.type === 'skip') {
+        // Rule numbering column - parse as optional number
+        const num = parseInt(cell?.trim() || '', 10);
+        if (!isNaN(num)) {
+          rule.number = num;
+        }
+      } else if (col.type === 'condition') {
+        const cellValue = parseCellValue(cell);
+        rule.conditions.set(col.name, cellValue);
+      } else if (col.type === 'action') {
+        const value = cell?.trim() || '';
+        if (value) {
+          rule.actions.set(col.name, value);
+        }
+      }
+    }
+
+    rules.push(rule);
+  }
+
+  return { rules, warnings };
+}
+
+// --- Main Decision Table Parser ---
+
+export function parseDecisionTable(elements: MdElement[]): { decisionTable: DecisionTableDef; warnings: string[] } {
+  let tableName = '';
+  let description: string | undefined;
+  let conditions: ConditionDef[] = [];
+  let actions: ActionOutputDef[] = [];
+  let rules: Rule[] = [];
+  let policy: 'first-match' | 'all-match' = 'first-match';
+  const warnings: string[] = [];
+
+  // Track current section
+  let currentSection: 'conditions' | 'actions' | 'rules' | null = null;
+  let currentTable: MdTable | null = null;
+
+  // Collect description from paragraphs before first ## heading
+  const descriptionParts: string[] = [];
+
+  for (let i = 0; i < elements.length; i++) {
+    const el = elements[i];
+
+    if (el.kind === 'heading') {
+      if (el.level === 1 && el.text.startsWith('decision_table ')) {
+        tableName = el.text.slice(15).trim();
+        continue;
+      }
+
+      if (el.level === 2) {
+        const sectionName = el.text.toLowerCase();
+
+        // Before processing first section, capture accumulated description
+        if (currentSection === null && descriptionParts.length > 0) {
+          description = descriptionParts.join(' ').trim();
+        }
+
+        if (sectionName === 'conditions') {
+          currentSection = 'conditions';
+        } else if (sectionName === 'actions') {
+          currentSection = 'actions';
+        } else if (sectionName === 'rules') {
+          currentSection = 'rules';
+        } else if (sectionName === 'metadata') {
+          currentSection = null; // metadata doesn't have a table
+        } else {
+          currentSection = null;
+        }
+        currentTable = null;
+        continue;
+      }
+
+      // Reset section on unknown headings
+      currentSection = null;
+      currentTable = null;
+    }
+
+    // Accumulate description from paragraphs and blockquotes before first section
+    if (currentSection === null) {
+      if (el.kind === 'paragraph') {
+        descriptionParts.push(el.text);
+      } else if (el.kind === 'blockquote') {
+        descriptionParts.push(el.text);
+      }
+    }
+
+    // Capture tables for current section
+    if (el.kind === 'table' && currentSection !== null) {
+      if (currentSection === 'conditions') {
+        conditions = parseConditionsTable(el);
+      } else if (currentSection === 'actions') {
+        actions = parseActionsTable(el);
+      } else if (currentSection === 'rules') {
+        const result = parseRulesTable(el, new Set(conditions.map(c => c.name)), new Set(actions.map(a => a.name)));
+        rules = result.rules;
+        warnings.push(...result.warnings);
+      }
+      currentTable = el;
+    }
+  }
+
+  const decisionTable: DecisionTableDef = {
+    name: tableName,
+    description,
+    conditions,
+    actions,
+    rules,
+    policy,
+  };
+
+  return { decisionTable, warnings };
+}
+
+// Parse a chunk of markdown elements that represents a single decision table
+// Returns null if the chunk doesn't start with # decision_table
+export function parseDecisionTableChunk(chunk: MdElement[]): DecisionTableDef | null {
+  if (chunk.length === 0) return null;
+
+  const firstHeading = chunk.find(el => el.kind === 'heading' && el.level === 1) as MdHeading | undefined;
+  if (!firstHeading || !firstHeading.text.startsWith('decision_table ')) {
+    return null;
+  }
+
+  const { decisionTable } = parseDecisionTable(chunk);
+  return decisionTable;
+}