shark-ai 0.4.0 → 0.4.1

package/dist/bin/shark.js

@@ -420,17 +420,17 @@ 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",
+    "read_file",
+    "delete_file",
+    "list_structure",
+    "modify_ast",
+    "search_ast",
     "run_command",
-    "use_mcp_tool",
-    // New AST Tools
+    "talk_with_user",
     "ast_list_structure",
+    "ast_get_method",
     "ast_add_method",
     "ast_modify_method",
     "ast_remove_method",
@@ -831,11 +831,11 @@ async function interactiveBusinessAnalyst() {
 
 // src/core/agents/specification-agent.ts
 import fs5 from "fs";
-import path7 from "path";
+import path6 from "path";
 
 // src/core/agents/agent-tools.ts
 import fs4 from "fs";
-import path6 from "path";
+import path5 from "path";
 import fg from "fast-glob";
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -1086,6 +1086,20 @@ var TypeScriptEditor = class {
       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
   // ═══════════════════════════════════════════════════════
@@ -1226,134 +1240,6 @@ var CodeEditorFactory = class {
   }
 };
 
-// src/core/services/code-review.service.ts
-import path5 from "path";
-var CodeReviewService = class {
-  /**
-   * 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.
-   */
-  static async reviewCode(filePath, newContent) {
-    const config = ConfigManager.getInstance().getConfig();
-    const validation = config.validation || { llmReviewExtensions: [".ts", ".tsx"], syntaxCheckExtensions: ["*"] };
-    const ext = path5.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);
-    }
-    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: ${path5.basename(filePath)}
-
-NEW CODE TO BE ADDED:
-\`\`\`
-${content}
-\`\`\`
-
-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}`;
-      }
-    } 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);
-    }
-  }
-  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}
-`;
-        }
-      }
-    }
-    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).
-`;
-    }
-    return Promise.resolve(report);
-  }
-};
-
 // src/core/agents/agent-tools.ts
 var execAsync = promisify(exec);
 function detectLineEnding(content) {
@@ -1363,7 +1249,7 @@ function detectLineEnding(content) {
 }
 function handleListFiles(dirPath) {
   try {
-    const fullPath = path6.resolve(process.cwd(), dirPath);
+    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) => {
@@ -1375,7 +1261,7 @@ function handleListFiles(dirPath) {
 }
 function handleReadFile(filePath, showLineNumbers = true) {
   try {
-    const fullPath = path6.resolve(process.cwd(), filePath);
+    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.`;
@@ -1421,47 +1307,6 @@ function replaceLineRange(filePath, startLine, endLine, newContent, tui2) {
     return false;
   }
 }
-async function generateFilePreview(filePath, startLine, endLine, newContent) {
-  try {
-    const fullPath = path6.resolve(process.cwd(), filePath);
-    if (!fs4.existsSync(fullPath)) return `Error: File ${filePath} does not exist.`;
-    const content = fs4.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 });
@@ -1549,19 +1394,19 @@ function resolveAstGrepCommand() {
   const binName = isWin ? "sg.cmd" : "sg";
   try {
     const currentFile = fileURLToPath(import.meta.url);
-    let dir = path6.dirname(currentFile);
+    let dir = path5.dirname(currentFile);
     for (let i = 0; i < 5; i++) {
-      const candidate = path6.join(dir, "node_modules", ".bin", binName);
+      const candidate = path5.join(dir, "node_modules", ".bin", binName);
       if (fs4.existsSync(candidate)) {
         return `"${candidate}"`;
       }
-      const parent = path6.dirname(dir);
+      const parent = path5.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
   } catch (e) {
   }
-  const cwdBin = path6.resolve(process.cwd(), "node_modules", ".bin", binName);
+  const cwdBin = path5.resolve(process.cwd(), "node_modules", ".bin", binName);
   if (fs4.existsSync(cwdBin)) {
     return `"${cwdBin}"`;
   }
@@ -1733,9 +1578,22 @@ async function astListStructure(filePath) {
 }
 async function astAddMethod(filePath, className, methodCode) {
   const editor = CodeEditorFactory.getEditor(filePath);
-  if (!editor) throw new Error(`AST editing not supported for: ${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}`);
@@ -1815,11 +1673,11 @@ async function interactiveSpecificationAgent(options = {}) {
   tui.intro("\u{1F3D7}\uFE0F  Specification Agent");
   const projectRoot = process.cwd();
   let contextContent = "";
-  const contextPath = path7.resolve(projectRoot, "_sharkrc", "project-context.md");
+  const contextPath = path6.resolve(projectRoot, "_sharkrc", "project-context.md");
   if (fs5.existsSync(contextPath)) {
     try {
       contextContent = fs5.readFileSync(contextPath, "utf-8");
-      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path7.relative(projectRoot, contextPath))}`);
+      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}`);
     }
@@ -1829,7 +1687,7 @@ async function interactiveSpecificationAgent(options = {}) {
     briefingContent = fs5.readFileSync(options.briefingPath, "utf-8");
     tui.log.info(`\u{1F4C4} Briefing loaded from: ${colors.dim(options.briefingPath)}`);
   } else {
-    const sharkRcBriefing = path7.resolve(projectRoot, "_sharkrc", "briefing.md");
+    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")}`);
@@ -1838,6 +1696,16 @@ async function interactiveSpecificationAgent(options = {}) {
     }
   }
   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.
@@ -1946,7 +1814,7 @@ ${result}
                     const BOM = "\uFEFF";
                     const contentToWrite = action.content || "";
                     const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-                    const dir = path7.dirname(action.path);
+                    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}`);
@@ -2096,7 +1964,7 @@ import { Command as Command2 } from "commander";
 
 // src/core/agents/scan-agent.ts
 import fs6 from "fs";
-import path8 from "path";
+import path7 from "path";
 var AGENT_TYPE3 = "scan_agent";
 function getAgentId3() {
   const config = ConfigManager.getInstance().getConfig();
@@ -2111,29 +1979,29 @@ async function interactiveScanAgent(options = {}) {
   const projectRoot = process.cwd();
   let outputFile;
   if (options.output) {
-    outputFile = path8.resolve(process.cwd(), options.output);
+    outputFile = path7.resolve(process.cwd(), options.output);
   } else {
-    const outputDir = path8.resolve(projectRoot, "_sharkrc");
+    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 = path8.resolve(projectRoot, "_bmad/project-context");
+        const fallbackDir = path7.resolve(projectRoot, "_bmad/project-context");
         if (!fs6.existsSync(fallbackDir)) fs6.mkdirSync(fallbackDir, { recursive: true });
-        outputFile = path8.join(fallbackDir, "project-context.md");
+        outputFile = path7.join(fallbackDir, "project-context.md");
       } else {
         fs6.mkdirSync(outputDir, { recursive: true });
-        outputFile = path8.join(outputDir, "project-context.md");
+        outputFile = path7.join(outputDir, "project-context.md");
       }
     } else {
       fs6.mkdirSync(outputDir, { recursive: true });
-      outputFile = path8.join(outputDir, "project-context.md");
+      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 = path8.relative(projectRoot, outputFile);
+  const configFileRelative = path7.relative(projectRoot, outputFile);
   const initialTemplate = `# Project Context
 
 ## Overview
@@ -2466,11 +2334,11 @@ ${result}
 
 `;
           } else if (action.type === "create_file" || action.type === "modify_file") {
-            const resolvedActionPath = path8.resolve(action.path || "");
-            const resolvedTargetPath = path8.resolve(targetPath);
+            const resolvedActionPath = path7.resolve(action.path || "");
+            const resolvedTargetPath = path7.resolve(targetPath);
             let isTarget = resolvedActionPath === resolvedTargetPath;
-            if (!isTarget && path8.basename(action.path || "") === "project-context.md") {
-              tui.log.warning(t("commands.scan.targetRedirect").replace("{0}", action.path || "").replace("{1}", path8.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;
             }
@@ -2611,7 +2479,7 @@ import { Command as Command3 } from "commander";
 
 // src/core/agents/developer-agent.ts
 import fs7 from "fs";
-import path9 from "path";
+import path8 from "path";
 var AGENT_TYPE4 = "developer_agent";
 async function validateTypeScript(filePath) {
   try {
@@ -2624,32 +2492,6 @@ async function validateTypeScript(filePath) {
     return { valid: false, error: e.message || "TypeScript validation failed" };
   }
 }
-function validateHtmlTagBalance(filePath) {
-  const content = fs7.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();
@@ -2657,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 = path9.resolve(projectRoot, "tech-spec.md");
-  if (!fs7.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 = fs7.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 += `
@@ -2679,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.
+You are a highly skilled Developer Agent.
+\u{1F449} **CURRENT TASK**: "${currentTask}"
 
-\u{1F449} **CURRENT TASK**: "${state.nextTask}"
-
-
-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.
-`;
-  } 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.
+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.
 `;
-  }
-  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 = path9.resolve(projectRoot, "_sharkrc", "project-context.md");
-  const specificContextPath = options.context ? path9.resolve(projectRoot, options.context) : defaultContextPath;
-  if (fs7.existsSync(specificContextPath)) {
-    try {
-      contextContent = fs7.readFileSync(specificContextPath, "utf-8");
-      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path9.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}
@@ -2803,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}
@@ -2812,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);
@@ -2845,417 +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 = path9.resolve(projectRoot, filePath);
-                const dir = path9.dirname(targetPath);
+              if (action.type === "create_file") {
+                const dir = path8.dirname(path8.resolve(projectRoot, filePath));
                 if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
-                if (isCreate) {
-                  const BOM = "\uFEFF";
-                  const contentToWrite = action.content || "";
-                  const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-                  fs7.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 = path9.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.
+                fs7.writeFileSync(path8.resolve(projectRoot, filePath), action.content || "", "utf-8");
+                executionResults += `[Action create_file]: Success
 
 `;
-                  }
-                  if (success) {
-                    executionResults += `[Action modify_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 = path9.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.
-
-`;
-                  }
-                }
               }
-            } else {
-              tui.log.error("\u274C Denied.");
-              executionResults += `[Action ${action.type}]: User Denied.
+              const val = await validateTypeScript(path8.resolve(projectRoot, filePath));
+              if (!val.valid) executionResults += `[Validation Failed]: ${val.error}
 
 `;
-            }
-          } 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]:
-${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.
-
-`;
-                if (targetPath.endsWith("tech-spec.md")) specUpdated = true;
-                const ext = path9.extname(targetPath);
-                if ([".ts", ".tsx"].includes(ext)) {
-                  const validation = await validateTypeScript(targetPath);
-                  if (!validation.valid) {
-                    executionResults += `
-[TYPESCRIPT VALIDATION FAILED]:
-${validation.error}
-
-`;
-                  }
-                }
-              } else {
-                executionResults += `[Action modify_ast]: Failed. Check logs.
-
-`;
-              }
             } else {
-              tui.log.error("\u274C Denied.");
-              executionResults += `[Action modify_ast]: User Denied.
+              executionResults += `[Action ${action.type}]: User Denied.
 
 `;
             }
           } else if (action.type.startsWith("ast_")) {
-            const targetPath = action.file_path || action.path || "";
-            tui.log.info(`\u{1F527} [AST] Action: ${colors.bold(action.type)} on ${targetPath}`);
-            if (action.type === "ast_list_structure") {
-              const result = await astListStructure(targetPath);
-              executionResults += `[Action ast_list_structure]:
-${result}
-
-`;
-            } else {
-              let approved = false;
-              if (autoApprovals.files) {
-                approved = true;
-                tui.log.success(`\u26A1 Auto-Approved AST Action: ${action.type}`);
+            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 {
-                const choice = await tui.select({
-                  message: `Execute ${action.type} on ${targetPath}?`,
-                  options: [
-                    { value: "yes", label: "Yes" },
-                    { value: "always", label: "Yes (Auto-Approve ALL Files)" },
-                    { 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;
-                }
+                result = `Unknown AST action: ${action.type}`;
               }
-              if (approved) {
-                try {
-                  let success = false;
-                  switch (action.type) {
-                    case "ast_add_class":
-                      success = await astAddClass(targetPath, action.class_name || "", action.extends_class || void 0, action.implements_interfaces || void 0);
-                      break;
-                    case "ast_add_method":
-                      success = await astAddMethod(targetPath, action.class_name || "", action.method_code || "");
-                      break;
-                    case "ast_add_property":
-                      success = await astAddProperty(targetPath, action.class_name || "", action.property_code || "");
-                      break;
-                    case "ast_remove_property":
-                      success = await astRemoveProperty(targetPath, action.class_name || "", action.property_name || "");
-                      break;
-                    case "ast_modify_method":
-                      success = await astModifyMethod(targetPath, action.class_name || "", action.method_name || "", action.new_body || "");
-                      break;
-                    case "ast_remove_method":
-                      success = await astRemoveMethod(targetPath, action.class_name || "", action.method_name || "");
-                      break;
-                    case "ast_add_decorator":
-                      success = await astAddDecorator(targetPath, action.class_name || "", action.decorator_code || "");
-                      break;
-                    case "ast_add_interface":
-                      success = await astAddInterface(targetPath, action.interface_code || "");
-                      break;
-                    case "ast_add_type_alias":
-                      success = await astAddTypeAlias(targetPath, action.type_code || "");
-                      break;
-                    case "ast_add_function":
-                      success = await astAddFunction(targetPath, action.function_code || "");
-                      break;
-                    case "ast_remove_function":
-                      success = await astRemoveFunction(targetPath, action.function_name || "");
-                      break;
-                    case "ast_add_import":
-                      success = await astAddImport(targetPath, action.import_statement || "");
-                      break;
-                    case "ast_remove_import":
-                      success = await astRemoveImport(targetPath, action.module_path || "");
-                      break;
-                    case "ast_organize_imports":
-                      success = await astOrganizeImports(targetPath);
-                      break;
-                  }
-                  if (success) {
-                    executionResults += `[Action ${action.type}]: Success
+              executionResults += `[Action ${action.type} Result]:
+${result}
 
 `;
-                    const config = ConfigManager.getInstance().getConfig();
-                    const validationEnabled = config.validation?.enablePostSaveValidation ?? true;
-                    if (validationEnabled) {
-                      const ext = path9.extname(targetPath);
-                      if ([".ts", ".tsx"].includes(ext)) {
-                        const validation = await validateTypeScript(targetPath);
-                        if (!validation.valid) {
-                          executionResults += `
-[TYPESCRIPT VALIDATION FAILED]:
-${validation.error}
+              tui.log.info(`\u26A1 AST Action ${colors.dim(action.type)}: ${result}`);
+            } catch (e) {
+              executionResults += `[Action ${action.type} Failed]: ${e.message}
 
 `;
-                        } else {
-                          tui.log.success("\u2705 TypeScript OK");
-                        }
-                      }
-                    }
-                  } else {
-                    executionResults += `[Action ${action.type}]: Failed (internal editor returned false).
+              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}
 
 `;
-                  }
-                } catch (e) {
-                  executionResults += `[Action ${action.type}]: Exception: ${e.message}
+          } 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 {
-                executionResults += `[Action ${action.type}]: 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,
@@ -3284,21 +2815,247 @@ 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 fs8 from "fs";
+import fs9 from "fs";
 import path10 from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -3369,8 +3126,8 @@ async function runQAAgent(options) {
   let projectContext = "";
   try {
     const contextPath = path10.join(process.cwd(), "_sharkrc", "project-context.md");
-    if (fs8.existsSync(contextPath)) {
-      projectContext = fs8.readFileSync(contextPath, "utf-8");
+    if (fs9.existsSync(contextPath)) {
+      projectContext = fs9.readFileSync(contextPath, "utf-8");
       tui.log.info(`\u{1F4D8} Context loaded from: _sharkrc/project-context.md`);
     }
   } catch (e) {
@@ -3483,7 +3240,7 @@ ${projectContext}
               const BOM = "\uFEFF";
               const contentToWrite = action.content;
               const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-              fs8.writeFileSync(fullPath, finalContent, { encoding: "utf-8" });
+              fs9.writeFileSync(fullPath, finalContent, { encoding: "utf-8" });
               tui.log.success(`File created: ${action.path}`);
               result = "File created successfully.";
             }