@orcalang/orca-lang 0.1.19 → 0.1.24

package/src/skills.ts

@@ -7,8 +7,16 @@ import { checkProperties } from './verifier/properties.js';
 import { compileToXState } from './compiler/xstate.js';
 import { compileToMermaid } from './compiler/mermaid.js';
 import { MachineDef, StateDef, GuardExpression, Type } from './parser/ast.js';
-import { verifyDecisionTable, verifyDecisionTables } from './verifier/dt-verifier.js';
-import { compileDecisionTableToTypeScript, compileDecisionTableToJSON } from './compiler/dt-compiler.js';
+import { DecisionTableDef } from './parser/dt-ast.js';
+import { verifyDecisionTable, verifyDecisionTables, checkFileContextAlignment, checkDTMachineIntegration, computeAlignedDTOutputDomain } from './verifier/dt-verifier.js';
+import {
+  compileDecisionTableToTypeScript,
+  compileDecisionTableToPython,
+  compileDecisionTableToGo,
+  compileDecisionTableToRust,
+  compileDecisionTableToJSON,
+  toSnakeCase,
+} from './compiler/dt-compiler.js';
 import { loadConfig, resolveConfigOverrides } from './config/index.js';
 import { createProvider } from './llm/index.js';
 import type { LLMProvider } from './llm/index.js';
@@ -88,6 +96,7 @@ export interface GenerateActionsResult {
   machine: string;
   actions: ActionScaffold[];
   scaffolds: Record<string, string>;
+  decisionTableCode?: Record<string, string>;  // DT name → compiled evaluator code
   tests?: Record<string, string>;
 }
 
@@ -247,8 +256,13 @@ export async function verifySkill(input: SkillInput): Promise<VerifySkillResult>
   const label = resolveLabel(input);
 
   let machine: MachineDef;
+  let fileDecisionTables: import('./parser/dt-ast.js').DecisionTableDef[] = [];
   try {
-    machine = parseSource(label, source);
+    const { file } = parseMarkdown(source);
+    if (file.machines.length === 0) throw new Error(`${label} contains no machine definition.`);
+    if (file.machines.length > 1) throw new Error(`${label} contains multiple machines.`);
+    machine = file.machines[0];
+    fileDecisionTables = file.decisionTables;
   } catch (err) {
     // Parse error - return as verification error
     const message = err instanceof Error ? err.message : String(err);
@@ -270,15 +284,28 @@ export async function verifySkill(input: SkillInput): Promise<VerifySkillResult>
   const structural = checkStructural(machine);
   const completeness = checkCompleteness(machine);
   const determinism = checkDeterminism(machine);
-  const properties = checkProperties(machine);
 
-  const mapError = (e: { code: string; message: string; severity: 'error' | 'warning'; location?: { state?: string; event?: string }; suggestion?: string }): SkillError => ({
+  // Check co-located decision table alignment and machine integration (single-machine files only)
+  const orcaFile = { machines: [machine], decisionTables: fileDecisionTables };
+  const dtOutputDomain = fileDecisionTables.length > 0 ? computeAlignedDTOutputDomain(orcaFile) : undefined;
+  const properties = checkProperties(machine, { dtOutputDomain });
+  const dtAlignment = fileDecisionTables.length > 0
+    ? checkFileContextAlignment(orcaFile)
+    : [];
+  const dtIntegration = fileDecisionTables.length > 0
+    ? checkDTMachineIntegration(orcaFile)
+    : [];
+
+  const mapError = (e: { code: string; message: string; severity: 'error' | 'warning'; location?: { state?: string; event?: string; decisionTable?: string; condition?: string; action?: string }; suggestion?: string }): SkillError => ({
     code: e.code,
     message: e.message,
     severity: e.severity,
     location: e.location ? {
       state: e.location.state,
       event: e.location.event,
+      decisionTable: e.location.decisionTable,
+      condition: e.location.condition,
+      action: e.location.action,
     } : undefined,
     suggestion: e.suggestion,
   });
@@ -288,6 +315,8 @@ export async function verifySkill(input: SkillInput): Promise<VerifySkillResult>
     ...completeness.errors.map(mapError),
     ...determinism.errors.map(mapError),
     ...properties.errors.map(mapError),
+    ...dtAlignment.map(mapError),
+    ...dtIntegration.map(mapError),
   ];
 
   return {
@@ -347,7 +376,18 @@ export async function generateActionsSkill(
   generateTests: boolean = false
 ): Promise<GenerateActionsResult> {
   const source = resolveSource(input);
-  const machine = parseSource(resolveLabel(input), source);
+
+  // Parse the full file to get both the machine and any co-located decision tables
+  const { file } = parseMarkdown(source);
+  const label = resolveLabel(input);
+  if (file.machines.length === 0) {
+    throw new Error(`${label} contains no machine definition.`);
+  }
+  if (file.machines.length > 1) {
+    throw new Error(`${label} contains multiple machines. Use a single-machine file for action generation.`);
+  }
+  const machine = file.machines[0];
+  const decisionTables = file.decisionTables;
 
   const actions: ActionScaffold[] = machine.actions.map(action => ({
     name: action.name,
@@ -359,6 +399,20 @@ export async function generateActionsSkill(
     context_used: extractContextFields(machine, action.name),
   }));
 
+  // Compile decision table evaluator code for each DT in the file
+  const decisionTableCode: Record<string, string> = {};
+  for (const dt of decisionTables) {
+    if (language === 'python') {
+      decisionTableCode[dt.name] = compileDecisionTableToPython(dt);
+    } else if (language === 'go') {
+      decisionTableCode[dt.name] = compileDecisionTableToGo(dt);
+    } else if (language === 'rust') {
+      decisionTableCode[dt.name] = compileDecisionTableToRust(dt);
+    } else {
+      decisionTableCode[dt.name] = compileDecisionTableToTypeScript(dt);
+    }
+  }
+
   let scaffolds: Record<string, string> = {};
   let tests: Record<string, string> = {};
 
@@ -373,7 +427,7 @@ export async function generateActionsSkill(
       temperature: config.temperature,
     });
 
-    scaffolds = await generateWithLLM(provider, actions, machine, language as CodeGeneratorType);
+    scaffolds = await generateWithLLM(provider, actions, machine, language as CodeGeneratorType, decisionTables);
 
     if (generateTests) {
       tests = await generateUnitTests(provider, actions, machine, language as CodeGeneratorType);
@@ -381,7 +435,13 @@ export async function generateActionsSkill(
   } else {
     // Use template-based scaffold generation
     for (const action of machine.actions) {
-      scaffolds[action.name] = generateActionScaffold(action, machine, language);
+      const matchedDT = findMatchingDT(action.name, decisionTables);
+      if (matchedDT && !action.hasEffect && isDTFullyAligned(matchedDT, machine)) {
+        // All DT conditions and outputs exist in context — generate fully wired code
+        scaffolds[action.name] = generateFullyWiredActionScaffold(action, machine, language, matchedDT);
+      } else {
+        scaffolds[action.name] = generateActionScaffold(action, machine, language, matchedDT ?? undefined);
+      }
     }
 
     if (generateTests) {
@@ -394,6 +454,7 @@ export async function generateActionsSkill(
     machine: machine.name,
     actions,
     scaffolds,
+    decisionTableCode: Object.keys(decisionTableCode).length > 0 ? decisionTableCode : undefined,
     tests: Object.keys(tests).length > 0 ? tests : undefined,
   };
 }
@@ -402,22 +463,35 @@ async function generateWithLLM(
   provider: LLMProvider,
   actions: ActionScaffold[],
   machine: MachineDef,
-  language: CodeGeneratorType
+  language: CodeGeneratorType,
+  decisionTables: DecisionTableDef[] = []
 ): Promise<Record<string, string>> {
   const generator = getCodeGenerator(language);
   const scaffolds: Record<string, string> = {};
 
+  const dtContext = decisionTables.length > 0
+    ? `\nDecision tables available:\n${decisionTables.map(dt =>
+        `- ${dt.name}: conditions=[${dt.conditions.map(c => c.name).join(', ')}] outputs=[${dt.actions.map(a => a.name).join(', ')}]`
+      ).join('\n')}`
+    : '';
+
   const systemPrompt = `You are an expert ${language} developer specializing in state machine action implementations.
 Given a machine definition and action signatures, generate complete action implementations.
 Follow the type signatures exactly. Use the provided context fields.
-If an action has an effect, return [newContext, effect] tuple.`;
+If an action has an effect, return [newContext, effect] tuple.
+If decision tables are listed, use their evaluator functions (e.g. evaluate${language === 'go' ? 'DtName' : 'DtName'}) when appropriate.`;
 
   for (const action of actions) {
+    const matchedDT = findMatchingDT(action.name, decisionTables);
+    const dtHint = matchedDT
+      ? `\nThis action should use the ${matchedDT.name} decision table evaluator.`
+      : '';
+
     const userPrompt = `Machine: ${machine.name}
-Context fields: ${machine.context.map(f => `${f.name}: ${f.type || 'unknown'}`).join(', ')}
+Context fields: ${machine.context.map(f => `${f.name}: ${f.type || 'unknown'}`).join(', ')}${dtContext}
 
 Action: ${action.signature}
-Description: ${action.name}${action.hasEffect ? ` (effect type: ${action.effectType})` : ''}
+Description: ${action.name}${action.hasEffect ? ` (effect type: ${action.effectType})` : ''}${dtHint}
 
 Generate the implementation:`;
 
@@ -436,7 +510,7 @@ Generate the implementation:`;
     } catch (err) {
       console.error(`LLM error for action ${action.name}: ${err instanceof Error ? err.message : String(err)}`);
       // Fall back to scaffold on error
-      scaffolds[action.name] = generateActionScaffold(action, machine, language);
+      scaffolds[action.name] = generateActionScaffold(action, machine, language, matchedDT ?? undefined);
     }
   }
 
@@ -507,6 +581,9 @@ function generateTemplateTestsForAction(action: ActionScaffold, machine: Machine
   if (language === 'go') {
     return generateGoTestScaffold(action, machine);
   }
+  if (language === 'rust') {
+    return generateRustTestScaffold(action, machine);
+  }
   return generateTypeScriptTestScaffold(action, machine);
 }
 
@@ -691,6 +768,63 @@ ${preserved.map(f => `\tif result["${f}"] != ctx["${f}"] {\n\t\tt.Errorf("${f}:
 `;
 }
 
+function generateRustTestScaffold(action: ActionScaffold, machine: MachineDef): string {
+  const ctxFields = machine.context.map(f => {
+    return `        "${f.name}": ${getDefaultValueForType(f.type, 'rust')}`;
+  }).join(',\n');
+  const contextUsed = action.context_used.length > 0 ? action.context_used : machine.context.map(f => f.name);
+  const preserved = contextUsed.filter(f => !actionModifiesField(action, f));
+
+  if (action.hasEffect) {
+    return `// Tests for ${action.name}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_${action.name}_executes_effect() {
+        let ctx = json!({
+${ctxFields}
+        });
+        let event = json!({"type": "test"});
+        let (result, effect) = ${action.name}(&ctx, &event);
+        assert!(result.is_object());
+        assert_eq!(effect.effect_type, "${action.effectType}");
+    }
+}
+`;
+  }
+
+  return `// Tests for ${action.name}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_${action.name}_transforms_context() {
+        let ctx = json!({
+${ctxFields}
+        });
+        let event = json!({"type": "test"});
+        let result = ${action.name}(&ctx, &event);
+        assert!(result.is_object());
+    }
+
+    #[test]
+    fn test_${action.name}_preserves_fields() {
+        let ctx = json!({
+${ctxFields}
+        });
+        let event = json!({"type": "test"});
+        let result = ${action.name}(&ctx, &event);
+${preserved.map(f => `        assert_eq!(result["${f}"], ctx["${f}"]);`).join('\n')}
+    }
+}
+`;
+}
+
 function actionModifiesField(action: ActionScaffold, fieldName: string): boolean {
   // Heuristic: if the action name suggests modification of a field, it likely modifies it
   const modifiers = ['increment', 'decrement', 'set', 'update', 'add', 'remove', 'clear', 'reset', 'toggle'];
@@ -712,7 +846,7 @@ function actionModifiesField(action: ActionScaffold, fieldName: string): boolean
 
 function getDefaultValueForType(type: any, language: string = 'typescript'): string {
   if (!type) {
-    return language === 'python' ? '""' : language === 'go' ? '""' : "''";
+    return language === 'python' ? '""' : language === 'go' ? '""' : language === 'rust' ? '"".to_string()' : "''";
   }
   if (typeof type === 'object' && 'kind' in type) {
     if (language === 'python') {
@@ -737,6 +871,22 @@ function getDefaultValueForType(type: any, language: string = 'typescript'): str
         case 'map': return 'nil';
         case 'custom': return 'nil';
       }
+    } else if (language === 'rust') {
+      switch (type.kind) {
+        case 'string': return '"".to_string()';
+        case 'int': return '0';
+        case 'decimal': return '0.0';
+        case 'bool': return 'false';
+        case 'optional': return 'null';
+        case 'array': return 'vec![]';
+        case 'map': return 'HashMap::new()';
+        case 'custom': {
+          // Handle common type aliases
+          if (type.name === 'float' || type.name === 'double') return '0.0';
+          if (type.name === 'integer' || type.name === 'long') return '0';
+          return 'null';
+        }
+      }
     } else {
       switch (type.kind) {
         case 'string': return "''";
@@ -750,7 +900,7 @@ function getDefaultValueForType(type: any, language: string = 'typescript'): str
       }
     }
   }
-  return language === 'python' ? 'None' : language === 'go' ? 'nil' : 'null';
+  return language === 'python' ? 'None' : language === 'go' ? 'nil' : language === 'rust' ? 'null' : 'null';
 }
 
 function extractContextFields(machine: MachineDef, actionName: string): string[] {
@@ -779,10 +929,292 @@ function toPascalCase(snake: string): string {
   return snake.split('_').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('');
 }
 
+/**
+ * Find a decision table whose name tokens overlap with the action name tokens.
+ * E.g. action "apply_routing_decision" matches DT "PaymentRouting" via "routing".
+ */
+function findMatchingDT(actionName: string, dts: DecisionTableDef[]): DecisionTableDef | null {
+  if (dts.length === 0) return null;
+  const actionTokens = new Set(
+    actionName.toLowerCase().split('_').filter(t => t.length > 2)
+  );
+  for (const dt of dts) {
+    const dtTokens = dt.name
+      .replace(/([A-Z])/g, ' $1')
+      .trim()
+      .toLowerCase()
+      .split(/\s+/)
+      .filter(t => t.length > 2);
+    if (dtTokens.some(t => actionTokens.has(t))) return dt;
+  }
+  return null;
+}
+
+/**
+ * Generate a commented example DT call block to include in an action stub.
+ */
+function generateDTCallComment(dt: DecisionTableDef, language: string): string {
+  const dtName = dt.name;
+
+  if (language === 'python') {
+    const fnName = `evaluate_${toSnakeCase(dtName)}`;
+    const inputClass = `${toPascalCase(dtName)}Input`;
+    const inputArgs = dt.conditions.map(c => {
+      const hint = c.type === 'enum' && c.values.length > 0
+        ? `str (${c.values.join(', ')})`
+        : c.type === 'bool' ? 'bool' : 'str';
+      return `    #     ${c.name}=...,  # ${hint} — map from ctx`;
+    }).join('\n');
+    const outputFields = dt.actions.map(a =>
+      `    #     # dt_result.${a.name} → ctx['${a.name}']`
+    ).join('\n');
+    return [
+      `    # Call ${fnName} to evaluate ${dtName} rules:`,
+      `    # dt_result = ${fnName}(${inputClass}(`,
+      inputArgs,
+      `    # ))`,
+      `    # if dt_result is not None:`,
+      outputFields,
+    ].join('\n');
+  }
+
+  if (language === 'go') {
+    const fnName = `Evaluate${toPascalCase(dtName)}`;
+    const inputStruct = `${toPascalCase(dtName)}Input`;
+    const inputArgs = dt.conditions.map(c => {
+      const goField = toPascalCase(c.name);
+      const hint = c.type === 'enum' && c.values.length > 0
+        ? `string (${c.values.join(', ')})`
+        : c.type === 'bool' ? 'bool' : 'string';
+      return `\t// \t${goField}: ..., // ${hint} — map from ctx`;
+    }).join('\n');
+    const outputFields = dt.actions.map(a =>
+      `\t// \tresult["${a.name}"] = dtResult.${toPascalCase(a.name)}`
+    ).join('\n');
+    return [
+      `\t// Call ${fnName} to evaluate ${dtName} rules:`,
+      `\t// dtResult := ${fnName}(${inputStruct}{`,
+      inputArgs,
+      `\t// })`,
+      `\t// if dtResult != nil {`,
+      outputFields,
+      `\t// }`,
+    ].join('\n');
+  }
+
+  if (language === 'rust') {
+    const fnName = `evaluate_${toSnakeCase(dtName)}`;
+    const inputStruct = `${toPascalCase(dtName)}Input`;
+    const inputArgs = dt.conditions.map(c => {
+      const hint = c.type === 'enum' && c.values.length > 0
+        ? `String (${c.values.join(', ')})`
+        : c.type === 'bool' ? 'bool' : c.type === 'int_range' ? 'i64' : 'String';
+      return `    //     ${c.name}: ..., // ${hint} — map from ctx`;
+    }).join('\n');
+    const outputFields = dt.actions.map(a =>
+      `    //     result["${a.name}"] = Value::String(dt_result.${a.name}.clone());`
+    ).join('\n');
+    return [
+      `    // Call ${fnName} to evaluate ${dtName} rules:`,
+      `    // let dt_input = ${inputStruct} {`,
+      inputArgs,
+      `    // };`,
+      `    // if let Some(dt_result) = ${fnName}(&dt_input) {`,
+      outputFields,
+      `    // }`,
+    ].join('\n');
+  }
+
+  // TypeScript (default)
+  const fnName = `evaluate${toPascalCase(dtName)}`;
+  const inputType = `${toPascalCase(dtName)}Input`;
+  const inputArgs = dt.conditions.map(c => {
+    const hint = c.type === 'enum' && c.values.length > 0
+      ? `enum: ${c.values.join(', ')}`
+      : c.type;
+    return `  //   ${c.name}: /* ctx.? */ as ${inputType}['${c.name}'],  // ${hint} — map from ctx`;
+  }).join('\n');
+  const outputFields = dt.actions.map(a =>
+    `  //   ${a.name}: dtResult.${a.name},`
+  ).join('\n');
+  return [
+    `  // Call ${fnName} to evaluate ${dtName} rules:`,
+    `  // const dtResult = ${fnName}({`,
+    inputArgs,
+    `  // });`,
+    `  // if (dtResult !== null) {`,
+    `  //   return { ...ctx,`,
+    outputFields,
+    `  //   };`,
+    `  // }`,
+  ].join('\n');
+}
+
+/**
+ * Returns true when every DT condition name and output name exists as a
+ * context field in the machine — the full co-location contract is satisfied.
+ */
+function isDTFullyAligned(dt: DecisionTableDef, machine: MachineDef): boolean {
+  const contextNames = new Set(machine.context.map(f => f.name));
+  return dt.conditions.every(c => contextNames.has(c.name)) &&
+         dt.actions.every(a => contextNames.has(a.name));
+}
+
+/** Generate a Go type assertion for reading a context value. */
+function goCtxRead(fieldName: string, condType: string): string {
+  if (condType === 'bool') return `ctx["${fieldName}"].(bool)`;
+  if (condType === 'int_range') return `ctx["${fieldName}"].(int)`;
+  return `ctx["${fieldName}"].(string)`;
+}
+
+/** Generate a Rust serde_json value extraction for reading a context value. */
+function rustCtxRead(fieldName: string, condType: string): string {
+  if (condType === 'bool') return `ctx["${fieldName}"].as_bool().unwrap_or_default()`;
+  if (condType === 'int_range') return `ctx["${fieldName}"].as_i64().unwrap_or_default()`;
+  if (condType === 'decimal_range') return `ctx["${fieldName}"].as_f64().unwrap_or_default()`;
+  return `ctx["${fieldName}"].as_str().unwrap_or_default().to_string()`;
+}
+
+function generateFullyWiredActionScaffold(
+  action: { name: string; parameters: string[]; returnType: string; hasEffect: boolean; effectType?: string },
+  machine: MachineDef,
+  language: string,
+  dt: DecisionTableDef
+): string {
+  if (language === 'python') {
+    const dtFnName = `evaluate_${toSnakeCase(dt.name)}`;
+    const inputClass = `${toPascalCase(dt.name)}Input`;
+    const inputArgs = dt.conditions
+      .map(c => `        ${c.name}=ctx['${c.name}'],`)
+      .join('\n');
+    const outputAssigns = dt.actions
+      .map(a => `            '${a.name}': dt_result.${a.name},`)
+      .join('\n');
+    return `# Action: ${action.name}
+# Decision table: ${dt.name}
+# Register via: machine.register_action("${action.name}", ${action.name})
+
+from typing import Any
+
+async def ${action.name}(ctx: dict[str, Any], event: Any = None) -> dict[str, Any]:
+    dt_result = ${dtFnName}(${inputClass}(
+${inputArgs}
+    ))
+    if dt_result is not None:
+        return {**ctx,
+${outputAssigns}
+        }
+    return dict(ctx)
+`;
+  }
+
+  if (language === 'go') {
+    const fnName = toPascalCase(action.name);
+    const dtFnName = `Evaluate${toPascalCase(dt.name)}`;
+    const inputStruct = `${toPascalCase(dt.name)}Input`;
+    const ctxReads = dt.conditions.map(c => {
+      const varName = toPascalCase(c.name).charAt(0).toLowerCase() + toPascalCase(c.name).slice(1);
+      return `\t${varName}, _ := ${goCtxRead(c.name, c.type)}`;
+    }).join('\n');
+    const inputFields = dt.conditions.map(c => {
+      const goField = toPascalCase(c.name);
+      const varName = goField.charAt(0).toLowerCase() + goField.slice(1);
+      return `\t\t${goField}: ${varName},`;
+    }).join('\n');
+    const outputAssigns = dt.actions
+      .map(a => `\t\tresult["${a.name}"] = dtResult.${toPascalCase(a.name)}`)
+      .join('\n');
+    return `// Action: ${action.name}
+// Decision table: ${dt.name}
+// Register via: machine.RegisterAction("${action.name}", ${fnName})
+
+func ${fnName}(ctx orca.Context, event map[string]any) map[string]any {
+${ctxReads}
+\tdtResult := ${dtFnName}(${inputStruct}{
+${inputFields}
+\t})
+\tresult := make(orca.Context)
+\tfor k, v := range ctx {
+\t\tresult[k] = v
+\t}
+\tif dtResult != nil {
+${outputAssigns}
+\t}
+\treturn result
+}
+`;
+  }
+
+  if (language === 'rust') {
+    const dtFnName = `evaluate_${toSnakeCase(dt.name)}`;
+    const inputStruct = `${toPascalCase(dt.name)}Input`;
+    const ctxReads = dt.conditions
+      .map(c => `    let ${c.name} = ${rustCtxRead(c.name, c.type)};`)
+      .join('\n');
+    const inputFields = dt.conditions
+      .map(c => `        ${c.name},`)
+      .join('\n');
+    const outputAssigns = dt.actions
+      .map(a => {
+        const aType = a.type as string;
+        if (aType === 'bool') return `        result["${a.name}"] = Value::Bool(dt_result.${a.name});`;
+        if (aType === 'int_range') return `        result["${a.name}"] = json!(dt_result.${a.name});`;
+        if (aType === 'decimal_range') return `        result["${a.name}"] = json!(dt_result.${a.name});`;
+        return `        result["${a.name}"] = Value::String(dt_result.${a.name}.clone());`;
+      })
+      .join('\n');
+    return `// Action: ${action.name}
+// Decision table: ${dt.name}
+// Register via: machine.register_action_rust("${action.name}", Box::new(${action.name}))
+
+use serde_json::{Value, json};
+
+fn ${action.name}(ctx: &Value, event: &Value) -> Value {
+${ctxReads}
+    let dt_input = ${inputStruct} {
+${inputFields}
+    };
+    if let Some(dt_result) = ${dtFnName}(&dt_input) {
+        let mut result = ctx.clone();
+${outputAssigns}
+        return result;
+    }
+    ctx.clone()
+}
+`;
+  }
+
+  // TypeScript (default)
+  const dtFnName = `evaluate${toPascalCase(dt.name)}`;
+  const inputArgs = dt.conditions
+    .map(c => `    ${c.name}: ctx.${c.name},`)
+    .join('\n');
+  const outputAssigns = dt.actions
+    .map(a => `      ${a.name}: dtResult.${a.name},`)
+    .join('\n');
+  return `// Action: ${action.name}
+// Decision table: ${dt.name}
+
+export function ${action.name}(ctx: Context): Context {
+  const dtResult = ${dtFnName}({
+${inputArgs}
+  });
+  if (dtResult !== null) {
+    return {
+      ...ctx,
+${outputAssigns}
+    };
+  }
+  return { ...ctx };
+}
+`;
+}
+
 function generateActionScaffold(
   action: { name: string; parameters: string[]; returnType: string; hasEffect: boolean; effectType?: string },
   machine: MachineDef,
-  language: string
+  language: string,
+  matchedDT?: DecisionTableDef
 ): string {
   if (language === 'python') {
     if (action.hasEffect) {
@@ -800,13 +1232,17 @@ async def ${action.name}(effect: Effect) -> EffectResult:
     return EffectResult(status=EffectStatus.SUCCESS, data={})
 `;
     }
-    return `# Action: ${action.name}
+    const pyDTComment = matchedDT ? '\n' + generateDTCallComment(matchedDT, 'python') + '\n' : '';
+    const pyTodo = matchedDT
+      ? `    # TODO: Implement action using ${matchedDT.name} decision table`
+      : '    # TODO: Implement action';
+    return `# Action: ${action.name}${matchedDT ? `\n# Decision table: ${matchedDT.name}` : ''}
 # Register via: machine.register_action("${action.name}", ${action.name})
 
 from typing import Any
 
-async def ${action.name}(ctx: dict[str, Any], event: Any = None) -> dict[str, Any]:
-    # TODO: Implement action
+async def ${action.name}(ctx: dict[str, Any], event: Any = None) -> dict[str, Any]:${pyDTComment}
+${pyTodo}
     return dict(ctx)
 `;
   }
@@ -827,11 +1263,15 @@ func ${fnName}(effect orca.Effect) orca.EffectResult {
 }
 `;
     }
-    return `// Action: ${action.name}
+    const goDTComment = matchedDT ? '\n' + generateDTCallComment(matchedDT, 'go') + '\n' : '';
+    const goTodo = matchedDT
+      ? `\t// TODO: Implement action using ${matchedDT.name} decision table`
+      : '\t// TODO: Implement action';
+    return `// Action: ${action.name}${matchedDT ? `\n// Decision table: ${matchedDT.name}` : ''}
 // Register via: machine.RegisterAction("${action.name}", ${fnName})
 
-func ${fnName}(ctx orca.Context, event map[string]any) map[string]any {
-\t// TODO: Implement action
+func ${fnName}(ctx orca.Context, event map[string]any) map[string]any {${goDTComment}
+${goTodo}
 \tresult := make(orca.Context)
 \tfor k, v := range ctx {
 \t\tresult[k] = v
@@ -841,6 +1281,36 @@ func ${fnName}(ctx orca.Context, event map[string]any) map[string]any {
 `;
   }
 
+  if (language === 'rust') {
+    if (action.hasEffect) {
+      return `// Action: ${action.name}
+// Effect: ${action.effectType}
+// Register via: machine.register_action_rust("${action.name}", Box::new(${action.name}))
+
+use serde_json::Value;
+
+fn ${action.name}(ctx: &Value, event: &Value) -> (Value, Effect) {
+    // TODO: Implement effect
+    (ctx.clone(), Effect { effect_type: "${action.effectType}".to_string(), payload: Value::Null })
+}
+`;
+    }
+    const rustDTComment = matchedDT ? '\n' + generateDTCallComment(matchedDT, 'rust') + '\n' : '';
+    const rustTodo = matchedDT
+      ? `    // TODO: Implement action using ${matchedDT.name} decision table`
+      : '    // TODO: Implement action';
+    return `// Action: ${action.name}${matchedDT ? `\n// Decision table: ${matchedDT.name}` : ''}
+// Register via: machine.register_action_rust("${action.name}", Box::new(${action.name}))
+
+use serde_json::Value;
+
+fn ${action.name}(ctx: &Value, event: &Value) -> Value {${rustDTComment}
+${rustTodo}
+    ctx.clone()
+}
+`;
+  }
+
   // TypeScript (default)
   const params = action.parameters.map(p => {
     if (p === 'ctx' || p === 'Context') return 'ctx: Context';
@@ -863,10 +1333,15 @@ export function ${action.name}(${params}): [Context, Effect<${action.effectType}
 // }
 `;
   }
-  return `// Action: ${action.name}
 
-export function ${action.name}(ctx: Context): Context {
-  // TODO: Implement action
+  const tsDTComment = matchedDT ? '\n' + generateDTCallComment(matchedDT, 'typescript') + '\n' : '';
+  const tsTodo = matchedDT
+    ? `  // TODO: Implement action using ${matchedDT.name} decision table`
+    : '  // TODO: Implement action';
+  return `// Action: ${action.name}${matchedDT ? `\n// Decision table: ${matchedDT.name}` : ''}
+
+export function ${action.name}(ctx: Context): Context {${tsDTComment}
+${tsTodo}
   return { ...ctx };
 }
 `;
@@ -1700,7 +2175,7 @@ export interface VerifyDTSkillResult {
 
 export interface CompileDTSkillResult {
   status: 'success' | 'error';
-  target: 'typescript' | 'json';
+  target: string;
   output: string;
   warnings: SkillError[];
 }
@@ -1813,7 +2288,7 @@ export function verifyDTSkill(input: SkillInput): VerifyDTSkillResult {
 /**
  * Compile a decision table to TypeScript or JSON.
  */
-export function compileDTSkill(input: SkillInput, target: 'typescript' | 'json' = 'typescript'): CompileDTSkillResult {
+export function compileDTSkill(input: SkillInput, target: string = 'typescript'): CompileDTSkillResult {
   try {
     const source = resolveSource(input);
     const { file } = parseMarkdown(source);
@@ -1828,9 +2303,24 @@ export function compileDTSkill(input: SkillInput, target: 'typescript' | 'json'
     }
 
     const dt = file.decisionTables[0];
-    const output = target === 'json'
-      ? compileDecisionTableToJSON(dt)
-      : compileDecisionTableToTypeScript(dt);
+    let output: string;
+    switch (target) {
+      case 'json':
+        output = compileDecisionTableToJSON(dt);
+        break;
+      case 'python':
+        output = compileDecisionTableToPython(dt);
+        break;
+      case 'go':
+        output = compileDecisionTableToGo(dt);
+        break;
+      case 'rust':
+        output = compileDecisionTableToRust(dt);
+        break;
+      default:
+        output = compileDecisionTableToTypeScript(dt);
+        break;
+    }
 
     return { status: 'success', target, output, warnings: [] };
   } catch (err) {