dirac-lang 0.1.10 → 0.1.12

package/config.yml

@@ -1,6 +1,6 @@
 # Dirac server configuration
 llmProvider: ollama 
-llmModel: llama2
+llmModel: deepseek-r1:8b 
 
 embeddingServer:
  host: "localhost"

package/dist/{chunk-3LRJLSZC.js → chunk-GTSDTB7P.js}

@@ -1,7 +1,7 @@
 import {
   DiracParser,
   integrate
-} from "./chunk-UDA4H3GU.js";
+} from "./chunk-YSEKILQM.js";
 import {
   createSession,
   getAvailableSubroutines,

package/dist/{chunk-UDA4H3GU.js → chunk-YSEKILQM.js}

@@ -79,6 +79,7 @@ async function executeDefvar(session, element) {
   const valueAttr = element.attributes.value;
   const visibleAttr = element.attributes.visible || "false";
   const literal = "literal" in element.attributes;
+  const trim = "trim" in element.attributes;
   if (!name) {
     throw new Error("<defvar> requires name attribute");
   }
@@ -109,6 +110,9 @@ async function executeDefvar(session, element) {
   } else {
     value = "";
   }
+  if (trim && typeof value === "string") {
+    value = value.trim();
+  }
   setVariable(session, name, value, visible);
 }
 
@@ -370,12 +374,12 @@ async function executeIf(session, element) {
   const condition = await evaluatePredicate(session, conditionElement);
   if (condition) {
     if (thenElement) {
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-BYQIE2MI.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-QEWHGYCE.js");
       await integrateChildren2(session, thenElement);
     }
   } else {
     if (elseElement) {
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-BYQIE2MI.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-QEWHGYCE.js");
       await integrateChildren2(session, elseElement);
     }
   }
@@ -388,7 +392,7 @@ async function evaluatePredicate(session, predicateElement) {
     return await evaluateCondition(session, predicateElement);
   }
   const outputLengthBefore = session.output.length;
-  const { integrate: integrate2 } = await import("./interpreter-BYQIE2MI.js");
+  const { integrate: integrate2 } = await import("./interpreter-QEWHGYCE.js");
   await integrate2(session, predicateElement);
   const newOutputChunks = session.output.slice(outputLengthBefore);
   const result = newOutputChunks.join("").trim();
@@ -411,11 +415,11 @@ async function evaluateCondition(session, condElement) {
   }
   const outputLengthBefore = session.output.length;
   const args = [];
-  const { integrate: integrate2 } = await import("./interpreter-BYQIE2MI.js");
+  const { integrate: integrate2 } = await import("./interpreter-QEWHGYCE.js");
   for (const child of condElement.children) {
     if (child.tag.toLowerCase() === "arg") {
       const argOutputStart = session.output.length;
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-BYQIE2MI.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-QEWHGYCE.js");
       await integrateChildren2(session, child);
       const newChunks = session.output.slice(argOutputStart);
       const argValue = newChunks.join("");
@@ -675,8 +679,13 @@ then you call it like
       example = example.replace(/&quot;/g, '"').replace(/&#58;/g, ":");
       systemPrompt += ">" + example + "</" + sub.name + ">";
     }
-    systemPrompt += "\nDo NOT invent or use any tags not listed above. For example, do NOT use <changeBackground> or <set-background>. Only use the allowed tags.\nInstructions: Output only valid Dirac XML tags from the list above. Do not include explanations or extra text.";
-    systemPrompt += "\nAfter generating your answer, check the command/tag list again and ensure every tag you use is in the list above. If any tag is not in the list, do not output it\u2014regenerate your answer using only allowed tags.";
+    systemPrompt += "\n\nIMPORTANT INSTRUCTIONS:";
+    systemPrompt += "\n1. Output ONLY valid XML tags from the list above";
+    systemPrompt += "\n2. Do NOT include any explanations, descriptions, or extra text";
+    systemPrompt += "\n3. Do NOT use bullet points or formatting - just pure XML";
+    systemPrompt += "\n4. Do NOT invent tags - only use tags from the list above";
+    systemPrompt += "\n5. Start your response directly with the XML tag (e.g., <add ...>)";
+    systemPrompt += "\n\nDouble-check: Does your response contain ONLY XML tags? If not, remove all non-XML text.";
     prompt = systemPrompt + "\nUser: " + userPrompt + "\nOutput:";
     if (session.debug || process.env.DIRAC_LOG_PROMPT === "1") {
       console.error("[LLM] Full prompt sent to LLM:\n" + prompt + "\n");
@@ -727,6 +736,9 @@ then you call it like
       const validateTags = element.attributes["validate"] === "true";
       const autocorrect = element.attributes["autocorrect"] === "true";
       const maxRetries = parseInt(element.attributes["max-retries"] || "0", 10);
+      const feedbackMode = element.attributes["feedback"] === "true";
+      const maxIterations = parseInt(element.attributes["max-iterations"] || "3", 10);
+      const replaceTick = element.attributes["replace-tick"] === "true";
       if (session.debug) {
         console.error(`[LLM] Executing response as Dirac code:
 ${result}
@@ -734,37 +746,126 @@ ${result}
         if (validateTags) {
           console.error(`[LLM] Tag validation enabled (autocorrect: ${autocorrect}, max-retries: ${maxRetries})`);
         }
-      }
-      const replaceTick = element.attributes["replace-tick"] === "true";
-      let diracCode = result.trim();
-      if (replaceTick && diracCode.startsWith("```")) {
-        const match = diracCode.match(/^```(\w+)?\n?/m);
-        if (match && match[1] === "bash") {
-          const endIdx = diracCode.indexOf("```", 3);
-          let bashContent = diracCode.slice(match[0].length, endIdx).trim();
-          diracCode = `<system>${bashContent}</system>`;
-        } else {
-          diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, "").replace(/\n?```$/m, "").trim();
+        if (feedbackMode) {
+          console.error(`[LLM] Feedback mode enabled (max iterations: ${maxIterations})`);
         }
       }
-      try {
-        const parser = new DiracParser();
-        let dynamicAST = parser.parse(diracCode);
-        if (validateTags) {
-          const { validateDiracCode, applyCorrectedTags } = await import("./tag-validator-I3GLCBVD.js");
-          let validation = await validateDiracCode(session, dynamicAST, { autocorrect });
-          let retryCount = 0;
-          while (!validation.valid && retryCount < maxRetries) {
-            retryCount++;
-            if (session.debug) {
-              console.error(`[LLM] Validation failed (attempt ${retryCount}/${maxRetries}):`, validation.errorMessages);
-            }
-            const errorFeedback = validation.errorMessages.join("\n");
-            const retryPrompt = `Your previous response had the following errors:
+      let iteration = 0;
+      while (iteration < maxIterations && (iteration === 0 || feedbackMode)) {
+        iteration++;
+        if (session.debug && feedbackMode) {
+          console.error(`[LLM] Feedback iteration ${iteration}/${maxIterations}`);
+        }
+        let diracCode = result.trim();
+        if (replaceTick && diracCode.startsWith("```")) {
+          const match = diracCode.match(/^```(\w+)?\n?/m);
+          if (match && match[1] === "bash") {
+            const endIdx = diracCode.indexOf("```", 3);
+            let bashContent = diracCode.slice(match[0].length, endIdx).trim();
+            diracCode = `<system>${bashContent}</system>`;
+          } else {
+            diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, "").replace(/\n?```$/m, "").trim();
+          }
+        }
+        const outputBefore = feedbackMode ? session.output.slice() : [];
+        try {
+          const parser = new DiracParser();
+          let dynamicAST = parser.parse(diracCode);
+          if (validateTags) {
+            const { validateDiracCode, applyCorrectedTags } = await import("./tag-validator-I3GLCBVD.js");
+            let validation = await validateDiracCode(session, dynamicAST, { autocorrect });
+            let retryCount = 0;
+            while (!validation.valid && retryCount < maxRetries) {
+              retryCount++;
+              if (session.debug) {
+                console.error(`[LLM] Validation failed (attempt ${retryCount}/${maxRetries}):`, validation.errorMessages);
+              }
+              const errorFeedback = validation.errorMessages.join("\n");
+              const retryPrompt = `Your previous response had the following errors:
 ${errorFeedback}
 
 Please fix these errors and generate valid Dirac XML again. Remember to only use the allowed tags.`;
-            dialogHistory.push({ role: "user", content: retryPrompt });
+              dialogHistory.push({ role: "user", content: retryPrompt });
+              if (isOpenAI) {
+                const response = await session.llmClient.chat.completions.create({
+                  model,
+                  max_tokens: maxTokens,
+                  temperature,
+                  messages: dialogHistory
+                });
+                result = response.choices[0]?.message?.content || "";
+              } else if (isOllama) {
+                const ollamaPrompt = dialogHistory.map((m) => `${m.role.charAt(0).toUpperCase() + m.role.slice(1)}: ${m.content}`).join("\n");
+                result = await session.llmClient.complete(ollamaPrompt, {
+                  model,
+                  temperature,
+                  max_tokens: maxTokens
+                });
+              } else {
+                const response = await session.llmClient.messages.create({
+                  model,
+                  max_tokens: maxTokens,
+                  temperature,
+                  messages: dialogHistory
+                });
+                const content = response.content[0];
+                result = content.type === "text" ? content.text : "";
+              }
+              dialogHistory.push({ role: "assistant", content: result });
+              if (contextVar) {
+                setVariable(session, contextVar, dialogHistory, true);
+              }
+              if (session.debug) {
+                console.error(`[LLM] Retry ${retryCount} response:
+${result}
+`);
+              }
+              diracCode = result.trim();
+              if (replaceTick && diracCode.startsWith("```")) {
+                const match = diracCode.match(/^```(\w+)?\n?/m);
+                if (match && match[1] === "bash") {
+                  const endIdx = diracCode.indexOf("```", 3);
+                  let bashContent = diracCode.slice(match[0].length, endIdx).trim();
+                  diracCode = `<system>${bashContent}</system>`;
+                } else {
+                  diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, "").replace(/\n?```$/m, "").trim();
+                }
+              }
+              dynamicAST = parser.parse(diracCode);
+              validation = await validateDiracCode(session, dynamicAST, { autocorrect });
+            }
+            if (!validation.valid) {
+              throw new Error(`Tag validation failed after ${maxRetries} retries:
+${validation.errorMessages.join("\n")}`);
+            }
+            if (autocorrect) {
+              dynamicAST = applyCorrectedTags(dynamicAST, validation.results);
+              if (session.debug) {
+                console.error("[LLM] Applied auto-corrections to tags");
+              }
+            }
+          }
+          await integrate(session, dynamicAST);
+          if (feedbackMode) {
+            const outputAfter = session.output.slice();
+            const executionOutput = outputAfter.slice(outputBefore.length).join("");
+            if (session.debug) {
+              console.error(`[LLM] Execution output (${executionOutput.length} chars):
+${executionOutput}
+`);
+            }
+            const feedbackPrompt = `The code executed successfully. Here is the output:
+\`\`\`
+${executionOutput}
+\`\`\`
+
+Please review the output carefully. If the output is correct and complete, respond with ONLY the word "DONE" and nothing else. If the output is incorrect or incomplete, generate corrected Dirac XML code.`;
+            if (session.debug) {
+              console.error(`[LLM] Feedback prompt:
+${feedbackPrompt}
+`);
+            }
+            dialogHistory.push({ role: "user", content: feedbackPrompt });
             if (isOpenAI) {
               const response = await session.llmClient.chat.completions.create({
                 model,
@@ -795,41 +896,28 @@ Please fix these errors and generate valid Dirac XML again. Remember to only use
               setVariable(session, contextVar, dialogHistory, true);
             }
             if (session.debug) {
-              console.error(`[LLM] Retry ${retryCount} response:
+              console.error(`[LLM] Feedback response:
 ${result}
 `);
             }
-            diracCode = result.trim();
-            if (replaceTick && diracCode.startsWith("```")) {
-              const match = diracCode.match(/^```(\w+)?\n?/m);
-              if (match && match[1] === "bash") {
-                const endIdx = diracCode.indexOf("```", 3);
-                let bashContent = diracCode.slice(match[0].length, endIdx).trim();
-                diracCode = `<system>${bashContent}</system>`;
-              } else {
-                diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, "").replace(/\n?```$/m, "").trim();
+            const responseStart = result.trim().substring(0, 100).toUpperCase();
+            if (responseStart.startsWith("DONE") || result.trim().toLowerCase().includes("looks correct") || result.trim().toLowerCase().includes("looks good")) {
+              if (session.debug) {
+                console.error(`[LLM] Feedback loop terminating - LLM indicated completion
+`);
               }
+              break;
             }
-            dynamicAST = parser.parse(diracCode);
-            validation = await validateDiracCode(session, dynamicAST, { autocorrect });
-          }
-          if (!validation.valid) {
-            throw new Error(`Tag validation failed after ${maxRetries} retries:
-${validation.errorMessages.join("\n")}`);
+          } else {
+            break;
           }
-          if (autocorrect) {
-            dynamicAST = applyCorrectedTags(dynamicAST, validation.results);
-            if (session.debug) {
-              console.error("[LLM] Applied auto-corrections to tags");
-            }
+        } catch (parseError) {
+          if (session.debug) {
+            console.error(`[LLM] Failed to parse as Dirac, treating as text: ${parseError}`);
           }
+          emit(session, result);
+          break;
         }
-        await integrate(session, dynamicAST);
-      } catch (parseError) {
-        if (session.debug) {
-          console.error(`[LLM] Failed to parse as Dirac, treating as text: ${parseError}`);
-        }
-        emit(session, result);
       }
     } else {
       emit(session, result);
@@ -1242,7 +1330,7 @@ async function executeTagCheck(session, element) {
       const executeTag = correctedTag || tagName;
       console.error(`[tag-check] Executing <${executeTag}/> as all checks passed and execute=true.`);
       const elementToExecute = correctedTag ? { ...child, tag: correctedTag } : child;
-      const { integrate: integrate2 } = await import("./interpreter-BYQIE2MI.js");
+      const { integrate: integrate2 } = await import("./interpreter-QEWHGYCE.js");
       await integrate2(session, elementToExecute);
     }
   }
@@ -1251,7 +1339,7 @@ async function executeTagCheck(session, element) {
 // src/tags/throw.ts
 async function executeThrow(session, element) {
   const exceptionName = element.attributes?.name || "exception";
-  const { integrateChildren: integrateChildren2 } = await import("./interpreter-BYQIE2MI.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-QEWHGYCE.js");
   const exceptionDom = {
     tag: "exception-content",
     attributes: { name: exceptionName },
@@ -1264,7 +1352,7 @@ async function executeThrow(session, element) {
 // src/tags/try.ts
 async function executeTry(session, element) {
   setExceptionBoundary(session);
-  const { integrateChildren: integrateChildren2 } = await import("./interpreter-BYQIE2MI.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-QEWHGYCE.js");
   await integrateChildren2(session, element);
   unsetExceptionBoundary(session);
 }
@@ -1274,7 +1362,7 @@ async function executeCatch(session, element) {
   const exceptionName = element.attributes?.name || "exception";
   const caughtCount = lookupException(session, exceptionName);
   if (caughtCount > 0) {
-    const { integrateChildren: integrateChildren2 } = await import("./interpreter-BYQIE2MI.js");
+    const { integrateChildren: integrateChildren2 } = await import("./interpreter-QEWHGYCE.js");
     await integrateChildren2(session, element);
   }
   flushCurrentException(session);
@@ -1283,7 +1371,7 @@ async function executeCatch(session, element) {
 // src/tags/exception.ts
 async function executeException(session, element) {
   const exceptions = getCurrentExceptions(session);
-  const { integrateChildren: integrateChildren2 } = await import("./interpreter-BYQIE2MI.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-QEWHGYCE.js");
   for (const exceptionDom of exceptions) {
     await integrateChildren2(session, exceptionDom);
   }

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   execute
-} from "./chunk-3LRJLSZC.js";
-import "./chunk-UDA4H3GU.js";
+} from "./chunk-GTSDTB7P.js";
+import "./chunk-YSEKILQM.js";
 import "./chunk-E7IWGUE6.js";
 
 // src/cli.ts
@@ -11,7 +11,7 @@ import "dotenv/config";
 // package.json
 var package_default = {
   name: "dirac-lang",
-  version: "0.1.10",
+  version: "0.1.12",
   description: "LLM-Augmented Declarative Execution",
   type: "module",
   main: "dist/index.js",

package/dist/index.js

@@ -2,11 +2,11 @@ import {
   createLLMAdapter,
   execute,
   executeUserCommand
-} from "./chunk-3LRJLSZC.js";
+} from "./chunk-GTSDTB7P.js";
 import {
   DiracParser,
   integrate
-} from "./chunk-UDA4H3GU.js";
+} from "./chunk-YSEKILQM.js";
 import {
   createSession,
   getAvailableSubroutines,

package/dist/{interpreter-BYQIE2MI.js → interpreter-QEWHGYCE.js}

@@ -1,7 +1,7 @@
 import {
   integrate,
   integrateChildren
-} from "./chunk-UDA4H3GU.js";
+} from "./chunk-YSEKILQM.js";
 import "./chunk-E7IWGUE6.js";
 export {
   integrate,

package/dist/test-runner.js

@@ -1,7 +1,7 @@
 import {
   DiracParser,
   integrate
-} from "./chunk-UDA4H3GU.js";
+} from "./chunk-YSEKILQM.js";
 import {
   createSession,
   getOutput

package/examples/llm-feedback-debug.di

@@ -0,0 +1,30 @@
+#!/usr/bin/env dirac
+<!-- Test: Feedback with math calculation - DEBUG VERSION -->
+
+<dirac>
+<subroutine name="add" description="addition of two numbers" param-a="number:required:first argument::2" param-b="number:required:second argument::3">
+  <output>DEBUG: a=<variable name="a" />, b=<variable name="b" />
+</output>
+  <expr eval="plus">
+    <arg><variable name="a" /></arg>
+    <arg><variable name="b" /></arg>
+  </expr>
+</subroutine>
+
+<llm 
+  execute="true" 
+  feedback="true" 
+  autocorrect="true"
+  max-iterations="3"
+  replace-tick="true"
+  output-var="generated_code">
+Calculate 5 + 3 using the add subroutine and display the result.
+</llm>
+
+<output>
+
+Generated code was:
+<variable name="generated_code" />
+</output>
+
+</dirac>

package/examples/llm-feedback-demo.di

@@ -0,0 +1,19 @@
+#!/usr/bin/env dirac
+<!-- Test: LLM feedback mode
+Description: Test the feedback loop where LLM generates code, sees output, and can iterate
+Expected: Should output "Hello from feedback loop!" and eventually say "DONE"
+-->
+
+<dirac>
+<llm 
+  execute="true" 
+  feedback="true" 
+  max-iterations="2"
+  validate="true"
+  autocorrect="true"
+  max-retries="2"
+  replace-tick="true"
+  no-extra="true">
+Use the output tag to print "Hello from feedback loop!"
+</llm>
+</dirac>

package/examples/llm-feedback-math.di

@@ -0,0 +1,22 @@
+#!/usr/bin/env dirac
+<!-- Test: Feedback with math calculation -->
+
+<dirac>
+<subroutine name="add" description="addition of two numbers " param-a="number:required:first argument::1st arg" param-b="number:required:second argument::2nd arg">
+  <expr eval="plus">
+    <arg><variable name="a" /></arg>
+    <arg><variable name="b" /></arg>
+  </expr>
+</subroutine>
+
+<llm 
+  execute="true" 
+  feedback="true" 
+  validate="true"
+  autocorrect="true"
+  max-iterations="3"
+  replace-tick="true">
+Calculate 5 + 3 using the add subroutine and display the result.
+</llm>
+
+</dirac>

package/examples/llm-feedback-simple.di

@@ -0,0 +1,16 @@
+#!/usr/bin/env dirac
+<!-- Test: Simple feedback mode without validation -->
+
+<dirac>
+<subroutine name="greet" param-name="string">
+  <output>Hello, <variable name="name" />!</output>
+</subroutine>
+
+<llm 
+  execute="true" 
+  feedback="true" 
+  max-iterations="2"
+  replace-tick="true">
+Call greet with name="Feedback Test"
+</llm>
+</dirac>

package/examples/llm-feedback-sub.di

@@ -0,0 +1,22 @@
+#!/usr/bin/env dirac
+<!-- Test: LLM feedback mode with subroutine
+Description: Test feedback loop with a simple subroutine
+Expected: Should call print-message and see the feedback loop work
+-->
+
+<dirac>
+<subroutine name="print-message" param-text="string">
+  <output><variable name="text" /></output>
+</subroutine>
+
+<llm 
+  execute="true" 
+  feedback="true" 
+  max-iterations="2"
+  validate="true"
+  autocorrect="true"
+  max-retries="2"
+  replace-tick="true">
+Call print-message with text="Hello from feedback loop!"
+</llm>
+</dirac>

package/examples/llm-no-feedback.di

@@ -0,0 +1,10 @@
+
+<dirac>
+<subroutine name="greet" param-name="string">
+  <output>Hello, <variable name="name" />!</output>
+</subroutine>
+
+<llm execute="true" >
+ Hi, my name is Zhi, greet me
+</llm>
+</dirac>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dirac-lang",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "LLM-Augmented Declarative Execution",
   "type": "module",
   "main": "dist/index.js",

package/src/tags/defvar.ts

@@ -14,6 +14,7 @@ export async function executeDefvar(session: DiracSession, element: DiracElement
   const valueAttr = element.attributes.value;
   const visibleAttr = element.attributes.visible || 'false';
   const literal = 'literal' in element.attributes;
+  const trim = 'trim' in element.attributes; // Support trim attribute to remove leading/trailing whitespace
 
   if (!name) {
     throw new Error('<defvar> requires name attribute');
@@ -52,5 +53,10 @@ export async function executeDefvar(session: DiracSession, element: DiracElement
     value = '';
   }
 
+  // Apply trim if requested
+  if (trim && typeof value === 'string') {
+    value = value.trim();
+  }
+
   setVariable(session, name, value, visible);
 }

package/src/tags/llm.ts

@@ -111,8 +111,13 @@ for (const sub of subroutines) {
    example = example.replace(/"/g, '"').replace(/:/g, ':'); 
   systemPrompt += '>'+example+'</' + sub.name + '>';
 }
-    systemPrompt += '\nDo NOT invent or use any tags not listed above. For example, do NOT use <changeBackground> or <set-background>. Only use the allowed tags.\nInstructions: Output only valid Dirac XML tags from the list above. Do not include explanations or extra text.';
-    systemPrompt += '\nAfter generating your answer, check the command/tag list again and ensure every tag you use is in the list above. If any tag is not in the list, do not output it—regenerate your answer using only allowed tags.';
+    systemPrompt += '\n\nIMPORTANT INSTRUCTIONS:';
+    systemPrompt += '\n1. Output ONLY valid XML tags from the list above';
+    systemPrompt += '\n2. Do NOT include any explanations, descriptions, or extra text';
+    systemPrompt += '\n3. Do NOT use bullet points or formatting - just pure XML';
+    systemPrompt += '\n4. Do NOT invent tags - only use tags from the list above';
+    systemPrompt += '\n5. Start your response directly with the XML tag (e.g., <add ...>)';
+    systemPrompt += '\n\nDouble-check: Does your response contain ONLY XML tags? If not, remove all non-XML text.';
 
     prompt = systemPrompt + '\nUser: ' + userPrompt + '\nOutput:';
     if (session.debug || process.env.DIRAC_LOG_PROMPT === '1') {
@@ -177,56 +182,164 @@ for (const sub of subroutines) {
       const validateTags = element.attributes['validate'] === 'true';
       const autocorrect = element.attributes['autocorrect'] === 'true';
       const maxRetries = parseInt(element.attributes['max-retries'] || '0', 10);
+      const feedbackMode = element.attributes['feedback'] === 'true';
+      const maxIterations = parseInt(element.attributes['max-iterations'] || '3', 10);
+      const replaceTick = element.attributes['replace-tick'] === 'true';
       
       if (session.debug) {
         console.error(`[LLM] Executing response as Dirac code:\n${result}\n`);
         if (validateTags) {
           console.error(`[LLM] Tag validation enabled (autocorrect: ${autocorrect}, max-retries: ${maxRetries})`);
         }
-      }
-
-      // Only replace triple backtick code blocks if replace-tick="true" is set
-      const replaceTick = element.attributes['replace-tick'] === 'true';
-      let diracCode = result.trim();
-      if (replaceTick && diracCode.startsWith('```')) {
-        // Check for bash, xml, html, dirac, or no language
-        const match = diracCode.match(/^```(\w+)?\n?/m);
-        if (match && match[1] === 'bash') {
-          // Find closing triple backticks
-          const endIdx = diracCode.indexOf('```', 3);
-          let bashContent = diracCode.slice(match[0].length, endIdx).trim();
-          diracCode = `<system>${bashContent}</system>`;
-        } else {
-          // Remove opening and closing backticks for xml/html/dirac/none
-          diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, '').replace(/\n?```$/m, '').trim();
+        if (feedbackMode) {
+          console.error(`[LLM] Feedback mode enabled (max iterations: ${maxIterations})`);
         }
       }
+
+      // Feedback loop: execute, capture output, send back to LLM, repeat
+      let iteration = 0;
       
-      try {
-        // Parse the LLM's output as Dirac code
-        const parser = new DiracParser();
-        let dynamicAST = parser.parse(diracCode);
+      while (iteration < maxIterations && (iteration === 0 || feedbackMode)) {
+        iteration++;
+        if (session.debug && feedbackMode) {
+          console.error(`[LLM] Feedback iteration ${iteration}/${maxIterations}`);
+        }
         
-        // Validate tags if requested
-        if (validateTags) {
-          const { validateDiracCode, applyCorrectedTags } = await import('../utils/tag-validator.js');
-          let validation = await validateDiracCode(session, dynamicAST, { autocorrect });
-          let retryCount = 0;
+        // Only replace triple backtick code blocks if replace-tick="true" is set
+        let diracCode = result.trim();
+        if (replaceTick && diracCode.startsWith('```')) {
+          // Check for bash, xml, html, dirac, or no language
+          const match = diracCode.match(/^```(\w+)?\n?/m);
+          if (match && match[1] === 'bash') {
+            // Find closing triple backticks
+            const endIdx = diracCode.indexOf('```', 3);
+            let bashContent = diracCode.slice(match[0].length, endIdx).trim();
+            diracCode = `<system>${bashContent}</system>`;
+          } else {
+            // Remove opening and closing backticks for xml/html/dirac/none
+            diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, '').replace(/\n?```$/m, '').trim();
+          }
+        }
+        
+        // Capture output before execution (for feedback)
+        const outputBefore = feedbackMode ? session.output.slice() : [];
+        
+        try {
+          // Parse the LLM's output as Dirac code
+          const parser = new DiracParser();
+          let dynamicAST = parser.parse(diracCode);
           
-          while (!validation.valid && retryCount < maxRetries) {
-            retryCount++;
+          // Validate tags if requested
+          if (validateTags) {
+            const { validateDiracCode, applyCorrectedTags } = await import('../utils/tag-validator.js');
+            let validation = await validateDiracCode(session, dynamicAST, { autocorrect });
+            let retryCount = 0;
+            
+            while (!validation.valid && retryCount < maxRetries) {
+              retryCount++;
+              if (session.debug) {
+                console.error(`[LLM] Validation failed (attempt ${retryCount}/${maxRetries}):`, validation.errorMessages);
+              }
+              
+              // Build error feedback for LLM
+              const errorFeedback = validation.errorMessages.join('\n');
+              const retryPrompt = `Your previous response had the following errors:\n${errorFeedback}\n\nPlease fix these errors and generate valid Dirac XML again. Remember to only use the allowed tags.`;
+              
+              // Add error feedback to dialog history
+              dialogHistory.push({ role: 'user', content: retryPrompt });
+              
+              // Retry LLM call
+              if (isOpenAI) {
+                const response = await session.llmClient.chat.completions.create({
+                  model,
+                  max_tokens: maxTokens,
+                  temperature,
+                  messages: dialogHistory,
+                });
+                result = response.choices[0]?.message?.content || '';
+              } else if (isOllama) {
+                const ollamaPrompt = dialogHistory.map(m => `${m.role.charAt(0).toUpperCase() + m.role.slice(1)}: ${m.content}`).join('\n');
+                result = await session.llmClient.complete(ollamaPrompt, {
+                  model,
+                  temperature,
+                  max_tokens: maxTokens,
+                });
+              } else {
+                const response = await session.llmClient.messages.create({
+                  model,
+                  max_tokens: maxTokens,
+                  temperature,
+                  messages: dialogHistory,
+                });
+                const content = response.content[0];
+                result = content.type === 'text' ? content.text : '';
+              }
+              
+              // Add new response to dialog history
+              dialogHistory.push({ role: 'assistant', content: result });
+              
+              // Update context variable if present
+              if (contextVar) {
+                setVariable(session, contextVar, dialogHistory, true);
+              }
+              
+              if (session.debug) {
+                console.error(`[LLM] Retry ${retryCount} response:\n${result}\n`);
+              }
+              
+              // Clean up and parse the new response
+              diracCode = result.trim();
+              if (replaceTick && diracCode.startsWith('```')) {
+                const match = diracCode.match(/^```(\w+)?\n?/m);
+                if (match && match[1] === 'bash') {
+                  const endIdx = diracCode.indexOf('```', 3);
+                  let bashContent = diracCode.slice(match[0].length, endIdx).trim();
+                  diracCode = `<system>${bashContent}</system>`;
+                } else {
+                  diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, '').replace(/\n?```$/m, '').trim();
+                }
+              }
+              
+              dynamicAST = parser.parse(diracCode);
+              validation = await validateDiracCode(session, dynamicAST, { autocorrect });
+            }
+            
+            if (!validation.valid) {
+              throw new Error(`Tag validation failed after ${maxRetries} retries:\n${validation.errorMessages.join('\n')}`);
+            }
+            
+            // Apply auto-corrections if enabled
+            if (autocorrect) {
+              dynamicAST = applyCorrectedTags(dynamicAST, validation.results);
+              if (session.debug) {
+                console.error('[LLM] Applied auto-corrections to tags');
+              }
+            }
+          }
+          
+          // Execute the validated (and possibly corrected) code
+          await integrate(session, dynamicAST);
+          
+          // If feedback mode, capture execution output and send back to LLM
+          if (feedbackMode) {
+            const outputAfter = session.output.slice();
+            const executionOutput = outputAfter.slice(outputBefore.length).join('');
+            
             if (session.debug) {
-              console.error(`[LLM] Validation failed (attempt ${retryCount}/${maxRetries}):`, validation.errorMessages);
+              console.error(`[LLM] Execution output (${executionOutput.length} chars):\n${executionOutput}\n`);
             }
             
-            // Build error feedback for LLM
-            const errorFeedback = validation.errorMessages.join('\n');
-            const retryPrompt = `Your previous response had the following errors:\n${errorFeedback}\n\nPlease fix these errors and generate valid Dirac XML again. Remember to only use the allowed tags.`;
+            // Build feedback prompt
+            const feedbackPrompt = `The code executed successfully. Here is the output:\n\`\`\`\n${executionOutput}\n\`\`\`\n\nPlease review the output carefully. If the output is correct and complete, respond with ONLY the word "DONE" and nothing else. If the output is incorrect or incomplete, generate corrected Dirac XML code.`;
             
-            // Add error feedback to dialog history
-            dialogHistory.push({ role: 'user', content: retryPrompt });
+            if (session.debug) {
+              console.error(`[LLM] Feedback prompt:\n${feedbackPrompt}\n`);
+            }
             
-            // Retry LLM call
+            // Add feedback to dialog history
+            dialogHistory.push({ role: 'user', content: feedbackPrompt });
+            
+            // Get LLM's assessment
             if (isOpenAI) {
               const response = await session.llmClient.chat.completions.create({
                 model,
@@ -253,7 +366,7 @@ for (const sub of subroutines) {
               result = content.type === 'text' ? content.text : '';
             }
             
-            // Add new response to dialog history
+            // Add response to dialog history
             dialogHistory.push({ role: 'assistant', content: result });
             
             // Update context variable if present
@@ -262,48 +375,33 @@ for (const sub of subroutines) {
             }
             
             if (session.debug) {
-              console.error(`[LLM] Retry ${retryCount} response:\n${result}\n`);
+              console.error(`[LLM] Feedback response:\n${result}\n`);
             }
             
-            // Clean up and parse the new response
-            diracCode = result.trim();
-            if (replaceTick && diracCode.startsWith('```')) {
-              const match = diracCode.match(/^```(\w+)?\n?/m);
-              if (match && match[1] === 'bash') {
-                const endIdx = diracCode.indexOf('```', 3);
-                let bashContent = diracCode.slice(match[0].length, endIdx).trim();
-                diracCode = `<system>${bashContent}</system>`;
-              } else {
-                diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, '').replace(/\n?```$/m, '').trim();
+            // Check if LLM says we're done (check at start of response)
+            const responseStart = result.trim().substring(0, 100).toUpperCase();
+            if (responseStart.startsWith('DONE') || result.trim().toLowerCase().includes('looks correct') || result.trim().toLowerCase().includes('looks good')) {
+              if (session.debug) {
+                console.error(`[LLM] Feedback loop terminating - LLM indicated completion\n`);
               }
+              break;
             }
             
-            dynamicAST = parser.parse(diracCode);
-            validation = await validateDiracCode(session, dynamicAST, { autocorrect });
+            // Otherwise, continue to next iteration with new LLM response
+          } else {
+            // No feedback mode, exit after first execution
+            break;
           }
           
-          if (!validation.valid) {
-            throw new Error(`Tag validation failed after ${maxRetries} retries:\n${validation.errorMessages.join('\n')}`);
+        } catch (parseError) {
+          // If parsing fails, treat as plain text
+          if (session.debug) {
+            console.error(`[LLM] Failed to parse as Dirac, treating as text: ${parseError}`);
           }
-          
-          // Apply auto-corrections if enabled
-          if (autocorrect) {
-            dynamicAST = applyCorrectedTags(dynamicAST, validation.results);
-            if (session.debug) {
-              console.error('[LLM] Applied auto-corrections to tags');
-            }
-          }
-        }
-        
-        // Execute the validated (and possibly corrected) code
-        await integrate(session, dynamicAST);
-      } catch (parseError) {
-        // If parsing fails, treat as plain text
-        if (session.debug) {
-          console.error(`[LLM] Failed to parse as Dirac, treating as text: ${parseError}`);
+          emit(session, result);
+          break; // Exit feedback loop on parse error
         }
-        emit(session, result);
-      }
+      } // end while loop
     } else {
       // Otherwise emit to output as text
       emit(session, result);