shark-ai 0.4.20 → 0.4.24

package/dist/bin/shark.js

@@ -1,49 +1,14 @@
 #!/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-O6YG3GZN.js";
 import {
   ConfigManager,
   FileLogger,
+  authenticate,
   colors,
+  configCommand,
+  loginCommand,
+  tokenStorage,
   tui
-} from "../chunk-CUUMQTCW.js";
+} from "../chunk-NKE5GNDJ.js";
 
 // src/core/error/crash-handler.ts
 import fs from "fs";
@@ -102,10 +67,123 @@ Node: ${process.version}
 var crashHandler = CrashHandler.getInstance();
 
 // src/bin/shark.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } 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");
@@ -125,72 +203,4434 @@ var initAction = async () => {
         { value: "exit", label: "\u274C Exit" }
       ]
     });
-    if (tui.isCancel(action) || action === "exit") {
-      tui.outro("See you later! \u{1F44B}");
-      return;
+    if (tui.isCancel(action) || action === "exit") {
+      tui.outro("See you later! \u{1F44B}");
+      return;
+    }
+    if (action === "resume") {
+      tui.log.success(`Resuming work on ${colors.primary(existingState.projectName)}...`);
+      tui.outro(`To continue, run: "shark agent" (Context loaded)`);
+      return;
+    }
+  }
+  const projectName = await tui.text({
+    message: "What is the name of your project?",
+    placeholder: "e.g. My Awesome App",
+    validate: (value) => {
+      if (!value) return "Project name is required";
+      if (value.trim().length < 2) return "Project name must be at least 2 characters";
+    }
+  });
+  if (tui.isCancel(projectName)) {
+    tui.outro("Initialization cancelled.");
+    return;
+  }
+  const techStackOptions = TechStackEnum.options.map((stack) => ({
+    value: stack,
+    label: stack === "node-ts" ? "Node.js (TypeScript)" : stack === "nextjs" ? "Next.js" : stack.charAt(0).toUpperCase() + stack.slice(1)
+  }));
+  const techStack = await tui.select({
+    message: "Select your technology stack:",
+    options: techStackOptions
+  });
+  if (tui.isCancel(techStack)) {
+    tui.outro("Initialization cancelled.");
+    return;
+  }
+  const spinner = tui.spinner();
+  spinner.start("Initializing project workflow...");
+  try {
+    const newState = {
+      projectId: randomUUID(),
+      projectName,
+      techStack,
+      currentStage: "business_analysis",
+      stageStatus: "pending",
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      artifacts: [],
+      metadata: {
+        initializedBy: "shark-cli",
+        version: "0.0.1"
+      }
+    };
+    await workflowManager.save(newState);
+    spinner.stop("Project workflow created!");
+    tui.log.success(`Project ${colors.primary(projectName)} initialized successfully.`);
+    tui.log.message(`Your Project ID: ${colors.dim(newState.projectId)}`);
+    tui.outro('Ready to start! Run "shark agent" to begin analyzing requirements.');
+  } catch (error) {
+    spinner.stop("Initialization failed.", 1);
+    tui.log.error(error.message);
+    process.exit(1);
+  }
+};
+var initCommand = new Command("init").description("Initialize a new Shark project").action(initAction);
+
+// src/commands/dev.ts
+import { Command as Command2 } from "commander";
+
+// 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",
+    "activate_skill",
+    "define_subagent",
+    "invoke_subagent",
+    "send_message",
+    "manage_subagents",
+    "complete_task",
+    "wait",
+    "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(),
+  start_anchor: z2.string().nullable().optional(),
+  end_anchor: z2.string().nullable().optional(),
+  // Superpowers fields
+  skill_name: z2.string().nullable().optional(),
+  duration_seconds: z2.number().nullable().optional(),
+  Subagents: z2.array(z2.object({
+    TypeName: z2.string(),
+    Role: z2.string(),
+    Prompt: z2.string()
+  })).nullable().optional(),
+  Recipient: z2.string().nullable().optional(),
+  Message: z2.string().nullable().optional(),
+  Action: z2.enum(["list", "kill", "kill_all"]).nullable().optional(),
+  ConversationIds: z2.array(z2.string()).nullable().optional(),
+  // define_subagent fields
+  name: z2.string().nullable().optional(),
+  description: z2.string().nullable().optional(),
+  system_prompt: z2.string().nullable().optional(),
+  enable_write_tools: z2.boolean().nullable().optional(),
+  enable_subagent_tools: z2.boolean().nullable().optional(),
+  enable_mcp_tools: z2.boolean().nullable().optional()
+});
+var AgentCommandSchema = z2.object({
+  command: z2.string(),
+  description: z2.string(),
+  critical: z2.boolean()
+});
+var AgentResponseSchema = z2.object({
+  action: AgentActionSchema.nullable().optional(),
+  actions: z2.array(AgentActionSchema).default([]),
+  // Maintain backward compatibility
+  commands: z2.array(AgentCommandSchema).optional(),
+  // Maintain backward compatibility
+  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 });
+      const errMsg = e.message;
+      const cleanRaw = rawResponse.trim();
+      if (cleanRaw === "") {
+        const systemMsg2 = `[SYSTEM ERROR]: O modelo retornou uma resposta vazia. Por favor, tente novamente e forne\xE7a uma a\xE7\xE3o JSON v\xE1lida.`;
+        return {
+          action: {
+            type: "talk_with_user",
+            content: systemMsg2,
+            path: ""
+          },
+          actions: [{
+            type: "talk_with_user",
+            content: systemMsg2,
+            path: ""
+          }],
+          message: systemMsg2
+        };
+      }
+      const looksLikeJson = cleanRaw.startsWith("{") || cleanRaw.startsWith("[");
+      if (!looksLikeJson) {
+        return {
+          action: {
+            type: "talk_with_user",
+            content: rawResponse,
+            path: ""
+          },
+          actions: [{
+            type: "talk_with_user",
+            content: rawResponse,
+            path: ""
+          }],
+          message: rawResponse
+        };
+      }
+      const isTruncated = errMsg.includes("Unterminated string") || errMsg.includes("Unexpected end of JSON input");
+      const charCount = rawResponse.length;
+      const safeLimit = Math.floor(charCount * 0.9);
+      const systemMsg = isTruncated ? `[SYSTEM ERROR]: Sua resposta anterior foi cortada/truncada antes do final devido ao limite m\xE1ximo de tokens de sa\xEDda (output token limit) ap\xF3s atingir ${charCount} caracteres. O JSON ficou incompleto: ${errMsg}. Por favor, envie uma nova resposta com formato JSON completo e v\xE1lido (n\xE3o tente apenas completar o JSON anterior). Continue o trabalho l\xF3gico da tarefa de forma mais curta ou incremental (ex: criando apenas o esqueleto/estrutura b\xE1sica ou escrevendo uma parte menor do arquivo de cada vez). Garanta que o tamanho total desta nova resposta JSON seja menor que ${safeLimit} caracteres para evitar novos cortes.` : `[SYSTEM ERROR]: Falha ao parsear o JSON de resposta: ${errMsg}.`;
+      return {
+        action: {
+          type: "talk_with_user",
+          content: systemMsg,
+          path: ""
+        },
+        actions: [{
+          type: "talk_with_user",
+          content: systemMsg,
+          path: ""
+        }],
+        message: systemMsg
+      };
+    }
+  } 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) {
+        FileLogger.log("PARSER", "Inner JSON Parse Error", { error: e.message });
+        const errMsg = e.message;
+        const cleanContent = stringContent.trim();
+        const looksLikeJson = cleanContent.startsWith("{") || cleanContent.startsWith("[");
+        if (looksLikeJson) {
+          const isTruncated = errMsg.includes("Unterminated string") || errMsg.includes("Unexpected end of JSON input");
+          const charCount = stringContent.length;
+          const safeLimit = Math.floor(charCount * 0.9);
+          const systemMsg = isTruncated ? `[SYSTEM ERROR]: Sua resposta anterior foi cortada/truncada antes do final devido ao limite m\xE1ximo de tokens de sa\xEDda (output token limit) ap\xF3s atingir ${charCount} caracteres. O JSON ficou incompleto: ${errMsg}. Por favor, envie uma nova resposta com formato JSON completo e v\xE1lido (n\xE3o tente apenas completar o JSON anterior). Continue o trabalho l\xF3gico da tarefa de forma mais curta ou incremental (ex: criando apenas o esqueleto/estrutura b\xE1sica ou escrevendo uma parte menor do arquivo de cada vez). Garanta que o tamanho total desta nova resposta JSON seja menor que ${safeLimit} caracteres para evitar novos cortes.` : `[SYSTEM ERROR]: Falha ao parsear o JSON de resposta: ${errMsg}.`;
+          parsedObj = {
+            action: {
+              type: "talk_with_user",
+              content: systemMsg,
+              path: ""
+            },
+            actions: [{
+              type: "talk_with_user",
+              content: systemMsg,
+              path: ""
+            }],
+            summary: "Parsing failed due to truncated JSON response"
+          };
+        } else {
+          parsedObj = rawResponse;
+        }
+      }
+    } else {
+      parsedObj = rawResponse;
+    }
+    if (!parsedObj.actions && !parsedObj.action) {
+      parsedObj = rawResponse;
+    }
+  }
+  let normalizedAction = parsedObj.action;
+  let normalizedActions = parsedObj.actions;
+  if (!normalizedAction && (!normalizedActions || normalizedActions.length === 0) && parsedObj && typeof parsedObj === "object" && typeof parsedObj.type === "string") {
+    const validTypes = [
+      "create_file",
+      "modify_file",
+      "list_files",
+      "search_file",
+      "search_code",
+      "read_file",
+      "delete_file",
+      "talk_with_user",
+      "use_mcp_tool",
+      "list_structure",
+      "modify_ast",
+      "search_ast",
+      "run_command",
+      "activate_skill",
+      "define_subagent",
+      "invoke_subagent",
+      "send_message",
+      "manage_subagents",
+      "complete_task"
+    ];
+    if (validTypes.includes(parsedObj.type)) {
+      normalizedAction = parsedObj;
+      normalizedActions = [parsedObj];
+    }
+  }
+  if (!normalizedAction && normalizedActions && normalizedActions.length > 0) {
+    normalizedAction = normalizedActions[0];
+  } else if (normalizedAction && (!normalizedActions || normalizedActions.length === 0)) {
+    normalizedActions = [normalizedAction];
+  }
+  if (!normalizedAction && !normalizedActions) {
+    FileLogger.log("PARSER", "No Action/Actions Found - Constructing Default");
+    const content = parsedObj.message || (typeof parsedObj === "object" ? JSON.stringify(parsedObj) : String(parsedObj));
+    normalizedAction = {
+      type: "talk_with_user",
+      content,
+      path: ""
+    };
+    normalizedActions = [normalizedAction];
+  }
+  let normalizedCommands = [];
+  if (Array.isArray(parsedObj.commands)) {
+    normalizedCommands = parsedObj.commands.map((cmd) => {
+      if (typeof cmd === "string") {
+        return {
+          command: cmd,
+          description: `Execute ${cmd}`,
+          critical: false
+        };
+      }
+      if (cmd && typeof cmd === "object") {
+        return {
+          command: cmd.command || "",
+          description: cmd.description || `Execute ${cmd.command || ""}`,
+          critical: cmd.critical === true
+        };
+      }
+      return null;
+    }).filter(Boolean);
+  }
+  const result = {
+    action: normalizedAction,
+    actions: normalizedActions,
+    commands: normalizedCommands,
+    summary: parsedObj.summary || "",
+    conversation_id,
+    message: parsedObj.summary || "Agent Action"
+    // Backward compatibility
+  };
+  FileLogger.log("PARSER", "Final Result Constructed", { hasAction: !!result.action });
+  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/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}`));
+      }
+    }
+  }
+  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 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;
+      }
+    }
+  }
+};
+var sseClient = new SSEClient();
+
+// 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.'
+    );
+  }
+  return realm;
+}
+
+// src/core/api/prompts.ts
+var UNIFIED_SYSTEM_PROMPT = `Voc\xEA \xE9 o Shark Dev, um agente de intelig\xEAncia artificial de desenvolvimento colaborativo no Shark AI.
+Seu objetivo \xE9 ajudar o usu\xE1rio a analisar, especificar e implementar c\xF3digo de forma estruturada.
+
+\u2139\uFE0F SISTEMA DE \xC2NCORAS PARA LEITURA/EDI\xC7\xC3O DE ARQUIVOS (Anchor System):
+- Quando voc\xEA l\xEA um arquivo usando a a\xE7\xE3o 'read_file', cada linha do arquivo ser\xE1 retornada no formato: \`palavra_\xE2ncora\xA7conte\xFAdo_da_linha\`.
+- Exemplo: \`apple\xA7const x = 10;\`
+- Ao modificar um arquivo usando a a\xE7\xE3o 'modify_file', voc\xEA DEVE especificar:
+  - \`start_anchor\`: A palavra \xE2ncora (ex: \`apple\`) que marca o in\xEDcio do bloco a ser substitu\xEDdo.
+  - \`end_anchor\`: A palavra \xE2ncora (ex: \`apple\`) que marca o fim do bloco a ser substitu\xEDdo (inclusive).
+  - \`content\`: O novo conte\xFAdo que substituir\xE1 todo o bloco entre (e incluindo) as duas \xE2ncoras.
+  - Importante: Use APENAS a palavra \xE2ncora no campo \`start_anchor\` e \`end_anchor\` (por exemplo: \`apple\`), e N\xC3O a linha inteira ou o separador \`\xA7\`.
+
+\u26A0\uFE0F REGRA GERAL PARA ARQUIVOS GRANDES (Evitar JSON truncado):
+- Evite criar ou modificar arquivos grandes (como planos, documenta\xE7\xF5es ou c\xF3digos extensos) de uma \xFAnica vez.
+- Limite de Sa\xEDda R\xEDgido: A API possui um limite m\xE1ximo de tokens de sa\xEDda. Para sua seguran\xE7a, garanta que o conte\xFAdo de cada resposta JSON sua tenha no m\xE1ximo 15.000 caracteres (cerca de 4.000 tokens). NUNCA gere respostas \xFAnicas maiores do que isso.
+- Se a tarefa exigir criar ou modificar arquivos longos, siga estritamente esta l\xF3gica:
+  1. Use 'create_file' para criar apenas a estrutura b\xE1sica ou esqueleto do arquivo (cabe\xE7alhos e se\xE7\xF5es vazias).
+  2. Nas rodadas subsequentes, use 'modify_file' com o sistema de \xE2ncoras para preencher/atualizar o conte\xFAdo de forma incremental e em peda\xE7os menores (no m\xE1ximo 50 a 100 linhas por vez).
+- Isso evita que a sua resposta JSON seja cortada no meio devido ao limite m\xE1ximo de tokens de sa\xEDda da API.
+
+\u{1F6A8} REGRAS CR\xCDTICAS DE RESPOSTA (JSON):
+- Voc\xEA DEVE responder APENAS com um objeto JSON v\xE1lido.
+- N\xE3o inclua nenhuma introdu\xE7\xE3o, explica\xE7\xE3o ou bloco de markdown fora do JSON.
+- Se precisar falar com o usu\xE1rio, use a action com type 'talk_with_user'.
+
+SUA SA\xCDDA DEVE SEGUIR EXATAMENTE ESTE FORMATO JSON:
+{
+  "action": {
+    "type": "create_file" | "modify_file" | "read_file" | "list_files" | "search_file" | "search_code" | "delete_file" | "run_command" | "talk_with_user" | "use_mcp_tool" | "activate_skill" | "define_subagent" | "invoke_subagent" | "send_message" | "manage_subagents" | "complete_task" | "wait",
+    "path": "caminho/relativo/do/arquivo (opcional)",
+    "content": "conte\xFAdo do arquivo ou mensagem para o usu\xE1rio (opcional)",
+    "start_anchor": "\xE2ncora de in\xEDcio de substitui\xE7\xE3o (modify_file apenas)",
+    "end_anchor": "\xE2ncora de fim de substitui\xE7\xE3o (modify_file apenas)",
+    "command": "comando bash a ser executado (run_command apenas)",
+    "query": "termo de busca (search_code apenas)",
+    "tool_name": "nome da ferramenta MCP (use_mcp_tool apenas)",
+    "tool_args": "argumentos em string JSON para MCP (use_mcp_tool apenas)",
+    "skill_name": "nome da habilidade a ativar (activate_skill apenas)",
+    "duration_seconds": "tempo m\xE1ximo em segundos para aguardar atualiza\xE7\xF5es (opcional, wait apenas)",
+    "Subagents": [
+      {
+        "TypeName": "tipo do subagente",
+        "Role": "papel do subagente",
+        "Prompt": "instru\xE7\xF5es de tarefa para o subagente"
+      }
+    ] (invoke_subagent apenas),
+    "Recipient": "ID da conversa de destino da mensagem (send_message apenas)",
+    "Message": "conte\xFAdo da mensagem a ser enviada (send_message apenas)",
+    "Action": "list" | "kill" | "kill_all" (manage_subagents apenas),
+    "ConversationIds": ["lista de IDs de conversa para cancelar"] (manage_subagents apenas, opcional),
+    "name": "nome do subagente (define_subagent apenas)",
+    "description": "descri\xE7\xE3o do subagente (define_subagent apenas)",
+    "system_prompt": "prompt de sistema customizado (define_subagent apenas)",
+    "enable_write_tools": true | false (define_subagent apenas, opcional),
+    "enable_subagent_tools": true | false (define_subagent apenas, opcional),
+    "enable_mcp_tools": true | false (define_subagent apenas, opcional)
+  },
+  "summary": "Resumo de 1 frase do que voc\xEA realizou nesta rodada."
+}`;
+var AGENT_RESPONSE_JSON_SCHEMA = {
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "AgentResponse",
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "create_file",
+            "modify_file",
+            "read_file",
+            "list_files",
+            "search_file",
+            "search_code",
+            "delete_file",
+            "run_command",
+            "talk_with_user",
+            "use_mcp_tool",
+            "activate_skill",
+            "define_subagent",
+            "invoke_subagent",
+            "send_message",
+            "manage_subagents",
+            "complete_task",
+            "wait"
+          ]
+        },
+        "path": { "type": ["string", "null"] },
+        "content": { "type": ["string", "null"] },
+        "start_anchor": { "type": ["string", "null"] },
+        "end_anchor": { "type": ["string", "null"] },
+        "command": { "type": ["string", "null"] },
+        "query": { "type": ["string", "null"] },
+        "tool_name": { "type": ["string", "null"] },
+        "tool_args": { "type": ["string", "null"] },
+        "skill_name": { "type": ["string", "null"] },
+        "duration_seconds": {
+          "type": ["integer", "null"],
+          "description": "Tempo maximo em segundos para aguardar atualizacoes."
+        },
+        "Subagents": {
+          "type": ["array", "null"],
+          "items": {
+            "type": "object",
+            "properties": {
+              "TypeName": { "type": "string" },
+              "Role": { "type": "string" },
+              "Prompt": { "type": "string" }
+            },
+            "required": ["TypeName", "Role", "Prompt"]
+          }
+        },
+        "Recipient": { "type": ["string", "null"] },
+        "Message": { "type": ["string", "null"] },
+        "Action": { "type": ["string", "null"], "enum": ["list", "kill", "kill_all"] },
+        "ConversationIds": {
+          "type": ["array", "null"],
+          "items": { "type": "string" }
+        },
+        "name": { "type": ["string", "null"] },
+        "description": { "type": ["string", "null"] },
+        "system_prompt": { "type": ["string", "null"] },
+        "enable_write_tools": { "type": ["boolean", "null"] },
+        "enable_subagent_tools": { "type": ["boolean", "null"] },
+        "enable_mcp_tools": { "type": ["boolean", "null"] }
+      },
+      "required": ["type"]
+    },
+    "summary": { "type": "string" }
+  },
+  "required": ["action"]
+};
+
+// src/core/api/stackspot-provider.ts
+var StackSpotProvider = class {
+  constructor(agentType) {
+    this.agentType = agentType;
+    const config = ConfigManager.getInstance().getConfig();
+    this.agentId = config.stackspot?.agentId;
+  }
+  agentId;
+  getAgentId() {
+    const config = ConfigManager.getInstance().getConfig();
+    const configKeyMapping = {
+      "developer_agent": "dev",
+      "business_analyst": "ba",
+      "specification_agent": "spec",
+      "qa_agent": "qa",
+      "scan_agent": "scan",
+      "code_review": "codeReview"
+    };
+    const mappedKey = configKeyMapping[this.agentType];
+    if (mappedKey && config.agents?.[mappedKey]) {
+      return config.agents[mappedKey];
+    }
+    const envIdMapping = {
+      "business_analyst": process.env.STACKSPOT_BA_AGENT_ID,
+      "developer_agent": process.env.STACKSPOT_DEV_AGENT_ID,
+      "qa_agent": process.env.STACKSPOT_QA_AGENT_ID,
+      "specification_agent": process.env.STACKSPOT_SPEC_AGENT_ID,
+      "scan_agent": process.env.STACKSPOT_SCAN_AGENT_ID,
+      "code_review": process.env.STACKSPOT_CODE_REVIEW_AGENT_ID
+    };
+    const envResolved = envIdMapping[this.agentType];
+    if (envResolved) {
+      return envResolved;
+    }
+    if (this.agentId && this.agentId !== "01KEQCGJ65YENRA4QBXVN1YFFX") {
+      return this.agentId;
+    }
+    const defaultIdMapping = {
+      "business_analyst": "01KEJ95G304TNNAKGH5XNEEBVD",
+      "developer_agent": "01KEQCGJ65YENRA4QBXVN1YFFX",
+      "qa_agent": "01KEQFJZ3Q3JER11NH22HEZX9X",
+      "specification_agent": "01KEPXTX37FTB4N672TZST4SGP",
+      "scan_agent": "01KEQ9AHWB550J2244YBH3QATN",
+      "code_review": ""
+    };
+    const resolved = defaultIdMapping[this.agentType];
+    if (this.agentType === "code_review") {
+      if (!resolved) {
+        throw new Error("Agent ID for 'code_review' is not configured.");
+      }
+      return resolved;
+    }
+    return resolved || "01KEQCGJ65YENRA4QBXVN1YFFX";
+  }
+  getAgentVersion() {
+    const config = ConfigManager.getInstance().getConfig();
+    const versionMapping = {
+      "business_analyst": config.agentVersions?.ba || process.env.STACKSPOT_BA_AGENT_VERSION,
+      "developer_agent": config.agentVersions?.dev || process.env.STACKSPOT_DEV_AGENT_VERSION,
+      "qa_agent": config.agentVersions?.qa || process.env.STACKSPOT_QA_AGENT_VERSION,
+      "specification_agent": config.agentVersions?.spec || process.env.STACKSPOT_SPEC_AGENT_VERSION,
+      "scan_agent": config.agentVersions?.scan || process.env.STACKSPOT_SCAN_AGENT_VERSION,
+      "code_review": config.agentVersions?.codeReview || process.env.STACKSPOT_CODE_REVIEW_AGENT_VERSION
+    };
+    return versionMapping[this.agentType];
+  }
+  async streamChat(prompt, options) {
+    const realm = await getActiveRealm();
+    let token = null;
+    try {
+      token = await ensureValidToken(realm);
+    } catch (error) {
+      token = await tokenStorage.getToken(realm);
+    }
+    if (!token) {
+      throw new Error(`No authentication token found for realm '${realm}'. Please run 'shark login'.`);
+    }
+    const isFirstTurn = !options.conversationId;
+    const finalPrompt = isFirstTurn ? `SYSTEM INSTRUCTIONS:
+${UNIFIED_SYSTEM_PROMPT}
+
+USER REQUEST:
+${prompt}` : prompt;
+    const requestPayload = {
+      user_prompt: finalPrompt,
+      streaming: true,
+      stackspot_knowledge: false,
+      return_ks_in_response: true,
+      deep_search_ks: false,
+      use_conversation: true,
+      conversation_id: options.conversationId
+    };
+    const agentVersion = this.getAgentVersion();
+    if (agentVersion) {
+      requestPayload.agent_version_number = agentVersion;
+    }
+    const effectiveAgentId = this.getAgentId();
+    const agentUrl = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${effectiveAgentId}/chat`;
+    const headers = {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+    const sanitizedHeaders = { ...headers };
+    if (sanitizedHeaders["Authorization"]) {
+      sanitizedHeaders["Authorization"] = "Bearer ***";
+    }
+    FileLogger.log("PROVIDER_REQUEST", "Request payload sent to StackSpot API", {
+      agentId: effectiveAgentId,
+      url: agentUrl,
+      headers: sanitizedHeaders,
+      payload: requestPayload
+    });
+    let fullMessage = "";
+    let rawResponse = {};
+    await sseClient.streamAgentResponse(
+      agentUrl,
+      requestPayload,
+      headers,
+      {
+        onChunk: (chunk) => {
+          fullMessage += chunk;
+          if (options.onChunk) {
+            options.onChunk(chunk);
+          }
+        },
+        onComplete: async (message, metadata) => {
+          rawResponse = {
+            message: message || fullMessage,
+            conversation_id: metadata?.conversation_id || options.conversationId
+          };
+        },
+        onError: (error) => {
+          throw error;
+        }
+      }
+    );
+    FileLogger.log("PROVIDER_RESPONSE", "Raw response from StackSpot API", { rawResponse });
+    const parsedResponse = parseAgentResponse(rawResponse);
+    if (options.onComplete) {
+      options.onComplete(parsedResponse);
+    }
+    return parsedResponse;
+  }
+};
+
+// src/core/workflow/history-manager.ts
+import fs3 from "fs";
+import path3 from "path";
+var HistoryManager = class {
+  static getHistoryDir() {
+    const dir = path3.resolve(process.cwd(), "_sharkrc", "history");
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+  }
+  static getFilePath(conversationId) {
+    return path3.resolve(this.getHistoryDir(), `${conversationId}.json`);
+  }
+  static async getHistory(conversationId) {
+    const filePath = this.getFilePath(conversationId);
+    if (!fs3.existsSync(filePath)) {
+      return [];
+    }
+    try {
+      const raw = fs3.readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  static async saveHistory(conversationId, messages) {
+    const filePath = this.getFilePath(conversationId);
+    fs3.writeFileSync(filePath, JSON.stringify(messages, null, 2), "utf-8");
+  }
+  static async appendMessage(conversationId, message) {
+    const history = await this.getHistory(conversationId);
+    history.push(message);
+    await this.saveHistory(conversationId, history);
+  }
+};
+
+// src/core/api/openai-compatible-provider.ts
+import crypto from "crypto";
+var OpenAICompatibleProvider = class {
+  constructor(options) {
+    this.options = options;
+  }
+  getAgentSystemPrompt(agentType) {
+    return UNIFIED_SYSTEM_PROMPT;
+  }
+  async streamChat(prompt, options) {
+    const conversationId = options.conversationId || crypto.randomUUID();
+    const history = await HistoryManager.getHistory(conversationId);
+    if (history.length === 0) {
+      history.push({
+        role: "system",
+        content: this.getAgentSystemPrompt(options.agentType)
+      });
+    }
+    history.push({ role: "user", content: prompt });
+    const requestPayload = {
+      model: this.options.model,
+      messages: history,
+      stream: true,
+      temperature: 0.2
+    };
+    if (this.options.useStructuredOutputs) {
+      requestPayload.response_format = {
+        type: "json_schema",
+        json_schema: {
+          name: "agent_response",
+          strict: true,
+          schema: {
+            type: "object",
+            properties: {
+              action: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string",
+                    enum: [
+                      "create_file",
+                      "modify_file",
+                      "read_file",
+                      "list_files",
+                      "search_file",
+                      "search_code",
+                      "delete_file",
+                      "run_command",
+                      "talk_with_user",
+                      "use_mcp_tool",
+                      "activate_skill",
+                      "define_subagent",
+                      "invoke_subagent",
+                      "send_message",
+                      "manage_subagents",
+                      "complete_task",
+                      "list_structure",
+                      "modify_ast",
+                      "search_ast",
+                      "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: { type: ["string", "null"] },
+                  content: { type: ["string", "null"] },
+                  start_anchor: { type: ["string", "null"] },
+                  end_anchor: { type: ["string", "null"] },
+                  command: { type: ["string", "null"] },
+                  query: { type: ["string", "null"] },
+                  tool_name: { type: ["string", "null"] },
+                  tool_args: { type: ["string", "null"] },
+                  line_range: {
+                    type: ["array", "null"],
+                    items: { type: "number" }
+                  },
+                  target_content: { type: ["string", "null"] },
+                  is_regex: { type: ["boolean", "null"] },
+                  pattern: { type: ["string", "null"] },
+                  fix: { type: ["string", "null"] },
+                  language: { type: ["string", "null"] },
+                  file_path: { type: ["string", "null"] },
+                  class_name: { type: ["string", "null"] },
+                  method_name: { type: ["string", "null"] },
+                  method_code: { type: ["string", "null"] },
+                  property_name: { type: ["string", "null"] },
+                  property_code: { type: ["string", "null"] },
+                  extends_class: { type: ["string", "null"] },
+                  implements_interfaces: {
+                    type: ["array", "null"],
+                    items: { type: "string" }
+                  },
+                  decorator_code: { type: ["string", "null"] },
+                  interface_code: { type: ["string", "null"] },
+                  type_code: { type: ["string", "null"] },
+                  function_name: { type: ["string", "null"] },
+                  function_code: { type: ["string", "null"] },
+                  import_statement: { type: ["string", "null"] },
+                  module_path: { type: ["string", "null"] },
+                  new_body: { type: ["string", "null"] },
+                  confirmed: { type: ["boolean", "null"] },
+                  skill_name: { type: ["string", "null"] },
+                  Subagents: {
+                    type: ["array", "null"],
+                    items: {
+                      type: "object",
+                      properties: {
+                        TypeName: { type: "string" },
+                        Role: { type: "string" },
+                        Prompt: { type: "string" }
+                      },
+                      required: ["TypeName", "Role", "Prompt"],
+                      additionalProperties: false
+                    }
+                  },
+                  Recipient: { type: ["string", "null"] },
+                  Message: { type: ["string", "null"] },
+                  Action: { type: ["string", "null"] },
+                  ConversationIds: {
+                    type: ["array", "null"],
+                    items: { type: "string" }
+                  },
+                  name: { type: ["string", "null"] },
+                  description: { type: ["string", "null"] },
+                  system_prompt: { type: ["string", "null"] },
+                  enable_write_tools: { type: ["boolean", "null"] },
+                  enable_subagent_tools: { type: ["boolean", "null"] },
+                  enable_mcp_tools: { type: ["boolean", "null"] }
+                },
+                required: [
+                  "type",
+                  "path",
+                  "content",
+                  "start_anchor",
+                  "end_anchor",
+                  "command",
+                  "query",
+                  "tool_name",
+                  "tool_args",
+                  "line_range",
+                  "target_content",
+                  "is_regex",
+                  "pattern",
+                  "fix",
+                  "language",
+                  "file_path",
+                  "class_name",
+                  "method_name",
+                  "method_code",
+                  "property_name",
+                  "property_code",
+                  "extends_class",
+                  "implements_interfaces",
+                  "decorator_code",
+                  "interface_code",
+                  "type_code",
+                  "function_name",
+                  "function_code",
+                  "import_statement",
+                  "module_path",
+                  "new_body",
+                  "confirmed",
+                  "skill_name",
+                  "Subagents",
+                  "Recipient",
+                  "Message",
+                  "Action",
+                  "ConversationIds",
+                  "name",
+                  "description",
+                  "system_prompt",
+                  "enable_write_tools",
+                  "enable_subagent_tools",
+                  "enable_mcp_tools"
+                ],
+                additionalProperties: false
+              },
+              summary: { type: "string" }
+            },
+            required: ["action", "summary"],
+            additionalProperties: false
+          }
+        }
+      };
+    } else {
+      requestPayload.response_format = { type: "json_object" };
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.options.apiKey) {
+      headers["Authorization"] = `Bearer ${this.options.apiKey}`;
+    }
+    const sanitizedHeaders = { ...headers };
+    if (sanitizedHeaders["Authorization"]) {
+      sanitizedHeaders["Authorization"] = "Bearer ***";
+    }
+    FileLogger.log("PROVIDER_REQUEST", "Request payload sent to OpenAI Compatible API", {
+      baseURL: this.options.baseURL,
+      headers: sanitizedHeaders,
+      payload: requestPayload
+    });
+    const res = await fetch(`${this.options.baseURL}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestPayload)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`OpenAI API request failed: ${res.status} ${res.statusText} - ${errBody}`);
+    }
+    const reader = res.body?.getReader();
+    if (!reader) {
+      throw new Error("Response body reader is undefined");
+    }
+    try {
+      const decoder = new TextDecoder();
+      let fullContent = "";
+      let done = false;
+      let buffer = "";
+      while (!done) {
+        const { value, done: doneReading } = await reader.read();
+        done = doneReading;
+        if (value) {
+          buffer += decoder.decode(value, { stream: !done });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            const clean = line.trim();
+            if (!clean || clean === "data: [DONE]") continue;
+            if (clean.startsWith("data: ")) {
+              let parsed;
+              try {
+                parsed = JSON.parse(clean.substring(6));
+              } catch {
+                continue;
+              }
+              if (parsed && parsed.error) {
+                throw new Error(`OpenAI Stream Error: ${JSON.stringify(parsed.error)}`);
+              }
+              const delta = parsed?.choices?.[0]?.delta?.content || "";
+              if (delta) {
+                fullContent += delta;
+                if (options.onChunk) {
+                  options.onChunk(delta);
+                }
+              }
+            }
+          }
+        }
+      }
+      if (buffer) {
+        const clean = buffer.trim();
+        if (clean && clean !== "data: [DONE]" && clean.startsWith("data: ")) {
+          let parsed;
+          try {
+            parsed = JSON.parse(clean.substring(6));
+          } catch {
+          }
+          if (parsed && parsed.error) {
+            throw new Error(`OpenAI Stream Error: ${JSON.stringify(parsed.error)}`);
+          }
+          const delta = parsed?.choices?.[0]?.delta?.content || "";
+          if (delta) {
+            fullContent += delta;
+            if (options.onChunk) {
+              options.onChunk(delta);
+            }
+          }
+        }
+      }
+      FileLogger.log("PROVIDER_RESPONSE", "Raw response from OpenAI Compatible API", { fullContent });
+      const parsedResponse = parseAgentResponse(fullContent);
+      parsedResponse.conversation_id = conversationId;
+      history.push({ role: "assistant", content: JSON.stringify(parsedResponse) });
+      await HistoryManager.saveHistory(conversationId, history);
+      if (options.onComplete) {
+        options.onComplete(parsedResponse);
+      }
+      return parsedResponse;
+    } finally {
+      if (typeof reader.releaseLock === "function") {
+        reader.releaseLock();
+      }
+    }
+  }
+};
+
+// src/core/api/provider-resolver.ts
+var ProviderResolver = class {
+  static getProvider(agentType) {
+    const config = ConfigManager.getInstance().getConfig();
+    if (config.provider === "openai-compatible") {
+      const opt = config["openai-compatible"] || {};
+      return new OpenAICompatibleProvider({
+        baseURL: opt.baseURL || "http://localhost:11434/v1",
+        apiKey: opt.apiKey || "ollama",
+        model: opt.model || "llama3",
+        useStructuredOutputs: opt.useStructuredOutputs ?? true
+      });
+    }
+    return new StackSpotProvider(agentType);
+  }
+};
+
+// 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/core/workflow/anchor-state-manager.ts
+import fs4 from "fs";
+import path4 from "path";
+import { diffLines } from "diff";
+var AnchorStateManager = class {
+  cache = /* @__PURE__ */ new Map();
+  wordPool = [];
+  constructor() {
+    this.initializeWordPool();
+  }
+  initializeWordPool() {
+    this.wordPool = [
+      // group 1
+      "apple",
+      "beach",
+      "cabin",
+      "dust",
+      "edge",
+      "stone",
+      "river",
+      "tree",
+      "leaf",
+      "flower",
+      "grass",
+      "seed",
+      "soil",
+      "sand",
+      "rock",
+      "hill",
+      "path",
+      "road",
+      "street",
+      "house",
+      "room",
+      "door",
+      "window",
+      "wall",
+      "roof",
+      "floor",
+      "desk",
+      "chair",
+      "table",
+      "book",
+      "pen",
+      "paper",
+      "bag",
+      "box",
+      "cup",
+      "plate",
+      "bowl",
+      "spoon",
+      "fork",
+      "knife",
+      "food",
+      "bread",
+      "milk",
+      "water",
+      "tea",
+      "fruit",
+      "pear",
+      "peach",
+      "plum",
+      "grape",
+      "melon",
+      "berry",
+      "nut",
+      "bean",
+      "corn",
+      "rice",
+      "oat",
+      "wheat",
+      "fish",
+      "bird",
+      "cat",
+      "dog",
+      "cow",
+      "sheep",
+      "goat",
+      "pig",
+      "horse",
+      "deer",
+      "bear",
+      "wolf",
+      "fox",
+      "lion",
+      "tiger",
+      "seal",
+      "whale",
+      "crab",
+      "frog",
+      "toad",
+      "snake",
+      "worm",
+      "bee",
+      "ant",
+      "fly",
+      "spider",
+      "moth",
+      "fern",
+      "moss",
+      "pine",
+      "oak",
+      "maple",
+      "birch",
+      "willow",
+      "ash",
+      "elm",
+      "palm",
+      "rose",
+      "lily",
+      "daisy",
+      "tulip",
+      "iris",
+      // group 2
+      "about",
+      "above",
+      "actor",
+      "acute",
+      "admit",
+      "adopt",
+      "adult",
+      "after",
+      "again",
+      "agent",
+      "agree",
+      "ahead",
+      "alarm",
+      "album",
+      "alert",
+      "alike",
+      "alive",
+      "allow",
+      "alone",
+      "along",
+      "alter",
+      "among",
+      "anger",
+      "angle",
+      "angry",
+      "apart",
+      "appeal",
+      "apron",
+      "arena",
+      "argue",
+      "arise",
+      "array",
+      "arrow",
+      "aside",
+      "asset",
+      "audio",
+      "audit",
+      "avoid",
+      "award",
+      "aware",
+      "awful",
+      "back",
+      "bacon",
+      "badge",
+      "baker",
+      "ball",
+      "band",
+      "bank",
+      "base",
+      "basic",
+      "basil",
+      "basin",
+      "basis",
+      "bath",
+      "baton",
+      "bayou",
+      "bead",
+      "beak",
+      "beam",
+      "beast",
+      "beat",
+      "beauty",
+      "beef",
+      "beer",
+      "beet",
+      "begin",
+      "begun",
+      "being",
+      "belief",
+      "bell",
+      "belly",
+      "below",
+      "bench",
+      "bend",
+      "best",
+      "bible",
+      "bike",
+      "bill",
+      "bind",
+      "bingo",
+      "birth",
+      "bite",
+      "black",
+      "blade",
+      "blame",
+      "blank",
+      "blast",
+      "blaze",
+      "bleed",
+      "blend",
+      "blind",
+      "blink",
+      "block",
+      "blond",
+      "blood",
+      "bloom",
+      "blow",
+      "blue",
+      "blunt",
+      "blush",
+      // group 3
+      "board",
+      "boast",
+      "boat",
+      "body",
+      "boil",
+      "bold",
+      "bolt",
+      "bomb",
+      "bond",
+      "bone",
+      "bonus",
+      "boom",
+      "boost",
+      "boot",
+      "booth",
+      "border",
+      "bore",
+      "boss",
+      "both",
+      "bough",
+      "bound",
+      "boy",
+      "brace",
+      "brain",
+      "brake",
+      "branch",
+      "brand",
+      "brass",
+      "brave",
+      "break",
+      "breast",
+      "breath",
+      "breezy",
+      "brick",
+      "bride",
+      "bridge",
+      "brief",
+      "bright",
+      "brim",
+      "bring",
+      "brisk",
+      "broad",
+      "broil",
+      "broke",
+      "bronze",
+      "brook",
+      "broom",
+      "broth",
+      "brown",
+      "brush",
+      "bubble",
+      "bucket",
+      "buckle",
+      "bud",
+      "budget",
+      "buffet",
+      "bugle",
+      "build",
+      "built",
+      "bulb",
+      "bulk",
+      "bull",
+      "bullet",
+      "bump",
+      "bunch",
+      "bundle",
+      "bunk",
+      "bunny",
+      "burden",
+      "bureau",
+      "burn",
+      "burst",
+      "bush",
+      "busy",
+      "butler",
+      "butter",
+      "button",
+      "buyer",
+      "buzz",
+      "cable",
+      "cactus",
+      "cage",
+      "cake",
+      "calf",
+      "calm",
+      "came",
+      "camel",
+      "camera",
+      "camp",
+      "canal",
+      "candle",
+      "candy",
+      "cane",
+      "canoe",
+      "canopy",
+      "canvas",
+      "canyon",
+      "cape",
+      "capital",
+      "captain",
+      // group 4
+      "car",
+      "card",
+      "care",
+      "cargo",
+      "carol",
+      "carpet",
+      "carrot",
+      "carry",
+      "cart",
+      "carve",
+      "case",
+      "cash",
+      "cask",
+      "cast",
+      "castle",
+      "catch",
+      "cater",
+      "cattle",
+      "cause",
+      "cave",
+      "caviar",
+      "cavity",
+      "cedar",
+      "celery",
+      "cell",
+      "cellar",
+      "cello",
+      "cement",
+      "census",
+      "center",
+      "cereal",
+      "chain",
+      "chalk",
+      "chamber",
+      "chance",
+      "change",
+      "channel",
+      "chapel",
+      "chapter",
+      "char",
+      "charcoal",
+      "charge",
+      "charm",
+      "chart",
+      "chase",
+      "chasm",
+      "cheap",
+      "cheat",
+      "check",
+      "cheek",
+      "cheer",
+      "cheese",
+      "chef",
+      "cherry",
+      "chess",
+      "chest",
+      "chew",
+      "chick",
+      "chief",
+      "child",
+      "chili",
+      "chill",
+      "chime",
+      "chin",
+      "china",
+      "chip",
+      "chirp",
+      "chisel",
+      "choir",
+      "choke",
+      "choose",
+      "chop",
+      "chord",
+      "chore",
+      "chorus",
+      "chose",
+      "chrome",
+      "chubby",
+      "chuck",
+      "chunk",
+      "church",
+      "cider",
+      "cigar",
+      "cinder",
+      "circle",
+      "circus",
+      "cite",
+      "citizen",
+      "city",
+      "civic",
+      // group 5
+      "civil",
+      "clad",
+      "claim",
+      "clam",
+      "clamp",
+      "clan",
+      "clap",
+      "clasp",
+      "class",
+      "clause",
+      "claw",
+      "clay",
+      "clean",
+      "clear",
+      "cleat",
+      "cleft",
+      "clerk",
+      "clever",
+      "click",
+      "client",
+      "cliff",
+      "climate",
+      "climb",
+      "cling",
+      "clinic",
+      "clip",
+      "cloak",
+      "clock",
+      "clod",
+      "clog",
+      "clone",
+      "close",
+      "closet",
+      "cloth",
+      "cloud",
+      "clove",
+      "clown",
+      "club",
+      "cluck",
+      "clue",
+      "clump",
+      "clumsy",
+      "clung",
+      "cluster",
+      "coach",
+      "coal",
+      "coast",
+      "coat",
+      "cobalt",
+      "cobra",
+      "cobweb",
+      "cocoa",
+      "coconut",
+      "cod",
+      "code",
+      "coffee",
+      "coffin",
+      "cog",
+      "coil",
+      "coin",
+      "coke",
+      "cold",
+      "collar",
+      "collie",
+      "colony",
+      "color",
+      "colt",
+      "column",
+      "comb",
+      "combat",
+      "come",
+      "comedy",
+      "comet",
+      "comfort",
+      "comic",
+      "comma",
+      "common",
+      "compact",
+      "company",
+      "compare",
+      // group 6
+      "compass",
+      "compel",
+      "complex",
+      "comply",
+      "comrade",
+      "concise",
+      "concrete",
+      "condor",
+      "cone",
+      "confer",
+      "conga",
+      "conic",
+      "connect",
+      "consul",
+      "contest",
+      "context",
+      "contract",
+      "control",
+      "convert",
+      "convex",
+      "convey",
+      "convoy",
+      "cook",
+      "cookie",
+      "cool",
+      "coop",
+      "cope",
+      "copper",
+      "copy",
+      "coral",
+      "cord",
+      "core",
+      "cork",
+      "corner",
+      "cornet",
+      "corps",
+      "cosmic",
+      "cost",
+      "costume",
+      "cottage",
+      "cotton",
+      "couch",
+      "cough",
+      "could",
+      "council",
+      "counsel",
+      "count",
+      "counter",
+      "country",
+      "county",
+      "coup",
+      "couple",
+      "courage",
+      "course",
+      "court",
+      "cousin",
+      "cove",
+      "cover",
+      "covet",
+      "coward",
+      "coyote",
+      "crack",
+      "cradle",
+      "craft",
+      "crag",
+      "cram",
+      "cramp",
+      "cranberry",
+      "crane",
+      "crank",
+      "crash",
+      "crate",
+      "crater",
+      "cravat",
+      "crave",
+      "craw",
+      "crawl",
+      "crayon",
+      "craze",
+      "crazy",
+      "creak",
+      "cream",
+      "create",
+      "credit",
+      "creed",
+      "creek",
+      "creep",
+      "crepe",
+      "cress",
+      "crest",
+      // group 7
+      "crew",
+      "crib",
+      "cricket",
+      "cried",
+      "crier",
+      "crime",
+      "crimson",
+      "cringe",
+      "cripple",
+      "crisis",
+      "crisp",
+      "critic",
+      "croak",
+      "crock",
+      "crocus",
+      "crony",
+      "crook",
+      "crop",
+      "cross",
+      "croup",
+      "crow",
+      "crowd",
+      "crown",
+      "crude",
+      "cruel",
+      "crumb",
+      "crumple",
+      "crush",
+      "crust",
+      "crutch",
+      "cry",
+      "crypt",
+      "crystal",
+      "cub",
+      "cube",
+      "cuckoo",
+      "cucumber",
+      "cuff",
+      "cult",
+      "culture",
+      "cupboard",
+      "curb",
+      "curd",
+      "cure",
+      "curfew",
+      "curl",
+      "currant",
+      "current",
+      "curry",
+      "curse",
+      "curve",
+      "cushion",
+      "custard",
+      "custom",
+      "cut",
+      "cute",
+      "cutter",
+      "cycle",
+      "cyclone",
+      "cynic",
+      "cypress",
+      "dad",
+      "dagger",
+      "daily",
+      "dairy",
+      "dale",
+      "dally",
+      "dam",
+      "damage",
+      "dame",
+      "damp",
+      "dance",
+      "dandy",
+      "danger",
+      "dapple",
+      "dare",
+      "dark",
+      "darling",
+      "darn",
+      "dart",
+      // group 8
+      "dash",
+      "date",
+      "datum",
+      "daub",
+      "daughter",
+      "dawn",
+      "daze",
+      "dazzle",
+      "deacon",
+      "dead",
+      "deaf",
+      "deal",
+      "dealer",
+      "dean",
+      "dear",
+      "death",
+      "debar",
+      "debate",
+      "debit",
+      "debris",
+      "debt",
+      "decade",
+      "decay",
+      "decent",
+      "decide",
+      "deck",
+      "declare",
+      "decline",
+      "decor",
+      "decoy",
+      "decrease",
+      "decree",
+      "deduct",
+      "deed",
+      "deep",
+      "defeat",
+      "defect",
+      "defend",
+      "defer",
+      "deficit",
+      "defile",
+      "define",
+      "deform",
+      "defray",
+      "defy",
+      "degree",
+      "delay",
+      "delegate",
+      "delight",
+      "deliver",
+      "dell",
+      "delta",
+      "deluge",
+      "delve",
+      "demand",
+      "demean",
+      "demerit",
+      "demise",
+      "demo",
+      "demote",
+      "demur",
+      "den",
+      "denial",
+      "denote",
+      "denounce",
+      "dense",
+      "density",
+      "dent",
+      "dental",
+      "dentist",
+      "deny",
+      "depart",
+      "depend",
+      "depict",
+      "deplore",
+      "deport",
+      "depose",
+      "deposit",
+      // group 9
+      "depot",
+      "depth",
+      "deputy",
+      "derby",
+      "derive",
+      "dervish",
+      "descend",
+      "descent",
+      "describe",
+      "desert",
+      "deserve",
+      "design",
+      "desire",
+      "desolate",
+      "despair",
+      "despise",
+      "despite",
+      "despot",
+      "dessert",
+      "destiny",
+      "destroy",
+      "detach",
+      "detail",
+      "detain",
+      "detect",
+      "deter",
+      "detest",
+      "detour",
+      "deuce",
+      "develop",
+      "deviate",
+      "device",
+      "devil",
+      "devise",
+      "devoid",
+      "devote",
+      "devour",
+      "devout",
+      "dew",
+      "diagram",
+      "dial",
+      "dialect",
+      "dialogue",
+      "diameter",
+      "diamond",
+      "diary",
+      "dice",
+      "dictate",
+      "diction",
+      "dictionary",
+      "did",
+      "die",
+      "diet",
+      "differ",
+      "difficult",
+      "diffuse",
+      "dig",
+      "digest",
+      "digger",
+      "digit",
+      "dignity",
+      "dike",
+      "dilute",
+      "dim",
+      "dime",
+      "diminish",
+      "dimple",
+      "din",
+      "dine",
+      "diner",
+      "dinghy",
+      "dingle",
+      "dinner",
+      "dint",
+      "dip",
+      "diphthong",
+      "diploma",
+      "dire",
+      "direct",
+      "director",
+      // group 10
+      "dirge",
+      "dirk",
+      "dirt",
+      "dirty",
+      "disable",
+      "disarm",
+      "disaster",
+      "disavow",
+      "disband",
+      "discard",
+      "discern",
+      "discharge",
+      "disciple",
+      "discipline",
+      "disclose",
+      "discomfit",
+      "discord",
+      "discount",
+      "discourse",
+      "discover",
+      "discreet",
+      "discrepant",
+      "discretion",
+      "discuss",
+      "disdain",
+      "disease",
+      "disfavor",
+      "disfigure",
+      "disgrace",
+      "disguise",
+      "disgust",
+      "dish",
+      "dishevel",
+      "dishonest",
+      "dishonor",
+      "disinfect",
+      "disinherit",
+      "disintegrate",
+      "dislike",
+      "dislocate",
+      "dislodge",
+      "disloyal",
+      "dismal",
+      "dismantle",
+      "dismay",
+      "dismember",
+      "dismiss",
+      "dismount",
+      "disobey",
+      "disorder",
+      "disown",
+      "disparage",
+      "disparate",
+      "disparity",
+      "dispatch",
+      "dispel",
+      "dispense",
+      "disperse",
+      "displace",
+      "display",
+      "displease",
+      "dispose",
+      "disprove",
+      "dispipe",
+      "disqualify",
+      "disquiet",
+      "disregard",
+      "disrepute",
+      "disrespect",
+      "disrobe",
+      "disrupt",
+      "dissatisfy",
+      "dissect",
+      "dissemble",
+      "disseminate",
+      "dissent",
+      "dissertation",
+      "disservice",
+      "dissident",
+      "dissimilar",
+      "dissipate",
+      "dissolve",
+      "dissonant",
+      "dissuade",
+      "distance",
+      "distant",
+      "distaste",
+      "distemper",
+      "distend",
+      "distich",
+      "distill",
+      "distinct",
+      "distinguish",
+      "distort",
+      "distract",
+      "distrain",
+      "distress",
+      "distribute",
+      "district",
+      "distrust",
+      "disturb",
+      "disunion",
+      "disuse",
+      "ditch",
+      "ditty",
+      "diurnal",
+      "divan",
+      "dive",
+      "diverge",
+      "diverse",
+      "diversion",
+      "diversity",
+      "divert",
+      "divest",
+      "divide",
+      "dividend",
+      "divine",
+      "diviner",
+      "divinity",
+      "divisible",
+      "division",
+      "divisor",
+      "divorce",
+      "divulge",
+      "dizzy",
+      "do",
+      "docile",
+      "dock",
+      "doctor",
+      "doctrine",
+      "document",
+      "dodge",
+      "doe",
+      "doer",
+      "dogma",
+      "dogmatic",
+      "dole",
+      "doll",
+      "dollar",
+      "domain",
+      "dome",
+      "domestic",
+      "domicile",
+      "dominant",
+      "dominate",
+      "domineer",
+      "dominion",
+      "domino",
+      "don",
+      "donation",
+      "done",
+      "donkey",
+      "donor",
+      "doom",
+      "dormant",
+      "dormitory",
+      "dormouse",
+      "dose",
+      "dot",
+      "double",
+      "doublet",
+      "doubt",
+      "doubtful",
+      "dough",
+      "doughnut",
+      "doughty",
+      "dour",
+      "douse",
+      "dove",
+      "dowager",
+      "dowdy",
+      "dower",
+      "downcast",
+      "downfall",
+      "downright",
+      "downy",
+      "dowry"
+    ];
+  }
+  allocateAnchor(usedAnchors) {
+    for (const word of this.wordPool) {
+      if (!usedAnchors.has(word)) {
+        usedAnchors.add(word);
+        return word;
+      }
+    }
+    let counter = 1;
+    while (true) {
+      const word = `anchor_${counter}`;
+      if (!usedAnchors.has(word)) {
+        usedAnchors.add(word);
+        return word;
+      }
+      counter++;
+    }
+  }
+  getAnchoredContent(filePath) {
+    const absolutePath = path4.resolve(filePath);
+    let lineStates = this.cache.get(absolutePath);
+    if (!lineStates) {
+      const content = fs4.readFileSync(absolutePath, "utf8");
+      const hasTrailingNewline = content.endsWith("\n");
+      const lines = hasTrailingNewline ? content.slice(0, -1).split("\n") : content.split("\n");
+      const usedAnchors = /* @__PURE__ */ new Set();
+      lineStates = lines.map((line) => {
+        const anchor = this.allocateAnchor(usedAnchors);
+        return { anchor, text: line };
+      });
+      this.cache.set(absolutePath, lineStates);
+    }
+    return lineStates.map((ls) => `${ls.anchor}\xA7${ls.text}`).join("\n");
+  }
+  applyAnchoredEdit(filePath, startAnchor, endAnchor, content) {
+    const absolutePath = path4.resolve(filePath);
+    let lineStates = this.cache.get(absolutePath);
+    if (!lineStates) {
+      this.getAnchoredContent(absolutePath);
+      lineStates = this.cache.get(absolutePath);
+    }
+    const startIndex = lineStates.findIndex((ls) => ls.anchor === startAnchor);
+    if (startIndex === -1) {
+      throw new Error(`Start anchor "${startAnchor}" not found`);
+    }
+    const endIndex = lineStates.findIndex((ls) => ls.anchor === endAnchor);
+    if (endIndex === -1) {
+      throw new Error(`End anchor "${endAnchor}" not found`);
+    }
+    if (startIndex > endIndex) {
+      throw new Error(`Invalid range: start anchor "${startAnchor}" is after end anchor "${endAnchor}"`);
+    }
+    const originalContent = fs4.readFileSync(absolutePath, "utf8");
+    const hasTrailingNewline = originalContent.endsWith("\n");
+    const oldLines = lineStates.map((ls) => ls.text);
+    const cleanContent = content.endsWith("\n") ? content.slice(0, -1) : content;
+    const newEditLines = cleanContent.split("\n");
+    const updatedLines = [
+      ...oldLines.slice(0, startIndex),
+      ...newEditLines,
+      ...oldLines.slice(endIndex + 1)
+    ];
+    const fileContentToWrite = updatedLines.join("\n") + (hasTrailingNewline ? "\n" : "");
+    fs4.writeFileSync(absolutePath, fileContentToWrite, "utf8");
+    const usedAnchors = /* @__PURE__ */ new Set();
+    for (let i = 0; i < lineStates.length; i++) {
+      usedAnchors.add(lineStates[i].anchor);
+    }
+    const oldEditSegment = lineStates.slice(startIndex, endIndex + 1);
+    const oldEditLines = oldEditSegment.map((ls) => ls.text);
+    const diffs = diffLines(oldEditLines.join("\n"), cleanContent);
+    const reconciledEditStates = [];
+    let oldEditIndex = 0;
+    for (const change of diffs) {
+      const changeLines = change.value.split("\n");
+      if (changeLines.length > 1 && changeLines[changeLines.length - 1] === "") {
+        changeLines.pop();
+      }
+      if (change.removed) {
+        oldEditIndex += changeLines.length;
+      } else if (change.added) {
+        for (const line of changeLines) {
+          const anchor = this.allocateAnchor(usedAnchors);
+          reconciledEditStates.push({ anchor, text: line });
+        }
+      } else {
+        for (let i = 0; i < changeLines.length; i++) {
+          const oldLs = oldEditSegment[oldEditIndex];
+          if (oldLs) {
+            reconciledEditStates.push({ anchor: oldLs.anchor, text: oldLs.text });
+            usedAnchors.add(oldLs.anchor);
+          } else {
+            const anchor = this.allocateAnchor(usedAnchors);
+            reconciledEditStates.push({ anchor, text: changeLines[i] });
+          }
+          oldEditIndex++;
+        }
+      }
+    }
+    const finalLineStates = [
+      ...lineStates.slice(0, startIndex),
+      ...reconciledEditStates,
+      ...lineStates.slice(endIndex + 1)
+    ];
+    this.cache.set(absolutePath, finalLineStates);
+  }
+};
+
+// src/core/agents/developer-agent.ts
+import fs9 from "fs";
+import path10 from "path";
+
+// src/core/agents/agent-tools.ts
+import fs6 from "fs";
+import path7 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 path6 from "path";
+
+// src/core/ast-editing/editors/typescript-editor.ts
+import { Project, SyntaxKind } from "ts-morph";
+import * as path5 from "path";
+import * as fs5 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 = path5.resolve(filePath);
+    let sourceFile = this.project.getSourceFile(absolutePath);
+    if (!sourceFile) {
+      if (!fs5.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 = path6.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 = path7.resolve(process.cwd(), dirPath);
+    if (!fs6.existsSync(fullPath)) return `Error: Directory ${dirPath} does not exist.`;
+    const items = fs6.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 = path7.resolve(process.cwd(), filePath);
+    if (!fs6.existsSync(fullPath)) return `Error: File ${filePath} does not exist.`;
+    const stats = fs6.statSync(fullPath);
+    if (stats.size > 100 * 1024) return `Error: File too large to read (${stats.size} bytes). Limit is 100KB.`;
+    const content = fs6.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 (!fs6.existsSync(filePath)) {
+      tui2.log.error(`\u274C File not found for modification: ${filePath}`);
+      return false;
+    }
+    const currentFileContent = fs6.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;
+    fs6.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 = path7.resolve(process.cwd(), filePath);
+        const stats = fs6.statSync(fullPath);
+        if (stats.size > MAX_FILE_SIZE_BYTES) continue;
+        const content = fs6.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 (!fs6.existsSync(filePath)) {
+    tui2.log.error(`\u274C File not found for modification: ${filePath}`);
+    return false;
+  }
+  const currentFileContent = fs6.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;
+  fs6.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 = path7.dirname(currentFile);
+    for (let i = 0; i < 5; i++) {
+      const candidate = path7.join(dir, "node_modules", ".bin", binName);
+      if (fs6.existsSync(candidate)) {
+        return `"${candidate}"`;
+      }
+      const parent = path7.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch (e) {
+  }
+  const cwdBin = path7.resolve(process.cwd(), "node_modules", ".bin", binName);
+  if (fs6.existsSync(cwdBin)) {
+    return `"${cwdBin}"`;
+  }
+  return "npx sg";
+}
+async function astGrepSearch(pattern, filePath, language, tui2) {
+  const { spawn } = await import("child_process");
+  try {
+    if (!fs6.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 (!fs6.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/workflow/skill-manager.ts
+import fs7 from "fs/promises";
+import path8 from "path";
+import os2 from "os";
+var SkillManager = class {
+  activeSkills = /* @__PURE__ */ new Set();
+  skillPrompts = /* @__PURE__ */ new Map();
+  async loadSkillFromFile(filePath) {
+    const content = await fs7.readFile(filePath, "utf-8");
+    const cleanContent = content.replace(/^---[\s\S]*?---\s*/, "");
+    return cleanContent;
+  }
+  async activateSkill(skillName) {
+    if (this.activeSkills.has(skillName)) {
+      return `Skill ${skillName} is already active.`;
+    }
+    this.reset();
+    const globalPath = path8.join(os2.homedir(), ".shark", "skills", skillName, "SKILL.md");
+    const localPath = path8.join(process.cwd(), ".agents", "skills", skillName, "SKILL.md");
+    let skillPath = "";
+    try {
+      await fs7.access(localPath);
+      skillPath = localPath;
+    } catch {
+      try {
+        await fs7.access(globalPath);
+        skillPath = globalPath;
+      } catch {
+        throw new Error(`Skill '${skillName}' not found globally or locally.`);
+      }
+    }
+    const prompt = await this.loadSkillFromFile(skillPath);
+    this.activeSkills.add(skillName);
+    this.skillPrompts.set(skillName, prompt);
+    return prompt;
+  }
+  getSystemInstructionExtension() {
+    if (this.activeSkills.size === 0) return "";
+    let extension = "\n\n<EXTREMELY_IMPORTANT>\n";
+    for (const [name, prompt] of this.skillPrompts.entries()) {
+      extension += `
+--- ACTIVE SKILL: ${name} ---
+${prompt}
+`;
+    }
+    extension += "\n</EXTREMELY_IMPORTANT>\n";
+    return extension;
+  }
+  async listAvailableSkills() {
+    const globalSkillsDir = path8.join(os2.homedir(), ".shark", "skills");
+    const localSkillsDir = path8.join(process.cwd(), ".agents", "skills");
+    const skillNames = /* @__PURE__ */ new Set();
+    const readDir = async (dir) => {
+      try {
+        const entries = await fs7.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const skillMdPath = path8.join(dir, entry.name, "SKILL.md");
+            try {
+              await fs7.access(skillMdPath);
+              skillNames.add(entry.name);
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    };
+    await readDir(globalSkillsDir);
+    await readDir(localSkillsDir);
+    return Array.from(skillNames).sort();
+  }
+  reset() {
+    this.activeSkills.clear();
+    this.skillPrompts.clear();
+  }
+};
+var skillManager = new SkillManager();
+
+// src/core/workflow/subagent-manager.ts
+import crypto2 from "crypto";
+import fs8 from "fs";
+import path9 from "path";
+import { fork } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var SubagentManager = class {
+  subagents = /* @__PURE__ */ new Map();
+  customTypes = /* @__PURE__ */ new Map();
+  registerSubagent(id, type, role, parentId) {
+    this.subagents.set(id, { id, type, role, status: "running", parentId });
+  }
+  terminateSubagent(id, success = true, isCancelled = false) {
+    const state = this.subagents.get(id);
+    if (state) {
+      if (state.status === "cancelled") {
+        return;
+      }
+      if (isCancelled) {
+        state.status = "cancelled";
+      } else {
+        state.status = success ? "completed" : "failed";
+      }
+    }
+  }
+  isSubagentActive(id) {
+    return this.subagents.get(id)?.status === "running";
+  }
+  hasSubagent(id) {
+    return this.subagents.has(id);
+  }
+  getSubagentState(id) {
+    return this.subagents.get(id);
+  }
+  updateSubagentSummary(id, summary) {
+    const state = this.subagents.get(id);
+    if (state) {
+      state.summary = summary;
+    }
+  }
+  sendMessage(recipient, message) {
+    const mailboxDir = path9.resolve(process.cwd(), ".shark", "mailbox", recipient);
+    fs8.mkdirSync(mailboxDir, { recursive: true });
+    const filePath = path9.join(mailboxDir, `${Date.now()}-${crypto2.randomUUID()}.json`);
+    fs8.writeFileSync(filePath, JSON.stringify({ message }), "utf-8");
+  }
+  retrieveMessages(id) {
+    const mailboxDir = path9.resolve(process.cwd(), ".shark", "mailbox", id);
+    if (!fs8.existsSync(mailboxDir)) {
+      return [];
+    }
+    const files = fs8.readdirSync(mailboxDir);
+    files.sort();
+    const messages = [];
+    for (const file of files) {
+      const filePath = path9.join(mailboxDir, file);
+      try {
+        const content = fs8.readFileSync(filePath, "utf-8");
+        const data = JSON.parse(content);
+        if (data && typeof data.message === "string") {
+          messages.push(data.message);
+        }
+      } catch (e) {
+      }
+      try {
+        fs8.unlinkSync(filePath);
+      } catch (e) {
+      }
+    }
+    return messages;
+  }
+  peekMessages(id) {
+    const mailboxDir = path9.resolve(process.cwd(), ".shark", "mailbox", id);
+    if (!fs8.existsSync(mailboxDir)) {
+      return [];
+    }
+    const files = fs8.readdirSync(mailboxDir);
+    files.sort();
+    const messages = [];
+    for (const file of files) {
+      const filePath = path9.join(mailboxDir, file);
+      try {
+        const content = fs8.readFileSync(filePath, "utf-8");
+        const data = JSON.parse(content);
+        if (data && typeof data.message === "string") {
+          messages.push(data.message);
+        }
+      } catch (e) {
+      }
+    }
+    return messages;
+  }
+  defineSubagentType(name, description, systemPrompt, options = {}) {
+    this.customTypes.set(name, {
+      name,
+      description,
+      systemPrompt,
+      ...options
+    });
+  }
+  getCustomSubagentType(name) {
+    return this.customTypes.get(name);
+  }
+  getSubagentLogs(id, maxLines = 50) {
+    if (!/^[a-zA-Z0-9-]+$/.test(id)) {
+      throw new Error("Invalid subagent ID format");
+    }
+    const projectRoot = process.cwd();
+    const logFile = path9.resolve(projectRoot, "_sharkrc", "history", `subagent-${id}-console.log`);
+    if (!fs8.existsSync(logFile)) {
+      return "No console logs found for this subagent.";
+    }
+    try {
+      let content = fs8.readFileSync(logFile, "utf-8");
+      if (content.endsWith("\n")) {
+        content = content.slice(0, -1);
+      }
+      const lines = content.split("\n");
+      const tail = lines.slice(-maxLines);
+      return tail.join("\n");
+    } catch (e) {
+      return `Failed to read subagent logs: ${e.message}`;
+    }
+  }
+  getActiveSubagents() {
+    return Array.from(this.subagents.values()).filter((s) => s.status === "running");
+  }
+  getActiveSubagentsForParent(parentId) {
+    return Array.from(this.subagents.values()).filter((s) => s.status === "running" && s.parentId === parentId);
+  }
+  killSubagent(id) {
+    const state = this.subagents.get(id);
+    if (state) {
+      if (state.childProcess) {
+        try {
+          state.childProcess.kill("SIGTERM");
+        } catch (e) {
+        }
+      }
+      this.terminateSubagent(id, false, true);
+      if (state.parentId) {
+        const cancelMsg = `[Subagent Notification] Subagent ${state.role} (${id}) has finished with status: CANCELLED. Summary: Terminated by parent agent.`;
+        this.sendMessage(state.parentId, cancelMsg);
+      }
+    }
+  }
+  killAllSubagents() {
+    for (const [id, state] of this.subagents.entries()) {
+      if (state.status === "running") {
+        this.killSubagent(id);
+      }
+    }
+  }
+  async invokeSubagents(subagents, parentId, parentQueue) {
+    const invoked = [];
+    for (const sub of subagents) {
+      const id = `subagent-${crypto2.randomUUID()}`;
+      this.registerSubagent(id, sub.TypeName, sub.Role, parentId);
+      const promise = (async () => {
+        try {
+          const projectRoot = process.cwd();
+          const __filename2 = fileURLToPath2(import.meta.url);
+          const __dirname2 = path9.dirname(__filename2);
+          let packageRoot = __dirname2;
+          while (true) {
+            const pkgPath = path9.join(packageRoot, "package.json");
+            if (fs8.existsSync(pkgPath)) {
+              try {
+                const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+                if (pkg && pkg.name === "shark-ai") {
+                  break;
+                }
+              } catch (e) {
+              }
+            }
+            const parent = path9.dirname(packageRoot);
+            if (parent === packageRoot) {
+              break;
+            }
+            packageRoot = parent;
+          }
+          const pathToSharkJs = path9.resolve(packageRoot, "dist", "bin", "shark.js");
+          const customType = this.customTypes.get(sub.TypeName);
+          let customContext = `Voc\xEA est\xE1 executando em modo SUBAGENTE.
+`;
+          customContext += `- Seu ID \xE9: ${id}
+`;
+          customContext += `- O ID do seu Agente Pai \xE9: ${parentId}
+`;
+          customContext += `- Voc\xEA N\xC3O tem um terminal interativo com o usu\xE1rio humano. N\xE3o use 'talk_with_user' para interagir.
+`;
+          customContext += `- Para reportar progresso intermedi\xE1rio ou tirar d\xFAvidas com seu pai, use a a\xE7\xE3o 'send_message' com Recipient='${parentId}'.
+`;
+          customContext += `- Para concluir a tarefa e enviar o resultado detalhado em markdown, use obrigatoriamente a a\xE7\xE3o 'complete_task' com suas descobertas no campo 'content'.
+`;
+          if (customType) {
+            customContext += `Custom Prompt: ${customType.systemPrompt}
+`;
+          }
+          const instruction = customContext + "\n\n" + sub.Prompt;
+          const args = ["dev", "-t", instruction, "--taskId", id, "--auto"];
+          const child = fork(pathToSharkJs, args, {
+            cwd: projectRoot,
+            silent: true,
+            env: {
+              ...process.env,
+              SHARK_PARENT_ID: parentId,
+              SHARK_SUBAGENT_ROLE: sub.Role
+            }
+          });
+          const state2 = this.subagents.get(id);
+          if (state2) {
+            state2.childProcess = child;
+          }
+          const historyDir = path9.resolve(projectRoot, "_sharkrc", "history");
+          fs8.mkdirSync(historyDir, { recursive: true });
+          const consoleLogFile = path9.join(historyDir, `subagent-${id}-console.log`);
+          const logStream = fs8.createWriteStream(consoleLogFile, { flags: "a" });
+          if (child.stdout) {
+            child.stdout.pipe(logStream);
+          }
+          if (child.stderr) {
+            child.stderr.pipe(logStream);
+          }
+          const exitCode = await new Promise((resolve2) => {
+            child.on("exit", (code) => {
+              resolve2(code);
+            });
+          });
+          logStream.end();
+          const isCancelled = this.subagents.get(id)?.status === "cancelled";
+          const success = exitCode === 0;
+          this.terminateSubagent(id, success);
+          if (isCancelled) {
+            this.updateSubagentSummary(id, "Terminated by parent agent.");
+            tui.log.message(`
+Subagent ${sub.Role} (${id}) cancelled.`);
+          } else if (!success) {
+            this.updateSubagentSummary(id, "Failed");
+            const fallbackMsg = `[Subagent Notification] Subagent ${sub.Role} (${id}) has finished with status: FAILED. Summary: Subagent process exited with code ${exitCode}`;
+            const mailboxDir = path9.resolve(projectRoot, ".shark", "mailbox", parentId);
+            const hasMessages = fs8.existsSync(mailboxDir) && fs8.readdirSync(mailboxDir).length > 0;
+            if (!hasMessages) {
+              this.sendMessage(parentId, fallbackMsg);
+            }
+            tui.log.error(`Subagent ${sub.Role} (${id}) failed.`);
+          } else {
+            this.updateSubagentSummary(id, "Completed");
+            const parentMsgs = this.peekMessages(parentId);
+            const subagentMsg = parentMsgs.find((m) => m.includes(`(${id})`));
+            if (subagentMsg) {
+              tui.log.message(`
+${subagentMsg}`);
+            } else {
+              tui.log.success(`Subagent ${sub.Role} (${id}) completed successfully.`);
+            }
+          }
+          if (parentQueue) {
+            let summaryContent = "Tarefa conclu\xEDda sem resumo.";
+            let statusVal = success ? "completed" : "failed";
+            if (isCancelled) {
+              summaryContent = "Terminated by parent agent.";
+              statusVal = "cancelled";
+            } else if (success) {
+              const parentMsgs = this.peekMessages(parentId);
+              const subagentMsg = parentMsgs.find((m) => m.includes(`(${id})`));
+              if (subagentMsg) {
+                summaryContent = subagentMsg;
+              }
+            } else {
+              summaryContent = `Subagente falhou com c\xF3digo de sa\xEDda ${exitCode}`;
+            }
+            parentQueue.push({
+              type: "subagent_notification",
+              content: summaryContent,
+              timestamp: Date.now(),
+              metadata: {
+                subagentId: id,
+                role: sub.Role,
+                status: statusVal
+              }
+            });
+          }
+        } catch (error) {
+          console.error(`Subagent ${id} failed to spawn:`, error);
+          this.terminateSubagent(id, false);
+          const errorMsg = error instanceof Error ? error.message : "Unknown error";
+          this.sendMessage(
+            parentId,
+            `[Subagent Notification] Subagent ${sub.Role} (${id}) has finished with status: FAILED. Summary: Subagent spawn failed: ${errorMsg}`
+          );
+          tui.log.error(`Subagent ${sub.Role} (${id}) failed to spawn.`);
+          if (parentQueue) {
+            parentQueue.push({
+              type: "subagent_notification",
+              content: `Subagente falhou ao iniciar: ${errorMsg}`,
+              timestamp: Date.now(),
+              metadata: {
+                subagentId: id,
+                role: sub.Role,
+                status: "failed"
+              }
+            });
+          }
+        }
+      })();
+      const state = this.subagents.get(id);
+      if (state) {
+        state.promise = promise;
+      }
+      invoked.push({ id, TypeName: sub.TypeName, Role: sub.Role });
+    }
+    return invoked;
+  }
+};
+var subagentManager = new SubagentManager();
+
+// src/core/workflow/message-queue.ts
+var MessageQueue = class {
+  queue = [];
+  pendingResolvers = [];
+  push(message) {
+    if (this.pendingResolvers.length > 0) {
+      const resolve2 = this.pendingResolvers.shift();
+      resolve2(message);
+    } else {
+      this.queue.push(message);
+    }
+  }
+  async next() {
+    if (this.queue.length > 0) {
+      return this.queue.shift();
+    }
+    return new Promise((resolve2) => {
+      this.pendingResolvers.push(resolve2);
+    });
+  }
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+};
+
+// src/core/agents/developer-agent.ts
+async function promptUser(message, initialValue, placeholder, prefix = "") {
+  let userReply = await tui.text({ message: `${prefix}${message}`, initialValue, placeholder });
+  while (userReply === "/skills") {
+    const availableSkills = await skillManager.listAvailableSkills();
+    const options = availableSkills.map((name) => ({ value: name, label: name }));
+    if (options.length === 0) {
+      tui.log.warning("Nenhuma skill encontrada. Execute `shark super` para instalar as skills.");
+    } else {
+      const selectedSkill = await tui.select({
+        message: "Selecione a Skill do Superpowers para ativar:",
+        options
+      });
+      if (!tui.isCancel(selectedSkill)) {
+        await skillManager.activateSkill(selectedSkill);
+        tui.log.success(`\u2714 Skill '${selectedSkill}' ativada com sucesso!`);
+      }
+    }
+    userReply = await tui.text({
+      message: `${prefix}${message}`,
+      initialValue,
+      placeholder: "digite a instru\xE7\xE3o da tarefa..."
+    });
+  }
+  return userReply;
+}
+async function waitForInputOrNotification(queue, promptMessage = "Your answer:", subagentPrefix = "", timeoutMs) {
+  let cancelled = false;
+  let resolvePromptPromise = null;
+  let timerId = null;
+  const promptPromise = new Promise((resolve2) => {
+    resolvePromptPromise = resolve2;
+  });
+  const runPrompt = async () => {
+    try {
+      const userReply = await promptUser(promptMessage, void 0, void 0, subagentPrefix);
+      if (!cancelled && resolvePromptPromise) {
+        resolvePromptPromise({
+          type: "user",
+          content: userReply,
+          timestamp: Date.now()
+        });
+      }
+    } catch (e) {
+    }
+  };
+  runPrompt();
+  const queuePromise = queue.next();
+  const promises = [promptPromise, queuePromise];
+  if (timeoutMs !== void 0 && timeoutMs !== null) {
+    const timeoutPromise = new Promise((resolve2) => {
+      timerId = setTimeout(() => {
+        resolve2({
+          type: "timeout",
+          content: "Wait timeout expired.",
+          timestamp: Date.now()
+        });
+      }, timeoutMs);
+    });
+    promises.push(timeoutPromise);
+  }
+  const winner = await Promise.race(promises);
+  if (timerId) {
+    clearTimeout(timerId);
+  }
+  if (winner.type === "subagent_notification" || winner.type === "timeout") {
+    cancelled = true;
+    process.stdin.emit("data", "\r");
+    await new Promise((r) => setTimeout(r, 50));
+    if (process.stdout.isTTY) {
+      process.stdout.write("\x1B[1A\x1B[2K\x1B[1A\x1B[2K");
     }
-    if (action === "resume") {
-      tui.log.success(`Resuming work on ${colors.primary(existingState.projectName)}...`);
-      tui.outro(`To continue, run: "shark agent" (Context loaded)`);
-      return;
+  }
+  return winner;
+}
+function formatRoleForUI(role) {
+  const limit = 20;
+  if (role.length <= limit) return role;
+  return role.substring(0, limit - 3) + "...";
+}
+async function interactiveDeveloperAgent(options = {}) {
+  const isAuto = options.auto === true || process.argv.includes("--auto");
+  const isSubagent = !!options.taskId && (options.taskId.startsWith("subagent-") || subagentManager.hasSubagent(options.taskId));
+  const projectRoot = process.cwd();
+  const messageQueue = new MessageQueue();
+  let currentTask = options.taskInstruction;
+  if (!currentTask) {
+    if (isSubagent) {
+      currentTask = "Subagent Task";
+    } else {
+      const userTask = await promptUser(
+        "O que voc\xEA gostaria que o Shark Dev fizesse?",
+        void 0,
+        "ex: crie uma API REST simples ou digite /skills para ativar diretrizes"
+      );
+      if (tui.isCancel(userTask) || !userTask) {
+        return { success: false, summary: "Task execution cancelled." };
+      }
+      currentTask = userTask;
     }
   }
-  const projectName = await tui.text({
-    message: "What is the name of your project?",
-    placeholder: "e.g. My Awesome App",
-    validate: (value) => {
-      if (!value) return "Project name is required";
-      if (value.trim().length < 2) return "Project name must be at least 2 characters";
+  let subagentPrefix = "";
+  if (options.taskId) {
+    const subState = subagentManager.getSubagentState(options.taskId);
+    if (subState) {
+      subagentPrefix = `[Subagent: ${formatRoleForUI(subState.role)}] `;
     }
-  });
-  if (tui.isCancel(projectName)) {
-    tui.outro("Initialization cancelled.");
-    return;
   }
-  const techStackOptions = TechStackEnum.options.map((stack) => ({
-    value: stack,
-    label: stack === "node-ts" ? "Node.js (TypeScript)" : stack === "nextjs" ? "Next.js" : stack.charAt(0).toUpperCase() + stack.slice(1)
-  }));
-  const techStack = await tui.select({
-    message: "Select your technology stack:",
-    options: techStackOptions
-  });
-  if (tui.isCancel(techStack)) {
-    tui.outro("Initialization cancelled.");
-    return;
+  const log = {
+    info: (msg) => tui.log.info(`${subagentPrefix}${msg}`),
+    warning: (msg) => tui.log.warning(`${subagentPrefix}${msg}`),
+    error: (msg) => tui.log.error(`${subagentPrefix}${msg}`),
+    success: (msg) => tui.log.success(`${subagentPrefix}${msg}`),
+    message: (msg) => tui.log.message(`${subagentPrefix}${msg}`)
+  };
+  let contextContent = "";
+  const defaultContextPath = path10.resolve(projectRoot, "_sharkrc", "project-context.md");
+  const specificContextPath = options.context ? path10.resolve(projectRoot, options.context) : defaultContextPath;
+  if (fs9.existsSync(specificContextPath)) {
+    try {
+      contextContent = fs9.readFileSync(specificContextPath, "utf-8");
+    } catch (e) {
+      log.warning(`Failed to read context file: ${e}`);
+    }
+  }
+  let basePrompt = ``;
+  if (contextContent) {
+    basePrompt += `
+
+--- 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 address the user's request:
+- If the request is a question, a request for explanation, or a discussion, answer the user using the 'talk_with_user' action. You can search the codebase or read files first to answer accurately. Once the explanation/discussion is complete, output a final response starting with "TASK_COMPLETED:" followed by a brief summary.
+- If the request is to implement changes, debug, or write code:
+  1. Implement the necessary changes.
+  2. Verify (compile/test).
+  3. When you are confident the task is done, output a final response starting with "TASK_COMPLETED:" followed by a brief technical summary of what you did.
+`;
+  let nextPrompt = basePrompt;
+  let keepGoing = true;
+  let finalSummary = "";
+  const conversationKey = options.taskId ? `dev_agent_${options.taskId}` : `dev_agent_${Date.now()}`;
+  const anchorManager = new AnchorStateManager();
   const spinner = tui.spinner();
-  spinner.start("Initializing project workflow...");
+  const handleCleanupSignal = (exitCode) => {
+    const currentId = options.taskId || "parent";
+    const active = subagentManager.getActiveSubagentsForParent(currentId);
+    if (active.length > 0) {
+      for (const sub of active) {
+        subagentManager.killSubagent(sub.id);
+      }
+    }
+    process.exit(exitCode);
+  };
+  const sigIntHandler = () => handleCleanupSignal(130);
+  const sigTermHandler = () => handleCleanupSignal(143);
+  process.on("SIGINT", sigIntHandler);
+  process.on("SIGTERM", sigTermHandler);
   try {
-    const newState = {
-      projectId: randomUUID(),
-      projectName,
-      techStack,
-      currentStage: "business_analysis",
-      stageStatus: "pending",
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      artifacts: [],
-      metadata: {
-        initializedBy: "shark-cli",
-        version: "0.0.1"
+    while (keepGoing) {
+      if (options.taskId && subagentManager.hasSubagent(options.taskId) && !subagentManager.isSubagentActive(options.taskId)) {
+        log.warning(`Subagent ${options.taskId} was terminated.`);
+        return { success: false, summary: "Subagent terminated by manager." };
       }
-    };
-    await workflowManager.save(newState);
-    spinner.stop("Project workflow created!");
-    tui.log.success(`Project ${colors.primary(projectName)} initialized successfully.`);
-    tui.log.message(`Your Project ID: ${colors.dim(newState.projectId)}`);
-    tui.outro('Ready to start! Run "shark agent" to begin analyzing requirements.');
-  } catch (error) {
-    spinner.stop("Initialization failed.", 1);
-    tui.log.error(error.message);
-    process.exit(1);
+      const recipientId = options.taskId || "parent";
+      const mailboxMessages = subagentManager.retrieveMessages(recipientId);
+      let currentTurnPrompt = nextPrompt;
+      if (mailboxMessages.length > 0) {
+        currentTurnPrompt += `
+
+\u2709\uFE0F NEW MAILBOX MESSAGES:
+${mailboxMessages.map((m) => `- ${m}`).join("\n")}
+`;
+      }
+      const myId = options.taskId || "parent";
+      const allSubagents = subagentManager.getActiveSubagentsForParent(myId);
+      if (allSubagents.length > 0) {
+        let panel = `
+
+--- CURRENT ACTIVE SUBAGENTS ---
+`;
+        panel += `You have ${allSubagents.length} active subagent(s) running in the background:
+`;
+        for (const sub of allSubagents) {
+          panel += `- ID: ${sub.id} | Role: ${sub.role} | Status: ${sub.status}
+`;
+        }
+        panel += `Use the 'wait' action if you have no other work and are waiting for these subagents to complete.
+`;
+        panel += `--------------------------------
+`;
+        currentTurnPrompt += panel;
+      }
+      const promptToSend = currentTurnPrompt + skillManager.getSystemInstructionExtension();
+      try {
+        const activeSubagents = subagentManager.getActiveSubagents();
+        const activeCount = activeSubagents.length;
+        const spinnerText = activeCount > 0 ? `\u{1F988} Shark Dev working... (Active subagents: ${activeCount})` : "\u{1F988} Shark Dev working...";
+        spinner.start(spinnerText);
+        const existingConversationId = await conversationManager.getConversationId(conversationKey);
+        const provider = ProviderResolver.getProvider("developer_agent");
+        const response = await provider.streamChat(promptToSend, {
+          conversationId: existingConversationId,
+          agentType: "developer_agent",
+          onChunk: () => {
+          }
+        });
+        if (response.conversation_id) {
+          await conversationManager.saveConversationId(conversationKey, response.conversation_id);
+        }
+        spinner.stop("Response received");
+        if (response.summary) {
+          if (options.taskId) {
+            subagentManager.updateSubagentSummary(options.taskId, response.summary);
+          }
+          log.info(`\u{1F4CC} Status: ${response.summary}`);
+        }
+        if (response.message && response.message.includes("TASK_COMPLETED:")) {
+          finalSummary = response.message.split("TASK_COMPLETED:")[1].trim();
+          log.success(`\u2714 Task Completed: ${finalSummary}`);
+          if (options.taskId) {
+            subagentManager.updateSubagentSummary(options.taskId, finalSummary);
+            keepGoing = false;
+            break;
+          }
+          if (!options.taskInstruction) {
+            let nextMsg;
+            if (!messageQueue.isEmpty()) {
+              nextMsg = await messageQueue.next();
+            } else {
+              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix);
+            }
+            if (nextMsg.type === "user") {
+              if (tui.isCancel(nextMsg.content)) {
+                keepGoing = false;
+                break;
+              }
+            }
+            nextPrompt = nextMsg.content;
+            continue;
+          } else {
+            keepGoing = false;
+            break;
+          }
+        }
+        if (response.message && response.message.includes("TASK_FAILED:")) {
+          const failureReason = response.message.split("TASK_FAILED:")[1].trim();
+          log.error(`\u274C Agent reported task failure: ${failureReason}`);
+          if (options.taskId) {
+            if (process.env.SHARK_PARENT_ID) {
+              const parentId = process.env.SHARK_PARENT_ID;
+              const role = process.env.SHARK_SUBAGENT_ROLE || "Subagent";
+              subagentManager.sendMessage(
+                parentId,
+                `[Subagent Notification] Subagent ${role} (${options.taskId}) has finished with status: FAILED. Summary: ${failureReason}`
+              );
+            }
+            return { success: false, summary: failureReason };
+          }
+          if (!options.taskInstruction) {
+            let nextMsg;
+            if (!messageQueue.isEmpty()) {
+              nextMsg = await messageQueue.next();
+            } else {
+              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix);
+            }
+            if (nextMsg.type === "user") {
+              if (tui.isCancel(nextMsg.content)) {
+                return { success: false, summary: failureReason };
+              }
+            }
+            nextPrompt = nextMsg.content;
+            continue;
+          } else {
+            return { success: false, summary: failureReason };
+          }
+        }
+        const action = response.action;
+        if (!action) {
+          if (isSubagent) {
+            log.warning("No action returned by the subagent. Exiting loop.");
+            keepGoing = false;
+            break;
+          }
+          if (response.message) {
+            log.info(colors.primary("\u{1F916} Shark Dev:"));
+            console.log(response.message);
+            let nextMsg;
+            if (!messageQueue.isEmpty()) {
+              nextMsg = await messageQueue.next();
+            } else {
+              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix);
+            }
+            if (nextMsg.type === "user") {
+              if (tui.isCancel(nextMsg.content)) {
+                keepGoing = false;
+                break;
+              }
+            }
+            nextPrompt = nextMsg.content;
+          } else {
+            log.warning("No action or message returned by the agent.");
+            let nextMsg;
+            if (!messageQueue.isEmpty()) {
+              nextMsg = await messageQueue.next();
+            } else {
+              nextMsg = await waitForInputOrNotification(messageQueue, "Agent returned empty response. Type a message to continue or press Ctrl+C to cancel:", subagentPrefix);
+            }
+            if (nextMsg.type === "user") {
+              if (tui.isCancel(nextMsg.content)) {
+                keepGoing = false;
+                break;
+              }
+            }
+            nextPrompt = nextMsg.content;
+          }
+          continue;
+        }
+        let resultMsg = "";
+        if (action.type === "read_file") {
+          const filePath = action.path || "";
+          log.info(`\u{1F4D6} Reading (Anchored): ${colors.dim(filePath)}`);
+          try {
+            const content = anchorManager.getAnchoredContent(filePath);
+            resultMsg = `[Action read_file(${filePath}) Success]:
+${content}`;
+          } catch (e) {
+            resultMsg = `[Action read_file(${filePath}) Failed]: ${e.message}`;
+          }
+        } else if (action.type === "modify_file") {
+          const filePath = action.path || "";
+          log.warning(`\u{1F4DD} Modify (Anchored): ${colors.bold(filePath)}`);
+          let approved = isAuto;
+          if (!approved) {
+            approved = await tui.confirm({ message: `Approve modify_file changes to ${filePath}?` });
+          }
+          if (approved) {
+            try {
+              anchorManager.applyAnchoredEdit(filePath, action.start_anchor || "", action.end_anchor || "", action.content || "");
+              resultMsg = `[Action modify_file(${filePath}) Success]`;
+            } catch (e) {
+              resultMsg = `[Action modify_file(${filePath}) Failed]: ${e.message}`;
+            }
+          } else {
+            resultMsg = `[Action modify_file(${filePath}) User Denied]`;
+          }
+        } else if (action.type === "create_file") {
+          const filePath = action.path || "";
+          log.warning(`\u{1F4DD} Create file: ${colors.bold(filePath)}`);
+          let approved = isAuto;
+          if (!approved) {
+            approved = await tui.confirm({ message: `Approve create_file changes to ${filePath}?` });
+          }
+          if (approved) {
+            try {
+              const resolvedPath = path10.resolve(projectRoot, filePath);
+              const dir = path10.dirname(resolvedPath);
+              if (!fs9.existsSync(dir)) {
+                fs9.mkdirSync(dir, { recursive: true });
+              }
+              fs9.writeFileSync(resolvedPath, action.content || "", "utf-8");
+              resultMsg = `[Action create_file(${filePath}) Success]`;
+            } catch (e) {
+              resultMsg = `[Action create_file(${filePath}) Failed]: ${e.message}`;
+            }
+          } else {
+            resultMsg = `[Action create_file(${filePath}) User Denied]`;
+          }
+        } else if (action.type === "delete_file") {
+          const filePath = action.path || "";
+          log.warning(`\u{1F5D1}\uFE0F Delete file: ${colors.bold(filePath)}`);
+          let approved = isAuto;
+          if (!approved) {
+            approved = await tui.confirm({ message: `Approve delete_file changes to ${filePath}?` });
+          }
+          if (approved) {
+            try {
+              const resolvedPath = path10.resolve(projectRoot, filePath);
+              if (fs9.existsSync(resolvedPath)) {
+                fs9.rmSync(resolvedPath, { force: true });
+              }
+              resultMsg = `[Action delete_file(${filePath}) Success]`;
+            } catch (e) {
+              resultMsg = `[Action delete_file(${filePath}) Failed]: ${e.message}`;
+            }
+          } else {
+            resultMsg = `[Action delete_file(${filePath}) User Denied]`;
+          }
+        } else if (action.type === "run_command") {
+          const cmd = action.command || "";
+          log.info(`\u{1F4BB} Executing: ${colors.dim(cmd)}`);
+          let approved = isAuto;
+          if (!approved) {
+            approved = await tui.confirm({ message: `Execute run_command: ${cmd}?` });
+          }
+          if (approved) {
+            try {
+              const output = await handleRunCommand(cmd);
+              resultMsg = `[Action run_command(${cmd}) Success]:
+${output}`;
+            } catch (e) {
+              resultMsg = `[Action run_command(${cmd}) Failed]: ${e.message}`;
+            }
+          } else {
+            resultMsg = `[Action run_command(${cmd}) User Denied]`;
+          }
+        } else if (action.type === "list_files") {
+          const dirPath = action.path || ".";
+          log.info(`\u{1F4C2} Scanning: ${colors.dim(dirPath)}`);
+          try {
+            const result = handleListFiles(dirPath);
+            resultMsg = `[Action list_files(${dirPath}) Success]:
+${result}`;
+          } catch (e) {
+            resultMsg = `[Action list_files(${dirPath}) Failed]: ${e.message}`;
+          }
+        } else if (action.type === "search_file") {
+          const pattern = action.path || "";
+          log.info(`\u{1F50D} Searching files: ${colors.dim(pattern)}`);
+          try {
+            const result = handleSearchFile(pattern);
+            resultMsg = `[Action search_file(${pattern}) Success]:
+${result}`;
+          } catch (e) {
+            resultMsg = `[Action search_file(${pattern}) Failed]: ${e.message}`;
+          }
+        } else if (action.type === "search_code") {
+          const glob = action.path || "src/**/*";
+          const query = action.query || "";
+          const isRegex = action.is_regex === true;
+          log.info(`\u{1F50E} Search code: ${colors.dim(`"${query}" in ${glob}`)}`);
+          try {
+            const result = handleSearchCode(glob, query, isRegex);
+            resultMsg = `[Action search_code("${query}" in "${glob}") Success]:
+${result}`;
+          } catch (e) {
+            resultMsg = `[Action search_code("${query}" in "${glob}") Failed]: ${e.message}`;
+          }
+        } else if (action.type === "use_mcp_tool") {
+          resultMsg = `[Action use_mcp_tool Failed]: MCP tools are not configured/available in this agent.`;
+        } else if (action.type === "activate_skill") {
+          const name = action.skill_name || "";
+          log.info(`\u26A1 Activating skill: ${colors.bold(name)}`);
+          try {
+            await skillManager.activateSkill(name);
+            resultMsg = `[System]: Skill '${name}' activated successfully.`;
+          } catch (e) {
+            resultMsg = `[System]: Failed to activate skill '${name}': ${e.message}`;
+          }
+        } else if (action.type === "talk_with_user") {
+          const isSystemError = action.content?.startsWith("[SYSTEM ERROR]");
+          if (isSystemError) {
+            log.error(`\u26A0\uFE0F Detectado erro na resposta do Agente (truncado ou inv\xE1lido).`);
+            log.info(colors.dim(action.content || ""));
+            if (isSubagent) {
+              resultMsg = action.content || "";
+              nextPrompt = resultMsg;
+              continue;
+            } else {
+              let approved = isAuto;
+              if (!approved) {
+                approved = await tui.confirm({ message: `Enviar notifica\xE7\xE3o de erro para o agente tentar se recuperar automaticamente?` });
+              }
+              if (approved) {
+                resultMsg = action.content || "";
+              } else {
+                let nextMsg;
+                if (!messageQueue.isEmpty()) {
+                  nextMsg = await messageQueue.next();
+                } else {
+                  nextMsg = await waitForInputOrNotification(messageQueue, "Seu prompt alternativo para o agente:", subagentPrefix);
+                }
+                if (nextMsg.type === "user") {
+                  if (tui.isCancel(nextMsg.content)) {
+                    keepGoing = false;
+                    break;
+                  }
+                }
+                resultMsg = nextMsg.content;
+              }
+            }
+          } else {
+            const contentStr = action.content || "";
+            const hasCompleted = contentStr.includes("TASK_COMPLETED:");
+            if (isSubagent) {
+              const summary = hasCompleted ? contentStr.split("TASK_COMPLETED:")[1].trim() : contentStr;
+              subagentManager.updateSubagentSummary(options.taskId, summary);
+              finalSummary = summary;
+              keepGoing = false;
+              break;
+            }
+            if (hasCompleted) {
+              finalSummary = contentStr.split("TASK_COMPLETED:")[1].trim();
+              log.success(`\u2714 Task Completed: ${finalSummary}`);
+              if (!options.taskInstruction) {
+                let nextMsg2;
+                if (!messageQueue.isEmpty()) {
+                  nextMsg2 = await messageQueue.next();
+                } else {
+                  nextMsg2 = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix);
+                }
+                if (nextMsg2.type === "user") {
+                  if (tui.isCancel(nextMsg2.content)) {
+                    keepGoing = false;
+                    break;
+                  }
+                }
+                nextPrompt = nextMsg2.content;
+                continue;
+              } else {
+                keepGoing = false;
+                break;
+              }
+            }
+            log.info(colors.primary("\u{1F916} Shark Dev:"));
+            console.log(contentStr);
+            let nextMsg;
+            if (!messageQueue.isEmpty()) {
+              nextMsg = await messageQueue.next();
+            } else {
+              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix);
+            }
+            if (nextMsg.type === "user") {
+              if (tui.isCancel(nextMsg.content)) {
+                keepGoing = false;
+                break;
+              }
+              resultMsg = `User Reply: ${nextMsg.content}`;
+            } else {
+              resultMsg = nextMsg.content;
+            }
+          }
+        } else if (action.type === "define_subagent") {
+          const name = action.name || "";
+          const desc = action.description || "";
+          const sysPrompt = action.system_prompt || "";
+          const opts = {
+            enableWriteTools: action.enable_write_tools ?? void 0,
+            enableSubagentTools: action.enable_subagent_tools ?? void 0,
+            enableMcpTools: action.enable_mcp_tools ?? void 0
+          };
+          log.info(`\u{1F6E0}\uFE0F Defining subagent type: ${colors.bold(name)}`);
+          subagentManager.defineSubagentType(name, desc, sysPrompt, opts);
+          resultMsg = `[Action define_subagent Success]: Defined subagent type '${name}'`;
+        } else if (action.type === "invoke_subagent") {
+          const subagentsToInvoke = action.Subagents || [];
+          log.info(`\u{1F680} Invoking ${subagentsToInvoke.length} subagent(s)`);
+          const parentId = options.taskId || "parent";
+          const invoked = await subagentManager.invokeSubagents(subagentsToInvoke, parentId, messageQueue);
+          resultMsg = `[Action invoke_subagent Success]: Invoked subagents:
+${invoked.map((s) => `- ID: ${s.id}, Type: ${s.TypeName}, Role: ${s.Role}`).join("\n")}`;
+        } else if (action.type === "send_message") {
+          const recipient = action.Recipient || "";
+          const message = action.Message || "";
+          log.info(`\u2709\uFE0F Sending message to ${colors.bold(recipient)}`);
+          subagentManager.sendMessage(recipient, message);
+          resultMsg = `[Action send_message Success]: Message sent to '${recipient}'`;
+        } else if (action.type === "manage_subagents") {
+          const subAction = action.Action || "";
+          const ids = action.ConversationIds || [];
+          log.info(`\u2699\uFE0F Managing subagents. Action: ${colors.bold(subAction)}`);
+          if (subAction === "list") {
+            const active = subagentManager.getActiveSubagents();
+            resultMsg = `[Action manage_subagents Success]: Active subagents:
+${active.map((s) => `- ID: ${s.id}, Type: ${s.type}, Role: ${s.role}`).join("\n")}`;
+          } else if (subAction === "read_logs") {
+            const id = ids[0];
+            if (!id) {
+              resultMsg = `[Action manage_subagents Failed]: No subagent ID provided in ConversationIds.`;
+            } else {
+              try {
+                const logs = subagentManager.getSubagentLogs(id);
+                resultMsg = `[Action manage_subagents Success]: Last log lines for subagent ${id}:
+\`\`\`
+${logs}
+\`\`\``;
+              } catch (e) {
+                resultMsg = `[Action manage_subagents Failed]: ${e.message}`;
+              }
+            }
+          } else if (subAction === "kill") {
+            for (const id of ids) {
+              subagentManager.killSubagent(id);
+            }
+            resultMsg = `[Action manage_subagents Success]: Terminated subagents: ${ids.join(", ")}`;
+          } else if (subAction === "kill_all") {
+            subagentManager.killAllSubagents();
+            resultMsg = `[Action manage_subagents Success]: Terminated all active subagents`;
+          } else {
+            resultMsg = `[Action manage_subagents Failed]: Unknown action '${subAction}'`;
+          }
+        } else if (action.type === "complete_task") {
+          const detailedContent = action.content || "";
+          const taskSummary = action.summary || "Task completed successfully.";
+          if (isSubagent) {
+            subagentManager.updateSubagentSummary(options.taskId, taskSummary);
+            if (process.env.SHARK_PARENT_ID) {
+              subagentManager.sendMessage(
+                process.env.SHARK_PARENT_ID,
+                `[Subagent Notification] Subagent ${process.env.SHARK_SUBAGENT_ROLE || "Subagent"} (${options.taskId}) completed.
+Result Details:
+${detailedContent}`
+              );
+            }
+          }
+          finalSummary = taskSummary;
+          keepGoing = false;
+          break;
+        } else if (action.type === "wait") {
+          const durationSeconds = action.duration_seconds || 0;
+          const durationMs = durationSeconds > 0 ? durationSeconds * 1e3 : void 0;
+          log.info(`\u23F3 Waiting for updates (Timeout: ${durationSeconds || "infinite"}s)...`);
+          let nextMsg;
+          if (!messageQueue.isEmpty()) {
+            nextMsg = await messageQueue.next();
+          } else {
+            nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix, durationMs);
+          }
+          if (nextMsg.type === "timeout") {
+            resultMsg = `[System]: Wait duration of ${durationSeconds} seconds expired. No notifications received.`;
+          } else if (nextMsg.type === "user") {
+            if (tui.isCancel(nextMsg.content)) {
+              keepGoing = false;
+              break;
+            }
+            resultMsg = `User Reply: ${nextMsg.content}`;
+          } else {
+            resultMsg = nextMsg.content;
+          }
+        } else {
+          resultMsg = `[Unsupported action type: ${action.type}]`;
+        }
+        FileLogger.log("TOOL_EXECUTION", `Action: ${action.type}`, { action, result: resultMsg });
+        nextPrompt = resultMsg;
+      } catch (e) {
+        log.error(e.message);
+        if (options.taskId && process.env.SHARK_PARENT_ID) {
+          const parentId = process.env.SHARK_PARENT_ID;
+          const role = process.env.SHARK_SUBAGENT_ROLE || "Subagent";
+          subagentManager.sendMessage(
+            parentId,
+            `[Subagent Notification] Subagent ${role} (${options.taskId}) has finished with status: FAILED. Summary: Error: ${e.message}`
+          );
+        }
+        keepGoing = false;
+        return { success: false, summary: `Error: ${e.message}` };
+      }
+    }
+    const finalResult = { success: true, summary: finalSummary || "Task completed without summary." };
+    if (options.taskId && process.env.SHARK_PARENT_ID) {
+      const parentId = process.env.SHARK_PARENT_ID;
+      const role = process.env.SHARK_SUBAGENT_ROLE || "Subagent";
+      subagentManager.sendMessage(
+        parentId,
+        `[Subagent Notification] Subagent ${role} (${options.taskId}) has finished with status: COMPLETED. Summary: ${finalResult.summary}`
+      );
+    }
+    log.success("\u2705 Task Scope Completed");
+    return finalResult;
+  } finally {
+    process.off("SIGINT", sigIntHandler);
+    process.off("SIGTERM", sigTermHandler);
+    const currentId = options.taskId || "parent";
+    const myActiveSubagents = subagentManager.getActiveSubagentsForParent(currentId);
+    if (myActiveSubagents.length > 0) {
+      log.info(`\u{1F9F9} Terminating ${myActiveSubagents.length} active child subagent(s) before exit...`);
+      for (const sub of myActiveSubagents) {
+        subagentManager.killSubagent(sub.id);
+      }
+    }
   }
-};
-var initCommand = new Command("init").description("Initialize a new Shark project").action(initAction);
+}
 
 // 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) => {
+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").option("--taskId <id>", "ID of the current subagent task").action(async (options) => {
   if (options.exportSchema) {
     console.log(JSON.stringify(AGENT_RESPONSE_JSON_SCHEMA, null, 2));
     return;
@@ -199,7 +4639,8 @@ var devCommand = new Command2("dev").description("Starts the Shark Developer Age
     const result = await interactiveDeveloperAgent({
       taskInstruction: options.task,
       context: options.context,
-      auto: options.yes || options.auto
+      auto: options.yes || options.auto,
+      taskId: options.taskId
     });
     if (!result.success) {
       console.error("Task execution failed:", result.summary);
@@ -215,8 +4656,8 @@ var devCommand = new Command2("dev").description("Starts the Shark Developer Age
 import { Command as Command3 } from "commander";
 
 // src/core/agents/legacy-developer-agent.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs10 from "fs";
+import path11 from "path";
 var AGENT_TYPE = "developer_agent";
 async function validateTypeScript(filePath) {
   try {
@@ -245,11 +4686,11 @@ async function interactiveDeveloperAgent2(options = {}) {
   }
   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)) {
+  const defaultContextPath = path11.resolve(projectRoot, "_sharkrc", "project-context.md");
+  const specificContextPath = options.context ? path11.resolve(projectRoot, options.context) : defaultContextPath;
+  if (fs10.existsSync(specificContextPath)) {
     try {
-      contextContent = fs2.readFileSync(specificContextPath, "utf-8");
+      contextContent = fs10.readFileSync(specificContextPath, "utf-8");
     } catch (e) {
       tui.log.warning(`Failed to read context file: ${e}`);
     }
@@ -391,9 +4832,9 @@ ${result}
             }
             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");
+                const dir = path11.dirname(path11.resolve(projectRoot, filePath));
+                if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
+                fs10.writeFileSync(path11.resolve(projectRoot, filePath), action.content || "", "utf-8");
                 executionResults += `[Action create_file]: Success
 
 `;
@@ -407,7 +4848,7 @@ ${result}
 
 `;
               }
-              const val = await validateTypeScript(path2.resolve(projectRoot, filePath));
+              const val = await validateTypeScript(path11.resolve(projectRoot, filePath));
               if (!val.valid) executionResults += `[Validation Failed]: ${val.error}
 
 `;
@@ -549,23 +4990,23 @@ async function callDevAgentApi(prompt, onChunk, conversationKey = AGENT_TYPE) {
 }
 
 // src/core/workflow/task-manager.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs11 from "fs";
+import path12 from "path";
 var TaskManager = class {
   projectRoot;
   specPath;
   constructor(projectRoot = process.cwd()) {
     this.projectRoot = projectRoot;
-    this.specPath = path3.resolve(this.projectRoot, "_sharkrc", "tech-spec.md");
+    this.specPath = path12.resolve(this.projectRoot, "_sharkrc", "tech-spec.md");
   }
   /**
    * Reads the tech-spec.md file and analyzes its current state.
    */
   analyzeSpecState() {
-    if (!fs3.existsSync(this.specPath)) {
+    if (!fs11.existsSync(this.specPath)) {
       return { status: "MISSING", allTasks: [] };
     }
-    const content = fs3.readFileSync(this.specPath, "utf-8");
+    const content = fs11.readFileSync(this.specPath, "utf-8");
     const lines = content.split("\n");
     const tasks = [];
     let taskIndex = 1;
@@ -631,7 +5072,7 @@ var TaskManager = class {
       console.error(`Task ${taskId} not found.`);
       return false;
     }
-    const content = fs3.readFileSync(this.specPath, "utf-8");
+    const content = fs11.readFileSync(this.specPath, "utf-8");
     const lines = content.split("\n");
     const targetLine = lines[task.line_number];
     if (!targetLine.includes(task.description)) {
@@ -640,7 +5081,7 @@ var TaskManager = class {
     }
     const newLine = targetLine.replace("- [ ]", "- [x]").replace("- [/]", "- [x]");
     lines[task.line_number] = newLine;
-    fs3.writeFileSync(this.specPath, lines.join("\n"), "utf-8");
+    fs11.writeFileSync(this.specPath, lines.join("\n"), "utf-8");
     return true;
   }
   /**
@@ -650,19 +5091,19 @@ var TaskManager = class {
     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 content = fs11.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");
+    fs11.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");
+    fs11.writeFileSync(this.specPath, newContent, "utf-8");
   }
   getSpecPath() {
     return this.specPath;
@@ -670,17 +5111,17 @@ var TaskManager = class {
 };
 
 // src/core/agents/specification-agent.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs12 from "fs";
+import path13 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)) {
+  const sharkRcDir = path13.resolve(projectRoot, "_sharkrc");
+  if (!fs12.existsSync(sharkRcDir)) fs12.mkdirSync(sharkRcDir, { recursive: true });
+  const outputFile = path13.resolve(sharkRcDir, "tech-spec.md");
+  if (!fs12.existsSync(outputFile)) {
     let initialContent = `# Technical Specification: {{PROJECT_NAME}}
 
 ## 1. Technology Stack
@@ -705,28 +5146,28 @@ async function interactiveSpecificationAgent(options = {}) {
 ## 5. Implementation Steps
 [TO BE FILLED - MUST BE CHECKBOXES]
 `;
-    const projectName = path4.basename(projectRoot);
+    const projectName = path13.basename(projectRoot);
     initialContent = initialContent.replace(/{{PROJECT_NAME}}/g, projectName);
     const BOM = "\uFEFF";
-    fs4.writeFileSync(outputFile, BOM + initialContent, { encoding: "utf-8" });
+    fs12.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 = path4.resolve(projectRoot, "_sharkrc", "project-context.md");
-  if (fs4.existsSync(contextPath)) {
-    contextContent = fs4.readFileSync(contextPath, "utf-8");
+  const contextPath = path13.resolve(projectRoot, "_sharkrc", "project-context.md");
+  if (fs12.existsSync(contextPath)) {
+    contextContent = fs12.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");
+  if (options.briefingPath && fs12.existsSync(options.briefingPath)) {
+    briefingContent = fs12.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");
+    const standardBriefing = path13.resolve(projectRoot, "_sharkrc", "briefing.md");
+    if (fs12.existsSync(standardBriefing)) {
+      briefingContent = fs12.readFileSync(standardBriefing, "utf-8");
       tui.log.info(`\u{1F4C4} Briefing loaded.`);
     }
   }
@@ -787,8 +5228,8 @@ async function runSpecLoop(initialMessage, targetPath, overrideAgentId) {
     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 (fs12.existsSync(targetPath)) {
+      const content = fs12.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");
     }
@@ -863,11 +5304,11 @@ ${result}
 
 `;
           } else if (["create_file", "modify_file"].includes(action.type)) {
-            let actionPath = path4.resolve(action.path || "");
-            const resolvedTargetPath = path4.resolve(targetPath);
+            let actionPath = path13.resolve(action.path || "");
+            const resolvedTargetPath = path13.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)}`);
+            if (!isTarget && path13.basename(actionPath) === "tech-spec.md") {
+              tui.log.warning(`Redirecting ${action.type} from ${action.path} to ${path13.relative(process.cwd(), targetPath)}`);
               action.path = targetPath;
               actionPath = resolvedTargetPath;
               isTarget = true;
@@ -883,7 +5324,7 @@ ${result}
             try {
               if (action.type === "create_file") {
                 const BOM = "\uFEFF";
-                fs4.writeFileSync(action.path, BOM + (action.content || ""), "utf-8");
+                fs12.writeFileSync(action.path, BOM + (action.content || ""), "utf-8");
                 tui.log.success(`\u2705 Created: ${action.path}`);
                 executionResults += `[Action create_file]: Success.
 `;
@@ -949,7 +5390,7 @@ Voc\xEA completou a FASE 2 com sucesso.
 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") : "";
+          const content = fs12.existsSync(targetPath) ? fs12.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";
@@ -981,7 +5422,7 @@ Voc\xEA \xE9 OBRIGADO a usar a action \`modify_file\` para preencher o conte\xFA
 
 User Reply: ${userReply}`;
         } else if (executionResults) {
-          const content = fs4.existsSync(targetPath) ? fs4.readFileSync(targetPath, "utf-8") : "";
+          const content = fs12.existsSync(targetPath) ? fs12.readFileSync(targetPath, "utf-8") : "";
           let systemMsg = "Execu\xE7\xE3o da ferramenta conclu\xEDda.";
           if (specUpdated) {
             if (content.includes("[TO BE")) {
@@ -1169,42 +5610,49 @@ var exportSchemaCommand = new Command4("export-schema").description("Outputs the
   console.log(JSON.stringify(AGENT_RESPONSE_JSON_SCHEMA, null, 2));
 });
 
-// src/commands/super.ts
+// src/commands/export-prompt.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 exportPromptCommand = new Command5("export-prompt").description("Outputs the unified agent system prompt").action(() => {
+  console.log(UNIFIED_SYSTEM_PROMPT);
+});
+
+// src/commands/super.ts
+import { Command as Command6 } from "commander";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import path14 from "path";
+import os3 from "os";
+import fs13 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");
+  const __filename2 = fileURLToPath3(import.meta.url);
+  const __dirname2 = path14.dirname(__filename2);
+  const packageRoot = path14.resolve(__dirname2, "../../");
+  const internalSkillsPath = path14.join(packageRoot, "skills");
+  const targetPath = options.local ? path14.join(process.cwd(), ".agents", "skills") : path14.join(os3.homedir(), ".shark", "skills");
   try {
     try {
-      await fs5.rm(targetPath, { recursive: true, force: true });
+      await fs13.rm(targetPath, { recursive: true, force: true });
     } catch {
     }
-    await fs5.mkdir(targetPath, { recursive: true });
-    await fs5.cp(internalSkillsPath, targetPath, { recursive: true, force: true });
+    await fs13.mkdir(targetPath, { recursive: true });
+    await fs13.cp(internalSkillsPath, targetPath, { recursive: true, force: true });
     console.log(`\u{1F680} Superpowers skills installed successfully to ${targetPath}`);
   } catch (error) {
     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);
+var superCommand = new Command6("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 Command6();
+var program = new Command7();
 program.name("shark").description("Shark CLI: AI-Native Collaborative Development Tool").version("0.0.1");
 program.addCommand(loginCommand);
 program.addCommand(initCommand);
 program.addCommand(devCommand);
 program.addCommand(legacyCommand);
 program.addCommand(exportSchemaCommand);
+program.addCommand(exportPromptCommand);
 program.addCommand(superCommand);
 program.command("config").description("Manage global configuration").action(configCommand.action);
 process.on("unhandledRejection", (err) => {