shark-ai 0.4.15 → 0.4.17

package/dist/bin/shark.js

@@ -1,15 +1,49 @@
 #!/usr/bin/env node
+import {
+  configCommand,
+  loginCommand
+} from "../chunk-JLE7NOEG.js";
+import {
+  AGENT_RESPONSE_JSON_SCHEMA,
+  ProviderResolver,
+  TechStackEnum,
+  astAddClass,
+  astAddDecorator,
+  astAddFunction,
+  astAddImport,
+  astAddInterface,
+  astAddMethod,
+  astAddProperty,
+  astAddTypeAlias,
+  astGetMethod,
+  astGetProperty,
+  astGrepRewrite,
+  astGrepSearch,
+  astListStructure,
+  astModifyMethod,
+  astModifyProperty,
+  astOrganizeImports,
+  astRemoveFunction,
+  astRemoveImport,
+  astRemoveMethod,
+  astRemoveProperty,
+  conversationManager,
+  handleListFiles,
+  handleReadFile,
+  handleRunCommand,
+  handleSearchCode,
+  handleSearchFile,
+  interactiveDeveloperAgent,
+  replaceLineRange,
+  startSmartReplace,
+  workflowManager
+} from "../chunk-T3DPAQAV.js";
 import {
   ConfigManager,
   FileLogger,
-  authenticate,
   colors,
-  configCommand,
-  loginCommand,
-  t,
-  tokenStorage,
   tui
-} from "../chunk-H6S7DYRG.js";
+} from "../chunk-CUUMQTCW.js";
 
 // src/core/error/crash-handler.ts
 import fs from "fs";
@@ -68,123 +102,10 @@ Node: ${process.version}
 var crashHandler = CrashHandler.getInstance();
 
 // src/bin/shark.ts
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 
 // src/commands/init.ts
 import { Command } from "commander";
-
-// src/core/workflow/workflow-manager.ts
-import fs2 from "fs/promises";
-import path2 from "path";
-
-// src/core/workflow/shark-workflow.schema.ts
-import { z } from "zod";
-var TechStackEnum = z.enum([
-  "react",
-  "nextjs",
-  "angular",
-  "vue",
-  "node-ts",
-  "python",
-  "dotnet",
-  "java",
-  "unknown"
-]);
-var WorkflowStageEnum = z.enum([
-  "business_analysis",
-  "specification",
-  "architecture",
-  "development",
-  "verification",
-  "deployment"
-]);
-var StageStatusEnum = z.enum([
-  "pending",
-  "in_progress",
-  "completed",
-  "failed",
-  "skipped"
-]);
-var WorkflowSchema = z.object({
-  projectId: z.string().uuid(),
-  projectName: z.string().min(1),
-  techStack: TechStackEnum.default("unknown"),
-  currentStage: WorkflowStageEnum.default("business_analysis"),
-  stageStatus: StageStatusEnum.default("pending"),
-  lastUpdated: z.string().datetime(),
-  // ISO 8601
-  conversationId: z.string().optional(),
-  conversations: z.record(z.string(), z.string()).optional(),
-  // agentType -> conversationId
-  artifacts: z.array(z.string()).default([]),
-  // Extensible metadata bag
-  metadata: z.record(z.unknown()).optional()
-});
-
-// src/core/workflow/workflow-manager.ts
-var WorkflowManager = class _WorkflowManager {
-  static instance;
-  filename = "shark-workflow.json";
-  tmpFilename = ".shark-workflow.tmp";
-  constructor() {
-  }
-  static getInstance() {
-    if (!_WorkflowManager.instance) {
-      _WorkflowManager.instance = new _WorkflowManager();
-    }
-    return _WorkflowManager.instance;
-  }
-  getFilePath() {
-    return path2.join(process.cwd(), this.filename);
-  }
-  getTmpFilePath() {
-    return path2.join(process.cwd(), this.tmpFilename);
-  }
-  async save(state) {
-    const parsed = WorkflowSchema.safeParse(state);
-    if (!parsed.success) {
-      throw new Error(`Invalid workflow state: ${parsed.error.message}`);
-    }
-    const filePath = this.getFilePath();
-    const tmpPath = this.getTmpFilePath();
-    const data = JSON.stringify(parsed.data, null, 2);
-    try {
-      await fs2.writeFile(tmpPath, data, "utf-8");
-      await fs2.rename(tmpPath, filePath);
-    } catch (error) {
-      throw new Error(`Failed to save workflow state atomically: ${error.message}`);
-    }
-  }
-  async load() {
-    const filePath = this.getFilePath();
-    try {
-      try {
-        await fs2.access(filePath);
-      } catch {
-        return null;
-      }
-      const content = await fs2.readFile(filePath, "utf-8");
-      const json = JSON.parse(content);
-      const parsed = WorkflowSchema.safeParse(json);
-      if (parsed.success) {
-        return parsed.data;
-      } else {
-        console.warn(colors.warning(`\u26A0\uFE0F  Corrupted workflow file detected: ${parsed.error.message}`));
-        return null;
-      }
-    } catch (error) {
-      console.warn(colors.warning(`\u26A0\uFE0F  Failed to load workflow state: ${error.message}`));
-      return null;
-    }
-  }
-  // Helper to get current state or default if none exists
-  async getOrInitState() {
-    return await this.load();
-  }
-};
-var workflowManager = WorkflowManager.getInstance();
-
-// src/commands/init.ts
 import { randomUUID } from "crypto";
 var initAction = async () => {
   tui.intro("Shark Project Initialization");
@@ -267,1707 +188,148 @@ var initAction = async () => {
 };
 var initCommand = new Command("init").description("Initialize a new Shark project").action(initAction);
 
-// src/core/api/stackspot-client.ts
-var AuthError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AuthError";
-  }
-};
-var STACKSPOT_AGENT_API_BASE = "https://genai-inference-app.stackspot.com";
-async function ensureValidToken(realm) {
-  let creds = await tokenStorage.getCredentials(realm);
-  if (!creds?.accessToken) {
-    throw new AuthError(`Authentication required for realm '${realm}'.
-Please run 'shark login' to authenticate.`);
-  }
-  const now = Math.floor(Date.now() / 1e3);
-  const buffer = 300;
-  if (creds.expiresAt && creds.clientId && creds.clientKey) {
-    if (now > creds.expiresAt - buffer) {
-      try {
-        const newTokens = await authenticate(realm, creds.clientId, creds.clientKey);
-        await tokenStorage.saveToken(
-          realm,
-          newTokens.access_token,
-          creds.clientId,
-          creds.clientKey,
-          newTokens.expires_in
-        );
-        return newTokens.access_token;
-      } catch (error) {
-        console.warn(colors.warning(`\u26A0\uFE0F Failed to auto-refresh token: ${error.message}`));
-      }
-    }
+// src/commands/dev.ts
+import { Command as Command2 } from "commander";
+var devCommand = new Command2("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").option("-y, --yes", "Automatically approve all actions without prompting").option("--auto", "Automatically approve all actions without prompting").option("--export-schema", "Export the agent response JSON schema").action(async (options) => {
+  if (options.exportSchema) {
+    console.log(JSON.stringify(AGENT_RESPONSE_JSON_SCHEMA, null, 2));
+    return;
   }
-  return creds.accessToken;
-}
-
-// src/core/api/sse-client.ts
-var SSEClient = class {
-  /**
-   * Streams agent response using Server-Sent Events.
-   * 
-   * @param url - The SSE endpoint URL
-   * @param requestPayload - The request payload to POST
-   * @param headers - Request headers (including Authorization)
-   * @param callbacks - Event callbacks for chunks, completion, and errors
-   */
-  async streamAgentResponse(url, requestPayload, headers, callbacks = {}) {
-    const { onChunk, onComplete, onError } = callbacks;
-    FileLogger.log("SSE", `Starting Request to ${url}`, {
-      headers,
-      payload: requestPayload
+  try {
+    const result = await interactiveDeveloperAgent({
+      taskInstruction: options.task,
+      context: options.context,
+      auto: options.yes || options.auto
     });
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          ...headers,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(requestPayload)
-      });
-      FileLogger.log("SSE", `Response Status: ${response.status} ${response.statusText}`);
-      const responseHeaders = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-      });
-      FileLogger.log("SSE", "Response Headers", responseHeaders);
-      if (!response.ok) {
-        const errorText = await response.text();
-        FileLogger.log("SSE", "Response Error Body", errorText);
-        throw new Error(`SSE request failed: ${response.status} ${response.statusText} - ${errorText}`);
-      }
-      if (!response.body) {
-        throw new Error("Response body is null");
-      }
-      const contentType = response.headers.get("content-type") || "";
-      const isJson = contentType.includes("application/json");
-      if (isJson) {
-        const jsonBody = await response.json();
-        FileLogger.log("SSE", "Received Non-Streaming JSON Response", { length: JSON.stringify(jsonBody).length });
-        let content = "";
-        if (typeof jsonBody === "string") content = jsonBody;
-        else if (jsonBody.message) content = jsonBody.message;
-        else if (jsonBody.choices?.[0]?.message?.content) content = jsonBody.choices[0].message.content;
-        else content = JSON.stringify(jsonBody);
-        if (onChunk) onChunk(content);
-        if (onComplete) onComplete(content, jsonBody);
-        return;
-      }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      let fullMessage = "";
-      let metadata = {};
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (line.startsWith("data:")) {
-            const data = line.slice(5).trim();
-            if (data === "[DONE]") {
-              FileLogger.log("SSE", "Stream Complete [DONE]", { fullMessage, metadata });
-              if (onComplete) {
-                onComplete(fullMessage, metadata);
-              }
-              return;
-            }
-            try {
-              const parsed = JSON.parse(data);
-              const chunk = parsed.message || parsed.content || data;
-              fullMessage += chunk;
-              if (parsed.conversation_id) {
-                metadata.conversation_id = parsed.conversation_id;
-              }
-              if (onChunk) {
-                onChunk(chunk);
-              }
-            } catch (parseError) {
-              fullMessage += data;
-              if (onChunk) {
-                onChunk(data);
-              }
-            }
-          }
-        }
-      }
-      FileLogger.log("SSE", "Stream Ended Naturally", { fullMessage, metadata });
-      if (onComplete) {
-        onComplete(fullMessage, metadata);
-      }
-    } catch (error) {
-      FileLogger.log("SSE", "Stream Error", error);
-      if (onError) {
-        onError(error instanceof Error ? error : new Error(String(error)));
-      } else {
-        throw error;
-      }
+    if (!result.success) {
+      console.error("Task execution failed:", result.summary);
+      process.exit(1);
     }
+  } catch (error) {
+    console.error("Error during development agent execution:", error.message);
+    process.exit(1);
   }
-};
-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",
-    "list_files",
-    "search_file",
-    "search_code",
-    "read_file",
-    "delete_file",
-    "list_structure",
-    "modify_ast",
-    "search_ast",
-    "run_command",
-    "talk_with_user",
-    "use_mcp_tool",
-    "ast_list_structure",
-    "ast_get_method",
-    "ast_add_method",
-    "ast_modify_method",
-    "ast_remove_method",
-    "ast_add_class",
-    "ast_get_property",
-    "ast_add_property",
-    "ast_modify_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(),
-  line_range: z2.array(z2.number()).nullable().optional(),
-  target_content: z2.string().nullable().optional(),
-  command: z2.string().nullable().optional(),
-  tool_name: z2.string().nullable().optional(),
-  tool_args: z2.string().nullable().optional(),
-  // JSON string argument
-  // search_code fields
-  query: z2.string().nullable().optional(),
-  is_regex: z2.boolean().nullable().optional(),
-  // AST-Grep fields
-  pattern: z2.string().nullable().optional(),
-  fix: z2.string().nullable().optional(),
-  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()
-});
-var AgentCommandSchema = z2.object({
-  command: z2.string(),
-  description: z2.string(),
-  critical: z2.boolean()
 });
-var AgentResponseSchema = z2.object({
-  actions: z2.array(AgentActionSchema),
-  commands: z2.array(AgentCommandSchema).optional(),
-  summary: z2.string().optional(),
-  // Legacy fields handling for smooth transition/fallback
-  message: z2.string().optional(),
-  conversation_id: z2.string().optional()
-});
-function parseAgentResponse(rawResponse) {
-  FileLogger.log("PARSER", "Parsing Agent Response", { rawType: typeof rawResponse });
-  let parsedObj = {};
-  let conversation_id;
-  if (typeof rawResponse === "string") {
-    FileLogger.log("PARSER", "Type String", { length: rawResponse.length });
-    try {
-      parsedObj = extractFirstJson(rawResponse);
-    } catch (e) {
-      FileLogger.log("PARSER", "String Parse Failed", { error: e.message });
-      return {
-        actions: [{
-          type: "talk_with_user",
-          content: rawResponse,
-          path: ""
-        }],
-        message: rawResponse
-      };
-    }
-  } else if (typeof rawResponse === "object" && rawResponse !== null) {
-    const anyResp = rawResponse;
-    conversation_id = anyResp.conversation_id;
-    FileLogger.log("PARSER", "Type Object", {
-      hasContent: !!anyResp.content,
-      hasMessage: !!anyResp.message,
-      messageType: typeof anyResp.message
-    });
-    const stringContent = anyResp.content || anyResp.message;
-    if (stringContent && typeof stringContent === "string") {
-      try {
-        const parsedInside = extractFirstJson(stringContent);
-        if (typeof parsedInside === "object" && parsedInside !== null) {
-          parsedObj = parsedInside;
-          FileLogger.log("PARSER", "Inner JSON Parsed", { keys: Object.keys(parsedObj) });
-        } else {
-          parsedObj = rawResponse;
-          FileLogger.log("PARSER", "Inner JSON was primitive");
-        }
-      } catch (e) {
-        parsedObj = rawResponse;
-        FileLogger.log("PARSER", "Inner JSON Parse Error - treating as raw", { error: e.message });
-      }
-    } else {
-      parsedObj = rawResponse;
-    }
-    if (!parsedObj.actions) {
-      parsedObj = rawResponse;
-    }
-  }
-  if (!parsedObj.actions) {
-    FileLogger.log("PARSER", "No Actions Found - Constructing Default");
-    return {
-      conversation_id,
-      actions: [{
-        type: "talk_with_user",
-        content: parsedObj.message || JSON.stringify(parsedObj),
-        path: ""
-      }],
-      message: parsedObj.message
-    };
-  }
-  const result = {
-    actions: parsedObj.actions,
-    commands: parsedObj.commands || [],
-    summary: parsedObj.summary || "",
-    conversation_id,
-    message: parsedObj.summary || "Agent Action"
-    // Backward compatibility
-  };
-  FileLogger.log("PARSER", "Final Result Constructed", { actionCount: result.actions.length });
-  try {
-    return AgentResponseSchema.parse(result);
-  } catch (e) {
-    FileLogger.log("PARSER", "Schema Validation Failed", { error: e.message });
-    throw e;
-  }
-}
-function extractFirstJson(str) {
-  try {
-    return JSON.parse(str);
-  } catch (e) {
-    const firstOpen = str.indexOf("{");
-    if (firstOpen === -1) throw e;
-    let balance = 0;
-    let inString = false;
-    let escape = false;
-    for (let i = firstOpen; i < str.length; i++) {
-      const char = str[i];
-      if (escape) {
-        escape = false;
-        continue;
-      }
-      if (char === "\\") {
-        escape = true;
-        continue;
-      }
-      if (char === '"') {
-        inString = !inString;
-        continue;
-      }
-      if (!inString) {
-        if (char === "{") balance++;
-        else if (char === "}") {
-          balance--;
-          if (balance === 0) {
-            const potentialJson = str.substring(firstOpen, i + 1);
-            try {
-              return JSON.parse(potentialJson);
-            } catch (innerE) {
-              throw e;
-            }
-          }
-        }
-      }
-    }
-    throw e;
-  }
-}
 
-// src/core/workflow/conversation-manager.ts
-var ConversationManager = class _ConversationManager {
-  static instance;
-  constructor() {
-  }
-  static getInstance() {
-    if (!_ConversationManager.instance) {
-      _ConversationManager.instance = new _ConversationManager();
-    }
-    return _ConversationManager.instance;
-  }
-  /**
-   * Saves a conversation ID for a specific agent type.
-   * 
-   * @param agentType - The type of agent (e.g., 'business_analyst', 'architect')
-   * @param conversationId - The conversation ID from the agent response
-   */
-  async saveConversationId(agentType, conversationId) {
-    const state = await workflowManager.load();
-    if (!state) {
-      throw new Error('No workflow state found. Please run "shark init" first.');
-    }
-    if (!state.conversations) {
-      state.conversations = {};
-    }
-    state.conversations[agentType] = conversationId;
-    await workflowManager.save(state);
-  }
-  /**
-   * Retrieves the conversation ID for a specific agent type.
-   * 
-   * @param agentType - The type of agent
-   * @returns The conversation ID, or undefined if none exists
-   */
-  async getConversationId(agentType) {
-    const state = await workflowManager.load();
-    if (!state || !state.conversations) {
-      return void 0;
-    }
-    return state.conversations[agentType];
-  }
-  /**
-   * Clears the conversation ID for a specific agent type.
-   * 
-   * @param agentType - The type of agent
-   */
-  async clearConversationId(agentType) {
-    const state = await workflowManager.load();
-    if (!state || !state.conversations) {
-      return;
-    }
-    delete state.conversations[agentType];
-    await workflowManager.save(state);
-  }
-  /**
-   * Clears all conversation IDs.
-   * Useful when transitioning to a new project or resetting state.
-   */
-  async clearAllConversations() {
-    const state = await workflowManager.load();
-    if (!state) {
-      return;
-    }
-    state.conversations = {};
-    await workflowManager.save(state);
-  }
-};
-var conversationManager = ConversationManager.getInstance();
+// src/commands/legacy.ts
+import { Command as Command3 } from "commander";
 
-// src/core/auth/get-active-realm.ts
-async function getActiveRealm() {
-  const configManager = ConfigManager.getInstance();
-  const config = configManager.getConfig();
-  const realm = config.activeRealm;
-  if (!realm) {
-    throw new Error(
-      'No active authentication found.\nPlease run "shark login" first to authenticate.'
-    );
+// src/core/agents/legacy-developer-agent.ts
+import fs2 from "fs";
+import path2 from "path";
+var AGENT_TYPE = "developer_agent";
+async function validateTypeScript(filePath) {
+  try {
+    const result = await handleRunCommand(`npx tsc --noEmit --skipLibCheck ${filePath}`);
+    if (result.trim() === "" || !result.includes("error TS")) {
+      return { valid: true };
+    }
+    return { valid: false, error: result };
+  } catch (e) {
+    return { valid: false, error: e.message || "TypeScript validation failed" };
   }
-  return realm;
 }
-
-// src/core/agents/business-analyst-agent.ts
-var AGENT_TYPE = "business_analyst";
 function getAgentId(overrideId) {
   if (overrideId) return overrideId;
   const config = ConfigManager.getInstance().getConfig();
-  if (config.agents?.ba) return config.agents.ba;
-  return process.env.STACKSPOT_BA_AGENT_ID || "01KEJ95G304TNNAKGH5XNEEBVD";
-}
-function getAgentVersion(overrideVersion) {
-  if (overrideVersion) return overrideVersion;
-  const config = ConfigManager.getInstance().getConfig();
-  if (config.agentVersions?.ba) return config.agentVersions.ba;
-  return process.env.STACKSPOT_BA_AGENT_VERSION;
+  if (config.agents?.dev) return config.agents.dev;
+  if (process.env.STACKSPOT_DEV_AGENT_ID) return process.env.STACKSPOT_DEV_AGENT_ID;
+  return "01KEQCGJ65YENRA4QBXVN1YFFX";
 }
-async function runBusinessAnalystAgent(prompt, options = {}) {
-  const { agentId, onChunk, onComplete } = options;
-  const realm = await getActiveRealm();
-  const token = await tokenStorage.getToken(realm);
-  if (!token) {
-    throw new Error(`No authentication token found for realm '${realm}'. Please run 'shark login'.`);
-  }
-  const existingConversationId = await conversationManager.getConversationId(AGENT_TYPE);
-  const requestPayload = {
-    user_prompt: prompt,
-    streaming: true,
-    stackspot_knowledge: false,
-    // Use agent's configured KS instead
-    return_ks_in_response: true,
-    deep_search_ks: false,
-    conversation_id: existingConversationId
-  };
-  const agentVersion = getAgentVersion();
-  if (agentVersion) {
-    requestPayload.agent_version_number = agentVersion;
+async function interactiveDeveloperAgent2(options = {}) {
+  FileLogger.init();
+  const agentId = getAgentId();
+  if (agentId === "PENDING_CONFIGURATION") {
+    tui.log.error("\u274C STACKSPOT_DEV_AGENT_ID not configured in .env");
+    return { success: false, summary: "Missing configuration." };
   }
-  const effectiveAgentId = getAgentId(options.agentId);
-  const agentUrl = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${effectiveAgentId}/chat`;
-  const headers = {
-    "Authorization": `Bearer ${token}`,
-    "Content-Type": "application/json"
-  };
-  let fullMessage = "";
-  let rawResponse = {};
-  await sseClient.streamAgentResponse(
-    agentUrl,
-    requestPayload,
-    headers,
-    {
-      onChunk: (chunk) => {
-        fullMessage += chunk;
-        if (onChunk) {
-          onChunk(chunk);
-        }
-      },
-      onComplete: async (message) => {
-        rawResponse = {
-          message: message || fullMessage,
-          conversation_id: existingConversationId
-          // Will be updated if new one provided
-        };
-      },
-      onError: (error) => {
-        throw error;
-      }
+  const projectRoot = process.cwd();
+  let contextContent = "";
+  const defaultContextPath = path2.resolve(projectRoot, "_sharkrc", "project-context.md");
+  const specificContextPath = options.context ? path2.resolve(projectRoot, options.context) : defaultContextPath;
+  if (fs2.existsSync(specificContextPath)) {
+    try {
+      contextContent = fs2.readFileSync(specificContextPath, "utf-8");
+    } catch (e) {
+      tui.log.warning(`Failed to read context file: ${e}`);
     }
-  );
-  const parsedResponse = parseAgentResponse(rawResponse);
-  if (parsedResponse.conversation_id) {
-    await conversationManager.saveConversationId(AGENT_TYPE, parsedResponse.conversation_id);
   }
-  if (onComplete) {
-    onComplete(parsedResponse);
+  const currentTask = options.taskInstruction || "Analyze the project and fix pending issues.";
+  let basePrompt = ``;
+  if (contextContent) {
+    basePrompt += `
+
+--- PROJECT CONTEXT ---
+${contextContent}
+-----------------------
+`;
   }
-  return parsedResponse;
-}
-async function interactiveBusinessAnalyst() {
-  tui.intro("\u{1F3AF} Business Analyst Agent");
-  const prompt = await tui.text({
-    message: "Describe your project idea",
-    placeholder: "E.g., I want to build a task management app for teams...",
-    validate: (value) => {
-      if (!value || value.length < 10) return "Please provide a detailed description (at least 10 characters)";
-    }
-  });
-  if (tui.isCancel(prompt)) {
-    tui.outro("Cancelled");
-    return;
+  if (options.history) {
+    basePrompt += `
+
+--- PREVIOUS EXECUTION SUMMARY ---
+${options.history}
+----------------------------------
+`;
   }
+  basePrompt += `
+
+\u{1F7E2} EXECUTION MODE
+
+You are a highly skilled Developer Agent.
+\u{1F449} **CURRENT TASK**: "${currentTask}"
+
+Your goal is to COMPLETE this specific task and then STOP.
+1. Implement the necessary changes.
+2. Verify (compile/test).
+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.
+`;
+  let nextPrompt = basePrompt;
+  let keepGoing = true;
   const spinner = tui.spinner();
-  spinner.start("\u{1F4AC} Business Analyst is thinking...");
-  let responseText = "";
-  try {
-    await runBusinessAnalystAgent(prompt, {
-      onChunk: (chunk) => {
-        responseText += chunk;
-        try {
-          if (responseText.trim().startsWith("{")) {
-            spinner.message(colors.dim("Receiving structured data..."));
-          } else {
-            spinner.message(colors.dim("Thinking..."));
-          }
-        } catch (e) {
+  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) {
+    try {
+      spinner.start("\u{1F988} Shark Dev working...");
+      const lastResponse = await callDevAgentApi(nextPrompt, (chunk) => {
+      }, conversationKey);
+      spinner.stop("Response received");
+      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;
         }
-      },
-      onComplete: async (response) => {
-        spinner.stop("Response received");
-        if (response.summary) {
-          tui.log.info(colors.italic(response.summary));
+        if (response.message && response.message.includes("TASK_FAILED:")) {
+          const failureReason = response.message.split("TASK_FAILED:")[1].trim();
+          tui.log.error(`\u274C Agent reported task failure: ${failureReason}`);
+          return { success: false, summary: failureReason };
         }
-        if (response.actions && response.actions.length > 0) {
-          for (const action of response.actions) {
-            if (action.type === "talk_with_user") {
-              tui.log.info(colors.success("\u{1F916} BA Agent:"));
-              console.log(action.content);
-            } else {
-              tui.log.warning(`
-\u{1F916} Agent wants to ${action.type}: ${colors.bold(action.path || "unknown")}`);
-              if (action.content) {
-                console.log(colors.dim("--- Content Preview ---"));
-                console.log(action.content.substring(0, 300) + (action.content.length > 300 ? "..." : ""));
-                console.log(colors.dim("-----------------------"));
-              }
-              const confirm = await tui.confirm({
-                message: `Allow agent to ${action.type} '${action.path}'?`,
-                active: "Yes",
-                inactive: "No"
-              });
-              if (confirm) {
-                tui.log.success(`\u2705 Action executed: ${action.path} created.`);
-              } else {
-                tui.log.error("\u274C Action denied.");
-              }
-            }
+        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;
         }
-      }
-    });
-    tui.outro("Session complete");
-  } catch (error) {
-    spinner.stop("\u274C Error", 1);
-    tui.log.error(error.message);
-    throw error;
-  }
-}
-
-// src/core/agents/specification-agent.ts
-import fs5 from "fs";
-import path6 from "path";
-
-// src/core/agents/agent-tools.ts
-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/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
-      }
-    });
-  }
-  /**
-   * Get or add source file to project
-   */
-  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 getProperty(filePath, className, propertyName) {
-    try {
-      const sourceFile = this.getSourceFile(filePath);
-      const classDecl = this.getClass(sourceFile, className);
-      const property = classDecl.getProperty(propertyName);
-      if (!property) {
-        return void 0;
-      }
-      return property.getText();
-    } catch (error) {
-      console.error(`Failed to get property "${propertyName}":`, error);
-      return void 0;
-    }
-  }
-  async modifyProperty(filePath, className, propertyName, newCode) {
-    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.replaceWithText(newCode);
-      classDecl.formatText();
-      await sourceFile.save();
-      return true;
-    } catch (error) {
-      console.error(`Failed to modify property "${propertyName}":`, 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 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 void 0;
-      }
-      return method.getText();
-    } catch (error) {
-      console.error(`Failed to get method "${methodName}":`, error);
-      return void 0;
-    }
-  }
-  // ═══════════════════════════════════════════════════════
-  // IMPLEMENTATION: Interface/Type Operations
-  // ═══════════════════════════════════════════════════════
-  async addInterface(filePath, interfaceCode) {
-    try {
-      const sourceFile = this.getSourceFile(filePath);
-      sourceFile.insertText(sourceFile.getEnd(), `
-
-${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(), `
-
-${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`);
-      }
-      func.remove();
-      await sourceFile.save();
-      return true;
-    } catch (error) {
-      console.error(`Failed to remove function "${functionName}":`, error);
-      return false;
-    }
-  }
-  // ═══════════════════════════════════════════════════════
-  // 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;
-    }
-  }
-  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;
-    }
-  }
-};
-
-// 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;
-  }
-};
-
-// src/core/agents/agent-tools.ts
-var execAsync = promisify(exec);
-function detectLineEnding(content) {
-  const crlf = content.split("\r\n").length - 1;
-  const lf = content.split("\n").length - 1 - crlf;
-  return crlf > lf ? "\r\n" : "\n";
-}
-function handleListFiles(dirPath) {
-  try {
-    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");
-  } catch (e) {
-    return `Error listing files: ${e.message}`;
-  }
-}
-function handleReadFile(filePath, showLineNumbers = true) {
-  try {
-    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 = fs4.readFileSync(fullPath, "utf-8");
-    if (showLineNumbers) {
-      const lines = content.split("\n");
-      return lines.map((line, idx) => `${idx + 1}: ${line}`).join("\n");
-    }
-    return content;
-  } catch (e) {
-    return `Error reading file: ${e.message}`;
-  }
-}
-function replaceLineRange(filePath, startLine, endLine, newContent, tui2) {
-  try {
-    if (!fs4.existsSync(filePath)) {
-      tui2.log.error(`\u274C File not found for modification: ${filePath}`);
-      return false;
-    }
-    const currentFileContent = fs4.readFileSync(filePath, "utf-8");
-    const lineEnding = detectLineEnding(currentFileContent);
-    const lines = currentFileContent.split(lineEnding);
-    if (startLine < 1 || startLine > lines.length) {
-      tui2.log.error(`\u274C Invalid start line: ${startLine}. File has ${lines.length} lines.`);
-      return false;
-    }
-    if (endLine < startLine || endLine > lines.length) {
-      tui2.log.error(`\u274C Invalid end line: ${endLine}. Must be >= startLine and <= file length.`);
-      return false;
-    }
-    const before = lines.slice(0, startLine - 1);
-    const after = lines.slice(endLine);
-    const newLines = newContent.split(lineEnding);
-    const normalizedNewLines = newContent.replace(/\r\n/g, "\n").split("\n");
-    const result = [...before, ...normalizedNewLines, ...after].join(lineEnding);
-    const BOM = "\uFEFF";
-    const finalContent = result.startsWith(BOM) ? result : BOM + result;
-    fs4.writeFileSync(filePath, finalContent, { encoding: "utf-8" });
-    tui2.log.success(`\u2705 Replaced lines ${startLine}-${endLine} in ${filePath}`);
-    return true;
-  } catch (e) {
-    tui2.log.error(`\u274C Error replacing line range: ${e.message}`);
-    return false;
-  }
-}
-function handleSearchFile(pattern) {
-  try {
-    const entries = fg.sync(pattern, { dot: true });
-    if (entries.length === 0) return "No files found matching pattern.";
-    return entries.slice(0, 50).join("\n");
-  } catch (e) {
-    return `Error searching files: ${e.message}`;
-  }
-}
-function handleSearchCode(globPattern, query, isRegex = false) {
-  const MAX_MATCHES = 50;
-  const MAX_FILE_SIZE_BYTES = 500 * 1024;
-  try {
-    const files = fg.sync(globPattern, { dot: true, absolute: false });
-    if (files.length === 0) return `No files found matching pattern: "${globPattern}"`;
-    let searchRegex;
-    try {
-      searchRegex = isRegex ? new RegExp(query, "gi") : new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
-    } catch {
-      return `Error: Invalid regex pattern: "${query}"`;
-    }
-    const results = [];
-    let totalMatches = 0;
-    for (const filePath of files) {
-      if (totalMatches >= MAX_MATCHES) break;
-      try {
-        const fullPath = path5.resolve(process.cwd(), filePath);
-        const stats = fs4.statSync(fullPath);
-        if (stats.size > MAX_FILE_SIZE_BYTES) continue;
-        const content = fs4.readFileSync(fullPath, "utf-8");
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-          if (totalMatches >= MAX_MATCHES) break;
-          searchRegex.lastIndex = 0;
-          if (searchRegex.test(lines[i])) {
-            results.push(`${filePath}:${i + 1}: ${lines[i].trim()}`);
-            totalMatches++;
-          }
-        }
-      } catch {
-      }
-    }
-    if (results.length === 0) {
-      return `No matches found for "${query}" in files matching "${globPattern}"`;
-    }
-    const limited = totalMatches >= MAX_MATCHES ? ` (limited to ${MAX_MATCHES})` : "";
-    return `Found ${totalMatches} match(es) for "${query}" in "${globPattern}"${limited}:
-${results.join("\n")}`;
-  } catch (e) {
-    return `Error searching code: ${e.message}`;
-  }
-}
-function startSmartReplace(filePath, newContent, targetContent, tui2) {
-  if (!fs4.existsSync(filePath)) {
-    tui2.log.error(`\u274C File not found for modification: ${filePath}`);
-    return false;
-  }
-  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)) {
-    tui2.log.error(`\u274C Target content not found in ${filePath} (checked with normalized line endings). Modification aborted.`);
-    console.log(colors.dim("--- Target Content Expected ---"));
-    console.log(targetContent.substring(0, 200) + "...");
-    return false;
-  }
-  const occurrences = currentFileContent.split(targetContent).length - 1;
-  if (occurrences > 1) {
-    tui2.log.error(`\u274C Ambiguous target: Found ${occurrences} occurrences in ${filePath}. Modification aborted.`);
-    return false;
-  }
-  const BOM = "\uFEFF";
-  const updatedContent = currentFileContent.replace(targetContent, newContent);
-  const finalContent = updatedContent.startsWith(BOM) ? updatedContent : BOM + updatedContent;
-  fs4.writeFileSync(filePath, finalContent, { encoding: "utf-8" });
-  tui2.log.success(`\u2705 Smart Replace Applied: ${filePath}`);
-  return true;
-}
-async function handleRunCommand(command) {
-  const { spawn } = await import("child_process");
-  try {
-    tui.log.info(`\u{1F4BB} Executing: ${colors.dim(command)}`);
-    return new Promise((resolve2) => {
-      const child = spawn(command, {
-        shell: true,
-        stdio: ["ignore", "pipe", "pipe"],
-        cwd: process.cwd()
-      });
-      let stdout = "";
-      let stderr = "";
-      const timer = setTimeout(() => {
-        child.kill();
-        resolve2(`Error: Command timed out after 5 minutes.
-Output so far:
-${stdout}
-${stderr}`);
-      }, 5 * 60 * 1e3);
-      child.stdout.on("data", (data) => {
-        const chunk = data.toString();
-        stdout += chunk;
-      });
-      child.stderr.on("data", (data) => {
-        stderr += data.toString();
-      });
-      child.on("close", (code) => {
-        clearTimeout(timer);
-        if (code === 0) {
-          resolve2(stdout.trim() || "Command executed successfully (no output).");
-        } else {
-          resolve2(`Command failed with exit code ${code}.
-STDERR:
-${stderr}
-STDOUT:
-${stdout}`);
-        }
-      });
-      child.on("error", (err) => {
-        clearTimeout(timer);
-        resolve2(`Error executing command: ${err.message}`);
-      });
-    });
-  } catch (e) {
-    return `Error launching command: ${e.message}`;
-  }
-}
-function resolveAstGrepCommand() {
-  const isWin = process.platform === "win32";
-  const binName = isWin ? "sg.cmd" : "sg";
-  try {
-    const currentFile = fileURLToPath(import.meta.url);
-    let dir = path5.dirname(currentFile);
-    for (let i = 0; i < 5; i++) {
-      const candidate = path5.join(dir, "node_modules", ".bin", binName);
-      if (fs4.existsSync(candidate)) {
-        return `"${candidate}"`;
-      }
-      const parent = path5.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-  } catch (e) {
-  }
-  const cwdBin = path5.resolve(process.cwd(), "node_modules", ".bin", binName);
-  if (fs4.existsSync(cwdBin)) {
-    return `"${cwdBin}"`;
-  }
-  return "npx sg";
-}
-async function astGrepSearch(pattern, filePath, language, tui2) {
-  const { spawn } = await import("child_process");
-  try {
-    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((resolve2) => {
-      const child = spawn(cmd, {
-        shell: true,
-        stdio: ["ignore", "pipe", "pipe"],
-        cwd: process.cwd(),
-        env: { ...process.env, NO_COLOR: "true" }
-        // Avoid ANSI codes in JSON output
-      });
-      let stdout = "";
-      let stderr = "";
-      child.stdout.on("data", (data) => stdout += data.toString());
-      child.stderr.on("data", (data) => stderr += data.toString());
-      child.on("close", (code) => {
-        if (code === 0 && stdout) {
-          resolve2(stdout);
-        } else if (code === 1 && !stderr) {
-          resolve2("No structural matches found.");
-        } else {
-          if (!stdout && !stderr) resolve2("No structural matches found.");
-          else {
-            tui2.log.error(`\u274C ast-grep search error (code ${code}): ${stderr}`);
-            resolve2(`Error executing ast-grep search: ${stderr || stdout}`);
-          }
-        }
-      });
-      child.on("error", (err) => {
-        resolve2(`Error executing ast-grep search: ${err.message}`);
-      });
-    });
-  } catch (e) {
-    tui2.log.error(`\u274C ast-grep search exception: ${e.message}`);
-    return `Error executing ast-grep search: ${e.message}`;
-  }
-}
-async function astGrepRewrite(pattern, fix, filePath, language, tui2) {
-  const { spawn } = await import("child_process");
-  try {
-    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((resolve2) => {
-      const child = spawn(cmd, {
-        shell: true,
-        stdio: ["ignore", "pipe", "pipe"],
-        cwd: process.cwd()
-      });
-      let stderr = "";
-      child.stderr.on("data", (data) => stderr += data.toString());
-      child.on("close", (code) => {
-        if (code === 0) {
-          tui2.log.success(`\u2705 AST Rewrite applied to ${filePath}`);
-          resolve2(true);
-        } else {
-          tui2.log.error(`\u274C AST Rewrite failed (code ${code}): ${stderr}`);
-          resolve2(false);
-        }
-      });
-      child.on("error", (err) => {
-        tui2.log.error(`\u274C AST Rewrite spawn error: ${err.message}`);
-        resolve2(false);
-      });
-    });
-  } catch (e) {
-    tui2.log.error(`\u274C Unexpected error in astGrepRewrite: ${e.message}`);
-    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 astGetProperty(filePath, className, propertyName) {
-  const editor = CodeEditorFactory.getEditor(filePath);
-  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
-  const propContent = await editor.getProperty(filePath, className, propertyName);
-  if (!propContent) {
-    return `Property "${propertyName}" not found in class "${className}"`;
-  }
-  return propContent;
-}
-async function astModifyProperty(filePath, className, propertyName, propertyCode) {
-  const editor = CodeEditorFactory.getEditor(filePath);
-  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
-  return await editor.modifyProperty(filePath, className, propertyName, 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";
-function getAgentId2(overrideId) {
-  if (overrideId) return overrideId;
-  const config = ConfigManager.getInstance().getConfig();
-  if (config.agents?.spec) return config.agents.spec;
-  return process.env.STACKSPOT_SPEC_AGENT_ID || "01KEPXTX37FTB4N672TZST4SGP";
-}
-function getAgentVersion2(overrideVersion) {
-  if (overrideVersion) return overrideVersion;
-  const config = ConfigManager.getInstance().getConfig();
-  if (config.agentVersions?.spec) return config.agentVersions.spec;
-  return process.env.STACKSPOT_SPEC_AGENT_VERSION;
-}
-async function interactiveSpecificationAgent(options = {}) {
-  FileLogger.init();
-  tui.intro("\u{1F3D7}\uFE0F  Specification Agent (Template-Based)");
-  const projectRoot = process.cwd();
-  const sharkRcDir = path6.resolve(projectRoot, "_sharkrc");
-  if (!fs5.existsSync(sharkRcDir)) fs5.mkdirSync(sharkRcDir, { recursive: true });
-  const outputFile = path6.resolve(sharkRcDir, "tech-spec.md");
-  if (!fs5.existsSync(outputFile)) {
-    let initialContent = `# Technical Specification: {{PROJECT_NAME}}
-
-## 1. Technology Stack
-[TO BE ANALYZED]
-- Language: [e.g. TypeScript]
-- Framework: [e.g. Node.js / React]
-- Database: [e.g. SQLite / PostgreSQL]
-- Key Libraries: [Top 5 dependencies]
-
-## 2. Architecture Overview
-[TO BE ANALYZED]
-[Brief description of architectural pattern]
-
-## 3. Data Model
-[TO BE ANALYZED]
-[Schema/ERD definitions]
-
-## 4. API / Interface Contracts
-[TO BE ANALYZED]
-[Main endpoints or CLI commands]
-
-## 5. Implementation Steps
-[TO BE FILLED - MUST BE CHECKBOXES]
-`;
-    const projectName = path6.basename(projectRoot);
-    initialContent = initialContent.replace(/{{PROJECT_NAME}}/g, projectName);
-    const BOM = "\uFEFF";
-    fs5.writeFileSync(outputFile, BOM + initialContent, { encoding: "utf-8" });
-    tui.log.success(`\u2705 Created: ${colors.bold("_sharkrc/tech-spec.md")}`);
-  } else {
-    tui.log.info(`\u{1F4C4} Using existing ${colors.bold("_sharkrc/tech-spec.md")}`);
-  }
-  let contextContent = "";
-  const contextPath = path6.resolve(projectRoot, "_sharkrc", "project-context.md");
-  if (fs5.existsSync(contextPath)) {
-    contextContent = fs5.readFileSync(contextPath, "utf-8");
-    tui.log.info(`\u{1F4D8} Context loaded.`);
-  }
-  let briefingContent = "";
-  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 standardBriefing = path6.resolve(projectRoot, "_sharkrc", "briefing.md");
-    if (fs5.existsSync(standardBriefing)) {
-      briefingContent = fs5.readFileSync(standardBriefing, "utf-8");
-      tui.log.info(`\u{1F4C4} Briefing loaded.`);
-    }
-  }
-  let initialPrompt = `
-Voc\xEA \xE9 o **Shark Spec**, um Arquiteto de Software S\xEAnior e Tech Lead.
-Seu objetivo final \xE9 produzir uma especifica\xE7\xE3o t\xE9cnica precisa para a tarefa no arquivo \`_sharkrc/tech-spec.md\`.
-
-\u26A0\uFE0F O SEU WORKFLOW \xC9 GUIADO POR FASES.
-N\xC3O TENTE ADIANTAR O TRABALHO (ex: investigar c\xF3digo ou preencher template agora).
-
-**VOC\xCA EST\xC1 NA FASE 1: ENTENDIMENTO DA TAREFA**
-- Use \`talk_with_user\` para perguntar ao usu\xE1rio qual tarefa espec\xEDfica, funcionalidade ou bug ele precisa especificar.
-- Confirme o escopo e os limites com o usu\xE1rio.
-- Se o escopo estiver perfeitamente claro e confirmado (com o usu\xE1rio), emita "PHASE_COMPLETED" no campo "summary" do JSON para avan\xE7ar.
-
-IMPORTANTE: Toda a sua comunica\xE7\xE3o DEVE ser em Portugu\xEAs.
-`;
-  if (briefingContent) {
-    initialPrompt += `
-\u2139\uFE0F Um documento de briefing foi encontrado. Ele define parcialmente a tarefa para a Fase 1.
-Confirme seu entendimento com o usu\xE1rio via \`talk_with_user\` antes de prosseguir para a Fase 2.
-
---- BRIEFING ---
-${briefingContent}
-----------------
-`;
-  } else {
-    initialPrompt += `
-\u2139\uFE0F Nenhum documento de briefing foi encontrado. Inicie a Fase 1 imediatamente: use \`talk_with_user\` para perguntar ao usu\xE1rio o que precisa ser especificado.
-`;
-  }
-  if (options.initialContext) {
-    initialPrompt += `
---- CONTEXTO DE EXECU\xC7\xC3O ANTERIOR (HANDOVER/FEEDBACK) ---
-${options.initialContext}
------------------------------------------------------
-`;
-  }
-  if (contextContent) {
-    initialPrompt += `
-\u2139\uFE0F O contexto do projeto est\xE1 dispon\xEDvel para refer\xEAncia. Use-o na Fase 2 para se alinhar com os padr\xF5es de arquitetura existentes, mas N\xC3O o use para preencher as se\xE7\xF5es de forma gen\xE9rica.
-
---- PROJECT CONTEXT ---
-${contextContent}
------------------------
-`;
-  }
-  await runSpecLoop(initialPrompt.trim(), outputFile, options.agentId);
-}
-async function runSpecLoop(initialMessage, targetPath, overrideAgentId) {
-  let nextPrompt = initialMessage;
-  let keepGoing = true;
-  let stepCount = 0;
-  let currentPhase = 1;
-  const MAX_STEPS = 30;
-  while (keepGoing && stepCount < MAX_STEPS) {
-    stepCount++;
-    const spinner = tui.spinner();
-    spinner.start(`\u{1F3D7}\uFE0F  Spec Agent working (Step ${stepCount}/${MAX_STEPS})...`);
-    let pendingSections = [];
-    if (fs5.existsSync(targetPath)) {
-      const content = fs5.readFileSync(targetPath, "utf-8");
-      if (content.includes("[TO BE ANALYZED]")) pendingSections.push("Analysis Sections (Stack, Arch, Data, API)");
-      if (content.includes("[TO BE FILLED")) pendingSections.push("Implementation Steps");
-    }
-    if (pendingSections.length === 0 && stepCount > 1) {
-    }
-    let responseText = "";
-    let lastResponse = null;
-    try {
-      lastResponse = await callSpecAgentApi(nextPrompt, (chunk) => {
-        responseText += chunk;
-      }, overrideAgentId);
-      spinner.stop("Response received");
-      if (lastResponse && lastResponse.actions) {
         let executionResults = "";
         let waitingForUser = false;
-        let specUpdated = false;
-        if (lastResponse.message && lastResponse.message.includes("PHASE_COMPLETED")) {
-          if (currentPhase === 1) {
-            currentPhase = 2;
-            tui.log.success(`\u2705 Fase 1 Conclu\xEDda. Iniciando Fase 2 (Investiga\xE7\xE3o).`);
-            nextPrompt = `[System Message]
-Voc\xEA completou a FASE 1 com sucesso.
-
-**VOC\xCA AGORA EST\xC1 NA FASE 2: INVESTIGA\xC7\xC3O**
-- Use \`search_code\` e \`list_files\` para explorar os arquivos relevantes \xE0 tarefa.
-- Prefira \`search_code\` em vez de \`read_file\` para buscar c\xF3digo sem inflar o contexto.
-- N\xC3O leia o projeto inteiro de forma gen\xE9rica.
-- REGRA DE OURO (READ-FIRST): Voc\xEA N\xC3O PODE referenciar um arquivo na especifica\xE7\xE3o t\xE9cnica que n\xE3o tenha investigado nesta fase.
-- Quando achar que possui toda a clareza t\xE9cnica sobre onde e o que deve ser feito no c\xF3digo, emita "PHASE_COMPLETED" no summary.`;
-            continue;
-          } else if (currentPhase === 2) {
-            currentPhase = 3;
-            tui.log.success(`\u2705 Fase 2 Conclu\xEDda. Iniciando Fase 3 (Preenchimento).`);
-            nextPrompt = `[System Message]
-Voc\xEA completou a FASE 2 com sucesso.
-
-**VOC\xCA AGORA EST\xC1 NA FASE 3: PREENCHIMENTO DO TEMPLATE**
-- Use \`modify_file\` no arquivo \`${targetPath}\` para substituir os placeholders pelo conte\xFAdo real levantado na fase de investiga\xE7\xE3o.
-- As se\xE7\xF5es 1-4 devem descrever o contexto da TAREFA, e n\xE3o o projeto como um todo.
-- Passos de Implementa\xE7\xE3o (Implementation Steps): APENAS checkboxes markdown: \`- [ ] [Verbo de A\xE7\xE3o] [O Que] em [Caminho Relativo]\`.
-- Quando TODOS os placeholders ([TO BE ANALYZED] ou [TO BE FILLED]) forem substitu\xEDdos e o trabalho conclu\xEDdo, emita "SPEC_UPDATED: Complete" no summary para finalizar.`;
-            continue;
-          }
-        }
-        if (lastResponse.message && lastResponse.message.includes("SPEC_UPDATED:")) {
-          if (currentPhase < 3) {
-            tui.log.warning(`O agente tentou finalizar prematuramente. For\xE7ando retorno para a fase atual...`);
-            nextPrompt = `[System Error]: Voc\xEA tentou finalizar a especifica\xE7\xE3o prematuramente emitindo SPEC_UPDATED, mas ainda est\xE1 na Fase ${currentPhase}. Voc\xEA s\xF3 pode finalizar quando estiver na Fase 3.
-
-Continue seu trabalho na Fase ${currentPhase} ou emita "PHASE_COMPLETED" se terminou esta etapa atual.`;
-            continue;
-          }
-          const content = fs5.existsSync(targetPath) ? fs5.readFileSync(targetPath, "utf-8") : "";
-          if (content.includes("[TO BE")) {
-            const pendingMatches = [...content.matchAll(/## ([^\n]+)[\s\S]*?\[TO BE/g)].map((m) => m[1]);
-            let missing = pendingMatches.length > 0 ? pendingMatches.join(", ") : "algumas se\xE7\xF5es";
-            tui.log.warning(`O agente tentou concluir prematuramente, mas h\xE1 placeholders pendentes. For\xE7ando retorno...`);
-            nextPrompt = `[System Error]: A valida\xE7\xE3o falhou e o bloqueio autom\xE1tico foi acionado.
-Voc\xEA tentou concluir a tarefa, mas o arquivo AINDA possui placeholders '[TO BE ANALYZED]' ou '[TO BE FILLED]'.
-As seguintes se\xE7\xF5es ainda cont\xEAm estes placeholders: ${missing}.
-Voc\xEA \xE9 OBRIGADO a usar a action \`modify_file\` para preencher o conte\xFAdo de cada uma dessas se\xE7\xF5es. Use o placeholder exato no campo \`target_content\`. N\xC3O repita a conclus\xE3o da tarefa at\xE9 corrigir todas as pend\xEAncias.`;
-            continue;
-          } else {
-            const updateSummary = lastResponse.message.split("SPEC_UPDATED:")[1].trim();
-            tui.log.success(`\u2705 Spec Finalized: ${updateSummary}`);
-            return;
-          }
-        }
-        for (const action of lastResponse.actions) {
+        for (const action of actions) {
           if (action.type === "talk_with_user") {
-            tui.log.info(colors.primary("\u{1F916} Architect:"));
+            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: ${colors.dim(action.path || ".")}`);
             const result = handleListFiles(action.path || ".");
@@ -1982,811 +344,493 @@ ${result}
 ${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}
+          } else if (action.type === "search_file") {
+            const result = handleSearchFile(action.path || "");
+            executionResults += `[Action search_file(${action.path}) Result]:
+${result}
+
+`;
+          } else if (action.type === "run_command") {
+            const cmd = action.command || "";
+            tui.log.info(`\u{1F4BB} Executing: ${colors.dim(cmd)}`);
+            let approved = autoApprovals.commands;
+            if (!approved) {
+              const choice = await tui.select({
+                message: `Execute: ${cmd}?`,
+                options: [{ value: "yes", label: "Yes" }, { value: "always", label: "Yes (Auto-Approve Session)" }, { value: "no", label: "No" }]
+              });
+              if (choice === "always") {
+                autoApprovals.commands = true;
+                approved = true;
+              } else if (choice === "yes") approved = true;
+            }
+            if (approved) {
+              const result = await handleRunCommand(cmd);
+              executionResults += `[Action run_command(${cmd}) Result]:
+${result}
+
+`;
+            } else {
+              executionResults += `[Action run_command]: User blocked execution.
+
+`;
+            }
+          } else if (["create_file", "modify_file"].includes(action.type)) {
+            const filePath = action.path || "";
+            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" }, { value: "always", label: "Yes (Auto-Approve Session)" }, { value: "no", label: "No" }]
+              });
+              if (choice === "always") {
+                autoApprovals.files = true;
+                approved = true;
+              } else if (choice === "yes") approved = true;
+            }
+            if (approved) {
+              if (action.type === "create_file") {
+                const dir = path2.dirname(path2.resolve(projectRoot, filePath));
+                if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+                fs2.writeFileSync(path2.resolve(projectRoot, filePath), action.content || "", "utf-8");
+                executionResults += `[Action create_file]: Success
+
+`;
+              } 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
+
+` : `[Action modify_file]: Failed
+
+`;
+              }
+              const val = await validateTypeScript(path2.resolve(projectRoot, filePath));
+              if (!val.valid) executionResults += `[Validation Failed]: ${val.error}
+
+`;
+            } else {
+              executionResults += `[Action ${action.type}]: User Denied.
+
+`;
+            }
+          } 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_get_property") {
+                tui.log.info(`\u{1F50D} Reading property ${colors.gray(action.property_name || "")} in ${colors.gray(action.class_name || "")}`);
+                const propContent = await astGetProperty(action.path || "", action.class_name || "", action.property_name || "");
+                result = `[AST Get Property] Content:
+${propContent}`;
+              } 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_modify_property") {
+                tui.log.info(`\u270F\uFE0F Modifying property ${colors.gray(action.property_name || "")} in ${colors.gray(action.class_name || "")}`);
+                const success = await astModifyProperty(action.path || "", action.class_name || "", action.property_name || "", action.property_code || "");
+                result = success ? "Property modified successfully." : "Failed to modify 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}
+
+`;
+              tui.log.info(`\u26A1 AST Action ${colors.dim(action.type)}: ${result}`);
+            } catch (e) {
+              executionResults += `[Action ${action.type} Failed]: ${e.message}
 
 `;
-          } else if (action.type === "search_code") {
-            const glob = action.path || "src/**/*";
-            const query = action.query || "";
-            const isRegex = action.is_regex === true;
-            tui.log.info(`\u{1F50E} Search code: ${colors.dim(`"${query}" in ${glob}`)}`);
-            const result = handleSearchCode(glob, query, isRegex);
-            executionResults += `[Action search_code("${query}" in "${glob}") Result]:
+              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 if (["create_file", "modify_file"].includes(action.type)) {
-            let actionPath = path6.resolve(action.path || "");
-            const resolvedTargetPath = path6.resolve(targetPath);
-            let isTarget = actionPath === resolvedTargetPath;
-            if (!isTarget && path6.basename(actionPath) === "tech-spec.md") {
-              tui.log.warning(`Redirecting ${action.type} from ${action.path} to ${path6.relative(process.cwd(), targetPath)}`);
-              action.path = targetPath;
-              actionPath = resolvedTargetPath;
-              isTarget = true;
-            }
-            if (!isTarget && action.type === "create_file") {
-              const confirm = await tui.confirm({ message: `Agent wants to create ${action.path}. Allow?` });
-              if (!confirm) {
-                executionResults += `[Action create_file]: User denied.
-`;
-                continue;
-              }
-            }
-            try {
-              if (action.type === "create_file") {
-                const BOM = "\uFEFF";
-                fs5.writeFileSync(action.path, BOM + (action.content || ""), "utf-8");
-                tui.log.success(`\u2705 Created: ${action.path}`);
-                executionResults += `[Action create_file]: Success.
-`;
-              } else if (action.type === "modify_file") {
-                if (action.target_content) {
-                  const success = startSmartReplace(action.path, action.content || "", action.target_content, tui);
-                  if (success) {
-                    executionResults += `[Action modify_file]: Success.
-`;
-                    specUpdated = true;
-                  } else {
-                    executionResults += `[Action modify_file]: Failed. Target content not found.
-`;
-                  }
-                } else {
-                  executionResults += `[Action modify_file]: Failed. 'target_content' is required.
-`;
-                }
-              }
-            } catch (e) {
-              executionResults += `[Action ${action.type}]: Error: ${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
+
+` : `[Action modify_ast]: Failed
+
 `;
-            }
           }
         }
-        if (waitingForUser) {
-          const userReply = await tui.text({ message: "Your answer", placeholder: "Type your answer..." });
-          if (tui.isCancel(userReply)) {
-            keepGoing = false;
-            return;
-          }
-          nextPrompt = `${executionResults}
-
-User Reply: ${userReply}`;
-        } else if (executionResults) {
-          const content = fs5.existsSync(targetPath) ? fs5.readFileSync(targetPath, "utf-8") : "";
-          let systemMsg = "Execu\xE7\xE3o da ferramenta conclu\xEDda.";
-          if (specUpdated) {
-            if (content.includes("[TO BE")) {
-              const pendingMatches = [...content.matchAll(/## ([^\n]+)[\s\S]*?\[TO BE/g)].map((m) => m[1]);
-              let missing = pendingMatches.length > 0 ? pendingMatches.join(", ") : "v\xE1rias se\xE7\xF5es";
-              systemMsg += `
-[System]: Se\xE7\xE3o atualizada com sucesso. A valida\xE7\xE3o detectou que AINDA H\xC1 placeholders pendentes ('[TO BE...]') nas seguintes se\xE7\xF5es: ${missing}.
-Por favor, envie uma nova action \`modify_file\` focada em uma destas se\xE7\xF5es obrigatoriamente. USE o respectivo placeholder no campo \`target_content\` para que o replace funcione.`;
-            } else {
-              systemMsg += "\n[System]: O arquivo parece completo! Se estiver satisfeito e possuir TODAS as implementa\xE7\xF5es descritas, retorne 'SPEC_UPDATED: Complete'.";
-            }
-          }
-          nextPrompt = `${executionResults}
-
-${systemMsg}`;
-        } else {
-          if (lastResponse.message) {
-            tui.log.info(colors.primary("\u{1F916} Architect (Message only):"));
-            console.log(lastResponse.message);
+        if (executionResults) {
+          if (waitingForUser) {
             const userReply = await tui.text({ message: "Your answer:" });
             if (tui.isCancel(userReply)) {
               keepGoing = false;
               break;
             }
-            nextPrompt = userReply;
+            nextPrompt = `${executionResults}
+User Reply: ${userReply}`;
           } else {
-            keepGoing = false;
+            nextPrompt = `${executionResults}
+[System]: Continue execution. If finished, output "TASK_COMPLETED: summary".`;
+            tui.log.info(colors.dim("Processing results..."));
           }
+        } else if (!keepGoing) {
+        } else if (waitingForUser) {
+        } else {
+          if (!isTaskCompleted && actions.length > 0) nextPrompt = "Please continue.";
         }
       } else {
-        tui.log.warning("No actions received.");
-        keepGoing = false;
+        tui.log.warning("No response received from agent.");
       }
-    } catch (error) {
-      spinner.stop("Error");
-      tui.log.error(error.message);
+    } catch (e) {
+      tui.log.error(e.message);
       keepGoing = false;
+      return { success: false, summary: `Error: ${e.message}` };
     }
   }
+  tui.log.success("\u2705 Task Scope Completed");
+  return { success: true, summary: finalSummary || "Task completed without summary." };
 }
-async function callSpecAgentApi(prompt, onChunk, agentId) {
-  const realm = await getActiveRealm();
-  const token = await ensureValidToken(realm);
-  const conversationId = await conversationManager.getConversationId(AGENT_TYPE2);
-  const payload = {
-    user_prompt: prompt,
-    streaming: true,
-    stackspot_knowledge: false,
-    return_ks_in_response: true,
-    use_conversation: true,
-    conversation_id: conversationId
-  };
-  const agentVersion = getAgentVersion2();
-  if (agentVersion) {
-    payload.agent_version_number = agentVersion;
-  }
-  const effectiveAgentId = getAgentId2(agentId);
-  const url = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${effectiveAgentId}/chat`;
-  let fullMsg = "";
-  let raw = {};
-  FileLogger.log("AGENT", "Calling Agent API", { agentId: effectiveAgentId, conversationId });
-  await sseClient.streamAgentResponse(url, payload, { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" }, {
-    onChunk: (c) => {
-      fullMsg += c;
-      onChunk(c);
-    },
-    onComplete: (msg, metadata) => {
-      const returnedId = metadata?.conversation_id;
-      raw = { message: msg || fullMsg, conversation_id: returnedId || conversationId };
-    },
-    onError: (e) => {
-      throw e;
-    }
+async function callDevAgentApi(prompt, onChunk, conversationKey = AGENT_TYPE) {
+  const existingConversationId = await conversationManager.getConversationId(conversationKey);
+  const provider = ProviderResolver.getProvider("developer_agent");
+  const parsedResponse = await provider.streamChat(prompt, {
+    conversationId: existingConversationId,
+    agentType: "developer_agent",
+    onChunk
   });
-  const parsed = parseAgentResponse(raw);
-  if (parsed.conversation_id) {
-    await conversationManager.saveConversationId(AGENT_TYPE2, parsed.conversation_id);
+  if (parsedResponse.conversation_id) {
+    await conversationManager.saveConversationId(conversationKey, parsedResponse.conversation_id);
   }
-  return parsed;
+  return parsedResponse;
 }
 
-// src/commands/scan.ts
-import { Command as Command2 } from "commander";
-
-// src/core/agents/scan-agent.ts
-import fs6 from "fs";
-import path7 from "path";
-var AGENT_TYPE3 = "scan_agent";
-function getAgentId3() {
-  const config = ConfigManager.getInstance().getConfig();
-  if (config.agents?.scan) return config.agents.scan;
-  return process.env.STACKSPOT_SCAN_AGENT_ID || "01KEQ9AHWB550J2244YBH3QATN";
-}
-function getAgentVersion3() {
-  const config = ConfigManager.getInstance().getConfig();
-  if (config.agentVersions?.scan) return config.agentVersions.scan;
-  return process.env.STACKSPOT_SCAN_AGENT_VERSION;
-}
-async function interactiveScanAgent(options = {}) {
-  FileLogger.init();
-  const config = ConfigManager.getInstance().getConfig();
-  const language = config.language || "English";
-  tui.intro(t("commands.scan.intro"));
-  const projectRoot = process.cwd();
-  let outputFile;
-  if (options.output) {
-    outputFile = path7.resolve(process.cwd(), options.output);
-  } else {
-    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 = path7.resolve(projectRoot, "_bmad/project-context");
-        if (!fs6.existsSync(fallbackDir)) fs6.mkdirSync(fallbackDir, { recursive: true });
-        outputFile = path7.join(fallbackDir, "project-context.md");
-      } else {
-        fs6.mkdirSync(outputDir, { recursive: true });
-        outputFile = path7.join(outputDir, "project-context.md");
+// src/core/workflow/task-manager.ts
+import fs3 from "fs";
+import path3 from "path";
+var TaskManager = class {
+  projectRoot;
+  specPath;
+  constructor(projectRoot = process.cwd()) {
+    this.projectRoot = projectRoot;
+    this.specPath = path3.resolve(this.projectRoot, "_sharkrc", "tech-spec.md");
+  }
+  /**
+   * Reads the tech-spec.md file and analyzes its current state.
+   */
+  analyzeSpecState() {
+    if (!fs3.existsSync(this.specPath)) {
+      return { status: "MISSING", allTasks: [] };
+    }
+    const content = fs3.readFileSync(this.specPath, "utf-8");
+    const lines = content.split("\n");
+    const tasks = [];
+    let taskIndex = 1;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      const pendingMatch = trimmed.match(/^- \[ \] (.*)/);
+      const completedMatch = trimmed.match(/^- \[x\] (.*)/i);
+      const progressMatch = trimmed.match(/^- \[\/\] (.*)/);
+      let currentTask = null;
+      let status2 = null;
+      let description = "";
+      if (pendingMatch) {
+        description = pendingMatch[1].trim();
+        status2 = "PENDING";
+      } else if (completedMatch) {
+        description = completedMatch[1].trim();
+        status2 = "COMPLETED";
+      } else if (progressMatch) {
+        description = progressMatch[1].trim();
+        status2 = "IN_PROGRESS";
       }
-    } else {
-      fs6.mkdirSync(outputDir, { recursive: true });
-      outputFile = path7.join(outputDir, "project-context.md");
+      if (status2 && description) {
+        let j = i + 1;
+        while (j < lines.length) {
+          const nextLine = lines[j];
+          const nextTrimmed = nextLine.trim();
+          if (!nextTrimmed || nextTrimmed.match(/^- \[[ x\/]\]/) || nextTrimmed.startsWith("#")) {
+            break;
+          }
+          description += "\n" + nextTrimmed;
+          j++;
+        }
+        currentTask = {
+          id: `task-${taskIndex++}`,
+          description,
+          status: status2,
+          line_number: i
+        };
+        tasks.push(currentTask);
+      }
+    }
+    let nextTask = tasks.find((t) => t.status === "IN_PROGRESS");
+    if (!nextTask) {
+      nextTask = tasks.find((t) => t.status === "PENDING");
     }
+    const status = !nextTask && tasks.length > 0 && tasks.every((t) => t.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
+    };
   }
-  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 = path7.relative(projectRoot, outputFile);
-  const initialTemplate = `# Project Context
-
-## Overview
-[TO BE ANALYZED]
-
-## Tech Stack
-[TO BE ANALYZED]
-
-## Architecture
-[TO BE ANALYZED]
-
-## Directory Structure
-[TO BE ANALYZED]
+  /**
+   * 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((t) => t.id === taskId);
+    if (!task) {
+      console.error(`Task ${taskId} not found.`);
+      return false;
+    }
+    const content = fs3.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;
+    fs3.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((t) => t.id === taskId);
+    if (!task) return false;
+    const content = fs3.readFileSync(this.specPath, "utf-8");
+    const lines = content.split("\n");
+    let targetLine = lines[task.line_number];
+    targetLine = targetLine.replace("- [ ]", "- [/]");
+    lines[task.line_number] = targetLine;
+    fs3.writeFileSync(this.specPath, lines.join("\n"), "utf-8");
+    return true;
+  }
+  /**
+   * Completely updates the spec file content (used by Spec Agent).
+   */
+  updateSpecContent(newContent) {
+    fs3.writeFileSync(this.specPath, newContent, "utf-8");
+  }
+  getSpecPath() {
+    return this.specPath;
+  }
+};
 
-## Key Components
-[TO BE ANALYZED]
+// src/core/agents/specification-agent.ts
+import fs4 from "fs";
+import path4 from "path";
+var AGENT_TYPE2 = "specification_agent";
+async function interactiveSpecificationAgent(options = {}) {
+  FileLogger.init();
+  tui.intro("\u{1F3D7}\uFE0F  Specification Agent (Template-Based)");
+  const projectRoot = process.cwd();
+  const sharkRcDir = path4.resolve(projectRoot, "_sharkrc");
+  if (!fs4.existsSync(sharkRcDir)) fs4.mkdirSync(sharkRcDir, { recursive: true });
+  const outputFile = path4.resolve(sharkRcDir, "tech-spec.md");
+  if (!fs4.existsSync(outputFile)) {
+    let initialContent = `# Technical Specification: {{PROJECT_NAME}}
 
-## API / Interfaces
-[TO BE ANALYZED]
+## 1. Technology Stack
+[TO BE ANALYZED - STACK]
+- Language: [e.g. TypeScript]
+- Framework: [e.g. Node.js / React]
+- Database: [e.g. SQLite / PostgreSQL]
+- Key Libraries: [Top 5 dependencies]
 
-## Data Layer
-[TO BE ANALYZED]
+## 2. Architecture Overview
+[TO BE ANALYZED - ARCHITECTURE]
+[Brief description of architectural pattern]
 
-## Configuration & Environment
-[TO BE ANALYZED]
+## 3. Data Model
+[TO BE ANALYZED - DATA MODEL]
+[Schema/ERD definitions]
 
-## Build & Development
-[TO BE ANALYZED]
+## 4. API / Interface Contracts
+[TO BE ANALYZED - API]
+[Main endpoints or CLI commands]
 
-## Key Patterns & Conventions
-[TO BE ANALYZED]
+## 5. Implementation Steps
+[TO BE FILLED - MUST BE CHECKBOXES]
 `;
-  if (!fs6.existsSync(outputFile)) {
+    const projectName = path4.basename(projectRoot);
+    initialContent = initialContent.replace(/{{PROJECT_NAME}}/g, projectName);
     const BOM = "\uFEFF";
-    fs6.writeFileSync(outputFile, BOM + initialTemplate, { encoding: "utf-8" });
-    tui.log.success(`${t("commands.scan.templateCreated")} ${outputFile}`);
+    fs4.writeFileSync(outputFile, BOM + initialContent, { encoding: "utf-8" });
+    tui.log.success(`\u2705 Created: ${colors.bold("_sharkrc/tech-spec.md")}`);
   } else {
-    tui.log.info(t("commands.scan.fileExists"));
+    tui.log.info(`\u{1F4C4} Using existing ${colors.bold("_sharkrc/tech-spec.md")}`);
   }
-  const superPrompt = `
-You are the **Scan Agent**, an expert software architect and analyst.
-Your mission is to explore this project's codebase THOROUGHLY and generate a COMPREHENSIVE context file that will be used by other AI agents (specifically a Developer Agent) to understand how to work on this project.
-
-**IMPORTANT**: The file \`${configFileRelative}\` has already been created with a template structure. Your job is to FILL IN each section by analyzing the project.
-
-**LANGUAGE INSTRUCTION**:
-You MUST write the content in **${language}**.
-
-**CRITICAL STRATEGY - INCREMENTAL UPDATES**:
-DO NOT try to rewrite the entire file at once! Instead:
-
-1. **Explore** the project using \`list_files\`, \`read_file\`, \`search_file\`
-2. **Update** specific sections incrementally using \`modify_file\`
-3. **Benefit**: Build a MUCH MORE DETAILED document without context size limitations
-
-**WORKFLOW - FILL EACH SECTION:**
-
-**Step 1 - Analyze Tech Stack:**
-- \`list_files\` root directory to see project structure
-- \`read_file\` package.json (or pom.xml, go.mod, requirements.txt, etc.)
-- \`modify_file\` to replace:
-  - \`target_content\`: "## Tech Stack\\n[TO BE ANALYZED]"
-  - \`content\`: Detailed tech stack with versions, dependencies, and their purposes
-
-**Step 2 - Analyze Directory Structure:**
-- \`list_files\` on ALL key directories (src, tests, config, docs, etc.)
-- Map the complete directory tree
-- \`modify_file\` to replace:
-  - \`target_content\`: "## Directory Structure\\n[TO BE ANALYZED]"
-  - \`content\`: Visual directory tree with purpose of each folder
-
-**Step 3 - Analyze Architecture:**
-- \`read_file\` entry points (main.ts, index.js, app.py, etc.)
-- \`read_file\` 5-10 source files to understand code patterns and organization
-- Identify architectural pattern (Clean Arch, MVC, Microservices, etc.)
-- \`modify_file\` to replace:
-  - \`target_content\`: "## Architecture\\n[TO BE ANALYZED]"
-  - \`content\`: Comprehensive architectural description with patterns and module organization
-
-**Step 4 - Document Components:**
-- Identify ALL major modules/components by reading source files
-- For each component: location, purpose, key files
-- \`modify_file\` to replace:
-  - \`target_content\`: "## Key Components\\n[TO BE ANALYZED]"
-  - \`content\`: Detailed list of components with their purposes
-
-**Step 5 - Document APIs (if applicable):**
-- Search for route definitions, controllers, API endpoints
-- Document base URL, main endpoints, request/response patterns
-- \`modify_file\` to replace:
-  - \`target_content\`: "## API / Interfaces\\n[TO BE ANALYZED]"
-  - \`content\`: API documentation (or "Not applicable" if no API)
-
-**Step 6 - Document Data Layer (if applicable):**
-- Search for database configs, ORM setup, model definitions
-- Document database type, ORM tool, key entities/tables
-- \`modify_file\` to replace:
-  - \`target_content\`: "## Data Layer\\n[TO BE ANALYZED]"
-  - \`content\`: Data layer details (or "Not applicable" if no database)
-
-**Step 7 - Configuration & Environment:**
-- Read config files (.env.example, config/, etc.)
-- Identify environment variables and their purposes
-- \`modify_file\` to replace:
-  - \`target_content\`: "## Configuration & Environment\\n[TO BE ANALYZED]"
-  - \`content\`: List of env vars and config files
-
-**Step 8 - Build & Development:**
-- Read package.json scripts, Makefile, build configs
-- Document dev, build, test, lint commands
-- \`modify_file\` to replace:
-  - \`target_content\`: "## Build & Development\\n[TO BE ANALYZED]"
-  - \`content\`: Commands for development workflow
-
-**Step 9 - Patterns & Conventions:**
-- Based on files read, document naming conventions, code organization
-- Note error handling, logging strategies
-- \`modify_file\` to replace:
-  - \`target_content\`: "## Key Patterns & Conventions\\n[TO BE ANALYZED]"
-  - \`content\`: Observed patterns and conventions
-
-**Step 10 - Overview (LAST):**
-- Synthesize all findings into a comprehensive overview
-- \`modify_file\` to replace:
-  - \`target_content\`: "## Overview\\n[TO BE ANALYZED]"
-  - \`content\`: Detailed project description with purpose and main functionality
-
-**HOW TO USE modify_file:**
-\`\`\`json
-{
-  "actions": [{
-    "type": "modify_file",
-    "path": "${configFileRelative}",
-    "target_content": "## Tech Stack\\n[TO BE ANALYZED]",
-    "content": "## Tech Stack\\n- **Language**: TypeScript 5.3\\n- **Runtime**: Node.js 20.x\\n..."
-  }]
-}
-\`\`\`
-
-\`\`\`markdown
-# Project Context
-
-## Overview
-[TO BE ANALYZED]
-
-## Tech Stack
-[TO BE ANALYZED]
-
-## Architecture
-[TO BE ANALYZED]
-
-## Directory Structure
-[TO BE ANALYZED]
-
-## Key Components
-[TO BE ANALYZED]
-
-## API / Interfaces
-[TO BE ANALYZED]
-
-## Data Layer
-[TO BE ANALYZED]
-
-## Configuration & Environment
-[TO BE ANALYZED]
-
-## Build & Development
-[TO BE ANALYZED]
-
-## Key Patterns & Conventions
-[TO BE ANALYZED]
-\`\`\`
-
-**Step 2 - Explore and Update Incrementally:**
-After creating the template, perform these analyses and UPDATE each section:
-
-**2.1 - Analyze Tech Stack:**
-- \`list_files\` root directory
-- \`read_file\` package.json (or equivalent manifest)
-- \`modify_file\` to replace "## Tech Stack\\n[TO BE ANALYZED]" with detailed findings
-
-**2.2 - Analyze Directory Structure:**
-- \`list_files\` on key directories (src, tests, config, etc.)
-- \`modify_file\` to replace "## Directory Structure\\n[TO BE ANALYZED]" with complete structure
-
-**2.3 - Analyze Architecture:**
-- \`read_file\` entry points (main.ts, index.js, etc.)
-- \`read_file\` 5-10 source files to understand patterns
-- \`modify_file\` to replace "## Architecture\\n[TO BE ANALYZED]" with architectural insights
-
-**2.4 - Document Components:**
-- Identify major modules/components
-- \`modify_file\` to replace "## Key Components\\n[TO BE ANALYZED]" with component details
-
-**2.5 - Document APIs (if applicable):**
-- Search for route definitions, controllers, API endpoints
-- \`modify_file\` to replace "## API / Interfaces\\n[TO BE ANALYZED]"
-
-**2.6 - Document Data Layer (if applicable):**
-- Search for database configs, ORM, models
-- \`modify_file\` to replace "## Data Layer\\n[TO BE ANALYZED]"
-
-**2.7 - Final Touches:**
-- Update remaining sections (Config, Build, Patterns)
-- Ensure Overview is comprehensive
-
-**HOW TO USE modify_file:**
-\`\`\`json
-{
-  "actions": [{
-    "type": "modify_file",
-    "path": "${configFileRelative}",
-    "target_content": "## Tech Stack\\n[TO BE ANALYZED]",
-    "content": "## Tech Stack\\n- **Language**: TypeScript 5.3\\n- **Runtime**: Node.js 20.x\\n- **Framework**: Express 4.18\\n..."
-  }]
-}
-\`\`\`
-
-**SECTION TEMPLATES (For your updates):**
-
-**Tech Stack:**
-\`\`\`markdown
-## Tech Stack
-- **Language**: [name + version]
-- **Runtime**: [name + version]
-- **Framework**: [name + version]
-- **Build Tool**: [name]
-- **Testing**: [framework]
-- **Key Dependencies**:
-  - [dep-name]: [purpose]
-  - [dep-name]: [purpose]
-\`\`\`
-
-**Architecture:**
-\`\`\`markdown
-## Architecture
-[Comprehensive description]
-- **Pattern**: [Clean Arch, MVC, etc.]
-- **Module Organization**: [how modules are structured]
-- **Layer Separation**: [controllers, services, repos]
-- **Configuration**: [how config is managed]
-\`\`\`
-
-**Directory Structure:**
-\`\`\`markdown
-## Directory Structure
-\\\`\\\`\\\`
-/src
-  /core        - [Purpose]
-  /commands    - [Purpose]
-  /ui          - [Purpose]
-/tests         - [Purpose]
-/docs          - [Purpose]
-\\\`\\\`\\\`
-\`\`\`
-
-**Key Components:**
-\`\`\`markdown
-## Key Components
-
-### [Component Name 1]
-- **Location**: \\\`path/to/component\\\`
-- **Purpose**: [What it does]
-- **Key Files**: [Important files]
-
-### [Component Name 2]
-- **Location**: \\\`path/to/component\\\`
-- **Purpose**: [What it does]
-- **Key Files**: [Important files]
-\`\`\`
-
-**DEPTH REQUIREMENT**:
-- Read MULTIPLE files (5-10 minimum) to understand patterns
-- Identify ALL major modules/components
-- Document API routes, database schemas if applicable
-- Note design patterns and architectural decisions
-- List important dependencies with their purposes
+  let contextContent = "";
+  const contextPath = path4.resolve(projectRoot, "_sharkrc", "project-context.md");
+  if (fs4.existsSync(contextPath)) {
+    contextContent = fs4.readFileSync(contextPath, "utf-8");
+    tui.log.info(`\u{1F4D8} Context loaded.`);
+  }
+  let briefingContent = "";
+  if (options.briefingPath && fs4.existsSync(options.briefingPath)) {
+    briefingContent = fs4.readFileSync(options.briefingPath, "utf-8");
+    tui.log.info(`\u{1F4C4} Briefing loaded from: ${colors.dim(options.briefingPath)}`);
+  } else {
+    const standardBriefing = path4.resolve(projectRoot, "_sharkrc", "briefing.md");
+    if (fs4.existsSync(standardBriefing)) {
+      briefingContent = fs4.readFileSync(standardBriefing, "utf-8");
+      tui.log.info(`\u{1F4C4} Briefing loaded.`);
+    }
+  }
+  let initialPrompt = `
+Voc\xEA \xE9 o **Shark Spec**, um Arquiteto de Software S\xEAnior e Tech Lead.
+Seu objetivo final \xE9 produzir uma especifica\xE7\xE3o t\xE9cnica precisa para a tarefa no arquivo \`_sharkrc/tech-spec.md\`.
 
-**RULES**:
-- Create template FIRST (step 1)
-- Update sections INCREMENTALLY (steps 2-7)
-- Do NOT wait to write everything at the end
-- Use \`modify_file\` to replace "[TO BE ANALYZED]" sections
-- Be DETAILED and COMPREHENSIVE
-- Take your time - you have up to 30 steps
-- Verify facts with \`read_file\` or \`search_file\` before documenting
-`.trim();
-  await runScanLoop(superPrompt, outputFile);
-}
-async function runScanLoop(initialPrompt, targetPath) {
-  let nextPrompt = initialPrompt;
-  let keepGoing = true;
-  let stepCount = 0;
-  const MAX_STEPS = 60;
-  while (keepGoing && stepCount < MAX_STEPS) {
-    stepCount++;
-    const spinner = tui.spinner();
-    const msg = t("commands.scan.analyzing").replace("{step}", stepCount.toString());
-    spinner.start(msg);
-    let responseText = "";
-    let lastResponse = null;
-    try {
-      lastResponse = await callScanAgentApi(nextPrompt, (chunk) => {
-        responseText += chunk;
-      });
-      spinner.stop(t("commands.scan.stepComplete"));
-      if (lastResponse && lastResponse.actions && lastResponse.actions.length > 0) {
-        let executionResults = "";
-        let fileCreated = false;
-        for (const action of lastResponse.actions) {
-          if (action.type === "list_files") {
-            tui.log.info(t("commands.scan.scanningDir").replace("{0}", colors.bold(action.path || ".")));
-            const result = handleListFiles(action.path || ".");
-            executionResults += `[Action list_files(${action.path}) Result]:
-${result}
+\u26A0\uFE0F O SEU WORKFLOW \xC9 GUIADO POR FASES.
+N\xC3O TENTE ADIANTAR O TRABALHO (ex: investigar c\xF3digo ou preencher template agora).
 
-`;
-          } else if (action.type === "read_file") {
-            tui.log.info(t("commands.scan.readingFile").replace("{0}", colors.bold(action.path || "")));
-            const result = handleReadFile(action.path || "");
-            executionResults += `[Action read_file(${action.path}) Result]:
-${result}
+**VOC\xCA EST\xC1 NA FASE 1: ENTENDIMENTO DA TAREFA**
+- Use \`talk_with_user\` para perguntar ao usu\xE1rio qual tarefa espec\xEDfica, funcionalidade ou bug ele precisa especificar.
+- Confirme o escopo e os limites com o usu\xE1rio.
+- Se o escopo estiver perfeitamente claro e confirmado (com o usu\xE1rio), emita "PHASE_COMPLETED" no campo "summary" do JSON para avan\xE7ar.
 
+IMPORTANTE: Toda a sua comunica\xE7\xE3o DEVE ser em Portugu\xEAs.
 `;
-          } else if (action.type === "search_file") {
-            tui.log.info(t("commands.scan.searching").replace("{0}", colors.bold(action.path || "")));
-            const result = handleSearchFile(action.path || "");
-            executionResults += `[Action search_file(${action.path}) Result]:
-${result}
+  if (briefingContent) {
+    initialPrompt += `
+\u2139\uFE0F Um documento de briefing foi encontrado. Ele define parcialmente a tarefa para a Fase 1.
+Confirme seu entendimento com o usu\xE1rio via \`talk_with_user\` antes de prosseguir para a Fase 2.
 
+--- BRIEFING ---
+${briefingContent}
+----------------
 `;
-          } else if (action.type === "create_file" || action.type === "modify_file") {
-            const resolvedActionPath = path7.resolve(action.path || "");
-            const resolvedTargetPath = path7.resolve(targetPath);
-            let isTarget = resolvedActionPath === resolvedTargetPath;
-            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;
-            }
-            if (isTarget) {
-              const finalPath = targetPath;
-              const BOM = "\uFEFF";
-              if (action.type === "create_file") {
-                const contentToWrite = action.content || "";
-                const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-                fs6.writeFileSync(finalPath, finalContent, { encoding: "utf-8" });
-                tui.log.success(t("commands.scan.generated").replace("{0}", finalPath));
-                fileCreated = true;
-              } else {
-                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;
-                    fs6.writeFileSync(finalPath, finalContent, { encoding: "utf-8" });
-                    tui.log.success(t("commands.scan.updated").replace("{0}", finalPath));
-                    fileCreated = true;
-                  } else {
-                    tui.log.warning(t("commands.scan.error") + ": " + t("commands.scan.contentNotFound"));
-                    executionResults += `[Action ${action.type}]: Failed. Target content not found in file.
-`;
-                    fileCreated = false;
-                  }
-                } else {
-                  tui.log.warning(t("commands.scan.error") + ": " + t("commands.scan.notFound"));
-                }
-              }
-              executionResults += `[Action ${action.type}]: Success. Task Completed.
-`;
-            } else {
-              tui.log.warning(t("commands.scan.error"));
-              executionResults += `[Action ${action.type}]: ${t("commands.scan.skipped")}
-`;
-            }
-          } else if (action.type === "talk_with_user") {
-            tui.log.info(colors.primary(t("commands.scan.agentAsks")));
-            console.log(action.content);
-            const reply = await tui.text({ message: t("commands.scan.agentInput"), placeholder: t("commands.scan.replyPlaceholder") });
-            executionResults += `[User Reply]: ${reply}
+  } else {
+    initialPrompt += `
+\u2139\uFE0F Nenhum documento de briefing foi encontrado. Inicie a Fase 1 imediatamente: use \`talk_with_user\` para perguntar ao usu\xE1rio o que precisa ser especificado.
 `;
-          }
-        }
-        if (fileCreated) {
-          const currentContent = fs6.readFileSync(targetPath, "utf-8");
-          const pendingSections = [];
-          const lines = currentContent.split("\n");
-          let currentSection = "";
-          for (const line of lines) {
-            if (line.startsWith("## ")) {
-              currentSection = line.substring(3).trim();
-            }
-            if (line.includes("[TO BE ANALYZED]")) {
-              if (currentSection && !pendingSections.includes(currentSection)) {
-                pendingSections.push(currentSection);
-              }
-            }
-          }
-          const pendingMsg = pendingSections.length > 0 ? `
-
-[System Helper]: ${t("commands.scan.pendingSections").replace("{0}", pendingSections.join(", "))}` : `
-
-[System Helper]: ${t("commands.scan.allPopulated")}`;
-          nextPrompt = `${executionResults}
-
-[System]: File updated successfully.${pendingMsg} Please continue with the next step of the analysis and focus on the pending sections.`;
-          FileLogger.log("SCAN", "Section updated, continuing loop", { step: stepCount, pending: pendingSections.length });
-        } else {
-          nextPrompt = executionResults;
-          FileLogger.log("SCAN", "Auto-replying with results", { length: executionResults.length });
-        }
-      } else {
-        tui.log.success(t("commands.scan.completed"));
-        keepGoing = false;
-      }
-    } catch (error) {
-      spinner.stop(t("common.error"));
-      tui.log.error(error.message);
-      keepGoing = false;
-    }
-  }
-}
-async function callScanAgentApi(prompt, onChunk) {
-  const realm = await getActiveRealm();
-  const token = await ensureValidToken(realm);
-  let conversationId = await conversationManager.getConversationId(AGENT_TYPE3);
-  const payload = {
-    user_prompt: prompt,
-    streaming: true,
-    stackspot_knowledge: false,
-    return_ks_in_response: true,
-    use_conversation: true,
-    conversation_id: conversationId
-  };
-  const agentVersion = getAgentVersion3();
-  if (agentVersion) {
-    payload.agent_version_number = agentVersion;
-  }
-  const url = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${getAgentId3()}/chat`;
-  let fullMsg = "";
-  let raw = {};
-  FileLogger.log("SCAN", "Calling API", { promptLength: prompt.length });
-  await sseClient.streamAgentResponse(url, payload, { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" }, {
-    onChunk: (c) => {
-      fullMsg += c;
-      onChunk(c);
-    },
-    onComplete: (msg, metadata) => {
-      const returnedId = metadata?.conversation_id;
-      raw = {
-        message: msg || fullMsg,
-        conversation_id: returnedId || conversationId
-      };
-    },
-    onError: (e) => {
-      throw e;
-    }
-  });
-  const parsed = parseAgentResponse(raw);
-  if (parsed.conversation_id) {
-    await conversationManager.saveConversationId(AGENT_TYPE3, parsed.conversation_id);
-  }
-  return parsed;
-}
-
-// src/commands/scan.ts
-var scanCommand = new Command2("scan").description("Analyze the project and generate context documentation").option("-o, --output <path>", "Output file path (default: _bmad/project-context/project-context.md)").option("--depth <level>", "Scan depth (quick, deep, exhaustive)", "quick").action(async (options) => {
-  try {
-    await interactiveScanAgent(options);
-  } catch (error) {
-    console.error("Error during scan:", error.message);
-    process.exit(1);
-  }
-});
-
-// src/commands/dev.ts
-import { Command as Command3 } from "commander";
-
-// src/core/agents/developer-agent.ts
-import fs7 from "fs";
-import path8 from "path";
-var AGENT_TYPE4 = "developer_agent";
-async function validateTypeScript(filePath) {
-  try {
-    const result = await handleRunCommand(`npx tsc --noEmit --skipLibCheck ${filePath}`);
-    if (result.trim() === "" || !result.includes("error TS")) {
-      return { valid: true };
-    }
-    return { valid: false, error: result };
-  } catch (e) {
-    return { valid: false, error: e.message || "TypeScript validation failed" };
-  }
-}
-function getAgentId4(overrideId) {
-  if (overrideId) return overrideId;
-  const config = ConfigManager.getInstance().getConfig();
-  if (config.agents?.dev) return config.agents.dev;
-  if (process.env.STACKSPOT_DEV_AGENT_ID) return process.env.STACKSPOT_DEV_AGENT_ID;
-  return "01KEQCGJ65YENRA4QBXVN1YFFX";
-}
-function getAgentVersion4(overrideVersion) {
-  if (overrideVersion) return overrideVersion;
-  const config = ConfigManager.getInstance().getConfig();
-  if (config.agentVersions?.dev) return config.agentVersions.dev;
-  if (process.env.STACKSPOT_DEV_AGENT_VERSION) return process.env.STACKSPOT_DEV_AGENT_VERSION;
-  return void 0;
-}
-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 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}`);
-    }
+  if (options.initialContext) {
+    initialPrompt += `
+--- CONTEXTO DE EXECU\xC7\xC3O ANTERIOR (HANDOVER/FEEDBACK) ---
+${options.initialContext}
+-----------------------------------------------------
+`;
   }
-  const currentTask = options.taskInstruction || "Analyze the project and fix pending issues.";
-  let basePrompt = ``;
   if (contextContent) {
-    basePrompt += `
+    initialPrompt += `
+\u2139\uFE0F O contexto do projeto est\xE1 dispon\xEDvel para refer\xEAncia. Use-o na Fase 2 para se alinhar com os padr\xF5es de arquitetura existentes, mas N\xC3O o use para preencher as se\xE7\xF5es de forma gen\xE9rica.
 
 --- PROJECT CONTEXT ---
 ${contextContent}
 -----------------------
 `;
   }
-  if (options.history) {
-    basePrompt += `
-
---- PREVIOUS EXECUTION SUMMARY ---
-${options.history}
-----------------------------------
-`;
-  }
-  basePrompt += `
-
-\u{1F7E2} EXECUTION MODE
-
-You are a highly skilled Developer Agent.
-\u{1F449} **CURRENT TASK**: "${currentTask}"
-
-Your goal is to COMPLETE this specific task and then STOP.
-1. Implement the necessary changes.
-2. Verify (compile/test).
-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.
-`;
-  let nextPrompt = basePrompt;
+  await runSpecLoop(initialPrompt.trim(), outputFile, options.agentId);
+}
+async function runSpecLoop(initialMessage, targetPath, overrideAgentId) {
+  let nextPrompt = initialMessage;
   let keepGoing = true;
-  const spinner = tui.spinner();
-  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) {
+  let stepCount = 0;
+  let currentPhase = 1;
+  const MAX_STEPS = 30;
+  while (keepGoing && stepCount < MAX_STEPS) {
+    stepCount++;
+    const spinner = tui.spinner();
+    spinner.start(`\u{1F3D7}\uFE0F  Spec Agent working (Step ${stepCount}/${MAX_STEPS})...`);
+    let pendingSections = [];
+    if (fs4.existsSync(targetPath)) {
+      const content = fs4.readFileSync(targetPath, "utf-8");
+      if (content.includes("[TO BE ANALYZED]")) pendingSections.push("Analysis Sections (Stack, Arch, Data, API)");
+      if (content.includes("[TO BE FILLED")) pendingSections.push("Implementation Steps");
+    }
+    if (pendingSections.length === 0 && stepCount > 1) {
+    }
+    let responseText = "";
+    let lastResponse = null;
     try {
-      spinner.start("\u{1F988} Shark Dev working...");
-      const lastResponse = await callDevAgentApi(nextPrompt, (chunk) => {
-      }, conversationKey);
+      lastResponse = await callSpecAgentApi(nextPrompt, (chunk) => {
+        responseText += chunk;
+      }, overrideAgentId);
       spinner.stop("Response received");
-      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 (response.message && response.message.includes("TASK_FAILED:")) {
-          const failureReason = response.message.split("TASK_FAILED:")[1].trim();
-          tui.log.error(`\u274C Agent reported task failure: ${failureReason}`);
-          return { success: false, summary: failureReason };
-        }
-        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;
-        }
+      if (lastResponse && lastResponse.actions) {
         let executionResults = "";
         let waitingForUser = false;
-        for (const action of actions) {
+        let specUpdated = false;
+        let hasSystemError = false;
+        let systemErrorContent = "";
+        for (const action of lastResponse.actions) {
           if (action.type === "talk_with_user") {
-            tui.log.info(colors.primary("\u{1F916} Shark Dev:"));
-            console.log(action.content);
-            if (!isTaskCompleted) waitingForUser = true;
+            const isSystemError = action.content?.startsWith("[SYSTEM ERROR]");
+            if (isSystemError) {
+              tui.log.error(`\u26A0\uFE0F Detectado erro na resposta do Agente (truncado ou inv\xE1lido).`);
+              tui.log.info(colors.dim(action.content || ""));
+              const approved = await tui.confirm({ message: `Enviar notifica\xE7\xE3o de erro para o agente tentar se recuperar automaticamente?` });
+              if (approved) {
+                hasSystemError = true;
+                systemErrorContent = action.content || "";
+              } else {
+                const userReply = await tui.text({ message: "Seu prompt alternativo para o agente:" });
+                if (tui.isCancel(userReply)) {
+                  keepGoing = false;
+                  return;
+                }
+                hasSystemError = true;
+                systemErrorContent = userReply;
+              }
+            } else {
+              tui.log.info(colors.primary("\u{1F916} Architect:"));
+              console.log(action.content);
+              waitingForUser = true;
+            }
           } else if (action.type === "list_files") {
             tui.log.info(`\u{1F4C2} Scanning: ${colors.dim(action.path || ".")}`);
             const result = handleListFiles(action.path || ".");
@@ -2802,359 +846,205 @@ ${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}
 
 `;
-          } else if (action.type === "run_command") {
-            const cmd = action.command || "";
-            tui.log.info(`\u{1F4BB} Executing: ${colors.dim(cmd)}`);
-            let approved = autoApprovals.commands;
-            if (!approved) {
-              const choice = await tui.select({
-                message: `Execute: ${cmd}?`,
-                options: [{ value: "yes", label: "Yes" }, { value: "always", label: "Yes (Auto-Approve Session)" }, { value: "no", label: "No" }]
-              });
-              if (choice === "always") {
-                autoApprovals.commands = true;
-                approved = true;
-              } else if (choice === "yes") approved = true;
-            }
-            if (approved) {
-              const result = await handleRunCommand(cmd);
-              executionResults += `[Action run_command(${cmd}) Result]:
+          } else if (action.type === "search_code") {
+            const glob = action.path || "src/**/*";
+            const query = action.query || "";
+            const isRegex = action.is_regex === true;
+            tui.log.info(`\u{1F50E} Search code: ${colors.dim(`"${query}" in ${glob}`)}`);
+            const result = handleSearchCode(glob, query, isRegex);
+            executionResults += `[Action search_code("${query}" in "${glob}") Result]:
 ${result}
 
 `;
-            } else {
-              executionResults += `[Action run_command]: User blocked execution.
-
-`;
-            }
           } else if (["create_file", "modify_file"].includes(action.type)) {
-            const filePath = action.path || "";
-            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" }, { value: "always", label: "Yes (Auto-Approve Session)" }, { value: "no", label: "No" }]
-              });
-              if (choice === "always") {
-                autoApprovals.files = true;
-                approved = true;
-              } else if (choice === "yes") approved = true;
+            let actionPath = path4.resolve(action.path || "");
+            const resolvedTargetPath = path4.resolve(targetPath);
+            let isTarget = actionPath === resolvedTargetPath;
+            if (!isTarget && path4.basename(actionPath) === "tech-spec.md") {
+              tui.log.warning(`Redirecting ${action.type} from ${action.path} to ${path4.relative(process.cwd(), targetPath)}`);
+              action.path = targetPath;
+              actionPath = resolvedTargetPath;
+              isTarget = true;
             }
-            if (approved) {
+            if (!isTarget && action.type === "create_file") {
+              const confirm = await tui.confirm({ message: `Agent wants to create ${action.path}. Allow?` });
+              if (!confirm) {
+                executionResults += `[Action create_file]: User denied.
+`;
+                continue;
+              }
+            }
+            try {
               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
-
+                const BOM = "\uFEFF";
+                fs4.writeFileSync(action.path, BOM + (action.content || ""), "utf-8");
+                tui.log.success(`\u2705 Created: ${action.path}`);
+                executionResults += `[Action create_file]: Success.
 `;
-              } 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
-
-` : `[Action modify_file]: Failed
-
+              } else if (action.type === "modify_file") {
+                if (action.target_content) {
+                  const success = startSmartReplace(action.path, action.content || "", action.target_content, tui);
+                  if (success) {
+                    executionResults += `[Action modify_file]: Success.
 `;
-              }
-              const val = await validateTypeScript(path8.resolve(projectRoot, filePath));
-              if (!val.valid) executionResults += `[Validation Failed]: ${val.error}
-
+                    specUpdated = true;
+                  } else {
+                    executionResults += `[Action modify_file]: Failed. Target content not found or ambiguous.
 `;
-            } else {
-              executionResults += `[Action ${action.type}]: User Denied.
-
+                  }
+                } else {
+                  executionResults += `[Action modify_file]: Failed. 'target_content' is required.
 `;
-            }
-          } 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_get_property") {
-                tui.log.info(`\u{1F50D} Reading property ${colors.gray(action.property_name || "")} in ${colors.gray(action.class_name || "")}`);
-                const propContent = await astGetProperty(action.path || "", action.class_name || "", action.property_name || "");
-                result = `[AST Get Property] Content:
-${propContent}`;
-              } 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_modify_property") {
-                tui.log.info(`\u270F\uFE0F Modifying property ${colors.gray(action.property_name || "")} in ${colors.gray(action.class_name || "")}`);
-                const success = await astModifyProperty(action.path || "", action.class_name || "", action.property_name || "", action.property_code || "");
-                result = success ? "Property modified successfully." : "Failed to modify 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}
-
-`;
-              tui.log.info(`\u26A1 AST Action ${colors.dim(action.type)}: ${result}`);
             } catch (e) {
-              executionResults += `[Action ${action.type} Failed]: ${e.message}
-
+              executionResults += `[Action ${action.type}]: Error: ${e.message}
 `;
-              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}
+          }
+        }
+        if (lastResponse.message && lastResponse.message.includes("PHASE_COMPLETED")) {
+          const extraContext = executionResults ? `
 
-`;
-          } 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
+Resultados das \xFAltimas a\xE7\xF5es executadas antes da conclus\xE3o:
+${executionResults}` : "";
+          if (currentPhase === 1) {
+            currentPhase = 2;
+            tui.log.success(`\u2705 Fase 1 Conclu\xEDda. Iniciando Fase 2 (Investiga\xE7\xE3o).`);
+            nextPrompt = `[System Message]
+Voc\xEA completou a FASE 1 com sucesso.
 
-` : `[Action modify_ast]: Failed
+**VOC\xCA AGORA EST\xC1 NA FASE 2: INVESTIGA\xC7\xC3O**
+- Use \`search_code\` e \`list_files\` para explorar os arquivos relevantes \xE0 tarefa.
+- Prefira \`search_code\` em vez de \`read_file\` para buscar c\xF3digo sem inflar o contexto.
+- N\xC3O leia o projeto inteiro de forma gen\xE9rica.
+- REGRA DE OURO (READ-FIRST): Voc\xEA N\xC3O PODE referenciar um arquivo na especifica\xE7\xE3o t\xE9cnica que n\xE3o tenha investigado nesta fase.
+- Quando achar que possui toda a clareza t\xE9cnica sobre onde e o que deve ser feito no c\xF3digo, emita "PHASE_COMPLETED" no summary.${extraContext}`;
+            continue;
+          } else if (currentPhase === 2) {
+            currentPhase = 3;
+            tui.log.success(`\u2705 Fase 2 Conclu\xEDda. Iniciando Fase 3 (Preenchimento).`);
+            nextPrompt = `[System Message]
+Voc\xEA completou a FASE 2 com sucesso.
 
-`;
+**VOC\xCA AGORA EST\xC1 NA FASE 3: PREENCHIMENTO DO TEMPLATE**
+- Use \`modify_file\` no arquivo \`${targetPath}\` para substituir os placeholders pelo conte\xFAdo real levantado na fase de investiga\xE7\xE3o.
+- As se\xE7\xF5es 1-4 devem descrever o contexto da TAREFA, e n\xE3o o projeto como um todo.
+- Passos de Implementa\xE7\xE3o (Implementation Steps): APENAS checkboxes markdown: \`- [ ] [Verbo de A\xE7\xE3o] [O Que] em [Caminho Relativo]\`.
+- Quando TODOS os placeholders ([TO BE ANALYZED...] ou [TO BE FILLED]) forem substitu\xEDdos e o trabalho conclu\xEDdo, emita "SPEC_UPDATED: Complete" no summary para finalizar.${extraContext}`;
+            continue;
+          }
+        }
+        if (lastResponse.message && lastResponse.message.includes("SPEC_UPDATED:")) {
+          if (currentPhase < 3) {
+            tui.log.warning(`O agente tentou finalizar prematuramente. For\xE7ando retorno para a fase atual...`);
+            nextPrompt = `[System Error]: Voc\xEA tentou finalizar a especifica\xE7\xE3o prematuramente emitindo SPEC_UPDATED, mas ainda est\xE1 na Fase ${currentPhase}. Voc\xEA s\xF3 pode finalizar quando estiver na Fase 3.
+
+Continue seu trabalho na Fase ${currentPhase} ou emita "PHASE_COMPLETED" se terminou esta etapa atual.`;
+            continue;
+          }
+          const content = fs4.existsSync(targetPath) ? fs4.readFileSync(targetPath, "utf-8") : "";
+          if (content.includes("[TO BE")) {
+            const pendingMatches = [...content.matchAll(/## ([^\n]+)[\s\S]*?\[TO BE/g)].map((m) => m[1]);
+            let missing = pendingMatches.length > 0 ? pendingMatches.join(", ") : "algumas se\xE7\xF5es";
+            tui.log.warning(`O agente tentou concluir prematuramente, mas h\xE1 placeholders pendentes. For\xE7ando retorno...`);
+            nextPrompt = `[System Error]: A valida\xE7\xE3o falhou e o bloqueio autom\xE1tico foi acionado.
+Voc\xEA tentou concluir a tarefa, mas o arquivo AINDA possui placeholders '[TO BE ANALYZED...]' ou '[TO BE FILLED]'.
+As seguintes se\xE7\xF5es ainda cont\xEAm estes placeholders: ${missing}.
+Voc\xEA \xE9 OBRIGADO a usar a action \`modify_file\` para preencher o conte\xFAdo de cada uma dessas se\xE7\xF5es. Use o placeholder exato no campo \`target_content\`. N\xC3O repita a conclus\xE3o da tarefa at\xE9 corrigir todas as pend\xEAncias.`;
+            continue;
+          } else {
+            const updateSummary = lastResponse.message.split("SPEC_UPDATED:")[1].trim();
+            tui.log.success(`\u2705 Spec Finalized: ${updateSummary}`);
+            return;
           }
         }
         if (executionResults) {
-          if (waitingForUser) {
+          FileLogger.log("TOOL_EXECUTION", "Specification Agent Actions Output", { executionResults });
+        }
+        if (hasSystemError) {
+          nextPrompt = systemErrorContent;
+        } else if (waitingForUser) {
+          const userReply = await tui.text({ message: "Your answer", placeholder: "Type your answer..." });
+          if (tui.isCancel(userReply)) {
+            keepGoing = false;
+            return;
+          }
+          FileLogger.log("USER_INPUT", "User response to specification agent", { userReply });
+          nextPrompt = `${executionResults}
+
+User Reply: ${userReply}`;
+        } else if (executionResults) {
+          const content = fs4.existsSync(targetPath) ? fs4.readFileSync(targetPath, "utf-8") : "";
+          let systemMsg = "Execu\xE7\xE3o da ferramenta conclu\xEDda.";
+          if (specUpdated) {
+            if (content.includes("[TO BE")) {
+              const pendingMatches = [...content.matchAll(/## ([^\n]+)[\s\S]*?\[TO BE/g)].map((m) => m[1]);
+              let missing = pendingMatches.length > 0 ? pendingMatches.join(", ") : "v\xE1rias se\xE7\xF5es";
+              systemMsg += `
+[System]: Se\xE7\xE3o atualizada com sucesso. A valida\xE7\xE3o detectou que AINDA H\xC1 placeholders pendentes ('[TO BE...]') nas seguintes se\xE7\xF5es: ${missing}.
+Por favor, envie uma nova action \`modify_file\` focada em uma destas se\xE7\xF5es obrigatoriamente. USE o respectivo placeholder no campo \`target_content\` para que o replace funcione.`;
+            } else {
+              systemMsg += "\n[System]: O arquivo parece completo! Se estiver satisfeito e possuir TODAS as implementa\xE7\xF5es descritas, retorne 'SPEC_UPDATED: Complete'.";
+            }
+          } else {
+            systemMsg += "\n[System]: A modifica\xE7\xE3o do arquivo falhou. Verifique se o `target_content` que voc\xEA usou existe EXATAMENTE como no arquivo e se ele \xE9 \xDANICO na hora de usar a action `modify_file`.";
+          }
+          nextPrompt = `${executionResults}
+
+${systemMsg}`;
+        } else {
+          if (lastResponse.message) {
+            tui.log.info(colors.primary("\u{1F916} Architect (Message only):"));
+            console.log(lastResponse.message);
             const userReply = await tui.text({ message: "Your answer:" });
             if (tui.isCancel(userReply)) {
               keepGoing = false;
               break;
             }
-            nextPrompt = `${executionResults}
-User Reply: ${userReply}`;
+            FileLogger.log("USER_INPUT", "User response to specification agent (Message only)", { userReply });
+            nextPrompt = userReply;
           } else {
-            nextPrompt = `${executionResults}
-[System]: Continue execution. If finished, output "TASK_COMPLETED: summary".`;
-            tui.log.info(colors.dim("Processing results..."));
+            keepGoing = false;
           }
-        } else if (!keepGoing) {
-        } else if (waitingForUser) {
-        } else {
-          if (!isTaskCompleted && actions.length > 0) nextPrompt = "Please continue.";
         }
       } else {
-        tui.log.warning("No response received from agent.");
+        tui.log.warning("No actions received.");
+        keepGoing = false;
       }
-    } catch (e) {
-      tui.log.error(e.message);
+    } catch (error) {
+      spinner.stop("Error");
+      tui.log.error(error.message);
       keepGoing = false;
-      return { success: false, summary: `Error: ${e.message}` };
     }
   }
-  tui.log.success("\u2705 Task Scope Completed");
-  return { success: true, summary: finalSummary || "Task completed without summary." };
 }
-async function callDevAgentApi(prompt, onChunk, conversationKey = AGENT_TYPE4) {
-  const realm = await getActiveRealm();
-  const token = await ensureValidToken(realm);
-  const conversationId = await conversationManager.getConversationId(conversationKey);
-  const payload = {
-    user_prompt: prompt,
-    streaming: true,
-    use_conversation: true,
-    conversation_id: conversationId,
-    stackspot_knowledge: false
-  };
-  const agentVersion = getAgentVersion4();
-  if (agentVersion) {
-    payload.agent_version_number = agentVersion;
-  }
-  const url = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${getAgentId4()}/chat`;
-  let fullMsg = "";
-  let raw = {};
-  await sseClient.streamAgentResponse(url, payload, { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" }, {
-    onChunk: (c) => {
-      fullMsg += c;
-      onChunk(c);
-    },
-    onComplete: (msg, metadata) => {
-      const returnedId = metadata?.conversation_id;
-      raw = {
-        message: msg || fullMsg,
-        conversation_id: returnedId || conversationId
-      };
-    },
-    onError: (e) => {
-      throw e;
-    }
+async function callSpecAgentApi(prompt, onChunk, agentId) {
+  const conversationId = await conversationManager.getConversationId(AGENT_TYPE2);
+  FileLogger.log("AGENT", "Calling Agent API", { agentId, conversationId });
+  const provider = ProviderResolver.getProvider("specification_agent");
+  if (agentId && "agentId" in provider) {
+    provider.agentId = agentId;
+  }
+  const parsed = await provider.streamChat(prompt, {
+    conversationId,
+    agentType: "specification_agent",
+    onChunk
   });
-  const parsed = parseAgentResponse(raw);
   if (parsed.conversation_id) {
-    await conversationManager.saveConversationId(conversationKey, parsed.conversation_id);
+    await conversationManager.saveConversationId(AGENT_TYPE2, 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, "_sharkrc", "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;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-      const pendingMatch = trimmed.match(/^- \[ \] (.*)/);
-      const completedMatch = trimmed.match(/^- \[x\] (.*)/i);
-      const progressMatch = trimmed.match(/^- \[\/\] (.*)/);
-      let currentTask = null;
-      let status2 = null;
-      let description = "";
-      if (pendingMatch) {
-        description = pendingMatch[1].trim();
-        status2 = "PENDING";
-      } else if (completedMatch) {
-        description = completedMatch[1].trim();
-        status2 = "COMPLETED";
-      } else if (progressMatch) {
-        description = progressMatch[1].trim();
-        status2 = "IN_PROGRESS";
-      }
-      if (status2 && description) {
-        let j = i + 1;
-        while (j < lines.length) {
-          const nextLine = lines[j];
-          const nextTrimmed = nextLine.trim();
-          if (!nextTrimmed || nextTrimmed.match(/^- \[[ x\/]\]/) || nextTrimmed.startsWith("#")) {
-            break;
-          }
-          description += "\n" + nextTrimmed;
-          j++;
-        }
-        currentTask = {
-          id: `task-${taskIndex++}`,
-          description,
-          status: status2,
-          line_number: i
-        };
-        tasks.push(currentTask);
-      }
-    }
-    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 Orchestration V2)").option("-t, --task <type>", "Initial task description (Quick Mode)").option("-c, --context <path>", "Path to custom context file").action(async (options) => {
+// src/commands/legacy.ts
+var legacyCommand = new Command3("legacy").description("Starts the Legacy Developer Agent task orchestration loop").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") {
@@ -3163,7 +1053,6 @@ var devCommand = new Command3("dev").description("Starts the Shark Developer Age
     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") {
@@ -3177,7 +1066,7 @@ var devCommand = new Command3("dev").description("Starts the Shark Developer Age
   let keepOrchestrating = true;
   let burnMode = false;
   let contextHistory = "";
-  tui.intro("\u{1F988} Shark Orchestrator V2");
+  tui.intro("\u{1F988} Shark Legacy Orchestrator");
   while (keepOrchestrating) {
     state = taskManager.analyzeSpecState();
     if (state.status === "COMPLETED") {
@@ -3236,7 +1125,7 @@ ${contextHistory}`
     }
     taskManager.markTaskInProgress(currentTask.id);
     tui.log.info(`\u26A1 Starting Micro-Context for Task: "${currentTask.description}"`);
-    const result = await interactiveDeveloperAgent({
+    const result = await interactiveDeveloperAgent2({
       taskId: currentTask.id,
       taskInstruction: currentTask.description,
       history: contextHistory,
@@ -3271,279 +1160,52 @@ ${contextHistory}`
       }
     }
   }
-  tui.outro("\u{1F988} Orchestration Finished.");
+  tui.outro("\u{1F988} Legacy Orchestration Finished.");
 });
 
-// src/commands/qa.ts
+// src/commands/export-schema.ts
 import { Command as Command4 } from "commander";
+var exportSchemaCommand = new Command4("export-schema").description("Outputs the agent response JSON Schema").action(() => {
+  console.log(JSON.stringify(AGENT_RESPONSE_JSON_SCHEMA, null, 2));
+});
 
-// src/core/agents/qa-agent.ts
-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";
-function getAgentId5() {
-  const config = ConfigManager.getInstance().getConfig();
-  if (config.agents?.qa) return config.agents.qa;
-  return process.env.STACKSPOT_QA_AGENT_ID || "01KEQFJZ3Q3JER11NH22HEZX9X";
-}
-function getAgentVersion5() {
-  const config = ConfigManager.getInstance().getConfig();
-  if (config.agentVersions?.qa) return config.agentVersions.qa;
-  return process.env.STACKSPOT_QA_AGENT_VERSION;
-}
-var ChromeDevToolsClient = class {
-  client = null;
-  transport = null;
-  async connect() {
-    if (this.client) return;
-    try {
-      this.transport = new StdioClientTransport({
-        command: "npx",
-        args: ["-y", "chrome-devtools-mcp@latest"]
-      });
-      this.client = new Client({
-        name: "shark-qa-client",
-        version: "1.0.0"
-      }, {
-        capabilities: {}
-      });
-      await this.client.connect(this.transport);
-      tui.log.success("\u{1F50C} Connected to Chrome DevTools MCP");
-    } catch (e) {
-      tui.log.error(`Failed to connect to Chrome MCP: ${e.message}`);
-      throw e;
-    }
-  }
-  async callTool(name, args) {
-    if (!this.client) await this.connect();
-    try {
-      const result = await this.client.callTool({
-        name,
-        arguments: args
-      });
-      return result;
-    } catch (e) {
-      return { isError: true, content: [{ type: "text", text: `MCP Error: ${e.message}` }] };
-    }
-  }
-  async close() {
-    if (this.transport) {
-      await this.transport.close();
-    }
-  }
-};
-var mcpClient = new ChromeDevToolsClient();
-async function runQAAgent(options) {
-  const agentId = getAgentId5();
-  if (!agentId) {
-    tui.log.error("\u274C STACKSPOT_QA_AGENT_ID not configured.");
-    tui.log.info("Please run: set STACKSPOT_QA_AGENT_ID=<your-id>");
-    return;
-  }
-  await mcpClient.connect();
-  tui.intro("\u{1F988} Shark QA Agent");
-  tui.log.info("Connecting to Chrome DevTools...");
-  const realm = await getActiveRealm();
-  const token = await tokenStorage.getToken(realm);
-  if (!token) {
-    tui.log.error('Authentication required. Run "shark login".');
-    return;
-  }
-  let projectContext = "";
+// src/commands/super.ts
+import { Command as Command5 } from "commander";
+import { fileURLToPath } from "url";
+import path5 from "path";
+import os2 from "os";
+import fs5 from "fs/promises";
+var superCommandAction = async (options = {}) => {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = path5.dirname(__filename2);
+  const packageRoot = path5.resolve(__dirname2, "../../");
+  const internalSkillsPath = path5.join(packageRoot, "skills");
+  const targetPath = options.local ? path5.join(process.cwd(), ".agents", "skills") : path5.join(os2.homedir(), ".shark", "skills");
   try {
-    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) {
-  }
-  let userMessage = `CONTEXTO DO PROJETO:
-${projectContext}
-
-`;
-  if (options.initialUrl) {
-    userMessage += `URL ALVO: ${options.initialUrl}
-`;
-  }
-  if (options.scenario) {
-    userMessage += `CEN\xC1RIO DE TESTE: ${options.scenario}
-`;
-  } else {
-    userMessage += `Por favor, aguarde instru\xE7\xF5es do usu\xE1rio.`;
-  }
-  let keepRunning = true;
-  while (keepRunning) {
-    const spinner = tui.spinner();
-    spinner.start("\u{1F916} Shark QA is thinking...");
-    let agentResponseText = "";
-    let agentResponse = null;
     try {
-      const existingConversationId = await conversationManager.getConversationId(AGENT_TYPE5);
-      await sseClient.streamAgentResponse(
-        `https://genai-inference-app.stackspot.com/v1/agent/${getAgentId5()}/chat`,
-        {
-          user_prompt: userMessage,
-          streaming: true,
-          use_conversation: true,
-          conversation_id: existingConversationId,
-          ...getAgentVersion5() ? { agent_version_number: getAgentVersion5() } : {}
-        },
-        {
-          "Authorization": `Bearer ${token}`
-        },
-        {
-          onChunk: (chunk) => {
-            agentResponseText += chunk;
-            if (agentResponseText.length > 10 && agentResponseText.trim().startsWith("{")) {
-              spinner.message("Receiving structured plan...");
-            }
-          },
-          onComplete: (fullText, metadata) => {
-            try {
-              if (metadata?.conversation_id) {
-                conversationManager.saveConversationId(AGENT_TYPE5, metadata.conversation_id);
-              }
-              agentResponse = parseAgentResponse(fullText || agentResponseText);
-            } catch (e) {
-              tui.log.error(`Parse Error: ${e.message}`);
-              agentResponse = { actions: [], summary: "Error parsing response", message: fullText };
-            }
-          }
-        }
-      );
-      spinner.stop("Response Received");
-    } catch (error) {
-      spinner.stop("Communication Error", 1);
-      tui.log.error(error.message);
-      keepRunning = false;
-      break;
-    }
-    const currentResponse = agentResponse;
-    if (!currentResponse) continue;
-    if (currentResponse.summary) {
-      tui.log.info(colors.primary(`\u{1F4CB} Plan: ${currentResponse.summary}`));
-    }
-    if (currentResponse.actions.length === 0) {
-      const reply = await tui.text({
-        message: "\u{1F916} Shark QA:",
-        placeholder: "Your reply..."
-      });
-      if (tui.isCancel(reply)) {
-        keepRunning = false;
-      } else {
-        userMessage = reply;
-      }
-      continue;
-    }
-    for (const action of currentResponse.actions) {
-      tui.log.info(colors.dim(`Executing: ${action.type}`));
-      let result = "";
-      try {
-        switch (action.type) {
-          case "talk_with_user":
-            const reply = await tui.text({
-              message: `\u{1F916} ${action.content}`
-            });
-            if (tui.isCancel(reply)) keepRunning = false;
-            else result = reply;
-            break;
-          case "use_mcp_tool":
-            if (action.tool_name) {
-              tui.log.info(`\u{1F527} MCP Tool: ${colors.bold(action.tool_name)}`);
-              let args = {};
-              try {
-                args = typeof action.tool_args === "string" ? JSON.parse(action.tool_args) : action.tool_args || {};
-              } catch (e) {
-                tui.log.warning("Failed to parse tool_args, using empty object");
-              }
-              const mcpResult = await mcpClient.callTool(action.tool_name, args);
-              result = JSON.stringify(mcpResult);
-              tui.log.success(`Result: ${result.substring(0, 100)}...`);
-            }
-            break;
-          case "create_file":
-            if (action.path && action.content) {
-              const fullPath = path10.resolve(process.cwd(), action.path);
-              const BOM = "\uFEFF";
-              const contentToWrite = action.content;
-              const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-              fs9.writeFileSync(fullPath, finalContent, { encoding: "utf-8" });
-              tui.log.success(`File created: ${action.path}`);
-              result = "File created successfully.";
-            }
-            break;
-          case "read_file":
-            result = handleReadFile(action.path || "");
-            break;
-          case "run_command":
-            const confirm = await tui.confirm({ message: `Run command: ${action.command}?` });
-            if (confirm && action.command) {
-              result = await handleRunCommand(action.command);
-            } else {
-              result = "Command execution denied by user.";
-            }
-            break;
-          default:
-            result = `Action ${action.type} not fully implemented in local client.`;
-        }
-      } catch (e) {
-        result = `Error executing ${action.type}: ${e.message}`;
-        tui.log.error(result);
-      }
-      userMessage = `[Action ${action.type} Result]:
-${result}
-
-`;
+      await fs5.rm(targetPath, { recursive: true, force: true });
+    } catch {
     }
-  }
-  await mcpClient.close();
-  tui.outro("\u{1F988} Shark QA Session Ended");
-}
-
-// src/commands/qa.ts
-var qaCommand = new Command4("qa").description("Start the Shark QA Agent to test web applications").option("--url <url>", "Initial URL to test").option("--scenario <scenario>", "Scenario description or test case to execute").action(async (options) => {
-  try {
-    await runQAAgent({
-      initialUrl: options.url,
-      scenario: options.scenario
-    });
+    await fs5.mkdir(targetPath, { recursive: true });
+    await fs5.cp(internalSkillsPath, targetPath, { recursive: true, force: true });
+    console.log(`\u{1F680} Superpowers skills installed successfully to ${targetPath}`);
   } catch (error) {
-    console.error("Failed to run QA Agent:", error.message);
+    console.error(`\u274C Failed to install superpowers skills: ${error.message}`);
     process.exit(1);
   }
-});
+};
+var superCommand = new Command5("super").description("Install Superpowers skills globally or locally").option("-l, --local", "Install skills locally in the current project under .agents/skills").action(superCommandAction);
 
 // src/bin/shark.ts
 crashHandler.init();
-var program = new Command5();
+var program = new Command6();
 program.name("shark").description("Shark CLI: AI-Native Collaborative Development Tool").version("0.0.1");
 program.addCommand(loginCommand);
 program.addCommand(initCommand);
-program.addCommand(scanCommand);
 program.addCommand(devCommand);
-program.addCommand(qaCommand);
-program.command("ba").description("Start Business Analyst Agent interactive session").option("--id <agent_id>", "Override Agent ID").action(async (options) => {
-  try {
-    await interactiveBusinessAnalyst();
-  } catch (error) {
-    console.error("Error:", error.message);
-    process.exit(1);
-  }
-});
-program.command("spec").description("Start Specification Agent interactive session").option("--id <agent_id>", "Override Agent ID").option("--briefing <path>", "Path to briefing file").action(async (options) => {
-  try {
-    await interactiveSpecificationAgent({
-      agentId: options.id,
-      briefingPath: options.briefing
-    });
-  } catch (error) {
-    console.error("Error:", error.message);
-    process.exit(1);
-  }
-});
+program.addCommand(legacyCommand);
+program.addCommand(exportSchemaCommand);
+program.addCommand(superCommand);
 program.command("config").description("Manage global configuration").action(configCommand.action);
 process.on("unhandledRejection", (err) => {
   console.error(colors.error("\u274C Unhandled Error:"), err);