shark-ai 0.3.18 → 0.4.1

package/dist/bin/shark.js

@@ -417,7 +417,35 @@ var sseClient = new SSEClient();
 // src/core/agents/agent-response-parser.ts
 import { z as z2 } from "zod";
 var AgentActionSchema = z2.object({
-  type: z2.enum(["create_file", "modify_file", "modify_ast", "search_ast", "delete_file", "talk_with_user", "list_files", "read_file", "search_file", "run_command", "use_mcp_tool"]),
+  type: z2.enum([
+    "create_file",
+    "modify_file",
+    "list_files",
+    "search_file",
+    "read_file",
+    "delete_file",
+    "list_structure",
+    "modify_ast",
+    "search_ast",
+    "run_command",
+    "talk_with_user",
+    "ast_list_structure",
+    "ast_get_method",
+    "ast_add_method",
+    "ast_modify_method",
+    "ast_remove_method",
+    "ast_add_class",
+    "ast_add_property",
+    "ast_remove_property",
+    "ast_add_decorator",
+    "ast_add_interface",
+    "ast_add_type_alias",
+    "ast_add_function",
+    "ast_remove_function",
+    "ast_add_import",
+    "ast_remove_import",
+    "ast_organize_imports"
+  ]),
   path: z2.string().nullable().optional(),
   // Nullable for strict mode combatibility
   content: z2.string().nullable().optional(),
@@ -433,6 +461,22 @@ var AgentActionSchema = z2.object({
   language: z2.string().nullable().optional(),
   file_path: z2.string().nullable().optional(),
   // Alias for path in ast-grep actions
+  // New AST Tool Specific Fields
+  class_name: z2.string().nullable().optional(),
+  method_name: z2.string().nullable().optional(),
+  method_code: z2.string().nullable().optional(),
+  property_name: z2.string().nullable().optional(),
+  property_code: z2.string().nullable().optional(),
+  extends_class: z2.string().nullable().optional(),
+  implements_interfaces: z2.array(z2.string()).nullable().optional(),
+  decorator_code: z2.string().nullable().optional(),
+  interface_code: z2.string().nullable().optional(),
+  type_code: z2.string().nullable().optional(),
+  function_name: z2.string().nullable().optional(),
+  function_code: z2.string().nullable().optional(),
+  import_statement: z2.string().nullable().optional(),
+  module_path: z2.string().nullable().optional(),
+  new_body: z2.string().nullable().optional(),
   // Preview confirmation
   confirmed: z2.boolean().nullable().optional()
 });
@@ -786,142 +830,413 @@ async function interactiveBusinessAnalyst() {
 }
 
 // src/core/agents/specification-agent.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path6 from "path";
 
 // src/core/agents/agent-tools.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 import fg from "fast-glob";
 import { exec } from "child_process";
 import { promisify } from "util";
 import { fileURLToPath } from "url";
 
-// src/core/services/code-review.service.ts
-import path3 from "path";
-var CodeReviewService = class {
+// src/core/ast-editing/editors/code-editor-factory.ts
+import * as path4 from "path";
+
+// src/core/ast-editing/editors/typescript-editor.ts
+import { Project, SyntaxKind } from "ts-morph";
+import * as path3 from "path";
+import * as fs3 from "fs";
+var TypeScriptEditor = class {
+  project;
+  constructor() {
+    this.project = new Project({
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: {
+        target: 99,
+        // ESNext
+        module: 99
+        // ESNext
+      }
+    });
+  }
   /**
-   * Reviews the code modification and returns a status/feedback string.
-   * This string is intended to be appended to the user Preview so the Agent can see it.
+   * Get or add source file to project
    */
-  static async reviewCode(filePath, newContent) {
-    const config = ConfigManager.getInstance().getConfig();
-    const validation = config.validation || { llmReviewExtensions: [".ts", ".tsx"], syntaxCheckExtensions: ["*"] };
-    const ext = path3.extname(filePath).toLowerCase();
-    const needsLlmReview = validation.llmReviewExtensions.includes(ext) || validation.llmReviewExtensions.includes("*");
-    if (needsLlmReview) {
-      return await this.performLlmReview(filePath, newContent);
-    }
-    const needsSyntaxCheck = validation.syntaxCheckExtensions.includes(ext) || validation.syntaxCheckExtensions.includes("*");
-    if (needsSyntaxCheck) {
-      return this.performSyntaxCheck(filePath, newContent);
-    }
-    return "\u2139\uFE0F  No specific validation configured for this file type.";
-  }
-  static getCodeReviewAgentId() {
-    const config = ConfigManager.getInstance().getConfig();
-    if (config.agents?.codeReview) return config.agents.codeReview;
-    if (process.env.STACKSPOT_CODE_REVIEW_AGENT_ID) return process.env.STACKSPOT_CODE_REVIEW_AGENT_ID;
-    return "";
-  }
-  static async performLlmReview(filePath, content) {
-    const agentId = this.getCodeReviewAgentId();
-    if (!agentId) {
-      return this.performSyntaxCheck(filePath, content);
+  getSourceFile(filePath) {
+    const absolutePath = path3.resolve(filePath);
+    let sourceFile = this.project.getSourceFile(absolutePath);
+    if (!sourceFile) {
+      if (!fs3.existsSync(absolutePath)) {
+        throw new Error(`File not found: ${absolutePath}`);
+      }
+      sourceFile = this.project.addSourceFileAtPath(absolutePath);
+    }
+    return sourceFile;
+  }
+  /**
+   * Get class declaration by name
+   */
+  getClass(sourceFile, className) {
+    const classDecl = sourceFile.getClass(className);
+    if (!classDecl) {
+      throw new Error(`Class "${className}" not found in ${sourceFile.getFilePath()}`);
+    }
+    return classDecl;
+  }
+  // ═══════════════════════════════════════════════════════
+  // IMPLEMENTATION: listStructure
+  // ═══════════════════════════════════════════════════════
+  async listStructure(filePath) {
+    const sourceFile = this.getSourceFile(filePath);
+    const classes = sourceFile.getClasses().map((cls) => ({
+      name: cls.getName() || "<anonymous>",
+      methods: cls.getMethods().map((m) => this.extractMethodInfo(m)),
+      properties: cls.getProperties().map((p) => this.extractPropertyInfo(p)),
+      decorators: cls.getDecorators().map((d) => d.getText()),
+      extendsClass: cls.getExtends()?.getText(),
+      implementsInterfaces: cls.getImplements().map((i) => i.getText())
+    }));
+    const interfaces = sourceFile.getInterfaces().map((iface) => ({
+      name: iface.getName(),
+      properties: iface.getProperties().map((p) => this.extractPropertyInfo(p)),
+      extends: iface.getExtends().map((e) => e.getText())
+    }));
+    const functions = sourceFile.getFunctions().map((fn) => ({
+      name: fn.getName() || "<anonymous>",
+      parameters: fn.getParameters().map((p) => ({
+        name: p.getName(),
+        type: p.getType().getText(),
+        isOptional: p.isOptional()
+      })),
+      returnType: fn.getReturnType().getText(),
+      isAsync: fn.isAsync(),
+      isExported: fn.isExported()
+    }));
+    const imports = sourceFile.getImportDeclarations().map((imp) => ({
+      modulePath: imp.getModuleSpecifierValue(),
+      isDefault: !!imp.getDefaultImport(),
+      namedImports: imp.getNamedImports().map((n) => n.getName()),
+      namespaceImport: imp.getNamespaceImport()?.getText()
+    }));
+    const exports = sourceFile.getExportedDeclarations();
+    const exportInfo = Array.from(exports.entries()).flatMap(
+      ([name, declarations]) => declarations.map((decl) => ({
+        name,
+        type: this.getDeclarationType(decl),
+        isDefault: sourceFile.getDefaultExportSymbol()?.getName() === name
+      }))
+    );
+    return {
+      classes,
+      interfaces,
+      functions,
+      imports,
+      exports: exportInfo
+    };
+  }
+  extractMethodInfo(method) {
+    return {
+      name: method.getName(),
+      parameters: method.getParameters().map((p) => ({
+        name: p.getName(),
+        type: p.getType().getText(),
+        isOptional: p.isOptional()
+      })),
+      returnType: method.getReturnType().getText(),
+      isAsync: method.isAsync(),
+      isStatic: method.isStatic(),
+      visibility: this.getVisibility(method),
+      decorators: method.getDecorators().map((d) => d.getText())
+    };
+  }
+  extractPropertyInfo(property) {
+    return {
+      name: property.getName(),
+      type: property.getType()?.getText(),
+      visibility: this.getVisibility(property),
+      isReadonly: property.isReadonly(),
+      initializer: property.getInitializer()?.getText()
+    };
+  }
+  getVisibility(node) {
+    if (node.hasModifier?.(SyntaxKind.PrivateKeyword)) return "private";
+    if (node.hasModifier?.(SyntaxKind.ProtectedKeyword)) return "protected";
+    return "public";
+  }
+  getDeclarationType(decl) {
+    if (decl.getKind() === SyntaxKind.ClassDeclaration) return "class";
+    if (decl.getKind() === SyntaxKind.FunctionDeclaration) return "function";
+    if (decl.getKind() === SyntaxKind.InterfaceDeclaration) return "interface";
+    if (decl.getKind() === SyntaxKind.TypeAliasDeclaration) return "type";
+    return "const";
+  }
+  // ═══════════════════════════════════════════════════════
+  // IMPLEMENTATION: Class Operations
+  // ═══════════════════════════════════════════════════════
+  async addClass(filePath, className, options) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      sourceFile.addClass({
+        name: className,
+        extends: options?.extendsClass,
+        implements: options?.implementsInterfaces,
+        isExported: true
+      });
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add class "${className}":`, error);
+      return false;
+    }
+  }
+  async addProperty(filePath, className, propertyCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const closeBrace = classDecl.getEnd() - 1;
+      classDecl.insertText(closeBrace, `
+  ${propertyCode}`);
+      classDecl.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add property to "${className}":`, error);
+      return false;
+    }
+  }
+  async removeProperty(filePath, className, propertyName) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const property = classDecl.getProperty(propertyName);
+      if (!property) {
+        throw new Error(`Property "${propertyName}" not found in class "${className}"`);
+      }
+      property.remove();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to remove property "${propertyName}":`, error);
+      return false;
+    }
+  }
+  async addMethod(filePath, className, methodCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const closeBrace = classDecl.getEnd() - 1;
+      classDecl.insertText(closeBrace, `
+  ${methodCode}
+`);
+      classDecl.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add method to "${className}":`, error);
+      return false;
+    }
+  }
+  async modifyMethod(filePath, className, methodName, newBody) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const method = classDecl.getMethod(methodName);
+      if (!method) {
+        throw new Error(`Method "${methodName}" not found in class "${className}"`);
+      }
+      method.setBodyText(newBody);
+      method.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to modify method "${methodName}":`, error);
+      return false;
+    }
+  }
+  async removeMethod(filePath, className, methodName) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const method = classDecl.getMethod(methodName);
+      if (!method) {
+        throw new Error(`Method "${methodName}" not found in class "${className}"`);
+      }
+      method.remove();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to remove method "${methodName}":`, error);
+      return false;
     }
+  }
+  async addDecorator(filePath, className, decoratorCode) {
     try {
-      const realm = await getActiveRealm();
-      const token = await ensureValidToken(realm);
-      const prompt = `You are a Code Review Specialist. Analyze the following code modification for file: ${path3.basename(filePath)}
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const start = classDecl.getStart();
+      sourceFile.insertText(start, `${decoratorCode}
+`);
+      sourceFile.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add decorator to "${className}":`, error);
+      return false;
+    }
+  }
+  async getMethod(filePath, className, methodName) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const method = classDecl.getMethod(methodName);
+      if (!method) {
+        return null;
+      }
+      return method.getText();
+    } catch (error) {
+      console.error(`Failed to get method "${methodName}":`, error);
+      return null;
+    }
+  }
+  // ═══════════════════════════════════════════════════════
+  // IMPLEMENTATION: Interface/Type Operations
+  // ═══════════════════════════════════════════════════════
+  async addInterface(filePath, interfaceCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      sourceFile.insertText(sourceFile.getEnd(), `
 
-NEW CODE TO BE ADDED:
-\`\`\`
-${content}
-\`\`\`
+${interfaceCode}`);
+      sourceFile.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add interface:`, error);
+      return false;
+    }
+  }
+  async addTypeAlias(filePath, typeCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      sourceFile.insertText(sourceFile.getEnd(), `
 
-Provide a concise review focusing on:
-1. Syntax errors or obvious bugs
-2. Potential runtime issues
-3. Code quality concerns
-
-Respond in JSON format with status, issues array, and summary.`;
-      const payload = {
-        user_prompt: prompt,
-        streaming: true,
-        use_conversation: true,
-        stackspot_knowledge: false
-      };
-      const url = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${agentId}/chat`;
-      let reviewText = "";
-      await sseClient.streamAgentResponse(url, payload, { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" }, {
-        onChunk: (c) => {
-          reviewText += c;
-        },
-        onComplete: () => {
-        },
-        onError: (e) => {
-          throw e;
-        }
-      });
-      const cleanedText = reviewText.trim();
-      FileLogger.log("CODE_REVIEW", "Raw Response Received", { length: cleanedText.length, content: cleanedText });
-      try {
-        const reviewData = extractFirstJson(cleanedText);
-        return this.formatReviewResponse(reviewData);
-      } catch (parseErr) {
-        FileLogger.log("CODE_REVIEW", "JSON Parse Failed", {
-          error: parseErr.message,
-          rawText: cleanedText
-        });
-        return `\u{1F916} **[AI Code Review Agent]**
-\u26A0\uFE0F Response format error. Raw output:
-${cleanedText}`;
+${typeCode}`);
+      sourceFile.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add type alias:`, error);
+      return false;
+    }
+  }
+  // ═══════════════════════════════════════════════════════
+  // IMPLEMENTATION: Function Operations
+  // ═══════════════════════════════════════════════════════
+  async addFunction(filePath, functionCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      sourceFile.insertText(sourceFile.getEnd(), `
+
+${functionCode}`);
+      sourceFile.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add function:`, error);
+      return false;
+    }
+  }
+  async removeFunction(filePath, functionName) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const func = sourceFile.getFunction(functionName);
+      if (!func) {
+        throw new Error(`Function "${functionName}" not found`);
       }
-    } catch (err) {
-      FileLogger.log("CODE_REVIEW", "LLM Review Failed", { error: err.message });
-      return `\u26A0\uFE0F AI Review unavailable (${err.message}). Using syntax check:
-` + await this.performSyntaxCheck(filePath, content);
+      func.remove();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to remove function "${functionName}":`, error);
+      return false;
     }
   }
-  static formatReviewResponse(data) {
-    let report = `\u{1F916} **[AI Code Review Agent]**
-`;
-    const statusIcon = data.status === "ok" ? "\u2705" : data.status === "warning" ? "\u26A0\uFE0F" : "\u274C";
-    report += `${statusIcon} **Status:** ${data.status.toUpperCase()}
-`;
-    if (data.issues && data.issues.length > 0) {
-      report += `
-**Issues Found:**
-`;
-      for (const issue of data.issues) {
-        const severityIcon = issue.severity === "error" ? "\u274C" : issue.severity === "warning" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
-        const lineInfo = issue.line ? `Linha ${issue.line}: ` : "";
-        report += `${severityIcon} ${lineInfo}${issue.message}
-`;
-        if (issue.suggestion) {
-          report += `   \u{1F4A1} ${issue.suggestion}
-`;
-        }
+  // ═══════════════════════════════════════════════════════
+  // IMPLEMENTATION: Import/Export Operations
+  // ═══════════════════════════════════════════════════════
+  async addImport(filePath, importStatement) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const lastImport = sourceFile.getImportDeclarations().pop();
+      const pos = lastImport ? lastImport.getEnd() : 0;
+      sourceFile.insertText(pos, `
+${importStatement}`);
+      this.organizeImports(filePath);
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add import:`, error);
+      return false;
+    }
+  }
+  async removeImport(filePath, modulePath) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const importDecls = sourceFile.getImportDeclarations().filter((imp) => imp.getModuleSpecifierValue() === modulePath);
+      if (importDecls.length === 0) {
+        throw new Error(`Import from "${modulePath}" not found`);
       }
+      importDecls.forEach((d) => d.remove());
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to remove import from "${modulePath}":`, error);
+      return false;
     }
-    report += `
-**Resumo:** ${data.summary}`;
-    return report;
   }
-  static performSyntaxCheck(filePath, content) {
-    let report = `\u{1F50D} **[Syntax Validator]**
-`;
-    const openBraces = (content.match(/\{/g) || []).length;
-    const closeBraces = (content.match(/\}/g) || []).length;
-    if (openBraces !== closeBraces) {
-      report += `\u274C **CRITICAL:** Brace mismatch detected! Found ${openBraces} '{' and ${closeBraces} '}'.
-`;
-      report += `   **Review your code carefully. Do not confirm if the block is incomplete.**`;
-    } else {
-      report += `\u2705 File structure looks balanced (Braces match).
-`;
+  async organizeImports(filePath) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      sourceFile.organizeImports();
+      const imports = sourceFile.getImportDeclarations();
+      const importStructure = imports.map((i) => i.getStructure());
+      importStructure.sort((a, b) => {
+        return a.moduleSpecifier.localeCompare(b.moduleSpecifier);
+      });
+      imports.forEach((i) => i.remove());
+      sourceFile.addImportDeclarations(importStructure);
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to organize imports:`, error);
+      return false;
     }
-    return Promise.resolve(report);
+  }
+};
+
+// src/core/ast-editing/editors/code-editor-factory.ts
+var CodeEditorFactory = class {
+  static tsEditor = null;
+  /**
+   * Returns appropriate editor for the file, or null if AST editing not supported
+   */
+  static getEditor(filePath) {
+    const ext = path4.extname(filePath).toLowerCase();
+    if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+      if (!this.tsEditor) {
+        this.tsEditor = new TypeScriptEditor();
+      }
+      return this.tsEditor;
+    }
+    return null;
+  }
+  /**
+   * Clear cached editors (useful for testing)
+   */
+  static clearCache() {
+    this.tsEditor = null;
   }
 };
 
@@ -934,9 +1249,9 @@ function detectLineEnding(content) {
 }
 function handleListFiles(dirPath) {
   try {
-    const fullPath = path4.resolve(process.cwd(), dirPath);
-    if (!fs3.existsSync(fullPath)) return `Error: Directory ${dirPath} does not exist.`;
-    const items = fs3.readdirSync(fullPath, { withFileTypes: true });
+    const fullPath = path5.resolve(process.cwd(), dirPath);
+    if (!fs4.existsSync(fullPath)) return `Error: Directory ${dirPath} does not exist.`;
+    const items = fs4.readdirSync(fullPath, { withFileTypes: true });
     return items.map((item) => {
       return `${item.isDirectory() ? "[DIR]" : "[FILE]"} ${item.name}`;
     }).join("\n");
@@ -946,11 +1261,11 @@ function handleListFiles(dirPath) {
 }
 function handleReadFile(filePath, showLineNumbers = true) {
   try {
-    const fullPath = path4.resolve(process.cwd(), filePath);
-    if (!fs3.existsSync(fullPath)) return `Error: File ${filePath} does not exist.`;
-    const stats = fs3.statSync(fullPath);
+    const fullPath = path5.resolve(process.cwd(), filePath);
+    if (!fs4.existsSync(fullPath)) return `Error: File ${filePath} does not exist.`;
+    const stats = fs4.statSync(fullPath);
     if (stats.size > 100 * 1024) return `Error: File too large to read (${stats.size} bytes). Limit is 100KB.`;
-    const content = fs3.readFileSync(fullPath, "utf-8");
+    const content = fs4.readFileSync(fullPath, "utf-8");
     if (showLineNumbers) {
       const lines = content.split("\n");
       return lines.map((line, idx) => `${idx + 1}: ${line}`).join("\n");
@@ -962,11 +1277,11 @@ function handleReadFile(filePath, showLineNumbers = true) {
 }
 function replaceLineRange(filePath, startLine, endLine, newContent, tui2) {
   try {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       tui2.log.error(`\u274C File not found for modification: ${filePath}`);
       return false;
     }
-    const currentFileContent = fs3.readFileSync(filePath, "utf-8");
+    const currentFileContent = fs4.readFileSync(filePath, "utf-8");
     const lineEnding = detectLineEnding(currentFileContent);
     const lines = currentFileContent.split(lineEnding);
     if (startLine < 1 || startLine > lines.length) {
@@ -984,7 +1299,7 @@ function replaceLineRange(filePath, startLine, endLine, newContent, tui2) {
     const result = [...before, ...normalizedNewLines, ...after].join(lineEnding);
     const BOM = "\uFEFF";
     const finalContent = result.startsWith(BOM) ? result : BOM + result;
-    fs3.writeFileSync(filePath, finalContent, { encoding: "utf-8" });
+    fs4.writeFileSync(filePath, finalContent, { encoding: "utf-8" });
     tui2.log.success(`\u2705 Replaced lines ${startLine}-${endLine} in ${filePath}`);
     return true;
   } catch (e) {
@@ -992,47 +1307,6 @@ function replaceLineRange(filePath, startLine, endLine, newContent, tui2) {
     return false;
   }
 }
-async function generateFilePreview(filePath, startLine, endLine, newContent) {
-  try {
-    const fullPath = path4.resolve(process.cwd(), filePath);
-    if (!fs3.existsSync(fullPath)) return `Error: File ${filePath} does not exist.`;
-    const content = fs3.readFileSync(fullPath, "utf-8");
-    const lines = content.split(/\r\n|\r|\n/);
-    const startIdx = startLine - 1;
-    const endIdx = endLine - 1;
-    if (startIdx < 0 || startIdx >= lines.length) return `Error: Start line ${startLine} is out of bounds (File has ${lines.length} lines).`;
-    if (endIdx < startIdx || endIdx >= lines.length) return `Error: End line ${endLine} is invalid.`;
-    const contextBefore = lines.slice(Math.max(0, startIdx - 3), startIdx).map((l, i) => `${Math.max(1, startLine - 3) + i} | ${l}`).join("\n");
-    const contentReplacing = lines.slice(startIdx, endIdx + 1).map((l, i) => `${startLine + i} | - ${l}`).join("\n");
-    const contextAfter = lines.slice(endIdx + 1, Math.min(lines.length, endIdx + 4)).map((l, i) => `${endLine + 1 + i} | ${l}`).join("\n");
-    const newLines = newContent.split("\n").map((l) => `+ ${l}`).join("\n");
-    let reviewFeedback = "";
-    try {
-      reviewFeedback = await CodeReviewService.reviewCode(filePath, newContent);
-    } catch (err) {
-      reviewFeedback = `\u26A0\uFE0F Code Review Service Unavailable: ${err.message}`;
-    }
-    return `PREVIEW OF CHANGES to ${filePath}:
---------------------------------------------------
-CONTEXT BEFORE:
-${contextBefore}
-
-CHANGES:
-${contentReplacing}
-${newLines}
-
-CONTEXT AFTER:
-${contextAfter}
---------------------------------------------------
-${reviewFeedback}
-
-IMPORTANT: Please verify that the lines being replaced (marked with -) are exactly what you intend to remove.
-If the context looks wrong, DO NOT CONFIRM. Re-read the file to check line numbers.
-`;
-  } catch (e) {
-    return `Error generating preview: ${e.message}`;
-  }
-}
 function handleSearchFile(pattern) {
   try {
     const entries = fg.sync(pattern, { dot: true });
@@ -1043,11 +1317,11 @@ function handleSearchFile(pattern) {
   }
 }
 function startSmartReplace(filePath, newContent, targetContent, tui2) {
-  if (!fs3.existsSync(filePath)) {
+  if (!fs4.existsSync(filePath)) {
     tui2.log.error(`\u274C File not found for modification: ${filePath}`);
     return false;
   }
-  const currentFileContent = fs3.readFileSync(filePath, "utf-8");
+  const currentFileContent = fs4.readFileSync(filePath, "utf-8");
   const normalizedTarget = targetContent.replace(/\r\n/g, "\n");
   const normalizedContent = currentFileContent.replace(/\r\n/g, "\n");
   if (!normalizedContent.includes(normalizedTarget)) {
@@ -1064,7 +1338,7 @@ function startSmartReplace(filePath, newContent, targetContent, tui2) {
   const BOM = "\uFEFF";
   const updatedContent = currentFileContent.replace(targetContent, newContent);
   const finalContent = updatedContent.startsWith(BOM) ? updatedContent : BOM + updatedContent;
-  fs3.writeFileSync(filePath, finalContent, { encoding: "utf-8" });
+  fs4.writeFileSync(filePath, finalContent, { encoding: "utf-8" });
   tui2.log.success(`\u2705 Smart Replace Applied: ${filePath}`);
   return true;
 }
@@ -1072,7 +1346,7 @@ async function handleRunCommand(command) {
   const { spawn } = await import("child_process");
   try {
     tui.log.info(`\u{1F4BB} Executing: ${colors.dim(command)}`);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const child = spawn(command, {
         shell: true,
         stdio: ["ignore", "pipe", "pipe"],
@@ -1082,7 +1356,7 @@ async function handleRunCommand(command) {
       let stderr = "";
       const timer = setTimeout(() => {
         child.kill();
-        resolve(`Error: Command timed out after 5 minutes.
+        resolve2(`Error: Command timed out after 5 minutes.
 Output so far:
 ${stdout}
 ${stderr}`);
@@ -1097,9 +1371,9 @@ ${stderr}`);
       child.on("close", (code) => {
         clearTimeout(timer);
         if (code === 0) {
-          resolve(stdout.trim() || "Command executed successfully (no output).");
+          resolve2(stdout.trim() || "Command executed successfully (no output).");
         } else {
-          resolve(`Command failed with exit code ${code}.
+          resolve2(`Command failed with exit code ${code}.
 STDERR:
 ${stderr}
 STDOUT:
@@ -1108,7 +1382,7 @@ ${stdout}`);
       });
       child.on("error", (err) => {
         clearTimeout(timer);
-        resolve(`Error executing command: ${err.message}`);
+        resolve2(`Error executing command: ${err.message}`);
       });
     });
   } catch (e) {
@@ -1120,20 +1394,20 @@ function resolveAstGrepCommand() {
   const binName = isWin ? "sg.cmd" : "sg";
   try {
     const currentFile = fileURLToPath(import.meta.url);
-    let dir = path4.dirname(currentFile);
+    let dir = path5.dirname(currentFile);
     for (let i = 0; i < 5; i++) {
-      const candidate = path4.join(dir, "node_modules", ".bin", binName);
-      if (fs3.existsSync(candidate)) {
+      const candidate = path5.join(dir, "node_modules", ".bin", binName);
+      if (fs4.existsSync(candidate)) {
         return `"${candidate}"`;
       }
-      const parent = path4.dirname(dir);
+      const parent = path5.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
   } catch (e) {
   }
-  const cwdBin = path4.resolve(process.cwd(), "node_modules", ".bin", binName);
-  if (fs3.existsSync(cwdBin)) {
+  const cwdBin = path5.resolve(process.cwd(), "node_modules", ".bin", binName);
+  if (fs4.existsSync(cwdBin)) {
     return `"${cwdBin}"`;
   }
   return "npx sg";
@@ -1141,13 +1415,13 @@ function resolveAstGrepCommand() {
 async function astGrepSearch(pattern, filePath, language, tui2) {
   const { spawn } = await import("child_process");
   try {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       return `\u274C File not found: ${filePath}`;
     }
     const sgCmd = resolveAstGrepCommand();
     const cmd = `${sgCmd} run -p "${pattern}" -l ${language} --json ${filePath}`;
     tui2.log.info(`\u{1F50D} [AST-GREP] Searching: ${cmd}`);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const child = spawn(cmd, {
         shell: true,
         stdio: ["ignore", "pipe", "pipe"],
@@ -1161,19 +1435,19 @@ async function astGrepSearch(pattern, filePath, language, tui2) {
       child.stderr.on("data", (data) => stderr += data.toString());
       child.on("close", (code) => {
         if (code === 0 && stdout) {
-          resolve(stdout);
+          resolve2(stdout);
         } else if (code === 1 && !stderr) {
-          resolve("No structural matches found.");
+          resolve2("No structural matches found.");
         } else {
-          if (!stdout && !stderr) resolve("No structural matches found.");
+          if (!stdout && !stderr) resolve2("No structural matches found.");
           else {
             tui2.log.error(`\u274C ast-grep search error (code ${code}): ${stderr}`);
-            resolve(`Error executing ast-grep search: ${stderr || stdout}`);
+            resolve2(`Error executing ast-grep search: ${stderr || stdout}`);
           }
         }
       });
       child.on("error", (err) => {
-        resolve(`Error executing ast-grep search: ${err.message}`);
+        resolve2(`Error executing ast-grep search: ${err.message}`);
       });
     });
   } catch (e) {
@@ -1184,14 +1458,14 @@ async function astGrepSearch(pattern, filePath, language, tui2) {
 async function astGrepRewrite(pattern, fix, filePath, language, tui2) {
   const { spawn } = await import("child_process");
   try {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       tui2.log.error(`\u274C File not found for AST modification: ${filePath}`);
       return false;
     }
     const sgCmd = resolveAstGrepCommand();
     const cmd = `${sgCmd} run -p "${pattern}" -r "${fix}" -l ${language} ${filePath} --update-all`;
     tui2.log.info(`\u270F\uFE0F [AST-GREP] Rewriting: pattern="${pattern}" fix="${fix.substring(0, 50)}..."`);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const child = spawn(cmd, {
         shell: true,
         stdio: ["ignore", "pipe", "pipe"],
@@ -1202,15 +1476,15 @@ async function astGrepRewrite(pattern, fix, filePath, language, tui2) {
       child.on("close", (code) => {
         if (code === 0) {
           tui2.log.success(`\u2705 AST Rewrite applied to ${filePath}`);
-          resolve(true);
+          resolve2(true);
         } else {
           tui2.log.error(`\u274C AST Rewrite failed (code ${code}): ${stderr}`);
-          resolve(false);
+          resolve2(false);
         }
       });
       child.on("error", (err) => {
         tui2.log.error(`\u274C AST Rewrite spawn error: ${err.message}`);
-        resolve(false);
+        resolve2(false);
       });
     });
   } catch (e) {
@@ -1218,6 +1492,173 @@ async function astGrepRewrite(pattern, fix, filePath, language, tui2) {
     return false;
   }
 }
+async function astListStructure(filePath) {
+  try {
+    const editor = CodeEditorFactory.getEditor(filePath);
+    if (!editor) {
+      return `[AST Error] File type not supported: ${filePath}. Use read_file instead.`;
+    }
+    const structure = await editor.listStructure(filePath);
+    let output = `[AST Structure of ${filePath}]
+
+`;
+    if (structure.classes.length > 0) {
+      output += `CLASSES:
+`;
+      structure.classes.forEach((cls) => {
+        output += `  - ${cls.name}`;
+        if (cls.extendsClass) output += ` extends ${cls.extendsClass}`;
+        if (cls.implementsInterfaces.length > 0) {
+          output += ` implements ${cls.implementsInterfaces.join(", ")}`;
+        }
+        output += `
+`;
+        if (cls.decorators.length > 0) {
+          output += `    Decorators: ${cls.decorators.join(", ")}
+`;
+        }
+        if (cls.properties.length > 0) {
+          output += `    Properties:
+`;
+          cls.properties.forEach((prop) => {
+            output += `      - ${prop.visibility} ${prop.name}: ${prop.type}
+`;
+          });
+        }
+        if (cls.methods.length > 0) {
+          output += `    Methods:
+`;
+          cls.methods.forEach((method) => {
+            const params = method.parameters.map((p) => `${p.name}: ${p.type}`).join(", ");
+            output += `      - ${method.visibility} ${method.name}(${params}): ${method.returnType}
+`;
+          });
+        }
+        output += `
+`;
+      });
+    }
+    if (structure.interfaces.length > 0) {
+      output += `INTERFACES:
+`;
+      structure.interfaces.forEach((iface) => {
+        output += `  - ${iface.name}
+`;
+        iface.properties.forEach((prop) => {
+          output += `      ${prop.name}: ${prop.type}
+`;
+        });
+      });
+      output += `
+`;
+    }
+    if (structure.functions.length > 0) {
+      output += `FUNCTIONS:
+`;
+      structure.functions.forEach((fn) => {
+        const params = fn.parameters.map((p) => `${p.name}: ${p.type}`).join(", ");
+        output += `  - ${fn.name}(${params}): ${fn.returnType}
+`;
+      });
+      output += `
+`;
+    }
+    if (structure.imports.length > 0) {
+      output += `IMPORTS:
+`;
+      structure.imports.forEach((imp) => {
+        output += `  - from "${imp.modulePath}": ${imp.namedImports.join(", ")}
+`;
+      });
+    }
+    return output;
+  } catch (error) {
+    return `[AST Error] ${error.message}`;
+  }
+}
+async function astAddMethod(filePath, className, methodCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) {
+    throw new Error(`No AST editor available for ${filePath}`);
+  }
+  return await editor.addMethod(filePath, className, methodCode);
+}
+async function astGetMethod(filePath, className, methodName) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) {
+    throw new Error(`No AST editor available for ${filePath}`);
+  }
+  const methodContent = await editor.getMethod(filePath, className, methodName);
+  if (!methodContent) {
+    return `Method "${methodName}" not found in class "${className}"`;
+  }
+  return methodContent;
+}
+async function astAddClass(filePath, className, extendsClass, implementsInterfaces) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addClass(filePath, className, { extendsClass, implementsInterfaces });
+}
+async function astAddProperty(filePath, className, propertyCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addProperty(filePath, className, propertyCode);
+}
+async function astRemoveProperty(filePath, className, propertyName) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.removeProperty(filePath, className, propertyName);
+}
+async function astModifyMethod(filePath, className, methodName, newBody) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.modifyMethod(filePath, className, methodName, newBody);
+}
+async function astRemoveMethod(filePath, className, methodName) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.removeMethod(filePath, className, methodName);
+}
+async function astAddDecorator(filePath, className, decoratorCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addDecorator(filePath, className, decoratorCode);
+}
+async function astAddInterface(filePath, interfaceCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addInterface(filePath, interfaceCode);
+}
+async function astAddTypeAlias(filePath, typeCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addTypeAlias(filePath, typeCode);
+}
+async function astAddFunction(filePath, functionCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addFunction(filePath, functionCode);
+}
+async function astRemoveFunction(filePath, functionName) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.removeFunction(filePath, functionName);
+}
+async function astAddImport(filePath, importStatement) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addImport(filePath, importStatement);
+}
+async function astRemoveImport(filePath, modulePath) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.removeImport(filePath, modulePath);
+}
+async function astOrganizeImports(filePath) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.organizeImports(filePath);
+}
 
 // src/core/agents/specification-agent.ts
 var AGENT_TYPE2 = "specification_agent";
@@ -1232,29 +1673,39 @@ async function interactiveSpecificationAgent(options = {}) {
   tui.intro("\u{1F3D7}\uFE0F  Specification Agent");
   const projectRoot = process.cwd();
   let contextContent = "";
-  const contextPath = path5.resolve(projectRoot, "_sharkrc", "project-context.md");
-  if (fs4.existsSync(contextPath)) {
+  const contextPath = path6.resolve(projectRoot, "_sharkrc", "project-context.md");
+  if (fs5.existsSync(contextPath)) {
     try {
-      contextContent = fs4.readFileSync(contextPath, "utf-8");
-      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path5.relative(projectRoot, contextPath))}`);
+      contextContent = fs5.readFileSync(contextPath, "utf-8");
+      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path6.relative(projectRoot, contextPath))}`);
     } catch (e) {
       tui.log.warning(`Failed to read context file: ${e}`);
     }
   }
   let briefingContent = "";
-  if (options.briefingPath && fs4.existsSync(options.briefingPath)) {
-    briefingContent = fs4.readFileSync(options.briefingPath, "utf-8");
+  if (options.briefingPath && fs5.existsSync(options.briefingPath)) {
+    briefingContent = fs5.readFileSync(options.briefingPath, "utf-8");
     tui.log.info(`\u{1F4C4} Briefing loaded from: ${colors.dim(options.briefingPath)}`);
   } else {
-    const sharkRcBriefing = path5.resolve(projectRoot, "_sharkrc", "briefing.md");
-    if (fs4.existsSync(sharkRcBriefing)) {
-      briefingContent = fs4.readFileSync(sharkRcBriefing, "utf-8");
+    const sharkRcBriefing = path6.resolve(projectRoot, "_sharkrc", "briefing.md");
+    if (fs5.existsSync(sharkRcBriefing)) {
+      briefingContent = fs5.readFileSync(sharkRcBriefing, "utf-8");
       tui.log.info(`\u{1F4C4} Standard Briefing loaded: ${colors.dim("_sharkrc/briefing.md")}`);
     } else {
       tui.log.info(colors.dim("\u2139\uFE0F No briefing file found in _sharkrc/briefing.md. Starting in interactive mode."));
     }
   }
   let initialPrompt = "";
+  if (options.initialContext) {
+    initialPrompt += `
+\u26A0\uFE0F **CONTEXTO DE EXECU\xC7\xC3O ANTERIOR (HANDOVER)**:
+O Developer Agent estava executando tarefas. Aqui est\xE1 o resumo do que aconteceu at\xE9 agora:
+"""
+${options.initialContext}
+"""
+Analise esse hist\xF3rico acima. Se houve falha, proponha fixes na spec. Se o usu\xE1rio pediu mudan\xE7a, use isso como base.
+`;
+  }
   if (briefingContent) {
     initialPrompt += `
 Abaixo est\xE1 o **Briefing de Neg\xF3cio** ou Descri\xE7\xE3o da Tarefa.
@@ -1363,9 +1814,9 @@ ${result}
                     const BOM = "\uFEFF";
                     const contentToWrite = action.content || "";
                     const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-                    const dir = path5.dirname(action.path);
-                    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
-                    fs4.writeFileSync(action.path, finalContent, { encoding: "utf-8" });
+                    const dir = path6.dirname(action.path);
+                    if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+                    fs5.writeFileSync(action.path, finalContent, { encoding: "utf-8" });
                     tui.log.success(`\u2705 Created: ${action.path}`);
                     executionResults += `[Action create_file(${action.path})]: Success
 
@@ -1383,7 +1834,7 @@ ${result}
 `;
                     }
                   } else if (action.type === "delete_file") {
-                    fs4.unlinkSync(action.path);
+                    fs5.unlinkSync(action.path);
                     tui.log.success(`\u2705 Deleted: ${action.path}`);
                     executionResults += `[Action delete_file(${action.path})]: Success
 
@@ -1512,8 +1963,8 @@ async function callSpecAgentApi(prompt, onChunk, agentId) {
 import { Command as Command2 } from "commander";
 
 // src/core/agents/scan-agent.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 var AGENT_TYPE3 = "scan_agent";
 function getAgentId3() {
   const config = ConfigManager.getInstance().getConfig();
@@ -1528,29 +1979,29 @@ async function interactiveScanAgent(options = {}) {
   const projectRoot = process.cwd();
   let outputFile;
   if (options.output) {
-    outputFile = path6.resolve(process.cwd(), options.output);
+    outputFile = path7.resolve(process.cwd(), options.output);
   } else {
-    const outputDir = path6.resolve(projectRoot, "_sharkrc");
-    if (!fs5.existsSync(outputDir)) {
-      const stat = fs5.existsSync(outputDir) ? fs5.statSync(outputDir) : null;
+    const outputDir = path7.resolve(projectRoot, "_sharkrc");
+    if (!fs6.existsSync(outputDir)) {
+      const stat = fs6.existsSync(outputDir) ? fs6.statSync(outputDir) : null;
       if (stat && stat.isFile()) {
         tui.log.warning(`Warning: '_sharkrc' exists as a file. Using '_bmad/project-context' instead to avoid overwrite.`);
-        const fallbackDir = path6.resolve(projectRoot, "_bmad/project-context");
-        if (!fs5.existsSync(fallbackDir)) fs5.mkdirSync(fallbackDir, { recursive: true });
-        outputFile = path6.join(fallbackDir, "project-context.md");
+        const fallbackDir = path7.resolve(projectRoot, "_bmad/project-context");
+        if (!fs6.existsSync(fallbackDir)) fs6.mkdirSync(fallbackDir, { recursive: true });
+        outputFile = path7.join(fallbackDir, "project-context.md");
       } else {
-        fs5.mkdirSync(outputDir, { recursive: true });
-        outputFile = path6.join(outputDir, "project-context.md");
+        fs6.mkdirSync(outputDir, { recursive: true });
+        outputFile = path7.join(outputDir, "project-context.md");
       }
     } else {
-      fs5.mkdirSync(outputDir, { recursive: true });
-      outputFile = path6.join(outputDir, "project-context.md");
+      fs6.mkdirSync(outputDir, { recursive: true });
+      outputFile = path7.join(outputDir, "project-context.md");
     }
   }
   tui.log.info(`${t("commands.scan.scanningProject")} ${colors.bold(projectRoot)}`);
   tui.log.info(`${t("commands.scan.outputTarget")} ${colors.bold(outputFile)}`);
   tui.log.info(`${t("commands.scan.language")} ${colors.bold(language)}`);
-  const configFileRelative = path6.relative(projectRoot, outputFile);
+  const configFileRelative = path7.relative(projectRoot, outputFile);
   const initialTemplate = `# Project Context
 
 ## Overview
@@ -1583,9 +2034,9 @@ async function interactiveScanAgent(options = {}) {
 ## Key Patterns & Conventions
 [TO BE ANALYZED]
 `;
-  if (!fs5.existsSync(outputFile)) {
+  if (!fs6.existsSync(outputFile)) {
     const BOM = "\uFEFF";
-    fs5.writeFileSync(outputFile, BOM + initialTemplate, { encoding: "utf-8" });
+    fs6.writeFileSync(outputFile, BOM + initialTemplate, { encoding: "utf-8" });
     tui.log.success(`${t("commands.scan.templateCreated")} ${outputFile}`);
   } else {
     tui.log.info(t("commands.scan.fileExists"));
@@ -1883,11 +2334,11 @@ ${result}
 
 `;
           } else if (action.type === "create_file" || action.type === "modify_file") {
-            const resolvedActionPath = path6.resolve(action.path || "");
-            const resolvedTargetPath = path6.resolve(targetPath);
+            const resolvedActionPath = path7.resolve(action.path || "");
+            const resolvedTargetPath = path7.resolve(targetPath);
             let isTarget = resolvedActionPath === resolvedTargetPath;
-            if (!isTarget && path6.basename(action.path || "") === "project-context.md") {
-              tui.log.warning(t("commands.scan.targetRedirect").replace("{0}", action.path || "").replace("{1}", path6.relative(process.cwd(), targetPath)));
+            if (!isTarget && path7.basename(action.path || "") === "project-context.md") {
+              tui.log.warning(t("commands.scan.targetRedirect").replace("{0}", action.path || "").replace("{1}", path7.relative(process.cwd(), targetPath)));
               isTarget = true;
               action.path = targetPath;
             }
@@ -1897,16 +2348,16 @@ ${result}
               if (action.type === "create_file") {
                 const contentToWrite = action.content || "";
                 const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-                fs5.writeFileSync(finalPath, finalContent, { encoding: "utf-8" });
+                fs6.writeFileSync(finalPath, finalContent, { encoding: "utf-8" });
                 tui.log.success(t("commands.scan.generated").replace("{0}", finalPath));
                 fileCreated = true;
               } else {
-                if (fs5.existsSync(finalPath)) {
-                  const currentContent = fs5.readFileSync(finalPath, "utf-8");
+                if (fs6.existsSync(finalPath)) {
+                  const currentContent = fs6.readFileSync(finalPath, "utf-8");
                   if (action.target_content && currentContent.includes(action.target_content)) {
                     const newContent = currentContent.replace(action.target_content, action.content || "");
                     const finalContent = newContent.startsWith(BOM) ? newContent : BOM + newContent;
-                    fs5.writeFileSync(finalPath, finalContent, { encoding: "utf-8" });
+                    fs6.writeFileSync(finalPath, finalContent, { encoding: "utf-8" });
                     tui.log.success(t("commands.scan.updated").replace("{0}", finalPath));
                     fileCreated = true;
                   } else {
@@ -1935,7 +2386,7 @@ ${result}
           }
         }
         if (fileCreated) {
-          const currentContent = fs5.readFileSync(targetPath, "utf-8");
+          const currentContent = fs6.readFileSync(targetPath, "utf-8");
           const pendingSections = [];
           const lines = currentContent.split("\n");
           let currentSection = "";
@@ -2027,8 +2478,8 @@ var scanCommand = new Command2("scan").description("Analyze the project and gene
 import { Command as Command3 } from "commander";
 
 // src/core/agents/developer-agent.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 from "path";
 var AGENT_TYPE4 = "developer_agent";
 async function validateTypeScript(filePath) {
   try {
@@ -2041,32 +2492,6 @@ async function validateTypeScript(filePath) {
     return { valid: false, error: e.message || "TypeScript validation failed" };
   }
 }
-function validateHtmlTagBalance(filePath) {
-  const content = fs6.readFileSync(filePath, "utf-8");
-  const stack = [];
-  const tagRegex = /<\/?(\w+)(?:\s[^>]*)?\s*\/?>/g;
-  const selfClosingTags = ["br", "hr", "img", "input", "meta", "link", "area", "base", "col", "embed", "param", "source", "track", "wbr"];
-  let match;
-  while ((match = tagRegex.exec(content)) !== null) {
-    const fullTag = match[0];
-    const tagName = match[1].toLowerCase();
-    if (fullTag.startsWith("</")) {
-      const expected = stack.pop();
-      if (expected !== tagName) {
-        return {
-          valid: false,
-          error: `Tag mismatch: expected </${expected}> but found </${tagName}> at position ${match.index}`
-        };
-      }
-    } else if (!fullTag.endsWith("/>") && !selfClosingTags.includes(tagName)) {
-      stack.push(tagName);
-    }
-  }
-  if (stack.length > 0) {
-    return { valid: false, error: `Unclosed tags: <${stack.join(">, <")}>` };
-  }
-  return { valid: true };
-}
 function getAgentId4(overrideId) {
   if (overrideId) return overrideId;
   const config = ConfigManager.getInstance().getConfig();
@@ -2074,19 +2499,25 @@ function getAgentId4(overrideId) {
   if (process.env.STACKSPOT_DEV_AGENT_ID) return process.env.STACKSPOT_DEV_AGENT_ID;
   return "01KEQCGJ65YENRA4QBXVN1YFFX";
 }
-function analyzeSpecState(projectRoot) {
-  const specPath = path7.resolve(projectRoot, "tech-spec.md");
-  if (!fs6.existsSync(specPath)) {
-    return { status: "MISSING" };
+async function interactiveDeveloperAgent(options = {}) {
+  FileLogger.init();
+  const agentId = getAgentId4();
+  if (agentId === "PENDING_CONFIGURATION") {
+    tui.log.error("\u274C STACKSPOT_DEV_AGENT_ID not configured in .env");
+    return { success: false, summary: "Missing configuration." };
   }
-  const content = fs6.readFileSync(specPath, "utf-8");
-  const match = content.match(/- \[ \] (.*)/);
-  if (match) {
-    return { status: "PENDING", nextTask: match[1].trim(), specContent: content };
+  const projectRoot = process.cwd();
+  let contextContent = "";
+  const defaultContextPath = path8.resolve(projectRoot, "_sharkrc", "project-context.md");
+  const specificContextPath = options.context ? path8.resolve(projectRoot, options.context) : defaultContextPath;
+  if (fs7.existsSync(specificContextPath)) {
+    try {
+      contextContent = fs7.readFileSync(specificContextPath, "utf-8");
+    } catch (e) {
+      tui.log.warning(`Failed to read context file: ${e}`);
+    }
   }
-  return { status: "COMPLETED", specContent: content };
-}
-function buildSystemPrompt(state, contextContent, additionalInstructions = "") {
+  const currentTask = options.taskInstruction || "Analyze the project and fix pending issues.";
   let basePrompt = ``;
   if (contextContent) {
     basePrompt += `
@@ -2096,117 +2527,69 @@ ${contextContent}
 -----------------------
 `;
   }
-  if (state.status === "MISSING") {
+  if (options.history) {
     basePrompt += `
 
-\u{1F6A8} CRITICAL: NO 'tech-spec.md' FOUND.
-
-Your FIRST priority is to analyze the user request and CREATE a 'tech-spec.md' file.
-
-\u26A0\uFE0F WORKFLOW:
-1. **Understand**: Clarify the goal with the user if needed.
-2. **Explore**: Use 'list_files'/'read_file' to find RELEVANT files for this specific task.
-3. **Specify**: Create 'tech-spec.md' referencing REAL file paths you found.
-
-DO NOT create a spec based on guesses. Verify file existence before writing the plan.
-
-Structure for 'tech-spec.md':
-\`\`\`markdown
-# Technical Spec: [Title]
-
-## Goal
-[Brief description]
-
-## Implementation Plan
-- [ ] Step 1: [Description]
-- [ ] Step 2: [Description]
-...
-\`\`\`
-User Request: "${additionalInstructions}"
+--- PREVIOUS EXECUTION SUMMARY ---
+${options.history}
+----------------------------------
 `;
-  } else if (state.status === "PENDING") {
-    basePrompt += `
+  }
+  basePrompt += `
 
 \u{1F7E2} EXECUTION MODE
 
-Use 'tech-spec.md' as your source of truth.
-
-\u{1F449} **CURRENT TASK**: "${state.nextTask}"
-
+You are a highly skilled Developer Agent.
+\u{1F449} **CURRENT TASK**: "${currentTask}"
 
-Focus ONLY on this task. Do not jump ahead.
+Your goal is to COMPLETE this specific task and then STOP.
 1. Implement the necessary changes.
 2. Verify (compile/test).
-3. **MANDATORY**: Use 'modify_file' to mark this task as '[x]' in 'tech-spec.md' when done.
+3. **MANDATORY**: When you are confident the task is done, output a final message starting with "TASK_COMPLETED:" followed by a brief technical summary of what you did.
 `;
-  } else {
-    basePrompt += `
-
-\u2728 ALL TASKS COMPLETED according to 'tech-spec.md'.
-
-Ask the user if they want to add more tasks or finish the session.
-`;
-  }
-  return basePrompt;
-}
-async function interactiveDeveloperAgent(options = {}) {
-  FileLogger.init();
-  tui.intro("\u{1F988} Shark Dev Agent (Spec-Driven)");
-  const agentId = getAgentId4();
-  if (agentId === "PENDING_CONFIGURATION") {
-    tui.log.error("\u274C STACKSPOT_DEV_AGENT_ID not configured in .env");
-    return;
-  }
-  const projectRoot = process.cwd();
-  let contextContent = "";
-  const defaultContextPath = path7.resolve(projectRoot, "_sharkrc", "project-context.md");
-  const specificContextPath = options.context ? path7.resolve(projectRoot, options.context) : defaultContextPath;
-  if (fs6.existsSync(specificContextPath)) {
-    try {
-      contextContent = fs6.readFileSync(specificContextPath, "utf-8");
-      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path7.relative(projectRoot, specificContextPath))}`);
-    } catch (e) {
-      tui.log.warning(`Failed to read context file: ${e}`);
-    }
-  } else {
-    tui.log.warning(`\u26A0\uFE0F No context file found. Agent will run without pre-loaded context.`);
-  }
-  let specState = analyzeSpecState(projectRoot);
-  let nextPrompt = buildSystemPrompt(specState, contextContent, options.task || "Start working.");
+  let nextPrompt = basePrompt;
   let keepGoing = true;
   const spinner = tui.spinner();
-  let stepCount = 0;
+  let finalSummary = "";
+  let isTaskCompleted = false;
+  const conversationKey = options.taskId ? `dev_agent_${options.taskId}` : `dev_agent_${Date.now()}`;
   let autoApprovals = {
     files: false,
     commands: false
   };
   while (keepGoing) {
-    stepCount++;
     try {
-      if (specState.status === "PENDING") {
-        tui.log.info(colors.bold(`\u{1F3AF} DOING: ${specState.nextTask}`));
-      } else if (specState.status === "MISSING") {
-        tui.log.info(colors.warning(`\u{1F4CB} PLANNING: Creating tech-spec.md`));
-      }
-      spinner.start("Waiting for Shark Dev...");
-      let lastResponse = null;
-      await callDevAgentApi(nextPrompt, (chunk) => {
-      }).then((resp) => {
-        lastResponse = resp;
-      });
+      spinner.start("\u{1F988} Shark Dev working...");
+      const lastResponse = await callDevAgentApi(nextPrompt, (chunk) => {
+      }, conversationKey);
       spinner.stop("Response received");
-      if (lastResponse && lastResponse.actions) {
+      if (lastResponse) {
         const response = lastResponse;
+        const actions = response.actions || [];
+        if (response.message && response.message.includes("TASK_COMPLETED:")) {
+          isTaskCompleted = true;
+          finalSummary = response.message.split("TASK_COMPLETED:")[1].trim();
+          keepGoing = false;
+        }
+        if (actions.length === 0 && response.message && !isTaskCompleted) {
+          tui.log.info(colors.primary("\u{1F916} Shark Dev:"));
+          console.log(response.message);
+          const userReply = await tui.text({ message: "Your answer:" });
+          if (tui.isCancel(userReply)) {
+            keepGoing = false;
+            break;
+          }
+          nextPrompt = userReply;
+        }
         let executionResults = "";
         let waitingForUser = false;
-        let specUpdated = false;
-        for (const action of response.actions) {
+        for (const action of actions) {
           if (action.type === "talk_with_user") {
             tui.log.info(colors.primary("\u{1F916} Shark Dev:"));
             console.log(action.content);
-            waitingForUser = true;
+            if (!isTaskCompleted) waitingForUser = true;
           } else if (action.type === "list_files") {
-            tui.log.info(`\u{1F4C2} Scanning dir: ${colors.dim(action.path || ".")}`);
+            tui.log.info(`\u{1F4C2} Scanning: ${colors.dim(action.path || ".")}`);
             const result = handleListFiles(action.path || ".");
             executionResults += `[Action list_files(${action.path}) Result]:
 ${result}
@@ -2220,7 +2603,6 @@ ${result}
 
 `;
           } else if (action.type === "search_file") {
-            tui.log.info(`\u{1F50D} Searching: ${colors.dim(action.path || "")}`);
             const result = handleSearchFile(action.path || "");
             executionResults += `[Action search_file(${action.path}) Result]:
 ${result}
@@ -2229,26 +2611,16 @@ ${result}
           } else if (action.type === "run_command") {
             const cmd = action.command || "";
             tui.log.info(`\u{1F4BB} Executing: ${colors.dim(cmd)}`);
-            let approved = false;
-            if (autoApprovals.commands) {
-              approved = true;
-              tui.log.success(`\u26A1 Auto-Approved Command: ${cmd}`);
-            } else {
+            let approved = autoApprovals.commands;
+            if (!approved) {
               const choice = await tui.select({
                 message: `Execute: ${cmd}?`,
-                options: [
-                  { value: "yes", label: "Yes (Execute once)" },
-                  { value: "always", label: "Yes (Output & Auto-Approve Commands for Session)" },
-                  { value: "no", label: "No (Skip)" }
-                ]
+                options: [{ value: "yes", label: "Yes" }, { value: "always", label: "Yes (Auto-Approve Session)" }, { value: "no", label: "No" }]
               });
               if (choice === "always") {
                 autoApprovals.commands = true;
                 approved = true;
-                tui.log.success("\u26A1 COMMANDS Auto-Approval ENABLED for this session.");
-              } else if (choice === "yes") {
-                approved = true;
-              }
+              } else if (choice === "yes") approved = true;
             }
             if (approved) {
               const result = await handleRunCommand(cmd);
@@ -2262,302 +2634,159 @@ ${result}
 `;
             }
           } else if (["create_file", "modify_file"].includes(action.type)) {
-            const isCreate = action.type === "create_file";
             const filePath = action.path || "";
-            tui.log.warning(`
-\u{1F916} Agent wants to ${isCreate ? "CREATE" : "MODIFY"}: ${colors.bold(filePath)}`);
-            if (action.content) {
-              const preview = action.content.length > 500 ? action.content.substring(0, 500) + "... (truncated)" : action.content;
-              console.log(colors.dim("--- Content ---\n") + preview + "\n" + colors.dim("---------------"));
-            }
-            if (!isCreate && action.line_range && !action.confirmed) {
-              tui.log.info("\u{1F6E1}\uFE0F  Generation Preview for Agent Verification...");
-              const [start, end] = action.line_range;
-              const previewDiff = await generateFilePreview(filePath, start, end, action.content || "");
-              executionResults += `[Action modify_file]: PENDING CONFIRMATION.
-
-${previewDiff}
-
-`;
-              executionResults += `USER/SYSTEM INSTRUCTION: Please review the above preview carefully.
-1. If the context and changes look correct, call 'modify_file' again with the SAME parameters AND "confirmed": true.
-2. If the context is wrong (e.g. wrong line numbers), call 'read_file' to check line numbers again, then correct your request.
-
-`;
-              tui.log.warning("\u26A0\uFE0F  Sent Preview to Agent for confirmation first.");
-              waitingForUser = false;
-              continue;
-            }
-            let approved = false;
-            if (autoApprovals.files) {
-              approved = true;
-              tui.log.success(`\u26A1 Auto-Approved File Action: ${filePath}`);
-            } else {
+            tui.log.warning(`\u{1F4DD} ${action.type === "create_file" ? "CREATE" : "MODIFY"}: ${colors.bold(filePath)}`);
+            let approved = autoApprovals.files;
+            if (!approved) {
               const choice = await tui.select({
                 message: `Approve changes to ${filePath}?`,
-                options: [
-                  { value: "yes", label: "Yes (Approve once)" },
-                  { value: "always", label: "Yes (Approve & Auto-Approve FILES for Session)" },
-                  { value: "no", label: "No (Skip)" }
-                ]
+                options: [{ value: "yes", label: "Yes" }, { value: "always", label: "Yes (Auto-Approve Session)" }, { value: "no", label: "No" }]
               });
               if (choice === "always") {
                 autoApprovals.files = true;
                 approved = true;
-                tui.log.success("\u26A1 FILE ACTIONS Auto-Approval ENABLED for this session.");
-              } else if (choice === "yes") {
-                approved = true;
-              }
+              } else if (choice === "yes") approved = true;
             }
             if (approved) {
-              if (filePath) {
-                const targetPath = path7.resolve(projectRoot, filePath);
-                const dir = path7.dirname(targetPath);
-                if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
-                if (isCreate) {
-                  const BOM = "\uFEFF";
-                  const contentToWrite = action.content || "";
-                  const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-                  fs6.writeFileSync(targetPath, finalContent, { encoding: "utf-8" });
-                  tui.log.success(`\u2705 Created: ${filePath}`);
-                  executionResults += `[Action create_file(${filePath})]: Success
-
-`;
-                  if (filePath.endsWith("tech-spec.md")) specUpdated = true;
-                  const config = ConfigManager.getInstance().getConfig();
-                  const validationEnabled = config.validation?.enablePostSaveValidation ?? true;
-                  if (validationEnabled) {
-                    const ext = path7.extname(filePath);
-                    if ([".ts", ".tsx"].includes(ext)) {
-                      tui.log.info("\u{1F50D} Validating TypeScript...");
-                      const validation = await validateTypeScript(filePath);
-                      if (!validation.valid) {
-                        tui.log.error("\u274C TypeScript validation failed");
-                        executionResults += `
-[TYPESCRIPT VALIDATION FAILED]:
-${validation.error}
-
-`;
-                        executionResults += `CRITICAL: The file has been saved but contains errors. Read the file again to verify line numbers before attempting to fix. Do not guess line numbers.
-`;
-                      } else {
-                        tui.log.success("\u2705 TypeScript OK");
-                      }
-                    }
-                    if (ext === ".html") {
-                      tui.log.info("\u{1F50D} Validating HTML...");
-                      const validation = validateHtmlTagBalance(filePath);
-                      if (!validation.valid) {
-                        tui.log.error("\u274C HTML validation failed");
-                        executionResults += `
-[HTML VALIDATION FAILED]:
-${validation.error}
-
-`;
-                        executionResults += `CRITICAL: Fix these errors before proceeding to next task.
-`;
-                      } else {
-                        tui.log.success("\u2705 HTML OK");
-                      }
-                    }
-                  }
-                } else {
-                  let success = false;
-                  tui.log.info(`\u{1F50D} Debug modify_file: line_range=${JSON.stringify(action.line_range)}, type=${typeof action.line_range}, isArray=${Array.isArray(action.line_range)}`);
-                  if (action.line_range && Array.isArray(action.line_range) && action.line_range.length === 2) {
-                    const [start, end] = action.line_range;
-                    success = replaceLineRange(filePath, start, end, action.content || "", tui);
-                  } else if (action.target_content) {
-                    success = startSmartReplace(filePath, action.content || "", action.target_content, tui);
-                  } else {
-                    tui.log.error("\u274C Missing line_range (recommended) or target_content for modification.");
-                    executionResults += `[Action modify_file]: Failed. Missing line_range or target_content.
-
-`;
-                  }
-                  if (success) {
-                    executionResults += `[Action modify_file(${filePath})]: Success
+              if (action.type === "create_file") {
+                const dir = path8.dirname(path8.resolve(projectRoot, filePath));
+                if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
+                fs7.writeFileSync(path8.resolve(projectRoot, filePath), action.content || "", "utf-8");
+                executionResults += `[Action create_file]: Success
 
 `;
-                    if (filePath.endsWith("tech-spec.md")) specUpdated = true;
-                    const config = ConfigManager.getInstance().getConfig();
-                    const validationEnabled = config.validation?.enablePostSaveValidation ?? true;
-                    if (validationEnabled) {
-                      const ext = path7.extname(filePath);
-                      if ([".ts", ".tsx"].includes(ext)) {
-                        tui.log.info("\u{1F50D} Validating TypeScript...");
-                        const validation = await validateTypeScript(filePath);
-                        if (!validation.valid) {
-                          tui.log.error("\u274C TypeScript validation failed");
-                          executionResults += `
-[TYPESCRIPT VALIDATION FAILED]:
-${validation.error}
+              } else {
+                let success = false;
+                if (action.line_range) success = replaceLineRange(filePath, action.line_range[0], action.line_range[1], action.content || "", tui);
+                else if (action.target_content) success = startSmartReplace(filePath, action.content || "", action.target_content, tui);
+                executionResults += success ? `[Action modify_file]: Success
 
-`;
-                          executionResults += `CRITICAL: Fix these errors before proceeding to next task.
-`;
-                        } else {
-                          tui.log.success("\u2705 TypeScript OK");
-                        }
-                      }
-                      if (ext === ".html") {
-                        tui.log.info("\u{1F50D} Validating HTML...");
-                        const validation = validateHtmlTagBalance(filePath);
-                        if (!validation.valid) {
-                          tui.log.error("\u274C HTML validation failed");
-                          executionResults += `
-[HTML VALIDATION FAILED]:
-${validation.error}
+` : `[Action modify_file]: Failed
 
 `;
-                          executionResults += `CRITICAL: Fix these errors before proceeding to next task.
-`;
-                        } else {
-                          tui.log.success("\u2705 HTML OK");
-                        }
-                      }
-                    }
-                  } else if (!action.line_range && !action.target_content) {
-                  } else {
-                    executionResults += `[Action modify_file(${filePath})]: FAILED. Target content not found or ambiguous. Read the file again to ensure accuracy.
+              }
+              const val = await validateTypeScript(path8.resolve(projectRoot, filePath));
+              if (!val.valid) executionResults += `[Validation Failed]: ${val.error}
 
 `;
-                  }
-                }
-              }
             } else {
-              tui.log.error("\u274C Denied.");
               executionResults += `[Action ${action.type}]: User Denied.
 
 `;
             }
-          } else if (action.type === "search_ast") {
-            tui.log.info(`\u{1F50D} Searching AST: ${action.pattern} in ${action.file_path || action.path}`);
-            const result = await astGrepSearch(
-              action.pattern || "",
-              action.file_path || action.path || "",
-              action.language || "typescript",
-              // default TS
-              tui
-            );
-            executionResults += `[Action search_ast]:
+          } else if (action.type.startsWith("ast_")) {
+            try {
+              let result = "";
+              if (action.type === "ast_list_structure") {
+                result = await astListStructure(action.path || "");
+              } else if (action.type === "ast_get_method") {
+                result = await astGetMethod(action.path || "", action.class_name || "", action.method_name || "");
+              } else if (action.type === "ast_add_method") {
+                const success = await astAddMethod(action.path || "", action.class_name || "", action.method_code || "");
+                result = success ? "Method added successfully." : "Failed to add method.";
+              } else if (action.type === "ast_modify_method") {
+                const success = await astModifyMethod(action.path || "", action.class_name || "", action.method_name || "", action.new_body || "");
+                result = success ? "Method modified successfully." : "Failed to modify method.";
+              } else if (action.type === "ast_remove_method") {
+                const success = await astRemoveMethod(action.path || "", action.class_name || "", action.method_name || "");
+                result = success ? "Method removed successfully." : "Failed to remove method.";
+              } else if (action.type === "ast_add_class") {
+                const success = await astAddClass(action.path || "", action.class_name || "", action.extends_class || void 0, action.implements_interfaces || void 0);
+                result = success ? "Class added successfully." : "Failed to add class.";
+              } else if (action.type === "ast_add_property") {
+                const success = await astAddProperty(action.path || "", action.class_name || "", action.property_code || "");
+                result = success ? "Property added successfully." : "Failed to add property.";
+              } else if (action.type === "ast_remove_property") {
+                const success = await astRemoveProperty(action.path || "", action.class_name || "", action.property_name || "");
+                result = success ? "Property removed successfully." : "Failed to remove property.";
+              } else if (action.type === "ast_add_decorator") {
+                const success = await astAddDecorator(action.path || "", action.class_name || "", action.decorator_code || "");
+                result = success ? "Decorator added successfully." : "Failed to add decorator.";
+              } else if (action.type === "ast_add_interface") {
+                const success = await astAddInterface(action.path || "", action.interface_code || "");
+                result = success ? "Interface added successfully." : "Failed to add interface.";
+              } else if (action.type === "ast_add_type_alias") {
+                const success = await astAddTypeAlias(action.path || "", action.type_code || "");
+                result = success ? "Type alias added successfully." : "Failed to add type alias.";
+              } else if (action.type === "ast_add_function") {
+                const success = await astAddFunction(action.path || "", action.function_code || "");
+                result = success ? "Function added successfully." : "Failed to add function.";
+              } else if (action.type === "ast_remove_function") {
+                const success = await astRemoveFunction(action.path || "", action.function_name || "");
+                result = success ? "Function removed successfully." : "Failed to remove function.";
+              } else if (action.type === "ast_add_import") {
+                const success = await astAddImport(action.path || "", action.import_statement || "");
+                result = success ? "Import added successfully." : "Failed to add import.";
+              } else if (action.type === "ast_remove_import") {
+                const success = await astRemoveImport(action.path || "", action.module_path || "");
+                result = success ? "Import removed successfully." : "Failed to remove import.";
+              } else if (action.type === "ast_organize_imports") {
+                const success = await astOrganizeImports(action.path || "");
+                result = success ? "Imports organized successfully." : "Failed to organize imports.";
+              } else {
+                result = `Unknown AST action: ${action.type}`;
+              }
+              executionResults += `[Action ${action.type} Result]:
 ${result}
 
 `;
-          } else if (action.type === "modify_ast") {
-            const targetPath = action.file_path || action.path || "";
-            tui.log.step(`\u{1F504} [AST] Modifying: ${targetPath}`);
-            tui.log.info(`Pattern: ${colors.primary(action.pattern || "")}`);
-            tui.log.info(`Fix: ${colors.success(action.fix || "")}`);
-            const approved = await tui.confirm({ message: "Execute this AST modification?" });
-            if (approved) {
-              const success = await astGrepRewrite(
-                action.pattern || "",
-                action.fix || "",
-                targetPath,
-                action.language || "typescript",
-                tui
-              );
-              if (success) {
-                executionResults += `[Action modify_ast]: Success.
+              tui.log.info(`\u26A1 AST Action ${colors.dim(action.type)}: ${result}`);
+            } catch (e) {
+              executionResults += `[Action ${action.type} Failed]: ${e.message}
 
 `;
-                if (targetPath.endsWith("tech-spec.md")) specUpdated = true;
-                const ext = path7.extname(targetPath);
-                if ([".ts", ".tsx"].includes(ext)) {
-                  const validation = await validateTypeScript(targetPath);
-                  if (!validation.valid) {
-                    executionResults += `
-[TYPESCRIPT VALIDATION FAILED]:
-${validation.error}
+              tui.log.error(`\u274C AST Action Error: ${e.message}`);
+            }
+          } else if (action.type === "search_ast") {
+            const result = await astGrepSearch(action.pattern || "", action.path || "", action.language || "typescript", tui);
+            executionResults += `[Action search_ast Result]:
+${result}
 
 `;
-                  }
-                }
-              } else {
-                executionResults += `[Action modify_ast]: Failed. Check logs.
+          } else if (action.type === "modify_ast") {
+            const success = await astGrepRewrite(action.pattern || "", action.fix || "", action.path || "", action.language || "typescript", tui);
+            executionResults += success ? `[Action modify_ast]: Success
 
-`;
-              }
-            } else {
-              tui.log.error("\u274C Denied.");
-              executionResults += `[Action modify_ast]: User Denied.
+` : `[Action modify_ast]: Failed
 
 `;
-            }
           }
         }
-        const previousState = specState;
-        specState = analyzeSpecState(projectRoot);
-        let systemInjection = "";
         if (executionResults) {
-          if (previousState.status === "PENDING" && specState.status === "PENDING" && previousState.nextTask !== specState.nextTask) {
-            systemInjection = `
-\u{1F389} Task "${previousState.nextTask}" COMPLETED! Next up: "${specState.nextTask}".
-`;
-          } else if (previousState.status === "PENDING" && specState.status === "PENDING" && previousState.nextTask === specState.nextTask) {
-            if (!specUpdated && stepCount % 3 === 0) {
-              systemInjection = `
-Reminder: You are still working on "${specState.nextTask}". Don't forget to mark it [x] in 'tech-spec.md' when done.
-`;
-            }
-          } else if (previousState.status === "MISSING" && specState.status === "PENDING") {
-            systemInjection = `
-\u2705 Spec Created! Starting execution of: "${specState.nextTask}".
-`;
-          }
           if (waitingForUser) {
             const userReply = await tui.text({ message: "Your answer:" });
             if (tui.isCancel(userReply)) {
               keepGoing = false;
               break;
             }
-            nextPrompt = `${executionResults}${systemInjection}
+            nextPrompt = `${executionResults}
 User Reply: ${userReply}`;
           } else {
-            nextPrompt = `${executionResults}${systemInjection}
-[System]: Continue.`;
+            nextPrompt = `${executionResults}
+[System]: Continue execution. If finished, output "TASK_COMPLETED: summary".`;
             tui.log.info(colors.dim("Processing results..."));
           }
+        } else if (!keepGoing) {
         } else if (waitingForUser) {
-          const userReply = await tui.text({ message: "Your answer:" });
-          if (tui.isCancel(userReply)) {
-            keepGoing = false;
-            break;
-          }
-          nextPrompt = userReply;
         } else {
-          if (response.message) {
-            tui.log.info(colors.primary("\u{1F916} Shark Dev:"));
-            console.log(response.message);
-            const userReply = await tui.text({ message: "Your answer:" });
-            if (tui.isCancel(userReply)) {
-              keepGoing = false;
-            } else {
-              nextPrompt = userReply;
-            }
-          } else {
-            tui.log.warning("Agent took no actions and sent no message.");
-            nextPrompt = "Please proceed or ask for clarification.";
-          }
+          if (!isTaskCompleted && actions.length > 0) nextPrompt = "Please continue.";
         }
       } else {
-        tui.log.warning("Invalid response from agent (no actions).");
-        nextPrompt = "Error: No valid actions returned. Please try again with JSON format.";
+        tui.log.warning("No response received from agent.");
       }
     } catch (e) {
-      spinner.stop("Error");
       tui.log.error(e.message);
-      FileLogger.log("DEV_AGENT", "Main Loop Error", e);
       keepGoing = false;
+      return { success: false, summary: `Error: ${e.message}` };
     }
   }
-  tui.outro("\u{1F44B} Shark Dev Session Ended");
+  tui.log.success("\u2705 Task Scope Completed");
+  return { success: true, summary: finalSummary || "Task completed without summary." };
 }
-async function callDevAgentApi(prompt, onChunk) {
+async function callDevAgentApi(prompt, onChunk, conversationKey = AGENT_TYPE4) {
   const realm = await getActiveRealm();
   const token = await ensureValidToken(realm);
-  const conversationId = await conversationManager.getConversationId(AGENT_TYPE4);
+  const conversationId = await conversationManager.getConversationId(conversationKey);
   const payload = {
     user_prompt: prompt,
     streaming: true,
@@ -2586,22 +2815,248 @@ async function callDevAgentApi(prompt, onChunk) {
   });
   const parsed = parseAgentResponse(raw);
   if (parsed.conversation_id) {
-    await conversationManager.saveConversationId(AGENT_TYPE4, parsed.conversation_id);
+    await conversationManager.saveConversationId(conversationKey, parsed.conversation_id);
   }
   return parsed;
 }
 
+// src/core/workflow/task-manager.ts
+import fs8 from "fs";
+import path9 from "path";
+var TaskManager = class {
+  projectRoot;
+  specPath;
+  constructor(projectRoot = process.cwd()) {
+    this.projectRoot = projectRoot;
+    this.specPath = path9.resolve(this.projectRoot, "tech-spec.md");
+  }
+  /**
+   * Reads the tech-spec.md file and analyzes its current state.
+   */
+  analyzeSpecState() {
+    if (!fs8.existsSync(this.specPath)) {
+      return { status: "MISSING", allTasks: [] };
+    }
+    const content = fs8.readFileSync(this.specPath, "utf-8");
+    const lines = content.split("\n");
+    const tasks = [];
+    let taskIndex = 1;
+    lines.forEach((line, index) => {
+      const trimmed = line.trim();
+      const pendingMatch = trimmed.match(/^- \[ \] (.*)/);
+      const completedMatch = trimmed.match(/^- \[x\] (.*)/i);
+      const progressMatch = trimmed.match(/^- \[\/\] (.*)/);
+      if (pendingMatch) {
+        tasks.push({
+          id: `task-${taskIndex++}`,
+          description: pendingMatch[1].trim(),
+          status: "PENDING",
+          line_number: index
+        });
+      } else if (completedMatch) {
+        tasks.push({
+          id: `task-${taskIndex++}`,
+          description: completedMatch[1].trim(),
+          status: "COMPLETED",
+          line_number: index
+        });
+      } else if (progressMatch) {
+        tasks.push({
+          id: `task-${taskIndex++}`,
+          description: progressMatch[1].trim(),
+          status: "IN_PROGRESS",
+          line_number: index
+        });
+      }
+    });
+    let nextTask = tasks.find((t2) => t2.status === "IN_PROGRESS");
+    if (!nextTask) {
+      nextTask = tasks.find((t2) => t2.status === "PENDING");
+    }
+    const status = !nextTask && tasks.length > 0 && tasks.every((t2) => t2.status === "COMPLETED") ? "COMPLETED" : "PENDING";
+    return {
+      status: tasks.length === 0 ? "MISSING" : status,
+      // Empty file is effectively "pending creation" but we treat as missing content logic elsewhere
+      nextTask,
+      allTasks: tasks
+    };
+  }
+  /**
+   * Marks a specific task as COMPLETED in the file.
+   * Uses line-based replacement to be safe.
+   */
+  markTaskAsDone(taskId) {
+    const state = this.analyzeSpecState();
+    const task = state.allTasks.find((t2) => t2.id === taskId);
+    if (!task) {
+      console.error(`Task ${taskId} not found.`);
+      return false;
+    }
+    const content = fs8.readFileSync(this.specPath, "utf-8");
+    const lines = content.split("\n");
+    const targetLine = lines[task.line_number];
+    if (!targetLine.includes(task.description)) {
+      console.error(`Concurrency Error: Task line content mistmatch. Expected "${task.description}" at line ${task.line_number}.`);
+      return false;
+    }
+    const newLine = targetLine.replace("- [ ]", "- [x]").replace("- [/]", "- [x]");
+    lines[task.line_number] = newLine;
+    fs8.writeFileSync(this.specPath, lines.join("\n"), "utf-8");
+    return true;
+  }
+  /**
+   * Marks a task as IN_PROGRESS.
+   */
+  markTaskInProgress(taskId) {
+    const state = this.analyzeSpecState();
+    const task = state.allTasks.find((t2) => t2.id === taskId);
+    if (!task) return false;
+    const content = fs8.readFileSync(this.specPath, "utf-8");
+    const lines = content.split("\n");
+    let targetLine = lines[task.line_number];
+    targetLine = targetLine.replace("- [ ]", "- [/]");
+    lines[task.line_number] = targetLine;
+    fs8.writeFileSync(this.specPath, lines.join("\n"), "utf-8");
+    return true;
+  }
+  /**
+   * Completely updates the spec file content (used by Spec Agent).
+   */
+  updateSpecContent(newContent) {
+    fs8.writeFileSync(this.specPath, newContent, "utf-8");
+  }
+  getSpecPath() {
+    return this.specPath;
+  }
+};
+
 // src/commands/dev.ts
-var devCommand = new Command3("dev").description("Starts the Shark Developer Agent (Shark Dev)").option("-t, --task <type>", "Initial task description").option("-c, --context <path>", "Path to custom context file").action(async (options) => {
-  await interactiveDeveloperAgent(options);
+var devCommand = new Command3("dev").description("Starts the Shark Developer Agent (Shark Dev Orchestration V2)").option("-t, --task <type>", "Initial task description (Quick Mode)").option("-c, --context <path>", "Path to custom context file").action(async (options) => {
+  const taskManager = new TaskManager(process.cwd());
+  let state = taskManager.analyzeSpecState();
+  if (state.status === "MISSING") {
+    tui.log.warning("\u{1F4CB} No tech-spec.md found.");
+    const confirm = await tui.confirm({ message: "Create a new Specification (Tech Spec)?" });
+    if (confirm) {
+      await interactiveSpecificationAgent({
+        briefingPath: options.task ? void 0 : void 0
+        // If task provided, maybe write a temp briefing? For now standard flow.
+      });
+      state = taskManager.analyzeSpecState();
+      if (state.status === "MISSING") {
+        tui.log.error("\u274C Spec creation aborted or failed.");
+        return;
+      }
+    } else {
+      return;
+    }
+  }
+  let keepOrchestrating = true;
+  let burnMode = false;
+  let contextHistory = "";
+  tui.intro("\u{1F988} Shark Orchestrator V2");
+  while (keepOrchestrating) {
+    state = taskManager.analyzeSpecState();
+    if (state.status === "COMPLETED") {
+      tui.log.success("\u{1F389} All tasks in tech-spec.md are COMPLETED!");
+      const choice = await tui.select({
+        message: "What next?",
+        options: [
+          { value: "exit", label: "Exit" },
+          { value: "new_spec", label: "New Specification (Reset)" }
+        ]
+      });
+      if (choice === "new_spec") {
+        await interactiveSpecificationAgent();
+        contextHistory = "";
+        continue;
+      } else {
+        keepOrchestrating = false;
+        break;
+      }
+    }
+    const currentTask = state.nextTask;
+    if (!currentTask) {
+      tui.log.error("Something went wrong. Status is not completed but no next task found.");
+      break;
+    }
+    tui.log.info(`
+\u{1F449} **NEXT TASK**: ${colors.bold(currentTask.description)}`);
+    if (!burnMode) {
+      const action = await tui.select({
+        message: "Orchestration Checkpoint:",
+        options: [
+          { value: "execute", label: "\u{1F680} Execute Task (Start)" },
+          { value: "burn", label: "\u{1F525} Burn Mode (Auto-Execute Remaining)" },
+          { value: "pivot", label: "\u{1F527} Pivot/Correct (Edit Spec)" },
+          { value: "skip", label: "\u23ED\uFE0F Skip Task (Mark Done without Executing)" },
+          { value: "stop", label: "\u{1F6D1} Stop Session" }
+        ]
+      });
+      if (action === "stop") {
+        keepOrchestrating = false;
+        break;
+      } else if (action === "burn") {
+        burnMode = true;
+      } else if (action === "skip") {
+        taskManager.markTaskAsDone(currentTask.id);
+        tui.log.info("Task skipped.");
+        continue;
+      } else if (action === "pivot") {
+        tui.log.info("Transferring control to Specification Agent...");
+        await interactiveSpecificationAgent({
+          initialContext: `User requested pivot after tasks:
+${contextHistory}`
+        });
+        continue;
+      }
+    }
+    taskManager.markTaskInProgress(currentTask.id);
+    tui.log.info(`\u26A1 Starting Micro-Context for Task: "${currentTask.description}"`);
+    const result = await interactiveDeveloperAgent({
+      taskId: currentTask.id,
+      taskInstruction: currentTask.description,
+      history: contextHistory,
+      context: options.context
+    });
+    if (result.success) {
+      tui.log.success(`\u2705 Task Completed: ${currentTask.description}`);
+      taskManager.markTaskAsDone(currentTask.id);
+      contextHistory += `
+[Task "${currentTask.description}" completed]: ${result.summary}`;
+    } else {
+      tui.log.error(`\u274C Task Failed: ${result.summary}`);
+      burnMode = false;
+      const recovery = await tui.select({
+        message: "Task Failed. Recovery Action:",
+        options: [
+          { value: "retry", label: "Retry (Run Agent Again)" },
+          { value: "pivot", label: "Pivot (Adjust Spec/Instructions)" },
+          { value: "ignore", label: "Ignore (Mark Done anyway)" },
+          { value: "stop", label: "Stop" }
+        ]
+      });
+      if (recovery === "stop") break;
+      if (recovery === "ignore") taskManager.markTaskAsDone(currentTask.id);
+      if (recovery === "pivot") {
+        await interactiveSpecificationAgent({
+          initialContext: `Task "${currentTask.description}" FAILED.
+Error: ${result.summary}
+History:
+${contextHistory}`
+        });
+      }
+    }
+  }
+  tui.outro("\u{1F988} Orchestration Finished.");
 });
 
 // src/commands/qa.ts
 import { Command as Command4 } from "commander";
 
 // src/core/agents/qa-agent.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path10 from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 var AGENT_TYPE5 = "qa_agent";
@@ -2670,9 +3125,9 @@ async function runQAAgent(options) {
   }
   let projectContext = "";
   try {
-    const contextPath = path8.join(process.cwd(), "_sharkrc", "project-context.md");
-    if (fs7.existsSync(contextPath)) {
-      projectContext = fs7.readFileSync(contextPath, "utf-8");
+    const contextPath = path10.join(process.cwd(), "_sharkrc", "project-context.md");
+    if (fs9.existsSync(contextPath)) {
+      projectContext = fs9.readFileSync(contextPath, "utf-8");
       tui.log.info(`\u{1F4D8} Context loaded from: _sharkrc/project-context.md`);
     }
   } catch (e) {
@@ -2781,11 +3236,11 @@ ${projectContext}
             break;
           case "create_file":
             if (action.path && action.content) {
-              const fullPath = path8.resolve(process.cwd(), action.path);
+              const fullPath = path10.resolve(process.cwd(), action.path);
               const BOM = "\uFEFF";
               const contentToWrite = action.content;
               const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-              fs7.writeFileSync(fullPath, finalContent, { encoding: "utf-8" });
+              fs9.writeFileSync(fullPath, finalContent, { encoding: "utf-8" });
               tui.log.success(`File created: ${action.path}`);
               result = "File created successfully.";
             }