@orcalang/orca-lang 0.1.19 → 0.1.24

package/dist/skills.js

@@ -6,8 +6,8 @@ import { checkDeterminism } from './verifier/determinism.js';
 import { checkProperties } from './verifier/properties.js';
 import { compileToXState } from './compiler/xstate.js';
 import { compileToMermaid } from './compiler/mermaid.js';
-import { verifyDecisionTables } from './verifier/dt-verifier.js';
-import { compileDecisionTableToTypeScript, compileDecisionTableToJSON } from './compiler/dt-compiler.js';
+import { verifyDecisionTables, checkFileContextAlignment, checkDTMachineIntegration, computeAlignedDTOutputDomain } from './verifier/dt-verifier.js';
+import { compileDecisionTableToTypeScript, compileDecisionTableToPython, compileDecisionTableToGo, compileDecisionTableToRust, compileDecisionTableToJSON, toSnakeCase, } from './compiler/dt-compiler.js';
 import { loadConfig } from './config/index.js';
 import { createProvider } from './llm/index.js';
 import { getCodeGenerator } from './generators/index.js';
@@ -136,8 +136,15 @@ export async function verifySkill(input) {
     const source = resolveSource(input);
     const label = resolveLabel(input);
     let machine;
+    let fileDecisionTables = [];
     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
@@ -159,7 +166,16 @@ export async function verifySkill(input) {
     const structural = checkStructural(machine);
     const completeness = checkCompleteness(machine);
     const determinism = checkDeterminism(machine);
-    const properties = checkProperties(machine);
+    // 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: e.code,
         message: e.message,
@@ -167,6 +183,9 @@ export async function verifySkill(input) {
         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,
     });
@@ -175,6 +194,8 @@ export async function verifySkill(input) {
         ...completeness.errors.map(mapError),
         ...determinism.errors.map(mapError),
         ...properties.errors.map(mapError),
+        ...dtAlignment.map(mapError),
+        ...dtIntegration.map(mapError),
     ];
     return {
         status: allErrors.some(e => e.severity === 'error') ? 'invalid' : 'valid',
@@ -221,7 +242,17 @@ export async function compileSkill(input, target) {
 }
 export async function generateActionsSkill(input, language = 'typescript', useLLM = false, configPath, generateTests = false) {
     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 = machine.actions.map(action => ({
         name: action.name,
         signature: `${action.name}(${action.parameters.join(', ')}) -> ${action.returnType}${action.hasEffect ? ` + Effect<${action.effectType}>` : ''}`,
@@ -231,6 +262,22 @@ export async function generateActionsSkill(input, language = 'typescript', useLL
         effectType: action.effectType,
         context_used: extractContextFields(machine, action.name),
     }));
+    // Compile decision table evaluator code for each DT in the file
+    const decisionTableCode = {};
+    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 = {};
     let tests = {};
     if (useLLM) {
@@ -243,7 +290,7 @@ export async function generateActionsSkill(input, language = 'typescript', useLL
             max_tokens: config.max_tokens,
             temperature: config.temperature,
         });
-        scaffolds = await generateWithLLM(provider, actions, machine, language);
+        scaffolds = await generateWithLLM(provider, actions, machine, language, decisionTables);
         if (generateTests) {
             tests = await generateUnitTests(provider, actions, machine, language);
         }
@@ -251,7 +298,14 @@ export async function generateActionsSkill(input, language = 'typescript', useLL
     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) {
             tests = generateTemplateTests(actions, machine, language);
@@ -262,22 +316,31 @@ export async function generateActionsSkill(input, language = 'typescript', useLL
         machine: machine.name,
         actions,
         scaffolds,
+        decisionTableCode: Object.keys(decisionTableCode).length > 0 ? decisionTableCode : undefined,
         tests: Object.keys(tests).length > 0 ? tests : undefined,
     };
 }
-async function generateWithLLM(provider, actions, machine, language) {
+async function generateWithLLM(provider, actions, machine, language, decisionTables = []) {
     const generator = getCodeGenerator(language);
     const scaffolds = {};
+    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:`;
         try {
@@ -295,7 +358,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);
         }
     }
     return scaffolds;
@@ -352,6 +415,9 @@ function generateTemplateTestsForAction(action, machine, language = 'typescript'
     if (language === 'go') {
         return generateGoTestScaffold(action, machine);
     }
+    if (language === 'rust') {
+        return generateRustTestScaffold(action, machine);
+    }
     return generateTypeScriptTestScaffold(action, machine);
 }
 function generateTypeScriptTestScaffold(action, machine) {
@@ -522,6 +588,60 @@ ${preserved.map(f => `\tif result["${f}"] != ctx["${f}"] {\n\t\tt.Errorf("${f}:
 }
 `;
 }
+function generateRustTestScaffold(action, machine) {
+    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, fieldName) {
     // 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'];
@@ -539,7 +659,7 @@ function actionModifiesField(action, fieldName) {
 }
 function getDefaultValueForType(type, language = 'typescript') {
     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') {
@@ -566,6 +686,25 @@ function getDefaultValueForType(type, language = 'typescript') {
                 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 "''";
@@ -579,7 +718,7 @@ function getDefaultValueForType(type, language = 'typescript') {
             }
         }
     }
-    return language === 'python' ? 'None' : language === 'go' ? 'nil' : 'null';
+    return language === 'python' ? 'None' : language === 'go' ? 'nil' : language === 'rust' ? 'null' : 'null';
 }
 function extractContextFields(machine, actionName) {
     const fields = [];
@@ -602,7 +741,270 @@ function extractContextFields(machine, actionName) {
 function toPascalCase(snake) {
     return snake.split('_').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('');
 }
-function generateActionScaffold(action, machine, language) {
+/**
+ * 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, dts) {
+    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, language) {
+    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, machine) {
+    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, condType) {
+    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, condType) {
+    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, machine, language, dt) {
+    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;
+            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, machine, language, matchedDT) {
     if (language === 'python') {
         if (action.hasEffect) {
             return `# Action: ${action.name}
@@ -619,13 +1021,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)
 `;
     }
@@ -645,17 +1051,50 @@ 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
 \t}
 \treturn result
 }
+`;
+    }
+    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)
@@ -681,10 +1120,14 @@ 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 };
 }
 `;
@@ -1502,9 +1945,24 @@ export function compileDTSkill(input, target = 'typescript') {
             };
         }
         const dt = file.decisionTables[0];
-        const output = target === 'json'
-            ? compileDecisionTableToJSON(dt)
-            : compileDecisionTableToTypeScript(dt);
+        let output;
+        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) {