diff --git a/app/components/chat/Artifact.tsx b/app/components/chat/Artifact.tsx
index cef5a39794..94987377d4 100644
--- a/app/components/chat/Artifact.tsx
+++ b/app/components/chat/Artifact.tsx
@@ -23,15 +23,16 @@ if (import.meta.hot) {
 
 interface ArtifactProps {
   messageId: string;
+  artifactId: string;
 }
 
-export const Artifact = memo(({ messageId }: ArtifactProps) => {
+export const Artifact = memo(({ artifactId }: ArtifactProps) => {
   const userToggledActions = useRef(false);
   const [showActions, setShowActions] = useState(false);
   const [allActionFinished, setAllActionFinished] = useState(false);
 
   const artifacts = useStore(workbenchStore.artifacts);
-  const artifact = artifacts[messageId];
+  const artifact = artifacts[artifactId];
 
   const actions = useStore(
     computed(artifact.runner.actions, (actions) => {
diff --git a/app/components/chat/Markdown.tsx b/app/components/chat/Markdown.tsx
index 3471c73380..fd0d770a23 100644
--- a/app/components/chat/Markdown.tsx
+++ b/app/components/chat/Markdown.tsx
@@ -34,12 +34,17 @@ export const Markdown = memo(
 
           if (className?.includes('__boltArtifact__')) {
             const messageId = node?.properties.dataMessageId as string;
+            const artifactId = node?.properties.dataArtifactId as string;
 
             if (!messageId) {
               logger.error(`Invalid message id ${messageId}`);
             }
 
-            return <Artifact messageId={messageId} />;
+            if (!artifactId) {
+              logger.error(`Invalid artifact id ${artifactId}`);
+            }
+
+            return <Artifact messageId={messageId} artifactId={artifactId} />;
           }
 
           if (className?.includes('__boltSelectedElement__')) {
diff --git a/app/lib/hooks/useMessageParser.ts b/app/lib/hooks/useMessageParser.ts
index 92e3a9673a..ff65fe7991 100644
--- a/app/lib/hooks/useMessageParser.ts
+++ b/app/lib/hooks/useMessageParser.ts
@@ -22,7 +22,10 @@ const messageParser = new EnhancedStreamingMessageParser({
     onActionOpen: (data) => {
       logger.trace('onActionOpen', data.action);
 
-      // we only add shell actions when when the close tag got parsed because only then we have the content
+      /*
+       * File actions are streamed, so we add them immediately to show progress
+       * Shell actions are complete when created by enhanced parser, so we wait for close
+       */
       if (data.action.type === 'file') {
         workbenchStore.addAction(data);
       }
@@ -30,6 +33,10 @@ const messageParser = new EnhancedStreamingMessageParser({
     onActionClose: (data) => {
       logger.trace('onActionClose', data.action);
 
+      /*
+       * Add non-file actions (shell, build, start, etc.) when they close
+       * Enhanced parser creates complete shell actions, so they're ready to execute
+       */
       if (data.action.type !== 'file') {
         workbenchStore.addAction(data);
       }
diff --git a/app/lib/runtime/__snapshots__/message-parser.spec.ts.snap b/app/lib/runtime/__snapshots__/message-parser.spec.ts.snap
index 4b60f10bd1..8e6ed9b0f1 100644
--- a/app/lib/runtime/__snapshots__/message-parser.spec.ts.snap
+++ b/app/lib/runtime/__snapshots__/message-parser.spec.ts.snap
@@ -7,7 +7,7 @@ exports[`StreamingMessageParser > valid artifacts with actions > should correctl
     "type": "shell",
   },
   "actionId": "0",
-  "artifactId": "artifact_1",
+  "artifactId": "message_1-0",
   "messageId": "message_1",
 }
 `;
@@ -19,14 +19,15 @@ exports[`StreamingMessageParser > valid artifacts with actions > should correctl
     "type": "shell",
   },
   "actionId": "0",
-  "artifactId": "artifact_1",
+  "artifactId": "message_1-0",
   "messageId": "message_1",
 }
 `;
 
 exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (0) > onArtifactClose 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -35,7 +36,8 @@ exports[`StreamingMessageParser > valid artifacts with actions > should correctl
 
 exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (0) > onArtifactOpen 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -49,7 +51,7 @@ exports[`StreamingMessageParser > valid artifacts with actions > should correctl
     "type": "shell",
   },
   "actionId": "0",
-  "artifactId": "artifact_1",
+  "artifactId": "message_1-0",
   "messageId": "message_1",
 }
 `;
@@ -63,7 +65,7 @@ exports[`StreamingMessageParser > valid artifacts with actions > should correctl
     "type": "file",
   },
   "actionId": "1",
-  "artifactId": "artifact_1",
+  "artifactId": "message_1-0",
   "messageId": "message_1",
 }
 `;
@@ -75,7 +77,7 @@ exports[`StreamingMessageParser > valid artifacts with actions > should correctl
     "type": "shell",
   },
   "actionId": "0",
-  "artifactId": "artifact_1",
+  "artifactId": "message_1-0",
   "messageId": "message_1",
 }
 `;
@@ -88,14 +90,15 @@ exports[`StreamingMessageParser > valid artifacts with actions > should correctl
     "type": "file",
   },
   "actionId": "1",
-  "artifactId": "artifact_1",
+  "artifactId": "message_1-0",
   "messageId": "message_1",
 }
 `;
 
 exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (1) > onArtifactClose 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -104,7 +107,8 @@ exports[`StreamingMessageParser > valid artifacts with actions > should correctl
 
 exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (1) > onArtifactOpen 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -113,7 +117,8 @@ exports[`StreamingMessageParser > valid artifacts with actions > should correctl
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (0) > onArtifactClose 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -122,7 +127,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (0) > onArtifactOpen 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -131,7 +137,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (1) > onArtifactClose 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": "bundled",
@@ -140,7 +147,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (1) > onArtifactOpen 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": "bundled",
@@ -149,7 +157,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (2) > onArtifactClose 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -158,7 +167,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (2) > onArtifactOpen 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -167,7 +177,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (3) > onArtifactClose 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -176,7 +187,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (3) > onArtifactOpen 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -185,7 +197,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (4) > onArtifactClose 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -194,7 +207,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (4) > onArtifactOpen 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -203,7 +217,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (5) > onArtifactClose 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -212,7 +227,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (5) > onArtifactOpen 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -221,7 +237,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (6) > onArtifactClose 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
@@ -230,7 +247,8 @@ exports[`StreamingMessageParser > valid artifacts without actions > should corre
 
 exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (6) > onArtifactOpen 1`] = `
 {
-  "id": "artifact_1",
+  "artifactId": "message_1-0",
+  "id": "message_1-0",
   "messageId": "message_1",
   "title": "Some title",
   "type": undefined,
diff --git a/app/lib/runtime/action-runner.ts b/app/lib/runtime/action-runner.ts
index 0c3e0f7e48..b14d3a89b0 100644
--- a/app/lib/runtime/action-runner.ts
+++ b/app/lib/runtime/action-runner.ts
@@ -140,7 +140,7 @@ export class ActionRunner {
         return this.#executeAction(actionId, isStreaming);
       })
       .catch((error) => {
-        console.error('Action failed:', error);
+        logger.error('Action execution promise failed:', error);
       });
 
     await this.#currentExecutionPromise;
@@ -259,6 +259,14 @@ export class ActionRunner {
       unreachable('Shell terminal not found');
     }
 
+    // Pre-validate command for common issues
+    const validationResult = await this.#validateShellCommand(action.content);
+
+    if (validationResult.shouldModify && validationResult.modifiedCommand) {
+      logger.debug(`Modified command: ${action.content} -> ${validationResult.modifiedCommand}`);
+      action.content = validationResult.modifiedCommand;
+    }
+
     const resp = await shell.executeCommand(this.runnerId.get(), action.content, () => {
       logger.debug(`[${action.type}]:Aborting Action\n\n`, action);
       action.abort();
@@ -266,7 +274,8 @@ export class ActionRunner {
     logger.debug(`${action.type} Shell Response: [exit code:${resp?.exitCode}]`);
 
     if (resp?.exitCode != 0) {
-      throw new ActionCommandError(`Failed To Execute Shell Command`, resp?.output || 'No Output Available');
+      const enhancedError = this.#createEnhancedShellError(action.content, resp?.exitCode, resp?.output);
+      throw new ActionCommandError(enhancedError.title, enhancedError.details);
     }
   }
 
@@ -549,4 +558,188 @@ export class ActionRunner {
       source: details?.source || 'netlify',
     });
   }
+
+  async #validateShellCommand(command: string): Promise<{
+    shouldModify: boolean;
+    modifiedCommand?: string;
+    warning?: string;
+  }> {
+    const trimmedCommand = command.trim();
+
+    // Handle rm commands that might fail due to missing files
+    if (trimmedCommand.startsWith('rm ') && !trimmedCommand.includes(' -f')) {
+      const rmMatch = trimmedCommand.match(/^rm\s+(.+)$/);
+
+      if (rmMatch) {
+        const filePaths = rmMatch[1].split(/\s+/);
+
+        // Check if any of the files exist using WebContainer
+        try {
+          const webcontainer = await this.#webcontainer;
+          const existingFiles = [];
+
+          for (const filePath of filePaths) {
+            if (filePath.startsWith('-')) {
+              continue;
+            } // Skip flags
+
+            try {
+              await webcontainer.fs.readFile(filePath);
+              existingFiles.push(filePath);
+            } catch {
+              // File doesn't exist, skip it
+            }
+          }
+
+          if (existingFiles.length === 0) {
+            // No files exist, modify command to use -f flag to avoid error
+            return {
+              shouldModify: true,
+              modifiedCommand: `rm -f ${filePaths.join(' ')}`,
+              warning: 'Added -f flag to rm command as target files do not exist',
+            };
+          } else if (existingFiles.length < filePaths.length) {
+            // Some files don't exist, modify to only remove existing ones with -f for safety
+            return {
+              shouldModify: true,
+              modifiedCommand: `rm -f ${filePaths.join(' ')}`,
+              warning: 'Added -f flag to rm command as some target files do not exist',
+            };
+          }
+        } catch (error) {
+          logger.debug('Could not validate rm command files:', error);
+        }
+      }
+    }
+
+    // Handle cd commands to non-existent directories
+    if (trimmedCommand.startsWith('cd ')) {
+      const cdMatch = trimmedCommand.match(/^cd\s+(.+)$/);
+
+      if (cdMatch) {
+        const targetDir = cdMatch[1].trim();
+
+        try {
+          const webcontainer = await this.#webcontainer;
+          await webcontainer.fs.readdir(targetDir);
+        } catch {
+          return {
+            shouldModify: true,
+            modifiedCommand: `mkdir -p ${targetDir} && cd ${targetDir}`,
+            warning: 'Directory does not exist, created it first',
+          };
+        }
+      }
+    }
+
+    // Handle cp/mv commands with missing source files
+    if (trimmedCommand.match(/^(cp|mv)\s+/)) {
+      const parts = trimmedCommand.split(/\s+/);
+
+      if (parts.length >= 3) {
+        const sourceFile = parts[1];
+
+        try {
+          const webcontainer = await this.#webcontainer;
+          await webcontainer.fs.readFile(sourceFile);
+        } catch {
+          return {
+            shouldModify: false,
+            warning: `Source file '${sourceFile}' does not exist`,
+          };
+        }
+      }
+    }
+
+    return { shouldModify: false };
+  }
+
+  #createEnhancedShellError(
+    command: string,
+    exitCode: number | undefined,
+    output: string | undefined,
+  ): {
+    title: string;
+    details: string;
+  } {
+    const trimmedCommand = command.trim();
+    const firstWord = trimmedCommand.split(/\s+/)[0];
+
+    // Common error patterns and their explanations
+    const errorPatterns = [
+      {
+        pattern: /cannot remove.*No such file or directory/,
+        title: 'File Not Found',
+        getMessage: () => {
+          const fileMatch = output?.match(/'([^']+)'/);
+          const fileName = fileMatch ? fileMatch[1] : 'file';
+
+          return `The file '${fileName}' does not exist and cannot be removed.\n\nSuggestion: Use 'ls' to check what files exist, or use 'rm -f' to ignore missing files.`;
+        },
+      },
+      {
+        pattern: /No such file or directory/,
+        title: 'File or Directory Not Found',
+        getMessage: () => {
+          if (trimmedCommand.startsWith('cd ')) {
+            const dirMatch = trimmedCommand.match(/cd\s+(.+)/);
+            const dirName = dirMatch ? dirMatch[1] : 'directory';
+
+            return `The directory '${dirName}' does not exist.\n\nSuggestion: Use 'mkdir -p ${dirName}' to create it first, or check available directories with 'ls'.`;
+          }
+
+          return `The specified file or directory does not exist.\n\nSuggestion: Check the path and use 'ls' to see available files.`;
+        },
+      },
+      {
+        pattern: /Permission denied/,
+        title: 'Permission Denied',
+        getMessage: () =>
+          `Permission denied for '${firstWord}'.\n\nSuggestion: The file may not be executable. Try 'chmod +x filename' first.`,
+      },
+      {
+        pattern: /command not found/,
+        title: 'Command Not Found',
+        getMessage: () =>
+          `The command '${firstWord}' is not available in WebContainer.\n\nSuggestion: Check available commands or use a package manager to install it.`,
+      },
+      {
+        pattern: /Is a directory/,
+        title: 'Target is a Directory',
+        getMessage: () =>
+          `Cannot perform this operation - target is a directory.\n\nSuggestion: Use 'ls' to list directory contents or add appropriate flags.`,
+      },
+      {
+        pattern: /File exists/,
+        title: 'File Already Exists',
+        getMessage: () => `File already exists.\n\nSuggestion: Use a different name or add '-f' flag to overwrite.`,
+      },
+    ];
+
+    // Try to match known error patterns
+    for (const errorPattern of errorPatterns) {
+      if (output && errorPattern.pattern.test(output)) {
+        return {
+          title: errorPattern.title,
+          details: errorPattern.getMessage(),
+        };
+      }
+    }
+
+    // Generic error with suggestions based on command type
+    let suggestion = '';
+
+    if (trimmedCommand.startsWith('npm ')) {
+      suggestion = '\n\nSuggestion: Try running "npm install" first or check package.json.';
+    } else if (trimmedCommand.startsWith('git ')) {
+      suggestion = "\n\nSuggestion: Check if you're in a git repository or if remote is configured.";
+    } else if (trimmedCommand.match(/^(ls|cat|rm|cp|mv)/)) {
+      suggestion = '\n\nSuggestion: Check file paths and use "ls" to see available files.';
+    }
+
+    return {
+      title: `Command Failed (exit code: ${exitCode})`,
+      details: `Command: ${trimmedCommand}\n\nOutput: ${output || 'No output available'}${suggestion}`,
+    };
+  }
 }
diff --git a/app/lib/runtime/enhanced-message-parser.ts b/app/lib/runtime/enhanced-message-parser.ts
index 9820302df0..0c96313687 100644
--- a/app/lib/runtime/enhanced-message-parser.ts
+++ b/app/lib/runtime/enhanced-message-parser.ts
@@ -12,6 +12,22 @@ export class EnhancedStreamingMessageParser extends StreamingMessageParser {
   private _processedCodeBlocks = new Map<string, Set<string>>();
   private _artifactCounter = 0;
 
+  // Optimized command pattern lookup
+  private _commandPatternMap = new Map<string, RegExp>([
+    ['npm', /^(npm|yarn|pnpm)\s+(install|run|start|build|dev|test|init|create|add|remove)/],
+    ['git', /^(git)\s+(add|commit|push|pull|clone|status|checkout|branch|merge|rebase|init|remote|fetch|log)/],
+    ['docker', /^(docker|docker-compose)\s+/],
+    ['build', /^(make|cmake|gradle|mvn|cargo|go)\s+/],
+    ['network', /^(curl|wget|ping|ssh|scp|rsync)\s+/],
+    ['webcontainer', /^(cat|chmod|cp|echo|hostname|kill|ln|ls|mkdir|mv|ps|pwd|rm|rmdir|xxd)\s*/],
+    ['webcontainer-extended', /^(alias|cd|clear|env|false|getconf|head|sort|tail|touch|true|uptime|which)\s*/],
+    ['interpreters', /^(node|python|python3|java|go|rust|ruby|php|perl)\s+/],
+    ['text-processing', /^(grep|sed|awk|cut|tr|sort|uniq|wc|diff)\s+/],
+    ['archive', /^(tar|zip|unzip|gzip|gunzip)\s+/],
+    ['process', /^(ps|top|htop|kill|killall|jobs|nohup)\s*/],
+    ['system', /^(df|du|free|uname|whoami|id|groups|date|uptime)\s*/],
+  ]);
+
   constructor(options: StreamingMessageParserOptions = {}) {
     super(options);
   }
@@ -46,32 +62,49 @@ export class EnhancedStreamingMessageParser extends StreamingMessageParser {
 
     const processed = this._processedCodeBlocks.get(messageId)!;
 
-    // Regex patterns for detecting code blocks with file indicators
-    const patterns = [
-      // Pattern 1: Explicit file creation/modification mentions
-      /(?:create|update|modify|edit|write|add|generate|here'?s?|file:?)\s+(?:a\s+)?(?:new\s+)?(?:file\s+)?(?:called\s+)?[`'"]*([\/\w\-\.]+\.\w+)[`'"]*:?\s*\n+```(\w*)\n([\s\S]*?)```/gi,
+    let enhanced = input;
 
-      // Pattern 2: Code blocks with filename comments
-      /```(\w*)\n(?:\/\/|#|<!--)\s*(?:file:?|filename:?)\s*([\/\w\-\.]+\.\w+).*?\n([\s\S]*?)```/gi,
+    // First, detect and handle shell commands separately
+    enhanced = this._detectAndWrapShellCommands(messageId, enhanced, processed);
 
-      // Pattern 3: File path followed by code block
-      /(?:^|\n)([\/\w\-\.]+\.\w+):?\s*\n+```(\w*)\n([\s\S]*?)```/gim,
+    // Optimized regex patterns with better performance
+    const patterns = [
+      // Pattern 1: File path followed by code block (most common, check first)
+      {
+        regex: /(?:^|\n)([\/\w\-\.]+\.\w+):?\s*\n+```(\w*)\n([\s\S]*?)```/gim,
+        type: 'file_path',
+      },
+
+      // Pattern 2: Explicit file creation mentions
+      {
+        regex:
+          /(?:create|update|modify|edit|write|add|generate|here'?s?|file:?)\s+(?:a\s+)?(?:new\s+)?(?:file\s+)?(?:called\s+)?[`'"]*([\/\w\-\.]+\.\w+)[`'"]*:?\s*\n+```(\w*)\n([\s\S]*?)```/gi,
+        type: 'explicit_create',
+      },
+
+      // Pattern 3: Code blocks with filename comments
+      {
+        regex: /```(\w*)\n(?:\/\/|#|<!--)\s*(?:file:?|filename:?)\s*([\/\w\-\.]+\.\w+).*?\n([\s\S]*?)```/gi,
+        type: 'comment_filename',
+      },
 
       // Pattern 4: Code block with "in <filename>" context
-      /(?:in|for|update)\s+[`'"]*([\/\w\-\.]+\.\w+)[`'"]*:?\s*\n+```(\w*)\n([\s\S]*?)```/gi,
-
-      // Pattern 5: HTML/Component files with clear structure
-      /```(?:jsx?|tsx?|html?|vue|svelte)\n(<[\w\-]+[^>]*>[\s\S]*?<\/[\w\-]+>[\s\S]*?)```/gi,
-
-      // Pattern 6: Package.json or config files
-      /```(?:json)?\n(\{[\s\S]*?"(?:name|version|scripts|dependencies|devDependencies)"[\s\S]*?\})```/gi,
+      {
+        regex: /(?:in|for|update)\s+[`'"]*([\/\w\-\.]+\.\w+)[`'"]*:?\s*\n+```(\w*)\n([\s\S]*?)```/gi,
+        type: 'in_filename',
+      },
+
+      // Pattern 5: Structured files (package.json, components)
+      {
+        regex:
+          /```(?:json|jsx?|tsx?|html?|vue|svelte)\n(\{[\s\S]*?"(?:name|version|scripts|dependencies|devDependencies)"[\s\S]*?\}|<\w+[^>]*>[\s\S]*?<\/\w+>[\s\S]*?)```/gi,
+        type: 'structured_file',
+      },
     ];
 
-    let enhanced = input;
-
-    // Process each pattern
+    // Process each pattern in order of likelihood
     for (const pattern of patterns) {
-      enhanced = enhanced.replace(pattern, (match, ...args) => {
+      enhanced = enhanced.replace(pattern.regex, (match, ...args) => {
         // Skip if already processed
         const blockHash = this._hashBlock(match);
 
@@ -83,25 +116,26 @@ export class EnhancedStreamingMessageParser extends StreamingMessageParser {
         let language: string;
         let content: string;
 
-        // Extract based on pattern
-        if (pattern.source.includes('file:?|filename:?')) {
-          // Pattern 2: filename in comment
+        // Extract based on pattern type
+        if (pattern.type === 'comment_filename') {
           [language, filePath, content] = args;
-        } else if (pattern.source.includes('<[\w\-]+[^>]*>')) {
-          // Pattern 5: HTML/Component detection
+        } else if (pattern.type === 'structured_file') {
           content = args[0];
-          language = 'jsx';
+          language = pattern.regex.source.includes('json') ? 'json' : 'jsx';
           filePath = this._inferFileNameFromContent(content, language);
-        } else if (pattern.source.includes('"name"|"version"')) {
-          // Pattern 6: package.json detection
-          content = args[0];
-          language = 'json';
-          filePath = 'package.json';
         } else {
-          // Other patterns
+          // file_path, explicit_create, in_filename patterns
           [filePath, language, content] = args;
         }
 
+        // Check if this should be treated as a shell command instead of a file
+        if (this._isShellCommand(content, language)) {
+          processed.add(blockHash);
+          logger.debug(`Auto-wrapped code block as shell command instead of file`);
+
+          return this._wrapInShellAction(content, messageId);
+        }
+
         // Clean up the file path
         filePath = this._normalizeFilePath(filePath);
 
@@ -110,6 +144,17 @@ export class EnhancedStreamingMessageParser extends StreamingMessageParser {
           return match; // Return original if invalid
         }
 
+        // Check if there's proper context for file creation
+        if (!this._hasFileContext(enhanced, match)) {
+          // If no clear file context, skip unless it's an explicit file pattern
+          const isExplicitFilePattern =
+            pattern.type === 'explicit_create' || pattern.type === 'comment_filename' || pattern.type === 'file_path';
+
+          if (!isExplicitFilePattern) {
+            return match; // Return original if no context
+          }
+        }
+
         // Mark as processed
         processed.add(blockHash);
 
@@ -166,6 +211,16 @@ ${content}
 </boltArtifact>`;
   }
 
+  private _wrapInShellAction(content: string, messageId: string): string {
+    const artifactId = `artifact-${messageId}-${this._artifactCounter++}`;
+
+    return `<boltArtifact id="${artifactId}" title="Shell Command" type="shell">
+<boltAction type="shell">
+${content.trim()}
+</boltAction>
+</boltArtifact>`;
+  }
+
   private _normalizeFilePath(filePath: string): string {
     // Remove quotes, backticks, and clean up
     filePath = filePath.replace(/[`'"]/g, '').trim();
@@ -202,7 +257,13 @@ ${content}
     }
 
     // Exclude certain patterns that are likely not real files
-    const excludePatterns = [/^\/?(tmp|temp|test|example)\//i, /\.(tmp|temp|bak|backup|old|orig)$/i];
+    const excludePatterns = [
+      /^\/?(tmp|temp|test|example)\//i,
+      /\.(tmp|temp|bak|backup|old|orig)$/i,
+      /^\/?(output|result|response)\//i, // Common AI response folders
+      /^code_\d+\.(sh|bash|zsh)$/i, // Auto-generated shell files (our target issue)
+      /^(untitled|new|demo|sample)\d*\./i, // Generic demo names
+    ];
 
     for (const pattern of excludePatterns) {
       if (pattern.test(filePath)) {
@@ -213,48 +274,28 @@ ${content}
     return true;
   }
 
-  private _detectLanguageFromPath(filePath: string): string {
-    const ext = filePath.split('.').pop()?.toLowerCase();
-
-    const languageMap: Record<string, string> = {
-      js: 'javascript',
-      jsx: 'jsx',
-      ts: 'typescript',
-      tsx: 'tsx',
-      py: 'python',
-      rb: 'ruby',
-      go: 'go',
-      rs: 'rust',
-      java: 'java',
-      cpp: 'cpp',
-      c: 'c',
-      cs: 'csharp',
-      php: 'php',
-      swift: 'swift',
-      kt: 'kotlin',
-      html: 'html',
-      css: 'css',
-      scss: 'scss',
-      sass: 'sass',
-      less: 'less',
-      json: 'json',
-      xml: 'xml',
-      yaml: 'yaml',
-      yml: 'yaml',
-      md: 'markdown',
-      sh: 'bash',
-      bash: 'bash',
-      zsh: 'bash',
-      fish: 'bash',
-      ps1: 'powershell',
-      sql: 'sql',
-      graphql: 'graphql',
-      gql: 'graphql',
-      vue: 'vue',
-      svelte: 'svelte',
-    };
-
-    return languageMap[ext || ''] || 'text';
+  private _hasFileContext(input: string, codeBlockMatch: string): boolean {
+    // Check if there's explicit file context around the code block
+    const matchIndex = input.indexOf(codeBlockMatch);
+
+    if (matchIndex === -1) {
+      return false;
+    }
+
+    // Look for context before the code block
+    const beforeContext = input.substring(Math.max(0, matchIndex - 200), matchIndex);
+    const afterContext = input.substring(matchIndex + codeBlockMatch.length, matchIndex + codeBlockMatch.length + 100);
+
+    const fileContextPatterns = [
+      /\b(create|write|save|add|update|modify|edit|generate)\s+(a\s+)?(new\s+)?file/i,
+      /\b(file|filename|filepath)\s*[:=]/i,
+      /\b(in|to|as)\s+[`'"]?[\w\-\.\/]+\.[a-z]{2,4}[`'"]?/i,
+      /\b(component|module|class|function)\s+\w+/i,
+    ];
+
+    const contextText = beforeContext + afterContext;
+
+    return fileContextPatterns.some((pattern) => pattern.test(contextText));
   }
 
   private _inferFileNameFromContent(content: string, language: string): string {
@@ -292,6 +333,192 @@ ${content}
     return hash.toString(36);
   }
 
+  private _isShellCommand(content: string, language: string): boolean {
+    // Check if language suggests shell execution
+    const shellLanguages = ['bash', 'sh', 'shell', 'zsh', 'fish', 'powershell', 'ps1'];
+    const isShellLang = shellLanguages.includes(language.toLowerCase());
+
+    if (!isShellLang) {
+      return false;
+    }
+
+    const trimmedContent = content.trim();
+    const lines = trimmedContent
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+    // Empty content is not a command
+    if (lines.length === 0) {
+      return false;
+    }
+
+    // First, check if it looks like script content (should NOT be treated as commands)
+    if (this._looksLikeScriptContent(trimmedContent)) {
+      return false; // This is a script file, not commands to execute
+    }
+
+    // Single line commands are likely to be executed
+    if (lines.length === 1) {
+      return this._isSingleLineCommand(lines[0]);
+    }
+
+    // Multi-line: check if it's a command sequence
+    return this._isCommandSequence(lines);
+  }
+
+  private _isSingleLineCommand(line: string): boolean {
+    // Check for command chains with &&, ||, |, ;
+    const hasChaining = /[;&|]{1,2}/.test(line);
+
+    if (hasChaining) {
+      // Split by chaining operators and check if parts look like commands
+      const parts = line.split(/[;&|]{1,2}/).map((p) => p.trim());
+      return parts.every((part) => part.length > 0 && !this._looksLikeScriptContent(part));
+    }
+
+    // Check for common command prefix patterns
+    const prefixPatterns = [
+      /^sudo\s+/, // sudo commands
+      /^time\s+/, // time profiling
+      /^nohup\s+/, // background processes
+      /^watch\s+/, // repeated execution
+      /^env\s+\w+=\w+\s+/, // environment variable setting
+    ];
+
+    // Remove prefixes to check the actual command
+    let cleanLine = line;
+
+    for (const prefix of prefixPatterns) {
+      cleanLine = cleanLine.replace(prefix, '');
+    }
+
+    // Optimized O(1) lookup using Map
+    for (const [, pattern] of this._commandPatternMap) {
+      if (pattern.test(cleanLine)) {
+        return true;
+      }
+    }
+
+    // Fallback to simple command detection
+    return this._isSimpleCommand(cleanLine);
+  }
+
+  private _isCommandSequence(lines: string[]): boolean {
+    // If most lines look like individual commands, treat as command sequence
+    const commandLikeLines = lines.filter(
+      (line) =>
+        line.length > 0 && !line.startsWith('#') && (this._isSingleLineCommand(line) || this._isSimpleCommand(line)),
+    );
+
+    // If more than 70% of non-comment lines are commands, treat as command sequence
+    return commandLikeLines.length / lines.length > 0.7;
+  }
+
+  private _isSimpleCommand(line: string): boolean {
+    // Simple heuristics for basic commands
+    const words = line.split(/\s+/);
+
+    if (words.length === 0) {
+      return false;
+    }
+
+    const firstWord = words[0];
+
+    // Don't treat variable assignments as commands (script-like)
+    if (line.includes('=') && !line.startsWith('export ') && !line.startsWith('env ') && !firstWord.includes('=')) {
+      return false;
+    }
+
+    // Don't treat function definitions as commands
+    if (line.includes('function ') || line.match(/^\w+\s*\(\s*\)/)) {
+      return false;
+    }
+
+    // Don't treat control structures as commands
+    if (/^(if|for|while|case|function|until|select)\s/.test(line)) {
+      return false;
+    }
+
+    // Don't treat here-documents as commands
+    if (line.includes('<<') || line.startsWith('EOF') || line.startsWith('END')) {
+      return false;
+    }
+
+    // Don't treat multi-line strings as commands
+    if (line.includes('"""') || line.includes("'''")) {
+      return false;
+    }
+
+    // Additional command-like patterns (fallback for unmatched commands)
+    const commandLikePatterns = [
+      /^[a-z][a-z0-9-_]*$/i, // Simple command names (like 'ls', 'grep', 'my-script')
+      /^\.\/[a-z0-9-_./]+$/i, // Relative executable paths (like './script.sh', './bin/command')
+      /^\/[a-z0-9-_./]+$/i, // Absolute executable paths (like '/usr/bin/command')
+      /^[a-z][a-z0-9-_]*\s+-.+/i, // Commands with flags (like 'command --flag')
+    ];
+
+    // Check if the first word looks like a command
+    const looksLikeCommand = commandLikePatterns.some((pattern) => pattern.test(firstWord));
+
+    return looksLikeCommand;
+  }
+
+  private _looksLikeScriptContent(content: string): boolean {
+    const lines = content.trim().split('\n');
+
+    // Indicators that this is a script file rather than commands to execute
+    const scriptIndicators = [
+      /^#!/, // Shebang
+      /function\s+\w+/, // Function definitions
+      /^\w+\s*\(\s*\)\s*\{/, // Function definition syntax
+      /^(if|for|while|case)\s+.*?(then|do|in)/, // Control structures
+      /^\w+=[^=].*$/, // Variable assignments (not comparisons)
+      /^(local|declare|readonly)\s+/,
+      /^(source|\.)\s+/, // Source other scripts
+      /^(exit|return)\s+\d+/, // Exit codes
+    ];
+
+    // Check each line for script indicators
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+
+      if (trimmedLine.length === 0 || trimmedLine.startsWith('#')) {
+        continue; // Skip empty lines and comments
+      }
+
+      if (scriptIndicators.some((pattern) => pattern.test(trimmedLine))) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  private _detectAndWrapShellCommands(_messageId: string, input: string, processed: Set<string>): string {
+    // Pattern to detect standalone shell code blocks that look like commands
+    const shellCommandPattern = /```(bash|sh|shell|zsh|fish|powershell|ps1)\n([\s\S]*?)```/gi;
+
+    return input.replace(shellCommandPattern, (match, language, content) => {
+      const blockHash = this._hashBlock(match);
+
+      if (processed.has(blockHash)) {
+        return match;
+      }
+
+      // Check if this looks like commands to execute rather than a script file
+      if (this._isShellCommand(content, language)) {
+        processed.add(blockHash);
+        logger.debug(`Auto-wrapped shell code block as command: ${language}`);
+
+        return this._wrapInShellAction(content, _messageId);
+      }
+
+      // If it looks like a script, let the file detection patterns handle it
+      return match;
+    });
+  }
+
   reset() {
     super.reset();
     this._processedCodeBlocks.clear();
diff --git a/app/lib/runtime/message-parser.spec.ts b/app/lib/runtime/message-parser.spec.ts
index 4c5ba479f7..ef4ef8e421 100644
--- a/app/lib/runtime/message-parser.spec.ts
+++ b/app/lib/runtime/message-parser.spec.ts
@@ -1,5 +1,6 @@
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
 import { StreamingMessageParser, type ActionCallback, type ArtifactCallback } from './message-parser';
+import { EnhancedStreamingMessageParser } from './enhanced-message-parser';
 
 interface ExpectedResult {
   output: string;
@@ -158,6 +159,584 @@ describe('StreamingMessageParser', () => {
   });
 });
 
+describe('EnhancedStreamingMessageParser', () => {
+  it('should detect shell commands in code blocks', () => {
+    const callbacks = {
+      onArtifactOpen: vi.fn(),
+      onArtifactClose: vi.fn(),
+      onActionOpen: vi.fn(),
+      onActionClose: vi.fn(),
+    };
+
+    const parser = new EnhancedStreamingMessageParser({
+      callbacks,
+    });
+
+    const input = '```bash\nnpm install && npm run dev\n```';
+    parser.parse('test_id', input);
+
+    expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+      expect.objectContaining({
+        action: expect.objectContaining({
+          type: 'shell',
+          content: 'npm install && npm run dev',
+        }),
+      }),
+    );
+  });
+
+  it('should detect file creation from code blocks with context', () => {
+    const callbacks = {
+      onArtifactOpen: vi.fn(),
+      onArtifactClose: vi.fn(),
+      onActionOpen: vi.fn(),
+      onActionClose: vi.fn(),
+    };
+
+    const parser = new EnhancedStreamingMessageParser({
+      callbacks,
+    });
+
+    const input =
+      'Create a new file called index.js:\n\n```javascript\nfunction hello() {\n  console.log("Hello World");\n}\n```';
+    parser.parse('test_id', input);
+
+    expect(callbacks.onArtifactOpen).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: expect.stringContaining('test_id-'),
+        title: 'index.js',
+      }),
+    );
+  });
+
+  it('should not create actions for code blocks without context', () => {
+    const callbacks = {
+      onArtifactOpen: vi.fn(),
+      onArtifactClose: vi.fn(),
+      onActionOpen: vi.fn(),
+      onActionClose: vi.fn(),
+    };
+
+    const parser = new EnhancedStreamingMessageParser({
+      callbacks,
+    });
+
+    const input = 'Here is some code:\n\n```javascript\nfunction test() {}\n```';
+    parser.parse('test_id', input);
+
+    expect(callbacks.onArtifactOpen).not.toHaveBeenCalled();
+    expect(callbacks.onActionOpen).not.toHaveBeenCalled();
+  });
+
+  describe('AI Model Output Patterns Integration Tests', () => {
+    let callbacks: {
+      onArtifactOpen: any;
+      onArtifactClose: any;
+      onActionOpen: any;
+      onActionClose: any;
+    };
+    let parser: EnhancedStreamingMessageParser;
+
+    beforeEach(() => {
+      callbacks = {
+        onArtifactOpen: vi.fn(),
+        onArtifactClose: vi.fn(),
+        onActionOpen: vi.fn(),
+        onActionClose: vi.fn(),
+      };
+      parser = new EnhancedStreamingMessageParser({ callbacks });
+    });
+
+    describe('GPT-4 style outputs', () => {
+      it('should handle file creation with explicit path', () => {
+        const input = `I'll create a React component for you.
+
+app/components/Button.tsx:
+
+\`\`\`tsx
+import React from 'react';
+
+interface ButtonProps {
+  children: React.ReactNode;
+  onClick: () => void;
+}
+
+export const Button: React.FC<ButtonProps> = ({ children, onClick }) => {
+  return (
+    <button onClick={onClick} className="btn">
+      {children}
+    </button>
+  );
+};
+\`\`\``;
+
+        parser.parse('test_gpt4_1', input);
+
+        expect(callbacks.onArtifactOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            title: 'Button.tsx',
+          }),
+        );
+        expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            action: expect.objectContaining({
+              type: 'file',
+              filePath: '/app/components/Button.tsx',
+            }),
+          }),
+        );
+      });
+
+      it('should handle package.json updates', () => {
+        const input = `Update your package.json file:
+
+package.json:
+
+\`\`\`json
+{
+  "name": "my-app",
+  "version": "1.0.0",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build"
+  },
+  "dependencies": {
+    "react": "^18.0.0"
+  }
+}
+\`\`\``;
+
+        parser.parse('test_gpt4_2', input);
+
+        expect(callbacks.onArtifactOpen).toHaveBeenCalled();
+        expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            action: expect.objectContaining({
+              type: 'file',
+              filePath: '/package.json',
+            }),
+          }),
+        );
+      });
+    });
+
+    describe('Claude style outputs', () => {
+      it('should handle create file instructions', () => {
+        const input = `I'll create a new configuration file for you.
+
+Create a file called \`config.ts\`:
+
+\`\`\`typescript
+export const config = {
+  apiUrl: 'https://api.example.com',
+  timeout: 5000,
+};
+\`\`\``;
+
+        parser.parse('test_claude_1', input);
+
+        expect(callbacks.onArtifactOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            title: 'config.ts',
+          }),
+        );
+        expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            action: expect.objectContaining({
+              type: 'file',
+              filePath: '/config.ts',
+            }),
+          }),
+        );
+      });
+
+      it('should handle "Here\'s the file" pattern', () => {
+        const input = `Here's styles.css:
+
+\`\`\`css
+.container {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+.button {
+  padding: 10px 20px;
+  border: none;
+  border-radius: 4px;
+}
+\`\`\``;
+
+        parser.parse('test_claude_2', input);
+
+        expect(callbacks.onArtifactOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            title: 'styles.css',
+          }),
+        );
+      });
+    });
+
+    describe('Gemini style outputs', () => {
+      it('should handle file comments in code', () => {
+        const input = `Here's your component:
+
+\`\`\`javascript
+// filename: utils/helper.js
+function formatDate(date) {
+  return new Intl.DateTimeFormat('en-US').format(date);
+}
+
+function debounce(func, wait) {
+  let timeout;
+  return function executedFunction(...args) {
+    const later = () => {
+      clearTimeout(timeout);
+      func(...args);
+    };
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+  };
+}
+
+export { formatDate, debounce };
+\`\`\``;
+
+        parser.parse('test_gemini_1', input);
+
+        expect(callbacks.onArtifactOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            title: 'helper.js',
+          }),
+        );
+        expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            action: expect.objectContaining({
+              type: 'file',
+              filePath: '/utils/helper.js',
+            }),
+          }),
+        );
+      });
+
+      it('should handle "update filename.ext" pattern', () => {
+        const input = `Update server.js:
+
+\`\`\`javascript
+const express = require('express');
+const app = express();
+
+app.get('/', (req, res) => {
+  res.send('Hello World!');
+});
+
+app.listen(3000, () => {
+  console.log('Server running on port 3000');
+});
+\`\`\``;
+
+        parser.parse('test_gemini_2', input);
+
+        expect(callbacks.onArtifactOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            title: 'server.js',
+          }),
+        );
+      });
+    });
+
+    describe('Shell Command Detection', () => {
+      it('should detect npm commands', () => {
+        const input = `Run these commands:
+
+\`\`\`bash
+npm install express cors
+npm run dev
+\`\`\``;
+
+        parser.parse('test_shell_1', input);
+
+        expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            action: expect.objectContaining({
+              type: 'shell',
+              content: 'npm install express cors\nnpm run dev',
+            }),
+          }),
+        );
+      });
+
+      it('should detect git commands', () => {
+        const input = `Initialize your repository:
+
+\`\`\`bash
+git init
+git add .
+git commit -m "Initial commit"
+\`\`\``;
+
+        parser.parse('test_shell_2', input);
+
+        expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            action: expect.objectContaining({
+              type: 'shell',
+              content: 'git init\ngit add .\ngit commit -m "Initial commit"',
+            }),
+          }),
+        );
+      });
+
+      it('should detect docker commands', () => {
+        const input = `Build and run the Docker container:
+
+\`\`\`bash
+docker build -t myapp .
+docker run -p 3000:3000 myapp
+\`\`\``;
+
+        parser.parse('test_shell_3', input);
+
+        expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            action: expect.objectContaining({
+              type: 'shell',
+              content: 'docker build -t myapp .\ndocker run -p 3000:3000 myapp',
+            }),
+          }),
+        );
+      });
+
+      it('should detect webcontainer commands', () => {
+        const input = `Check your files:
+
+\`\`\`bash
+ls -la
+cat package.json
+mkdir src
+\`\`\``;
+
+        parser.parse('test_shell_4', input);
+
+        expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            action: expect.objectContaining({
+              type: 'shell',
+              content: 'ls -la\ncat package.json\nmkdir src',
+            }),
+          }),
+        );
+      });
+    });
+
+    describe('Edge Cases and False Positive Prevention', () => {
+      it('should not create artifacts for generic code examples', () => {
+        const input = `Here's an example of how functions work:
+
+\`\`\`javascript
+function example() {
+  console.log("This is just an example");
+}
+\`\`\``;
+
+        parser.parse('test_edge_1', input);
+
+        expect(callbacks.onArtifactOpen).not.toHaveBeenCalled();
+        expect(callbacks.onActionOpen).not.toHaveBeenCalled();
+      });
+
+      it('should ignore temp and test file patterns', () => {
+        const input = `Create temp/test.js:
+
+\`\`\`javascript
+console.log("temporary test");
+\`\`\``;
+
+        parser.parse('test_edge_2', input);
+
+        expect(callbacks.onArtifactOpen).not.toHaveBeenCalled();
+        expect(callbacks.onActionOpen).not.toHaveBeenCalled();
+      });
+
+      it('should handle multiple code blocks with mixed content', () => {
+        const input = `First, create the component:
+
+components/Header.tsx:
+\`\`\`tsx
+import React from 'react';
+export const Header = () => <h1>Header</h1>;
+\`\`\`
+
+Then install dependencies:
+
+\`\`\`bash
+npm install react-router-dom
+\`\`\`
+
+Here's an example of usage:
+
+\`\`\`javascript
+// This is just an example
+function usage() {
+  return <Header />;
+}
+\`\`\``;
+
+        parser.parse('test_edge_3', input);
+
+        // Should create artifact for Header.tsx
+        expect(callbacks.onArtifactOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            title: 'Header.tsx',
+          }),
+        );
+
+        // Should create shell action for npm install
+        expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            action: expect.objectContaining({
+              type: 'shell',
+              content: 'npm install react-router-dom',
+            }),
+          }),
+        );
+
+        // Should not create action for the example usage
+        const fileActions = callbacks.onActionOpen.mock.calls.filter((call: any) => call[0].action.type === 'file');
+
+        expect(fileActions).toHaveLength(1); // Only Header.tsx
+      });
+
+      it('should validate file extensions', () => {
+        const input = `Create invalidfile:
+
+\`\`\`
+console.log("no extension");
+\`\`\``;
+
+        parser.parse('test_edge_4', input);
+
+        expect(callbacks.onArtifactOpen).not.toHaveBeenCalled();
+        expect(callbacks.onActionOpen).not.toHaveBeenCalled();
+      });
+
+      it('should handle complex file paths correctly', () => {
+        const input = `Create the nested component:
+
+src/components/ui/Button/index.tsx:
+
+\`\`\`tsx
+import React from 'react';
+export { Button } from './Button';
+\`\`\``;
+
+        parser.parse('test_edge_5', input);
+
+        expect(callbacks.onActionOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            action: expect.objectContaining({
+              type: 'file',
+              filePath: '/src/components/ui/Button/index.tsx',
+            }),
+          }),
+        );
+      });
+    });
+
+    describe('Performance and Deduplication', () => {
+      it('should handle incremental parsing correctly', () => {
+        // Parse incrementally (simulating streaming)
+        const chunks = ['Create config.js:\n\n\`\`\`javascript\n', "const config = { api: 'test' };\n\`\`\`"];
+        let fullInput = '';
+
+        for (const chunk of chunks) {
+          fullInput += chunk;
+          parser.parse('test_perf_1', fullInput);
+        }
+
+        // Should create artifact when complete
+        expect(callbacks.onArtifactOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            title: 'config.js',
+          }),
+        );
+      });
+
+      it('should handle streaming input correctly', () => {
+        const chunks = [
+          'Create the file:\n\n',
+          'app.js:\n\n',
+          '\`\`\`javascript\n',
+          'const app = ',
+          'express();\n',
+          'app.listen(3000);\n',
+          '\`\`\`',
+        ];
+
+        let fullInput = '';
+
+        for (const chunk of chunks) {
+          fullInput += chunk;
+          parser.parse('test_stream_1', fullInput);
+        }
+
+        expect(callbacks.onArtifactOpen).toHaveBeenCalledWith(
+          expect.objectContaining({
+            title: 'app.js',
+          }),
+        );
+      });
+    });
+
+    describe('Performance Benchmarks', () => {
+      it('should perform well with enhanced parsing', () => {
+        const testInputs = [
+          `Create app.tsx:\n\n\`\`\`tsx\nimport React from 'react';\nexport const App = () => <div>Hello</div>;\n\`\`\``,
+          `Run commands:\n\n\`\`\`bash\nnpm install\nnpm run dev\n\`\`\``,
+          `Here's config.json:\n\n\`\`\`json\n{"name": "test"}\n\`\`\``,
+          `Example code:\n\n\`\`\`javascript\nfunction example() {}\n\`\`\``,
+        ];
+
+        // Benchmark enhanced parser
+        const enhancedCallbacks = {
+          onArtifactOpen: vi.fn(),
+          onArtifactClose: vi.fn(),
+          onActionOpen: vi.fn(),
+          onActionClose: vi.fn(),
+        };
+
+        const enhancedParser = new EnhancedStreamingMessageParser({
+          callbacks: enhancedCallbacks,
+        });
+
+        const startTime = performance.now();
+        const iterations = 100;
+
+        for (let i = 0; i < iterations; i++) {
+          testInputs.forEach((input, index) => {
+            enhancedParser.parse(`perf_test_${i}_${index}`, input);
+          });
+          enhancedParser.reset();
+        }
+
+        const endTime = performance.now();
+        const duration = endTime - startTime;
+        const avgTimePerOp = duration / (iterations * testInputs.length);
+
+        // Should complete quickly (less than 1ms average per operation)
+        expect(avgTimePerOp).toBeLessThan(1.0);
+
+        // Should detect artifacts appropriately
+        expect(enhancedCallbacks.onArtifactOpen.mock.calls.length).toBeGreaterThan(0);
+
+        console.log(`Performance: ${avgTimePerOp.toFixed(4)}ms per operation`);
+        console.log(`Artifacts detected: ${enhancedCallbacks.onArtifactOpen.mock.calls.length}`);
+        console.log(`Actions detected: ${enhancedCallbacks.onActionOpen.mock.calls.length}`);
+      });
+    });
+  });
+});
+
 function runTest(input: string | string[], outputOrExpectedResult: string | ExpectedResult) {
   let expected: ExpectedResult;
 
diff --git a/app/lib/runtime/message-parser.ts b/app/lib/runtime/message-parser.ts
index 429c48e573..47769e2589 100644
--- a/app/lib/runtime/message-parser.ts
+++ b/app/lib/runtime/message-parser.ts
@@ -14,6 +14,7 @@ const logger = createScopedLogger('MessageParser');
 
 export interface ArtifactCallbackData extends BoltArtifactData {
   messageId: string;
+  artifactId?: string;
 }
 
 export interface ActionCallbackData {
@@ -36,6 +37,7 @@ export interface ParserCallbacks {
 
 interface ElementFactoryProps {
   messageId: string;
+  artifactId?: string;
 }
 
 type ElementFactory = (props: ElementFactoryProps) => string;
@@ -49,6 +51,7 @@ interface MessageState {
   position: number;
   insideArtifact: boolean;
   insideAction: boolean;
+  artifactCounter: number;
   currentArtifact?: BoltArtifactData;
   currentAction: BoltActionData;
   actionId: number;
@@ -84,6 +87,7 @@ export class StreamingMessageParser {
         position: 0,
         insideAction: false,
         insideArtifact: false,
+        artifactCounter: 0,
         currentAction: { content: '' },
         actionId: 0,
       };
@@ -97,8 +101,6 @@ export class StreamingMessageParser {
 
     while (i < input.length) {
       if (input.startsWith(BOLT_QUICK_ACTIONS_OPEN, i)) {
-        console.log('input:', input.slice(i));
-
         const actionsBlockEnd = input.indexOf(BOLT_QUICK_ACTIONS_CLOSE, i);
 
         if (actionsBlockEnd !== -1) {
@@ -223,7 +225,11 @@ export class StreamingMessageParser {
               break;
             }
           } else if (artifactCloseIndex !== -1) {
-            this._options.callbacks?.onArtifactClose?.({ messageId, ...currentArtifact });
+            this._options.callbacks?.onArtifactClose?.({
+              messageId,
+              artifactId: currentArtifact.id,
+              ...currentArtifact,
+            });
 
             state.insideArtifact = false;
             state.currentArtifact = undefined;
@@ -256,7 +262,9 @@ export class StreamingMessageParser {
 
               const artifactTitle = this.#extractAttribute(artifactTag, 'title') as string;
               const type = this.#extractAttribute(artifactTag, 'type') as string;
-              const artifactId = this.#extractAttribute(artifactTag, 'id') as string;
+
+              // const artifactId = this.#extractAttribute(artifactTag, 'id') as string;
+              const artifactId = `${messageId}-${state.artifactCounter++}`;
 
               if (!artifactTitle) {
                 logger.warn('Artifact title missing');
@@ -276,11 +284,15 @@ export class StreamingMessageParser {
 
               state.currentArtifact = currentArtifact;
 
-              this._options.callbacks?.onArtifactOpen?.({ messageId, ...currentArtifact });
+              this._options.callbacks?.onArtifactOpen?.({
+                messageId,
+                artifactId: currentArtifact.id,
+                ...currentArtifact,
+              });
 
               const artifactFactory = this._options.artifactElement ?? createArtifactElement;
 
-              output += artifactFactory({ messageId });
+              output += artifactFactory({ messageId, artifactId });
 
               i = openTagEnd + 1;
             } else {
@@ -301,69 +313,10 @@ export class StreamingMessageParser {
           break;
         }
       } else {
-        // Check for code blocks outside of artifacts
-        if (!state.insideArtifact && input[i] === '`' && input[i + 1] === '`' && input[i + 2] === '`') {
-          // Find the end of the code block
-          const languageEnd = input.indexOf('\n', i + 3);
-
-          if (languageEnd !== -1) {
-            const codeBlockEnd = input.indexOf('\n```', languageEnd + 1);
-
-            if (codeBlockEnd !== -1) {
-              // Extract language and code content
-              const language = input.slice(i + 3, languageEnd).trim();
-              const codeContent = input.slice(languageEnd + 1, codeBlockEnd);
-
-              // Determine file extension based on language
-              const fileExtension = this.#getFileExtension(language);
-              const fileName = `code_${++this.#artifactCounter}${fileExtension}`;
-
-              // Auto-generate artifact and action tags
-              const artifactId = `artifact_${Date.now()}_${this.#artifactCounter}`;
-              const autoArtifact = {
-                id: artifactId,
-                title: fileName,
-                type: 'code',
-              };
-
-              // Emit artifact open callback
-              this._options.callbacks?.onArtifactOpen?.({ messageId, ...autoArtifact });
-
-              // Add artifact element to output
-              const artifactFactory = this._options.artifactElement ?? createArtifactElement;
-              output += artifactFactory({ messageId });
-
-              // Emit action for file creation
-              const fileAction = {
-                type: 'file' as const,
-                filePath: fileName,
-                content: codeContent + '\n',
-              };
-
-              this._options.callbacks?.onActionOpen?.({
-                artifactId,
-                messageId,
-                actionId: String(state.actionId++),
-                action: fileAction,
-              });
-
-              this._options.callbacks?.onActionClose?.({
-                artifactId,
-                messageId,
-                actionId: String(state.actionId - 1),
-                action: fileAction,
-              });
-
-              // Emit artifact close callback
-              this._options.callbacks?.onArtifactClose?.({ messageId, ...autoArtifact });
-
-              // Move position past the code block
-              i = codeBlockEnd + 4; // +4 for \n```
-              continue;
-            }
-          }
-        }
-
+        /*
+         * Note: Auto-file-creation from code blocks is now handled by EnhancedMessageParser
+         * to avoid duplicate processing and provide better shell command detection
+         */
         output += input[i];
         i++;
       }
@@ -431,78 +384,6 @@ export class StreamingMessageParser {
     const match = tag.match(new RegExp(`${attributeName}="([^"]*)"`, 'i'));
     return match ? match[1] : undefined;
   }
-
-  #getFileExtension(language: string): string {
-    const languageMap: Record<string, string> = {
-      javascript: '.js',
-      js: '.js',
-      typescript: '.ts',
-      ts: '.ts',
-      jsx: '.jsx',
-      tsx: '.tsx',
-      python: '.py',
-      py: '.py',
-      java: '.java',
-      c: '.c',
-      cpp: '.cpp',
-      'c++': '.cpp',
-      csharp: '.cs',
-      'c#': '.cs',
-      php: '.php',
-      ruby: '.rb',
-      rb: '.rb',
-      go: '.go',
-      rust: '.rs',
-      rs: '.rs',
-      kotlin: '.kt',
-      kt: '.kt',
-      swift: '.swift',
-      html: '.html',
-      css: '.css',
-      scss: '.scss',
-      sass: '.sass',
-      less: '.less',
-      xml: '.xml',
-      json: '.json',
-      yaml: '.yaml',
-      yml: '.yml',
-      toml: '.toml',
-      markdown: '.md',
-      md: '.md',
-      sql: '.sql',
-      sh: '.sh',
-      bash: '.sh',
-      zsh: '.sh',
-      fish: '.fish',
-      powershell: '.ps1',
-      ps1: '.ps1',
-      dockerfile: '.dockerfile',
-      docker: '.dockerfile',
-      makefile: '.makefile',
-      make: '.makefile',
-      vim: '.vim',
-      lua: '.lua',
-      perl: '.pl',
-      r: '.r',
-      matlab: '.m',
-      julia: '.jl',
-      scala: '.scala',
-      clojure: '.clj',
-      haskell: '.hs',
-      erlang: '.erl',
-      elixir: '.ex',
-      nim: '.nim',
-      crystal: '.cr',
-      dart: '.dart',
-      vue: '.vue',
-      svelte: '.svelte',
-      astro: '.astro',
-    };
-
-    const normalized = language.toLowerCase();
-
-    return languageMap[normalized] || '.txt';
-  }
 }
 
 const createArtifactElement: ElementFactory = (props) => {
@@ -527,8 +408,6 @@ function createQuickActionElement(props: Record<string, string>, label: string)
     ...Object.entries(props).map(([key, value]) => `data-${camelToDashCase(key)}=${JSON.stringify(value)}`),
   ];
 
-  console.log('elementProps', `<button ${elementProps.join(' ')}>${label}</button>`);
-
   return `<button ${elementProps.join(' ')}>${label}</button>`;
 }
 
diff --git a/app/lib/stores/workbench.ts b/app/lib/stores/workbench.ts
index 6fdf35eaf4..0c617a7fe3 100644
--- a/app/lib/stores/workbench.ts
+++ b/app/lib/stores/workbench.ts
@@ -466,17 +466,17 @@ export class WorkbenchStore {
   }
 
   addArtifact({ messageId, title, id, type }: ArtifactCallbackData) {
-    const artifact = this.#getArtifact(messageId);
+    const artifact = this.#getArtifact(id);
 
     if (artifact) {
       return;
     }
 
-    if (!this.artifactIdList.includes(messageId)) {
-      this.artifactIdList.push(messageId);
+    if (!this.artifactIdList.includes(id)) {
+      this.artifactIdList.push(id);
     }
 
-    this.artifacts.setKey(messageId, {
+    this.artifacts.setKey(id, {
       id,
       title,
       closed: false,
@@ -509,14 +509,18 @@ export class WorkbenchStore {
     });
   }
 
-  updateArtifact({ messageId }: ArtifactCallbackData, state: Partial<ArtifactUpdateState>) {
-    const artifact = this.#getArtifact(messageId);
+  updateArtifact({ artifactId }: ArtifactCallbackData, state: Partial<ArtifactUpdateState>) {
+    if (!artifactId) {
+      return;
+    }
+
+    const artifact = this.#getArtifact(artifactId);
 
     if (!artifact) {
       return;
     }
 
-    this.artifacts.setKey(messageId, { ...artifact, ...state });
+    this.artifacts.setKey(artifactId, { ...artifact, ...state });
   }
   addAction(data: ActionCallbackData) {
     // this._addAction(data);
@@ -524,9 +528,9 @@ export class WorkbenchStore {
     this.addToExecutionQueue(() => this._addAction(data));
   }
   async _addAction(data: ActionCallbackData) {
-    const { messageId } = data;
+    const { artifactId } = data;
 
-    const artifact = this.#getArtifact(messageId);
+    const artifact = this.#getArtifact(artifactId);
 
     if (!artifact) {
       unreachable('Artifact not found');
@@ -543,9 +547,9 @@ export class WorkbenchStore {
     }
   }
   async _runAction(data: ActionCallbackData, isStreaming: boolean = false) {
-    const { messageId } = data;
+    const { artifactId } = data;
 
-    const artifact = this.#getArtifact(messageId);
+    const artifact = this.#getArtifact(artifactId);
 
     if (!artifact) {
       unreachable('Artifact not found');