shark-ai 0.4.24 → 0.4.27

package/dist/bin/shark.js

@@ -8,7 +8,10 @@ import {
   loginCommand,
   tokenStorage,
   tui
-} from "../chunk-NKE5GNDJ.js";
+} from "../chunk-LQ2PEYRD.js";
+import {
+  MemboxManager
+} from "../chunk-WJUQF54U.js";
 
 // src/core/error/crash-handler.ts
 import fs from "fs";
@@ -209,7 +212,7 @@ var initAction = async () => {
     }
     if (action === "resume") {
       tui.log.success(`Resuming work on ${colors.primary(existingState.projectName)}...`);
-      tui.outro(`To continue, run: "shark agent" (Context loaded)`);
+      tui.outro(`To continue, run: "shark dev" (Context loaded)`);
       return;
     }
   }
@@ -257,7 +260,7 @@ var initAction = async () => {
     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.');
+    tui.outro('Ready to start! Run "shark dev" to begin developing features.');
   } catch (error) {
     spinner.stop("Initialization failed.", 1);
     tui.log.error(error.message);
@@ -271,7 +274,21 @@ import { Command as Command2 } from "commander";
 
 // src/core/agents/agent-response-parser.ts
 import { z as z2 } from "zod";
-var AgentActionSchema = z2.object({
+import { jsonrepair } from "jsonrepair";
+var AgentActionSchema = z2.preprocess((val) => {
+  if (val && typeof val === "object") {
+    if (typeof val.type === "string") {
+      val.type = val.type.trim();
+    }
+    if (typeof val.Action === "string") {
+      val.Action = val.Action.trim();
+    }
+    if (val.Action !== void 0 && (val.type !== "manage_subagents" || val.Action === "")) {
+      val.Action = null;
+    }
+  }
+  return val;
+}, z2.object({
   type: z2.enum([
     "create_file",
     "modify_file",
@@ -293,6 +310,7 @@ var AgentActionSchema = z2.object({
     "manage_subagents",
     "complete_task",
     "wait",
+    "notify_user",
     "ast_list_structure",
     "ast_get_method",
     "ast_add_method",
@@ -369,7 +387,7 @@ var AgentActionSchema = z2.object({
   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(),
@@ -523,7 +541,9 @@ function parseAgentResponse(rawResponse) {
       "invoke_subagent",
       "send_message",
       "manage_subagents",
-      "complete_task"
+      "complete_task",
+      "wait",
+      "notify_user"
     ];
     if (validTypes.includes(parsedObj.type)) {
       normalizedAction = parsedObj;
@@ -535,6 +555,17 @@ function parseAgentResponse(rawResponse) {
   } else if (normalizedAction && (!normalizedActions || normalizedActions.length === 0)) {
     normalizedActions = [normalizedAction];
   }
+  if (normalizedAction && typeof normalizedAction.content === "object" && normalizedAction.content !== null) {
+    normalizedAction.content = JSON.stringify(normalizedAction.content);
+  }
+  if (Array.isArray(normalizedActions)) {
+    normalizedActions = normalizedActions.map((act) => {
+      if (act && act.content && typeof act.content === "object" && act.content !== null) {
+        return { ...act, content: JSON.stringify(act.content) };
+      }
+      return act;
+    });
+  }
   if (!normalizedAction && !normalizedActions) {
     FileLogger.log("PARSER", "No Action/Actions Found - Constructing Default");
     const content = parsedObj.message || (typeof parsedObj === "object" ? JSON.stringify(parsedObj) : String(parsedObj));
@@ -586,8 +617,25 @@ function extractFirstJson(str) {
   try {
     return JSON.parse(str);
   } catch (e) {
+    const isValidStructure = (val) => {
+      return val && typeof val === "object" && !Array.isArray(val) && ("action" in val || "actions" in val || "summary" in val || "type" in val);
+    };
+    try {
+      const repaired = JSON.parse(jsonrepair(str));
+      if (isValidStructure(repaired)) {
+        return repaired;
+      }
+    } catch {
+    }
     const firstOpen = str.indexOf("{");
     if (firstOpen === -1) throw e;
+    try {
+      const repaired = JSON.parse(jsonrepair(str.substring(firstOpen)));
+      if (isValidStructure(repaired)) {
+        return repaired;
+      }
+    } catch {
+    }
     let balance = 0;
     let inString = false;
     let escape = false;
@@ -614,7 +662,11 @@ function extractFirstJson(str) {
             try {
               return JSON.parse(potentialJson);
             } catch (innerE) {
-              throw e;
+              try {
+                return JSON.parse(jsonrepair(potentialJson));
+              } catch {
+                throw e;
+              }
             }
           }
         }
@@ -808,12 +860,14 @@ Seu objetivo \xE9 ajudar o usu\xE1rio a analisar, especificar e implementar c\xF
 \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'.
+- Se precisar falar com o usu\xE1rio e aguardar uma resposta dele, use a action com type 'talk_with_user'.
+- Se voc\xEA quiser apenas enviar uma mensagem informativa ou relat\xF3rio detalhado para o usu\xE1rio sem bloquear ou parar a execu\xE7\xE3o para receber resposta, use a action 'notify_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",
+    "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" | "notify_user",
     "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)",
@@ -871,7 +925,8 @@ var AGENT_RESPONSE_JSON_SCHEMA = {
             "send_message",
             "manage_subagents",
             "complete_task",
-            "wait"
+            "wait",
+            "notify_user"
           ]
         },
         "path": { "type": ["string", "null"] },
@@ -915,76 +970,176 @@ var AGENT_RESPONSE_JSON_SCHEMA = {
       },
       "required": ["type"]
     },
-    "summary": { "type": "string" }
+    "summary": {
+      "type": "string",
+      "description": "Resumo de uma \xFAnica frase muito curta e sucinta do que voc\xEA realizou nesta rodada. Evite explica\xE7\xF5es longas."
+    }
   },
   "required": ["action"]
 };
 
+// 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 deleteHistory(conversationId) {
+    const filePath = this.getFilePath(conversationId);
+    if (fs3.existsSync(filePath)) {
+      fs3.unlinkSync(filePath);
+    }
+  }
+  static async appendMessage(conversationId, message) {
+    const history = await this.getHistory(conversationId);
+    history.push(message);
+    await this.saveHistory(conversationId, history);
+  }
+  static getRawHistoryPath(conversationId) {
+    return this.getFilePath(conversationId);
+  }
+  static async getRawHistory(conversationId) {
+    return this.getHistory(conversationId);
+  }
+  static async saveRawHistory(conversationId, history) {
+    await this.saveHistory(conversationId, history);
+  }
+};
+
+// src/core/api/stackspot-provider.ts
+import crypto from "crypto";
+
+// src/core/workflow/skill-manager.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import os2 from "os";
+var SkillManager = class {
+  activeSkills = /* @__PURE__ */ new Set();
+  skillPrompts = /* @__PURE__ */ new Map();
+  async loadSkillFromFile(filePath) {
+    const content = await fs4.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 = path4.join(os2.homedir(), ".shark", "skills", skillName, "SKILL.md");
+    const localPath = path4.join(process.cwd(), ".agents", "skills", skillName, "SKILL.md");
+    let skillPath = "";
+    try {
+      await fs4.access(localPath);
+      skillPath = localPath;
+    } catch {
+      try {
+        await fs4.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 = path4.join(os2.homedir(), ".shark", "skills");
+    const localSkillsDir = path4.join(process.cwd(), ".agents", "skills");
+    const skillNames = /* @__PURE__ */ new Set();
+    const readDir = async (dir) => {
+      try {
+        const entries = await fs4.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const skillMdPath = path4.join(dir, entry.name, "SKILL.md");
+            try {
+              await fs4.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/api/stackspot-provider.ts
 var StackSpotProvider = class {
   constructor(agentType) {
     this.agentType = agentType;
     const config = ConfigManager.getInstance().getConfig();
     this.agentId = config.stackspot?.agentId;
+    this.useServerConversation = config.stackspot?.useServerConversation !== false;
   }
   agentId;
+  useServerConversation = true;
   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];
+    if (config.agents?.dev) {
+      return config.agents.dev;
     }
-    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];
+    const envResolved = process.env.STACKSPOT_DEV_AGENT_ID;
     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";
+    return "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];
+    return config.agentVersions?.dev || process.env.STACKSPOT_DEV_AGENT_VERSION;
   }
   async streamChat(prompt, options) {
     const realm = await getActiveRealm();
@@ -997,20 +1152,81 @@ var StackSpotProvider = class {
     if (!token) {
       throw new Error(`No authentication token found for realm '${realm}'. Please run 'shark login'.`);
     }
+    let systemPrompt = UNIFIED_SYSTEM_PROMPT;
+    let retrievedContext = "";
+    const isHelperCall = options.conversationId?.startsWith("membox-");
+    if (!isHelperCall) {
+      const { MemboxManager: MemboxManager2 } = await import("../membox-manager-ZDKXDZPF.js");
+      const memboxManager = new MemboxManager2();
+      const query = options?.searchQuery || prompt;
+      retrievedContext = await memboxManager.retrieveContext(query, []);
+      if (retrievedContext) {
+        systemPrompt = systemPrompt + "\n" + retrievedContext;
+      }
+    }
     const isFirstTurn = !options.conversationId;
-    const finalPrompt = isFirstTurn ? `SYSTEM INSTRUCTIONS:
-${UNIFIED_SYSTEM_PROMPT}
+    let finalPrompt = prompt;
+    const conversationId = options.conversationId || crypto.randomUUID();
+    let history = [];
+    if (!this.useServerConversation) {
+      history = await HistoryManager.getHistory(conversationId);
+      if (history.length === 0) {
+        history.push({
+          role: "system",
+          content: systemPrompt
+        });
+      }
+      history.push({ role: "user", content: prompt });
+      let compiledPrompt = "";
+      for (const msg of history) {
+        if (msg.role === "system") {
+          const skillExtension = skillManager.getSystemInstructionExtension();
+          const fullSystemPrompt = skillExtension ? msg.content + "\n" + skillExtension : msg.content;
+          compiledPrompt += `SYSTEM INSTRUCTIONS:
+${fullSystemPrompt}
+
+`;
+        } else if (msg.role === "user") {
+          compiledPrompt += `USER REQUEST:
+${msg.content}
+
+`;
+        } else if (msg.role === "assistant") {
+          compiledPrompt += `ASSISTANT RESPONSE:
+${msg.content}
+
+`;
+        }
+      }
+      finalPrompt = compiledPrompt;
+    } else {
+      const skillExtension = skillManager.getSystemInstructionExtension();
+      if (isFirstTurn) {
+        const fullSystemPrompt = skillExtension ? systemPrompt + "\n" + skillExtension : systemPrompt;
+        finalPrompt = `SYSTEM INSTRUCTIONS:
+${fullSystemPrompt}
 
 USER REQUEST:
-${prompt}` : prompt;
+${prompt}`;
+      } else {
+        finalPrompt = skillExtension ? prompt + "\n" + skillExtension : prompt;
+        if (retrievedContext) {
+          finalPrompt = `[MEM\xD3RIA E CONTEXTO RECUPERADOS]
+${retrievedContext}
+
+[MENSAGEM DO USU\xC1RIO]
+${finalPrompt}`;
+        }
+      }
+    }
     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
+      use_conversation: this.useServerConversation,
+      conversation_id: this.useServerConversation ? options.conversationId : conversationId
     };
     const agentVersion = this.getAgentVersion();
     if (agentVersion) {
@@ -1048,7 +1264,7 @@ ${prompt}` : prompt;
         onComplete: async (message, metadata) => {
           rawResponse = {
             message: message || fullMessage,
-            conversation_id: metadata?.conversation_id || options.conversationId
+            conversation_id: metadata?.conversation_id || conversationId
           };
         },
         onError: (error) => {
@@ -1058,6 +1274,11 @@ ${prompt}` : prompt;
     );
     FileLogger.log("PROVIDER_RESPONSE", "Raw response from StackSpot API", { rawResponse });
     const parsedResponse = parseAgentResponse(rawResponse);
+    if (!this.useServerConversation) {
+      parsedResponse.conversation_id = conversationId;
+      history.push({ role: "assistant", content: JSON.stringify(parsedResponse) });
+      await HistoryManager.saveHistory(conversationId, history);
+    }
     if (options.onComplete) {
       options.onComplete(parsedResponse);
     }
@@ -1065,46 +1286,8 @@ ${prompt}` : prompt;
   }
 };
 
-// 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";
+import crypto2 from "crypto";
 var OpenAICompatibleProvider = class {
   constructor(options) {
     this.options = options;
@@ -1113,7 +1296,7 @@ var OpenAICompatibleProvider = class {
     return UNIFIED_SYSTEM_PROMPT;
   }
   async streamChat(prompt, options) {
-    const conversationId = options.conversationId || crypto.randomUUID();
+    const conversationId = options.conversationId || crypto2.randomUUID();
     const history = await HistoryManager.getHistory(conversationId);
     if (history.length === 0) {
       history.push({
@@ -1122,9 +1305,32 @@ var OpenAICompatibleProvider = class {
       });
     }
     history.push({ role: "user", content: prompt });
+    const requestMessages = history.map((msg) => ({ ...msg }));
+    const isHelperCall = conversationId.startsWith("membox-");
+    if (!isHelperCall) {
+      let systemMsg = requestMessages.find((m) => m.role === "system");
+      if (!systemMsg) {
+        systemMsg = {
+          role: "system",
+          content: this.getAgentSystemPrompt(options.agentType)
+        };
+        requestMessages.unshift(systemMsg);
+      }
+      const { MemboxManager: MemboxManager2 } = await import("../membox-manager-ZDKXDZPF.js");
+      const memboxManager = new MemboxManager2();
+      const query = options?.searchQuery || prompt;
+      const retrievedContext = await memboxManager.retrieveContext(query, history);
+      if (retrievedContext) {
+        systemMsg.content = systemMsg.content + "\n" + retrievedContext;
+      }
+      const skillExtension = skillManager.getSystemInstructionExtension();
+      if (skillExtension) {
+        systemMsg.content = systemMsg.content + "\n" + skillExtension;
+      }
+    }
     const requestPayload = {
       model: this.options.model,
-      messages: history,
+      messages: requestMessages,
       stream: true,
       temperature: 0.2
     };
@@ -1134,172 +1340,7 @@ var OpenAICompatibleProvider = class {
         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
-          }
+          schema: toStrictOpenAISchema(AGENT_RESPONSE_JSON_SCHEMA)
         }
       };
     } else {
@@ -1320,20 +1361,26 @@ var OpenAICompatibleProvider = class {
       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");
-    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e5);
+    let reader = void 0;
     try {
+      const res = await fetch(`${this.options.baseURL}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestPayload),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        clearTimeout(timeoutId);
+        const errBody = await res.text();
+        throw new Error(`OpenAI API request failed: ${res.status} ${res.statusText} - ${errBody}`);
+      }
+      reader = res.body?.getReader();
+      if (!reader) {
+        clearTimeout(timeoutId);
+        throw new Error("Response body reader is undefined");
+      }
       const decoder = new TextDecoder();
       let fullContent = "";
       let done = false;
@@ -1389,6 +1436,7 @@ var OpenAICompatibleProvider = class {
           }
         }
       }
+      clearTimeout(timeoutId);
       FileLogger.log("PROVIDER_RESPONSE", "Raw response from OpenAI Compatible API", { fullContent });
       const parsedResponse = parseAgentResponse(fullContent);
       parsedResponse.conversation_id = conversationId;
@@ -1398,13 +1446,66 @@ var OpenAICompatibleProvider = class {
         options.onComplete(parsedResponse);
       }
       return parsedResponse;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new Error(`OpenAI API request timed out after 5 minutes.`);
+      }
+      throw error;
     } finally {
-      if (typeof reader.releaseLock === "function") {
+      if (reader && typeof reader.releaseLock === "function") {
         reader.releaseLock();
       }
     }
   }
 };
+function toStrictOpenAISchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+  const cloned = JSON.parse(JSON.stringify(schema));
+  delete cloned.$schema;
+  delete cloned.title;
+  function processNode(node) {
+    if (!node || typeof node !== "object") {
+      return;
+    }
+    if (node.type === "object") {
+      node.additionalProperties = false;
+      if (node.properties) {
+        const originalRequired = node.required || [];
+        const allProperties = Object.keys(node.properties);
+        node.required = allProperties;
+        for (const key of allProperties) {
+          const prop = node.properties[key];
+          if (!originalRequired.includes(key)) {
+            if (prop.type) {
+              if (Array.isArray(prop.type)) {
+                if (!prop.type.includes("null")) {
+                  prop.type.push("null");
+                }
+              } else if (typeof prop.type === "string") {
+                if (prop.type !== "null") {
+                  prop.type = [prop.type, "null"];
+                }
+              }
+            }
+          }
+          if (prop.enum && Array.isArray(prop.enum)) {
+            if (!prop.enum.includes(null)) {
+              prop.enum.push(null);
+            }
+          }
+          processNode(prop);
+        }
+      }
+    } else if (node.type === "array" && node.items) {
+      processNode(node.items);
+    }
+  }
+  processNode(cloned);
+  return cloned;
+}
 
 // src/core/api/provider-resolver.ts
 var ProviderResolver = class {
@@ -1493,8 +1594,8 @@ var ConversationManager = class _ConversationManager {
 var conversationManager = ConversationManager.getInstance();
 
 // src/core/workflow/anchor-state-manager.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { diffLines } from "diff";
 var AnchorStateManager = class {
   cache = /* @__PURE__ */ new Map();
@@ -2509,10 +2610,10 @@ var AnchorStateManager = class {
     }
   }
   getAnchoredContent(filePath) {
-    const absolutePath = path4.resolve(filePath);
+    const absolutePath = path5.resolve(filePath);
     let lineStates = this.cache.get(absolutePath);
     if (!lineStates) {
-      const content = fs4.readFileSync(absolutePath, "utf8");
+      const content = fs5.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();
@@ -2525,7 +2626,7 @@ var AnchorStateManager = class {
     return lineStates.map((ls) => `${ls.anchor}\xA7${ls.text}`).join("\n");
   }
   applyAnchoredEdit(filePath, startAnchor, endAnchor, content) {
-    const absolutePath = path4.resolve(filePath);
+    const absolutePath = path5.resolve(filePath);
     let lineStates = this.cache.get(absolutePath);
     if (!lineStates) {
       this.getAnchoredContent(absolutePath);
@@ -2542,7 +2643,7 @@ var AnchorStateManager = class {
     if (startIndex > endIndex) {
       throw new Error(`Invalid range: start anchor "${startAnchor}" is after end anchor "${endAnchor}"`);
     }
-    const originalContent = fs4.readFileSync(absolutePath, "utf8");
+    const originalContent = fs5.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;
@@ -2553,7 +2654,7 @@ var AnchorStateManager = class {
       ...oldLines.slice(endIndex + 1)
     ];
     const fileContentToWrite = updatedLines.join("\n") + (hasTrailingNewline ? "\n" : "");
-    fs4.writeFileSync(absolutePath, fileContentToWrite, "utf8");
+    fs5.writeFileSync(absolutePath, fileContentToWrite, "utf8");
     const usedAnchors = /* @__PURE__ */ new Set();
     for (let i = 0; i < lineStates.length; i++) {
       usedAnchors.add(lineStates[i].anchor);
@@ -2599,457 +2700,19 @@ var AnchorStateManager = class {
 };
 
 // src/core/agents/developer-agent.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs8 from "fs";
+import path8 from "path";
 
 // src/core/agents/agent-tools.ts
 import fs6 from "fs";
-import path7 from "path";
+import path6 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);
+    const fullPath = path6.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) => {
@@ -3059,54 +2722,6 @@ function handleListFiles(dirPath) {
     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 });
@@ -3133,7 +2748,7 @@ function handleSearchCode(globPattern, query, isRegex = false) {
     for (const filePath of files) {
       if (totalMatches >= MAX_MATCHES) break;
       try {
-        const fullPath = path7.resolve(process.cwd(), filePath);
+        const fullPath = path6.resolve(process.cwd(), filePath);
         const stats = fs6.statSync(fullPath);
         if (stats.size > MAX_FILE_SIZE_BYTES) continue;
         const content = fs6.readFileSync(fullPath, "utf-8");
@@ -3159,32 +2774,6 @@ ${results.join("\n")}`;
     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 {
@@ -3232,456 +2821,95 @@ ${stdout}`);
     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}"`;
+
+// src/core/workflow/subagent-manager.ts
+import crypto3 from "crypto";
+import fs7 from "fs";
+import path7 from "path";
+import { fork } from "child_process";
+import { fileURLToPath } from "url";
+var SubagentManager = class {
+  subagents = /* @__PURE__ */ new Map();
+  customTypes = /* @__PURE__ */ new Map();
+  messageSeq = 0;
+  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";
       }
-      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}"`;
+  isSubagentActive(id) {
+    return this.subagents.get(id)?.status === "running";
+  }
+  hasSubagent(id) {
+    return this.subagents.has(id);
   }
-  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}`;
+  getSubagentState(id) {
+    return this.subagents.get(id);
+  }
+  updateSubagentSummary(id, summary) {
+    const state = this.subagents.get(id);
+    if (state) {
+      state.summary = summary;
     }
-    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;
+  sendMessage(recipient, message) {
+    const mailboxDir = path7.resolve(process.cwd(), ".shark", "mailbox", recipient);
+    fs7.mkdirSync(mailboxDir, { recursive: true });
+    const seq = (this.messageSeq++).toString().padStart(6, "0");
+    const filePath = path7.join(mailboxDir, `${Date.now()}-${seq}-${crypto3.randomUUID()}.json`);
+    fs7.writeFileSync(filePath, JSON.stringify({ message }), "utf-8");
+  }
+  retrieveMessages(id) {
+    const mailboxDir = path7.resolve(process.cwd(), ".shark", "mailbox", id);
+    if (!fs7.existsSync(mailboxDir)) {
+      return [];
     }
-    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);
+    const files = fs7.readdirSync(mailboxDir);
+    files.sort();
+    const messages = [];
+    for (const file of files) {
+      const filePath = path7.join(mailboxDir, file);
+      try {
+        const content = fs7.readFileSync(filePath, "utf-8");
+        const data = JSON.parse(content);
+        if (data && typeof data.message === "string") {
+          messages.push(data.message);
         }
-      });
-      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;
+      } catch (e) {
+      }
+      try {
+        fs7.unlinkSync(filePath);
+      } catch (e) {
+      }
+    }
+    return messages;
   }
-}
-async function astListStructure(filePath) {
-  try {
-    const editor = CodeEditorFactory.getEditor(filePath);
-    if (!editor) {
-      return `[AST Error] File type not supported: ${filePath}. Use read_file instead.`;
+  peekMessages(id) {
+    const mailboxDir = path7.resolve(process.cwd(), ".shark", "mailbox", id);
+    if (!fs7.existsSync(mailboxDir)) {
+      return [];
     }
-    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);
+    const files = fs7.readdirSync(mailboxDir);
+    files.sort();
+    const messages = [];
+    for (const file of files) {
+      const filePath = path7.join(mailboxDir, file);
+      try {
+        const content = fs7.readFileSync(filePath, "utf-8");
+        const data = JSON.parse(content);
+        if (data && typeof data.message === "string") {
+          messages.push(data.message);
         }
       } catch (e) {
       }
@@ -3704,12 +2932,12 @@ var SubagentManager = class {
       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)) {
+    const logFile = path7.resolve(projectRoot, "_sharkrc", "history", `subagent-${id}-console.log`);
+    if (!fs7.existsSync(logFile)) {
       return "No console logs found for this subagent.";
     }
     try {
-      let content = fs8.readFileSync(logFile, "utf-8");
+      let content = fs7.readFileSync(logFile, "utf-8");
       if (content.endsWith("\n")) {
         content = content.slice(0, -1);
       }
@@ -3752,32 +2980,32 @@ var SubagentManager = class {
   async invokeSubagents(subagents, parentId, parentQueue) {
     const invoked = [];
     for (const sub of subagents) {
-      const id = `subagent-${crypto2.randomUUID()}`;
+      const id = `subagent-${crypto3.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;
+          const __filename3 = fileURLToPath(import.meta.url);
+          const __dirname3 = path7.dirname(__filename3);
+          let packageRoot = __dirname3;
           while (true) {
-            const pkgPath = path9.join(packageRoot, "package.json");
-            if (fs8.existsSync(pkgPath)) {
+            const pkgPath = path7.join(packageRoot, "package.json");
+            if (fs7.existsSync(pkgPath)) {
               try {
-                const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+                const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
                 if (pkg && pkg.name === "shark-ai") {
                   break;
                 }
               } catch (e) {
               }
             }
-            const parent = path9.dirname(packageRoot);
+            const parent = path7.dirname(packageRoot);
             if (parent === packageRoot) {
               break;
             }
             packageRoot = parent;
           }
-          const pathToSharkJs = path9.resolve(packageRoot, "dist", "bin", "shark.js");
+          const pathToSharkJs = path7.resolve(packageRoot, "dist", "bin", "shark.js");
           const customType = this.customTypes.get(sub.TypeName);
           let customContext = `Voc\xEA est\xE1 executando em modo SUBAGENTE.
 `;
@@ -3810,10 +3038,10 @@ var SubagentManager = class {
           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" });
+          const historyDir = path7.resolve(projectRoot, "_sharkrc", "history");
+          fs7.mkdirSync(historyDir, { recursive: true });
+          const consoleLogFile = path7.join(historyDir, `subagent-${id}-console.log`);
+          const logStream = fs7.createWriteStream(consoleLogFile, { flags: "a" });
           if (child.stdout) {
             child.stdout.pipe(logStream);
           }
@@ -3836,8 +3064,8 @@ 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;
+            const mailboxDir = path7.resolve(projectRoot, ".shark", "mailbox", parentId);
+            const hasMessages = fs7.existsSync(mailboxDir) && fs7.readdirSync(mailboxDir).length > 0;
             if (!hasMessages) {
               this.sendMessage(parentId, fallbackMsg);
             }
@@ -3939,22 +3167,30 @@ var MessageQueue = class {
 };
 
 // src/core/agents/developer-agent.ts
+var activeOnCommandHandler = void 0;
 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!`);
+  while (userReply && userReply.startsWith("/")) {
+    let handled = false;
+    if (activeOnCommandHandler) {
+      handled = await activeOnCommandHandler(userReply);
+    }
+    if (!handled && 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!`);
+        }
       }
+      handled = true;
     }
     userReply = await tui.text({
       message: `${prefix}${message}`,
@@ -3964,32 +3200,39 @@ async function promptUser(message, initialValue, placeholder, prefix = "") {
   }
   return userReply;
 }
-async function waitForInputOrNotification(queue, promptMessage = "Your answer:", subagentPrefix = "", timeoutMs) {
+async function waitForInputOrNotification(queue, promptMessage = "Your answer:", subagentPrefix = "", timeoutMs, isAuto = false) {
   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()
-        });
+  const promises2 = [];
+  if (!isAuto) {
+    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) {
       }
-    } catch (e) {
-    }
-  };
-  runPrompt();
+    };
+    runPrompt();
+    promises2.push(promptPromise);
+  }
   const queuePromise = queue.next();
-  const promises = [promptPromise, queuePromise];
+  promises2.push(queuePromise);
   if (timeoutMs !== void 0 && timeoutMs !== null) {
     const timeoutPromise = new Promise((resolve2) => {
       timerId = setTimeout(() => {
+        if (resolvePromptPromise) {
+          cancelled = true;
+        }
         resolve2({
           type: "timeout",
           content: "Wait timeout expired.",
@@ -3997,18 +3240,20 @@ async function waitForInputOrNotification(queue, promptMessage = "Your answer:",
         });
       }, timeoutMs);
     });
-    promises.push(timeoutPromise);
+    promises2.push(timeoutPromise);
   }
-  const winner = await Promise.race(promises);
+  const winner = await Promise.race(promises2);
   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 (!isAuto) {
+      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");
+      }
     }
   }
   return winner;
@@ -4054,11 +3299,11 @@ async function interactiveDeveloperAgent(options = {}) {
     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)) {
+  const defaultContextPath = path8.resolve(projectRoot, "_sharkrc", "project-context.md");
+  const specificContextPath = options.context ? path8.resolve(projectRoot, options.context) : defaultContextPath;
+  if (fs8.existsSync(specificContextPath)) {
     try {
-      contextContent = fs9.readFileSync(specificContextPath, "utf-8");
+      contextContent = fs8.readFileSync(specificContextPath, "utf-8");
     } catch (e) {
       log.warning(`Failed to read context file: ${e}`);
     }
@@ -4088,17 +3333,57 @@ 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 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, execute the 'complete_task' action with a brief summary in the 'summary' field and the full explanation in the 'content' field.
 - 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.
+  3. When you are confident the task is done, execute the 'complete_task' action with a brief technical summary of what you did in the 'summary' field and any additional details in the 'content' field.
+
+- Handling Subagent Notifications:
+  - When you receive notifications about subagent progress or completion in your mailbox, do NOT invoke the 'talk_with_user' action just to relay this information to the user if you still have other subagents running, or if you have further steps to execute yourself.
+  - Instead, process the subagent's output, update your task progress in the 'summary' field of your next action, and proceed with executing your next planned steps (or use the 'wait' action to continue waiting for other running subagents).
+  - Only use 'talk_with_user' if you genuinely require the user's input/decision to proceed, or when the entire task is ready for final discussion.
 `;
   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 onCommandHandler = async (command) => {
+    if (command === "/compact") {
+      tui.log.info("\u{1F988} Compactando mem\xF3ria de forma manual...");
+      const memboxManager = new MemboxManager();
+      const existingConversationId = await conversationManager.getConversationId(conversationKey);
+      if (existingConversationId) {
+        try {
+          const rawHistory = await HistoryManager.getRawHistory(existingConversationId);
+          const provider = ProviderResolver.getProvider("developer_agent");
+          const truncatedHistory = await memboxManager.compactHistory(rawHistory, provider, existingConversationId, true);
+          await HistoryManager.saveRawHistory(existingConversationId, truncatedHistory);
+          tui.log.success("\u2714 Mem\xF3ria compactada e truncada com sucesso!");
+        } catch (error) {
+          tui.log.error(`Erro durante a compacta\xE7\xE3o: ${error.message}`);
+        }
+      } else {
+        tui.log.warning("Nenhuma conversa\xE7\xE3o ativa para compactar.");
+      }
+      return true;
+    }
+    if (command === "/context") {
+      const existingConversationId = await conversationManager.getConversationId(conversationKey);
+      if (existingConversationId) {
+        const rawHistory = await HistoryManager.getRawHistory(existingConversationId);
+        const totalTokensEst = Math.ceil(JSON.stringify(rawHistory).length / 4);
+        tui.log.info(`\u{1F4CA} Hist\xF3rico ativo: ${rawHistory.length} mensagens`);
+        tui.log.info(`\u{1F4CA} Tamanho estimado: ${totalTokensEst} / 8000 tokens (${Math.round(totalTokensEst / 8e3 * 100)}% do limite)`);
+      } else {
+        tui.log.warning("Nenhuma conversa\xE7\xE3o ativa para analisar.");
+      }
+      return true;
+    }
+    return false;
+  };
+  activeOnCommandHandler = onCommandHandler;
   const spinner = tui.spinner();
   const handleCleanupSignal = (exitCode) => {
     const currentId = options.taskId || "parent";
@@ -4149,17 +3434,35 @@ ${mailboxMessages.map((m) => `- ${m}`).join("\n")}
 `;
         currentTurnPrompt += panel;
       }
-      const promptToSend = currentTurnPrompt + skillManager.getSystemInstructionExtension();
+      const promptToSend = currentTurnPrompt;
       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);
+        if (existingConversationId) {
+          const rawHistory = await HistoryManager.getRawHistory(existingConversationId);
+          const totalTokensEst = Math.ceil(JSON.stringify(rawHistory).length / 4);
+          const compactionTokenLimit = ConfigManager.getInstance().getConfig().memory?.compactionTokenLimit ?? 8e3;
+          if (totalTokensEst >= compactionTokenLimit) {
+            try {
+              log.info("\u{1F988} Limite de context/tokens atingido. Iniciando compacta\xE7\xE3o autom\xE1tica...");
+              const memboxManager = new MemboxManager();
+              const providerInstance = ProviderResolver.getProvider("developer_agent");
+              const truncatedHistory = await memboxManager.compactHistory(rawHistory, providerInstance, existingConversationId);
+              await HistoryManager.saveRawHistory(existingConversationId, truncatedHistory);
+              log.success("\u2714 Compacta\xE7\xE3o autom\xE1tica conclu\xEDda!");
+            } catch (error) {
+              log.error(`\u26A0\uFE0F Falha na compacta\xE7\xE3o autom\xE1tica: ${error.message}. Prosseguindo sem compacta\xE7\xE3o.`);
+            }
+          }
+        }
         const provider = ProviderResolver.getProvider("developer_agent");
         const response = await provider.streamChat(promptToSend, {
           conversationId: existingConversationId,
           agentType: "developer_agent",
+          searchQuery: nextPrompt,
           onChunk: () => {
           }
         });
@@ -4174,19 +3477,32 @@ ${mailboxMessages.map((m) => `- ${m}`).join("\n")}
           log.info(`\u{1F4CC} Status: ${response.summary}`);
         }
         if (response.message && response.message.includes("TASK_COMPLETED:")) {
+          const mainContent = response.message.split("TASK_COMPLETED:")[0].trim();
+          if (mainContent) {
+            log.info(colors.primary("\u{1F916} Shark Dev:"));
+            console.log(mainContent);
+          }
           finalSummary = response.message.split("TASK_COMPLETED:")[1].trim();
           log.success(`\u2714 Task Completed: ${finalSummary}`);
           if (options.taskId) {
             subagentManager.updateSubagentSummary(options.taskId, finalSummary);
+            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:
+${mainContent || finalSummary}`
+              );
+            }
             keepGoing = false;
             break;
           }
-          if (!options.taskInstruction) {
+          if (!options.auto || subagentManager.getActiveSubagentsForParent(myId).length > 0) {
             let nextMsg;
             if (!messageQueue.isEmpty()) {
               nextMsg = await messageQueue.next();
             } else {
-              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix);
+              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix, void 0, isAuto);
             }
             if (nextMsg.type === "user") {
               if (tui.isCancel(nextMsg.content)) {
@@ -4202,6 +3518,11 @@ ${mailboxMessages.map((m) => `- ${m}`).join("\n")}
           }
         }
         if (response.message && response.message.includes("TASK_FAILED:")) {
+          const mainContent = response.message.split("TASK_FAILED:")[0].trim();
+          if (mainContent) {
+            log.info(colors.primary("\u{1F916} Shark Dev:"));
+            console.log(mainContent);
+          }
           const failureReason = response.message.split("TASK_FAILED:")[1].trim();
           log.error(`\u274C Agent reported task failure: ${failureReason}`);
           if (options.taskId) {
@@ -4215,12 +3536,12 @@ ${mailboxMessages.map((m) => `- ${m}`).join("\n")}
             }
             return { success: false, summary: failureReason };
           }
-          if (!options.taskInstruction) {
+          if (!options.auto || subagentManager.getActiveSubagentsForParent(myId).length > 0) {
             let nextMsg;
             if (!messageQueue.isEmpty()) {
               nextMsg = await messageQueue.next();
             } else {
-              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix);
+              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix, void 0, isAuto);
             }
             if (nextMsg.type === "user") {
               if (tui.isCancel(nextMsg.content)) {
@@ -4247,7 +3568,7 @@ ${mailboxMessages.map((m) => `- ${m}`).join("\n")}
             if (!messageQueue.isEmpty()) {
               nextMsg = await messageQueue.next();
             } else {
-              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix);
+              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix, void 0, isAuto);
             }
             if (nextMsg.type === "user") {
               if (tui.isCancel(nextMsg.content)) {
@@ -4262,7 +3583,7 @@ ${mailboxMessages.map((m) => `- ${m}`).join("\n")}
             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);
+              nextMsg = await waitForInputOrNotification(messageQueue, "Agent returned empty response. Type a message to continue or press Ctrl+C to cancel:", subagentPrefix, void 0, isAuto);
             }
             if (nextMsg.type === "user") {
               if (tui.isCancel(nextMsg.content)) {
@@ -4311,12 +3632,12 @@ ${content}`;
           }
           if (approved) {
             try {
-              const resolvedPath = path10.resolve(projectRoot, filePath);
-              const dir = path10.dirname(resolvedPath);
-              if (!fs9.existsSync(dir)) {
-                fs9.mkdirSync(dir, { recursive: true });
+              const resolvedPath = path8.resolve(projectRoot, filePath);
+              const dir = path8.dirname(resolvedPath);
+              if (!fs8.existsSync(dir)) {
+                fs8.mkdirSync(dir, { recursive: true });
               }
-              fs9.writeFileSync(resolvedPath, action.content || "", "utf-8");
+              fs8.writeFileSync(resolvedPath, action.content || "", "utf-8");
               resultMsg = `[Action create_file(${filePath}) Success]`;
             } catch (e) {
               resultMsg = `[Action create_file(${filePath}) Failed]: ${e.message}`;
@@ -4333,9 +3654,9 @@ ${content}`;
           }
           if (approved) {
             try {
-              const resolvedPath = path10.resolve(projectRoot, filePath);
-              if (fs9.existsSync(resolvedPath)) {
-                fs9.rmSync(resolvedPath, { force: true });
+              const resolvedPath = path8.resolve(projectRoot, filePath);
+              if (fs8.existsSync(resolvedPath)) {
+                fs8.rmSync(resolvedPath, { force: true });
               }
               resultMsg = `[Action delete_file(${filePath}) Success]`;
             } catch (e) {
@@ -4426,7 +3747,7 @@ ${result}`;
                 if (!messageQueue.isEmpty()) {
                   nextMsg = await messageQueue.next();
                 } else {
-                  nextMsg = await waitForInputOrNotification(messageQueue, "Seu prompt alternativo para o agente:", subagentPrefix);
+                  nextMsg = await waitForInputOrNotification(messageQueue, "Seu prompt alternativo para o agente:", subagentPrefix, void 0, isAuto);
                 }
                 if (nextMsg.type === "user") {
                   if (tui.isCancel(nextMsg.content)) {
@@ -4443,19 +3764,33 @@ ${result}`;
             if (isSubagent) {
               const summary = hasCompleted ? contentStr.split("TASK_COMPLETED:")[1].trim() : contentStr;
               subagentManager.updateSubagentSummary(options.taskId, summary);
+              if (process.env.SHARK_PARENT_ID) {
+                const mainContent = hasCompleted ? contentStr.split("TASK_COMPLETED:")[0].trim() : contentStr;
+                subagentManager.sendMessage(
+                  process.env.SHARK_PARENT_ID,
+                  `[Subagent Notification] Subagent ${process.env.SHARK_SUBAGENT_ROLE || "Subagent"} (${options.taskId}) completed.
+Result Details:
+${mainContent}`
+                );
+              }
               finalSummary = summary;
               keepGoing = false;
               break;
             }
             if (hasCompleted) {
+              const mainContent = contentStr.split("TASK_COMPLETED:")[0].trim();
+              if (mainContent) {
+                log.info(colors.primary("\u{1F916} Shark Dev:"));
+                console.log(mainContent);
+              }
               finalSummary = contentStr.split("TASK_COMPLETED:")[1].trim();
               log.success(`\u2714 Task Completed: ${finalSummary}`);
-              if (!options.taskInstruction) {
+              if (!options.auto || subagentManager.getActiveSubagentsForParent(myId).length > 0) {
                 let nextMsg2;
                 if (!messageQueue.isEmpty()) {
                   nextMsg2 = await messageQueue.next();
                 } else {
-                  nextMsg2 = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix);
+                  nextMsg2 = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix, void 0, isAuto);
                 }
                 if (nextMsg2.type === "user") {
                   if (tui.isCancel(nextMsg2.content)) {
@@ -4476,7 +3811,7 @@ ${result}`;
             if (!messageQueue.isEmpty()) {
               nextMsg = await messageQueue.next();
             } else {
-              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix);
+              nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix, void 0, isAuto);
             }
             if (nextMsg.type === "user") {
               if (tui.isCancel(nextMsg.content)) {
@@ -4560,19 +3895,46 @@ 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);
+            finalSummary = taskSummary;
+            keepGoing = false;
+            break;
+          } else {
+            if (detailedContent) {
+              log.info(colors.primary("\u{1F916} Shark Dev:"));
+              console.log(detailedContent);
+            }
+            log.success(`\u2714 Task Completed: ${taskSummary}`);
+            if (!options.auto || subagentManager.getActiveSubagentsForParent(myId).length > 0) {
+              let nextMsg;
+              if (!messageQueue.isEmpty()) {
+                nextMsg = await messageQueue.next();
+              } else {
+                nextMsg = await waitForInputOrNotification(messageQueue, "Your answer:", subagentPrefix, void 0, isAuto);
+              }
+              if (nextMsg.type === "user") {
+                if (tui.isCancel(nextMsg.content)) {
+                  finalSummary = taskSummary;
+                  keepGoing = false;
+                  break;
+                }
+              }
+              nextPrompt = nextMsg.content;
+              continue;
+            } else {
+              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, isAuto);
           }
           if (nextMsg.type === "timeout") {
             resultMsg = `[System]: Wait duration of ${durationSeconds} seconds expired. No notifications received.`;
@@ -4585,6 +3947,13 @@ ${detailedContent}`
           } else {
             resultMsg = nextMsg.content;
           }
+        } else if (action.type === "notify_user") {
+          const messageContent = action.content || "";
+          if (messageContent) {
+            log.info(colors.primary("\u{1F916} Shark Dev:"));
+            console.log(messageContent);
+          }
+          resultMsg = `[Action notify_user Success]: Notifica\xE7\xE3o exibida com sucesso para o usu\xE1rio.`;
         } else {
           resultMsg = `[Unsupported action type: ${action.type}]`;
         }
@@ -4616,6 +3985,7 @@ ${detailedContent}`
     log.success("\u2705 Task Scope Completed");
     return finalResult;
   } finally {
+    activeOnCommandHandler = void 0;
     process.off("SIGINT", sigIntHandler);
     process.off("SIGTERM", sigTermHandler);
     const currentId = options.taskId || "parent";
@@ -4630,11 +4000,30 @@ ${detailedContent}`
 }
 
 // src/commands/dev.ts
-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) => {
+import { exec as exec2 } from "child_process";
+import * as path9 from "path";
+import * as fs9 from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path9.dirname(__filename2);
+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").option("--graph", "Enable real-time memory graph visualization", false).action(async (options) => {
   if (options.exportSchema) {
     console.log(JSON.stringify(AGENT_RESPONSE_JSON_SCHEMA, null, 2));
     return;
   }
+  if (options.graph) {
+    try {
+      const runDir = path9.join(process.cwd(), ".shark", "membox");
+      const configPath = path9.join(runDir, "graph-server.json");
+      if (fs9.existsSync(configPath)) {
+        fs9.unlinkSync(configPath);
+      }
+    } catch {
+    }
+    const cliPath = path9.resolve(__dirname2, "..", "bin", "shark.js");
+    const child = exec2(`node "${cliPath}" graph`);
+    child.unref();
+  }
   try {
     const result = await interactiveDeveloperAgent({
       taskInstruction: options.task,
@@ -4652,996 +4041,534 @@ var devCommand = new Command2("dev").description("Starts the Shark Developer Age
   }
 });
 
-// src/commands/legacy.ts
+// src/commands/export-schema.ts
 import { Command as Command3 } from "commander";
+var exportSchemaCommand = new Command3("export-schema").description("Outputs the agent response JSON Schema").action(() => {
+  console.log(JSON.stringify(AGENT_RESPONSE_JSON_SCHEMA, null, 2));
+});
 
-// src/core/agents/legacy-developer-agent.ts
-import fs10 from "fs";
-import path11 from "path";
-var AGENT_TYPE = "developer_agent";
-async function validateTypeScript(filePath) {
+// src/commands/export-prompt.ts
+import { Command as Command4 } from "commander";
+var exportPromptCommand = new Command4("export-prompt").description("Outputs the unified agent system prompt").action(() => {
+  console.log(UNIFIED_SYSTEM_PROMPT);
+});
+
+// src/commands/super.ts
+import { Command as Command5 } from "commander";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import path10 from "path";
+import os3 from "os";
+import fs10 from "fs/promises";
+var superCommandAction = async (options = {}) => {
+  const __filename3 = fileURLToPath3(import.meta.url);
+  const __dirname3 = path10.dirname(__filename3);
+  const packageRoot = path10.resolve(__dirname3, "../../");
+  const internalSkillsPath = path10.join(packageRoot, "skills");
+  const targetPath = options.local ? path10.join(process.cwd(), ".agents", "skills") : path10.join(os3.homedir(), ".shark", "skills");
   try {
-    const result = await handleRunCommand(`npx tsc --noEmit --skipLibCheck ${filePath}`);
-    if (result.trim() === "" || !result.includes("error TS")) {
-      return { valid: true };
-    }
-    return { valid: false, error: result };
-  } catch (e) {
-    return { valid: false, error: e.message || "TypeScript validation failed" };
-  }
-}
-function getAgentId(overrideId) {
-  if (overrideId) return overrideId;
-  const config = ConfigManager.getInstance().getConfig();
-  if (config.agents?.dev) return config.agents.dev;
-  if (process.env.STACKSPOT_DEV_AGENT_ID) return process.env.STACKSPOT_DEV_AGENT_ID;
-  return "01KEQCGJ65YENRA4QBXVN1YFFX";
-}
-async function interactiveDeveloperAgent2(options = {}) {
-  FileLogger.init();
-  const agentId = getAgentId();
-  if (agentId === "PENDING_CONFIGURATION") {
-    tui.log.error("\u274C STACKSPOT_DEV_AGENT_ID not configured in .env");
-    return { success: false, summary: "Missing configuration." };
-  }
-  const projectRoot = process.cwd();
-  let contextContent = "";
-  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 = fs10.readFileSync(specificContextPath, "utf-8");
-    } catch (e) {
-      tui.log.warning(`Failed to read context file: ${e}`);
+      await fs10.rm(targetPath, { recursive: true, force: true });
+    } catch {
     }
+    await fs10.mkdir(targetPath, { recursive: true });
+    await fs10.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);
   }
-  const currentTask = options.taskInstruction || "Analyze the project and fix pending issues.";
-  let basePrompt = ``;
-  if (contextContent) {
-    basePrompt += `
+};
+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);
 
---- PROJECT CONTEXT ---
-${contextContent}
------------------------
-`;
-  }
-  if (options.history) {
-    basePrompt += `
+// src/commands/graph.ts
+import { Command as Command6, Argument } from "commander";
+import * as http from "http";
+import * as fs11 from "fs";
+import * as path11 from "path";
+import { exec as exec3 } from "child_process";
 
---- PREVIOUS EXECUTION SUMMARY ---
-${options.history}
-----------------------------------
-`;
-  }
-  basePrompt += `
+// src/commands/graph-html.ts
+var GRAPH_HTML_TEMPLATE = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Shark Dev Memory Graph</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script type="text/javascript" src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600&family=JetBrains+Mono&display=swap" rel="stylesheet">
+    <style>
+        body { font-family: 'Inter', sans-serif; background-color: #0b0f19; color: #f3f4f6; }
+        .glass { background: rgba(15, 23, 42, 0.75); backdrop-filter: blur(12px); border: 1px solid rgba(255, 255, 255, 0.08); }
+    </style>
+</head>
+<body class="h-screen w-screen overflow-hidden flex flex-col">
+    <!-- Header -->
+    <header class="h-16 px-6 border-b border-white/5 flex items-center justify-between glass z-10">
+        <div class="flex items-center gap-3">
+            <span class="text-2xl">\u{1F988}</span>
+            <h1 class="text-lg font-semibold tracking-wide">Shark Memory Graph</h1>
+        </div>
+        <div class="flex items-center gap-4">
+            <input type="text" id="searchInput" placeholder="Search topics/events..." class="px-4 py-2 bg-white/5 border border-white/10 rounded-lg text-sm focus:outline-none focus:border-blue-500/50 w-64">
+            <div class="flex bg-white/5 rounded-lg p-0.5 border border-white/5">
+                <button id="btnBoxes" class="px-4 py-1.5 rounded-md text-xs font-medium bg-blue-600 text-white transition-all">Boxes Network</button>
+                <button id="btnTimeline" class="px-4 py-1.5 rounded-md text-xs font-medium text-gray-400 hover:text-white transition-all">Event Flow</button>
+            </div>
+        </div>
+    </header>
 
-\u{1F7E2} EXECUTION MODE
+    <!-- Main Content -->
+    <div class="flex-1 flex relative">
+        <!-- Canvas -->
+        <div id="network" class="flex-1 h-full"></div>
 
-You are a highly skilled Developer Agent.
-\u{1F449} **CURRENT TASK**: "${currentTask}"
+        <!-- Sidebar -->
+        <aside id="sidebar" class="w-96 glass border-l border-white/5 flex flex-col translate-x-full transition-transform duration-300 absolute right-0 top-0 bottom-0 z-20">
+            <div class="p-6 border-b border-white/5 flex items-center justify-between">
+                <h2 id="sidebarTitle" class="text-lg font-semibold text-blue-400">Node Details</h2>
+                <button id="btnCloseSidebar" class="text-gray-400 hover:text-white text-lg">&times;</button>
+            </div>
+            <div id="sidebarContent" class="flex-1 overflow-y-auto p-6 space-y-4">
+                <!-- Filled dynamically -->
+            </div>
+        </aside>
 
-Your goal is to COMPLETE this specific task and then STOP.
-1. Implement the necessary changes.
-2. Verify (compile/test).
-3. **MANDATORY**: When you are confident the task is done, output a final message starting with "TASK_COMPLETED:" followed by a brief technical summary of what you did.
-`;
-  let nextPrompt = basePrompt;
-  let keepGoing = true;
-  const spinner = tui.spinner();
-  let finalSummary = "";
-  let isTaskCompleted = false;
-  const conversationKey = options.taskId ? `dev_agent_${options.taskId}` : `dev_agent_${Date.now()}`;
-  let autoApprovals = {
-    files: false,
-    commands: false
-  };
-  while (keepGoing) {
-    try {
-      spinner.start("\u{1F988} Shark Dev working...");
-      const lastResponse = await callDevAgentApi(nextPrompt, (chunk) => {
-      }, conversationKey);
-      spinner.stop("Response received");
-      if (lastResponse) {
-        const response = lastResponse;
-        const actions = response.actions || [];
-        if (response.message && response.message.includes("TASK_COMPLETED:")) {
-          isTaskCompleted = true;
-          finalSummary = response.message.split("TASK_COMPLETED:")[1].trim();
-          keepGoing = false;
-        }
-        if (response.message && response.message.includes("TASK_FAILED:")) {
-          const failureReason = response.message.split("TASK_FAILED:")[1].trim();
-          tui.log.error(`\u274C Agent reported task failure: ${failureReason}`);
-          return { success: false, summary: failureReason };
-        }
-        if (actions.length === 0 && response.message && !isTaskCompleted) {
-          tui.log.info(colors.primary("\u{1F916} Shark Dev:"));
-          console.log(response.message);
-          const userReply = await tui.text({ message: "Your answer:" });
-          if (tui.isCancel(userReply)) {
-            keepGoing = false;
-            break;
-          }
-          nextPrompt = userReply;
-        }
-        let executionResults = "";
-        let waitingForUser = false;
-        for (const action of actions) {
-          if (action.type === "talk_with_user") {
-            tui.log.info(colors.primary("\u{1F916} Shark Dev:"));
-            console.log(action.content);
-            if (!isTaskCompleted) waitingForUser = true;
-          } else if (action.type === "list_files") {
-            tui.log.info(`\u{1F4C2} Scanning: ${colors.dim(action.path || ".")}`);
-            const result = handleListFiles(action.path || ".");
-            executionResults += `[Action list_files(${action.path}) Result]:
-${result}
+        <!-- Empty State overlay -->
+        <div id="emptyState" class="absolute inset-0 bg-[#0b0f19]/90 flex items-center justify-center hidden z-30">
+            <div class="max-w-md p-8 rounded-2xl glass text-center space-y-4">
+                <div class="text-4xl">\u{1F4AD}</div>
+                <h3 class="text-xl font-bold">Awaiting Memories...</h3>
+                <p class="text-sm text-gray-400">Start a chat session using <code class="bg-black/30 px-1.5 py-0.5 rounded text-blue-400">shark dev --graph</code> in another terminal to generate memory boxes.</p>
+            </div>
+        </div>
+    </div>
 
-`;
-          } else if (action.type === "read_file") {
-            tui.log.info(`\u{1F4D6} Reading: ${colors.dim(action.path || "")}`);
-            const result = handleReadFile(action.path || "");
-            executionResults += `[Action read_file(${action.path}) Result]:
-${result}
-
-`;
-          } else if (action.type === "search_file") {
-            const result = handleSearchFile(action.path || "");
-            executionResults += `[Action search_file(${action.path}) Result]:
-${result}
-
-`;
-          } else if (action.type === "run_command") {
-            const cmd = action.command || "";
-            tui.log.info(`\u{1F4BB} Executing: ${colors.dim(cmd)}`);
-            let approved = autoApprovals.commands;
-            if (!approved) {
-              const choice = await tui.select({
-                message: `Execute: ${cmd}?`,
-                options: [{ value: "yes", label: "Yes" }, { value: "always", label: "Yes (Auto-Approve Session)" }, { value: "no", label: "No" }]
-              });
-              if (choice === "always") {
-                autoApprovals.commands = true;
-                approved = true;
-              } else if (choice === "yes") approved = true;
+    <script>
+        let network = null;
+        let currentMode = 'boxes';
+        let graphData = { nodes: [], edges: [] };
+        let lastDataString = '';
+        
+        async function fetchGraphData() {
+            try {
+                const res = await fetch(\`/api/graph?mode=\${currentMode}\`);
+                const data = await res.json();
+                
+                const container = document.getElementById('emptyState');
+                if (data.nodes.length === 0) {
+                    container.classList.remove('hidden');
+                    return;
+                }
+                container.classList.add('hidden');
+                
+                const currentDataString = JSON.stringify({ nodes: data.nodes, edges: data.edges });
+                if (currentDataString === lastDataString) {
+                    highlightActiveNodes(data.activeNodes);
+                    return;
+                }
+                lastDataString = currentDataString;
+                
+                updateNetwork(data);
+            } catch (err) {
+                console.error("Error fetching graph data:", err);
             }
-            if (approved) {
-              const result = await handleRunCommand(cmd);
-              executionResults += `[Action run_command(${cmd}) Result]:
-${result}
+        }
 
-`;
+        function getOptionsForMode(mode) {
+            if (mode === 'timeline') {
+                return {
+                    layout: {
+                        hierarchical: {
+                            enabled: true,
+                            direction: 'LR',
+                            sortMethod: 'directed',
+                            nodeSpacing: 200,
+                            levelSeparation: 250
+                        }
+                    },
+                    physics: {
+                        enabled: false
+                    },
+                    interaction: { hover: true }
+                };
             } else {
-              executionResults += `[Action run_command]: User blocked execution.
-
-`;
-            }
-          } else if (["create_file", "modify_file"].includes(action.type)) {
-            const filePath = action.path || "";
-            tui.log.warning(`\u{1F4DD} ${action.type === "create_file" ? "CREATE" : "MODIFY"}: ${colors.bold(filePath)}`);
-            let approved = autoApprovals.files;
-            if (!approved) {
-              const choice = await tui.select({
-                message: `Approve changes to ${filePath}?`,
-                options: [{ value: "yes", label: "Yes" }, { value: "always", label: "Yes (Auto-Approve Session)" }, { value: "no", label: "No" }]
-              });
-              if (choice === "always") {
-                autoApprovals.files = true;
-                approved = true;
-              } else if (choice === "yes") approved = true;
+                return {
+                    layout: {
+                        hierarchical: {
+                            enabled: false
+                        }
+                    },
+                    physics: {
+                        enabled: true,
+                        solver: 'forceAtlas2Based',
+                        forceAtlas2Based: { gravitationalConstant: -50, centralGravity: 0.01, springLength: 100 }
+                    },
+                    interaction: { hover: true }
+                };
             }
-            if (approved) {
-              if (action.type === "create_file") {
-                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
+        }
 
-`;
-              } else {
-                let success = false;
-                if (action.line_range) success = replaceLineRange(filePath, action.line_range[0], action.line_range[1], action.content || "", tui);
-                else if (action.target_content) success = startSmartReplace(filePath, action.content || "", action.target_content, tui);
-                executionResults += success ? `[Action modify_file]: Success
+        function updateNetwork(data) {
+            graphData = data;
+            const container = document.getElementById('network');
+            
+            const visNodes = new vis.DataSet(data.nodes.map(n => {
+                const isActive = data.activeNodes && data.activeNodes.includes(n.id);
+                return {
+                    id: n.id,
+                    label: n.label,
+                    size: n.size || 15,
+                    shape: n.type === 'box' ? 'dot' : 'circle',
+                    color: {
+                        background: isActive ? '#d97706' : (n.type === 'box' ? '#1e40af' : '#065f46'),
+                        border: isActive ? '#fbbf24' : (n.type === 'box' ? '#3b82f6' : '#10b981'),
+                        highlight: { background: '#2563eb', border: '#60a5fa' }
+                    },
+                    font: { color: '#f3f4f6', face: 'Inter', size: 12 }
+                };
+            }));
 
-` : `[Action modify_file]: Failed
+            const visEdges = new vis.DataSet(data.edges.map(e => {
+                // Similarity-based edge thickness (e.similarity from 0.0 to 1.0)
+                const width = e.similarity ? Math.max(1, Math.round(e.similarity * 6)) : 2;
+                const isWeak = e.similarity && e.similarity < 0.6;
+                return {
+                    from: e.from,
+                    to: e.to,
+                    label: e.label || '',
+                    arrows: e.arrows || '',
+                    width: width,
+                    dashes: isWeak ? true : false,
+                    color: { color: '#4b5563', highlight: '#9ca3af' },
+                    font: { color: '#9ca3af', face: 'Inter', size: 10 }
+                };
+            }));
 
-`;
-              }
-              const val = await validateTypeScript(path11.resolve(projectRoot, filePath));
-              if (!val.valid) executionResults += `[Validation Failed]: ${val.error}
-
-`;
+            if (network) {
+                network.setData({ nodes: visNodes, edges: visEdges });
+                network.setOptions(getOptionsForMode(currentMode));
             } else {
-              executionResults += `[Action ${action.type}]: User Denied.
-
-`;
+                network = new vis.Network(container, { nodes: visNodes, edges: visEdges }, getOptionsForMode(currentMode));
+                
+                network.on('click', function(params) {
+                    if (params.nodes.length > 0) {
+                        showSidebar(params.nodes[0]);
+                    } else {
+                        hideSidebar();
+                    }
+                });
             }
-          } else if (action.type.startsWith("ast_")) {
-            try {
-              let result = "";
-              if (action.type === "ast_list_structure") {
-                result = await astListStructure(action.path || "");
-              } else if (action.type === "ast_get_method") {
-                result = await astGetMethod(action.path || "", action.class_name || "", action.method_name || "");
-              } else if (action.type === "ast_add_method") {
-                const success = await astAddMethod(action.path || "", action.class_name || "", action.method_code || "");
-                result = success ? "Method added successfully." : "Failed to add method.";
-              } else if (action.type === "ast_modify_method") {
-                const success = await astModifyMethod(action.path || "", action.class_name || "", action.method_name || "", action.new_body || "");
-                result = success ? "Method modified successfully." : "Failed to modify method.";
-              } else if (action.type === "ast_remove_method") {
-                const success = await astRemoveMethod(action.path || "", action.class_name || "", action.method_name || "");
-                result = success ? "Method removed successfully." : "Failed to remove method.";
-              } else if (action.type === "ast_add_class") {
-                const success = await astAddClass(action.path || "", action.class_name || "", action.extends_class || void 0, action.implements_interfaces || void 0);
-                result = success ? "Class added successfully." : "Failed to add class.";
-              } else if (action.type === "ast_get_property") {
-                tui.log.info(`\u{1F50D} Reading property ${colors.gray(action.property_name || "")} in ${colors.gray(action.class_name || "")}`);
-                const propContent = await astGetProperty(action.path || "", action.class_name || "", action.property_name || "");
-                result = `[AST Get Property] Content:
-${propContent}`;
-              } else if (action.type === "ast_add_property") {
-                const success = await astAddProperty(action.path || "", action.class_name || "", action.property_code || "");
-                result = success ? "Property added successfully." : "Failed to add property.";
-              } else if (action.type === "ast_modify_property") {
-                tui.log.info(`\u270F\uFE0F Modifying property ${colors.gray(action.property_name || "")} in ${colors.gray(action.class_name || "")}`);
-                const success = await astModifyProperty(action.path || "", action.class_name || "", action.property_name || "", action.property_code || "");
-                result = success ? "Property modified successfully." : "Failed to modify property.";
-              } else if (action.type === "ast_remove_property") {
-                const success = await astRemoveProperty(action.path || "", action.class_name || "", action.property_name || "");
-                result = success ? "Property removed successfully." : "Failed to remove property.";
-              } else if (action.type === "ast_add_decorator") {
-                const success = await astAddDecorator(action.path || "", action.class_name || "", action.decorator_code || "");
-                result = success ? "Decorator added successfully." : "Failed to add decorator.";
-              } else if (action.type === "ast_add_interface") {
-                const success = await astAddInterface(action.path || "", action.interface_code || "");
-                result = success ? "Interface added successfully." : "Failed to add interface.";
-              } else if (action.type === "ast_add_type_alias") {
-                const success = await astAddTypeAlias(action.path || "", action.type_code || "");
-                result = success ? "Type alias added successfully." : "Failed to add type alias.";
-              } else if (action.type === "ast_add_function") {
-                const success = await astAddFunction(action.path || "", action.function_code || "");
-                result = success ? "Function added successfully." : "Failed to add function.";
-              } else if (action.type === "ast_remove_function") {
-                const success = await astRemoveFunction(action.path || "", action.function_name || "");
-                result = success ? "Function removed successfully." : "Failed to remove function.";
-              } else if (action.type === "ast_add_import") {
-                const success = await astAddImport(action.path || "", action.import_statement || "");
-                result = success ? "Import added successfully." : "Failed to add import.";
-              } else if (action.type === "ast_remove_import") {
-                const success = await astRemoveImport(action.path || "", action.module_path || "");
-                result = success ? "Import removed successfully." : "Failed to remove import.";
-              } else if (action.type === "ast_organize_imports") {
-                const success = await astOrganizeImports(action.path || "");
-                result = success ? "Imports organized successfully." : "Failed to organize imports.";
-              } else {
-                result = `Unknown AST action: ${action.type}`;
-              }
-              executionResults += `[Action ${action.type} Result]:
-${result}
+        }
 
-`;
-              tui.log.info(`\u26A1 AST Action ${colors.dim(action.type)}: ${result}`);
-            } catch (e) {
-              executionResults += `[Action ${action.type} Failed]: ${e.message}
+        function highlightActiveNodes(activeNodeIds) {
+            if (!network || !activeNodeIds) return;
+            const nodesDataset = network.body.data.nodes;
+            graphData.nodes.forEach(n => {
+                const isActive = activeNodeIds.includes(n.id);
+                nodesDataset.update({
+                    id: n.id,
+                    color: {
+                        background: isActive ? '#d97706' : (n.type === 'box' ? '#1e40af' : '#065f46'),
+                        border: isActive ? '#fbbf24' : (n.type === 'box' ? '#3b82f6' : '#10b981')
+                    }
+                });
+            });
+        }
 
-`;
-              tui.log.error(`\u274C AST Action Error: ${e.message}`);
-            }
-          } else if (action.type === "search_ast") {
-            const result = await astGrepSearch(action.pattern || "", action.path || "", action.language || "typescript", tui);
-            executionResults += `[Action search_ast Result]:
-${result}
+        function showSidebar(nodeId) {
+            const node = graphData.nodes.find(n => n.id === nodeId);
+            if (!node || !node.details) return;
 
-`;
-          } else if (action.type === "modify_ast") {
-            const success = await astGrepRewrite(action.pattern || "", action.fix || "", action.path || "", action.language || "typescript", tui);
-            executionResults += success ? `[Action modify_ast]: Success
+            document.getElementById('sidebarTitle').innerText = node.label;
+            const content = document.getElementById('sidebarContent');
+            content.innerHTML = '';
 
-` : `[Action modify_ast]: Failed
+            if (node.type === 'box') {
+                const detail = node.details;
+                if (detail.keywords && detail.keywords.length > 0) {
+                    const tagContainer = document.createElement('div');
+                    tagContainer.className = 'flex flex-wrap gap-2';
+                    detail.keywords.forEach(kw => {
+                        const span = document.createElement('span');
+                        span.className = 'px-2 py-0.5 bg-blue-500/10 text-blue-400 rounded text-xs border border-blue-500/20';
+                        span.innerText = kw;
+                        tagContainer.appendChild(span);
+                    });
+                    content.appendChild(tagContainer);
+                }
 
-`;
-          }
-        }
-        if (executionResults) {
-          if (waitingForUser) {
-            const userReply = await tui.text({ message: "Your answer:" });
-            if (tui.isCancel(userReply)) {
-              keepGoing = false;
-              break;
+                if (detail.history) {
+                    const historyTitle = document.createElement('h4');
+                    historyTitle.className = 'text-sm font-semibold border-b border-white/5 pb-2 mt-4';
+                    historyTitle.innerText = 'Dialogue Logs';
+                    content.appendChild(historyTitle);
+
+                    detail.history.forEach(msg => {
+                        const bubble = document.createElement('div');
+                        bubble.className = \`p-3 rounded-lg text-sm \${msg.role === 'user' ? 'bg-white/5 border border-white/5' : 'bg-blue-600/10 border border-blue-600/20'}\`;
+                        bubble.innerHTML = \`<strong class="block text-xs text-gray-400 mb-1">\${msg.role.toUpperCase()}</strong>\${msg.content}\`;
+                        content.appendChild(bubble);
+                    });
+                }
+            } else {
+                const eventDesc = document.createElement('p');
+                eventDesc.className = 'text-sm text-gray-300';
+                eventDesc.innerText = node.details.event || '';
+                content.appendChild(eventDesc);
             }
-            nextPrompt = `${executionResults}
-User Reply: ${userReply}`;
-          } else {
-            nextPrompt = `${executionResults}
-[System]: Continue execution. If finished, output "TASK_COMPLETED: summary".`;
-            tui.log.info(colors.dim("Processing results..."));
-          }
-        } else if (!keepGoing) {
-        } else if (waitingForUser) {
-        } else {
-          if (!isTaskCompleted && actions.length > 0) nextPrompt = "Please continue.";
-        }
-      } else {
-        tui.log.warning("No response received from agent.");
-      }
-    } catch (e) {
-      tui.log.error(e.message);
-      keepGoing = false;
-      return { success: false, summary: `Error: ${e.message}` };
-    }
-  }
-  tui.log.success("\u2705 Task Scope Completed");
-  return { success: true, summary: finalSummary || "Task completed without summary." };
-}
-async function callDevAgentApi(prompt, onChunk, conversationKey = AGENT_TYPE) {
-  const existingConversationId = await conversationManager.getConversationId(conversationKey);
-  const provider = ProviderResolver.getProvider("developer_agent");
-  const parsedResponse = await provider.streamChat(prompt, {
-    conversationId: existingConversationId,
-    agentType: "developer_agent",
-    onChunk
-  });
-  if (parsedResponse.conversation_id) {
-    await conversationManager.saveConversationId(conversationKey, parsedResponse.conversation_id);
-  }
-  return parsedResponse;
-}
 
-// src/core/workflow/task-manager.ts
-import fs11 from "fs";
-import path12 from "path";
-var TaskManager = class {
-  projectRoot;
-  specPath;
-  constructor(projectRoot = process.cwd()) {
-    this.projectRoot = projectRoot;
-    this.specPath = path12.resolve(this.projectRoot, "_sharkrc", "tech-spec.md");
-  }
-  /**
-   * Reads the tech-spec.md file and analyzes its current state.
-   */
-  analyzeSpecState() {
-    if (!fs11.existsSync(this.specPath)) {
-      return { status: "MISSING", allTasks: [] };
-    }
-    const content = fs11.readFileSync(this.specPath, "utf-8");
-    const lines = content.split("\n");
-    const tasks = [];
-    let taskIndex = 1;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-      const pendingMatch = trimmed.match(/^- \[ \] (.*)/);
-      const completedMatch = trimmed.match(/^- \[x\] (.*)/i);
-      const progressMatch = trimmed.match(/^- \[\/\] (.*)/);
-      let currentTask = null;
-      let status2 = null;
-      let description = "";
-      if (pendingMatch) {
-        description = pendingMatch[1].trim();
-        status2 = "PENDING";
-      } else if (completedMatch) {
-        description = completedMatch[1].trim();
-        status2 = "COMPLETED";
-      } else if (progressMatch) {
-        description = progressMatch[1].trim();
-        status2 = "IN_PROGRESS";
-      }
-      if (status2 && description) {
-        let j = i + 1;
-        while (j < lines.length) {
-          const nextLine = lines[j];
-          const nextTrimmed = nextLine.trim();
-          if (!nextTrimmed || nextTrimmed.match(/^- \[[ x\/]\]/) || nextTrimmed.startsWith("#")) {
-            break;
-          }
-          description += "\n" + nextTrimmed;
-          j++;
+            document.getElementById('sidebar').classList.remove('translate-x-full');
         }
-        currentTask = {
-          id: `task-${taskIndex++}`,
-          description,
-          status: status2,
-          line_number: i
-        };
-        tasks.push(currentTask);
-      }
-    }
-    let nextTask = tasks.find((t) => t.status === "IN_PROGRESS");
-    if (!nextTask) {
-      nextTask = tasks.find((t) => t.status === "PENDING");
-    }
-    const status = !nextTask && tasks.length > 0 && tasks.every((t) => t.status === "COMPLETED") ? "COMPLETED" : "PENDING";
-    return {
-      status: tasks.length === 0 ? "MISSING" : status,
-      // Empty file is effectively "pending creation" but we treat as missing content logic elsewhere
-      nextTask,
-      allTasks: tasks
-    };
-  }
-  /**
-   * Marks a specific task as COMPLETED in the file.
-   * Uses line-based replacement to be safe.
-   */
-  markTaskAsDone(taskId) {
-    const state = this.analyzeSpecState();
-    const task = state.allTasks.find((t) => t.id === taskId);
-    if (!task) {
-      console.error(`Task ${taskId} not found.`);
-      return false;
-    }
-    const content = fs11.readFileSync(this.specPath, "utf-8");
-    const lines = content.split("\n");
-    const targetLine = lines[task.line_number];
-    if (!targetLine.includes(task.description)) {
-      console.error(`Concurrency Error: Task line content mistmatch. Expected "${task.description}" at line ${task.line_number}.`);
-      return false;
-    }
-    const newLine = targetLine.replace("- [ ]", "- [x]").replace("- [/]", "- [x]");
-    lines[task.line_number] = newLine;
-    fs11.writeFileSync(this.specPath, lines.join("\n"), "utf-8");
-    return true;
-  }
-  /**
-   * Marks a task as IN_PROGRESS.
-   */
-  markTaskInProgress(taskId) {
-    const state = this.analyzeSpecState();
-    const task = state.allTasks.find((t) => t.id === taskId);
-    if (!task) return false;
-    const content = 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;
-    fs11.writeFileSync(this.specPath, lines.join("\n"), "utf-8");
-    return true;
-  }
-  /**
-   * Completely updates the spec file content (used by Spec Agent).
-   */
-  updateSpecContent(newContent) {
-    fs11.writeFileSync(this.specPath, newContent, "utf-8");
-  }
-  getSpecPath() {
-    return this.specPath;
-  }
-};
-
-// src/core/agents/specification-agent.ts
-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 = 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
-[TO BE ANALYZED - STACK]
-- Language: [e.g. TypeScript]
-- Framework: [e.g. Node.js / React]
-- Database: [e.g. SQLite / PostgreSQL]
-- Key Libraries: [Top 5 dependencies]
 
-## 2. Architecture Overview
-[TO BE ANALYZED - ARCHITECTURE]
-[Brief description of architectural pattern]
-
-## 3. Data Model
-[TO BE ANALYZED - DATA MODEL]
-[Schema/ERD definitions]
+        function hideSidebar() {
+            document.getElementById('sidebar').classList.add('translate-x-full');
+        }
 
-## 4. API / Interface Contracts
-[TO BE ANALYZED - API]
-[Main endpoints or CLI commands]
+        document.getElementById('btnCloseSidebar').addEventListener('click', hideSidebar);
 
-## 5. Implementation Steps
-[TO BE FILLED - MUST BE CHECKBOXES]
-`;
-    const projectName = path13.basename(projectRoot);
-    initialContent = initialContent.replace(/{{PROJECT_NAME}}/g, projectName);
-    const BOM = "\uFEFF";
-    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 = 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 && 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 = path13.resolve(projectRoot, "_sharkrc", "briefing.md");
-    if (fs12.existsSync(standardBriefing)) {
-      briefingContent = fs12.readFileSync(standardBriefing, "utf-8");
-      tui.log.info(`\u{1F4C4} Briefing loaded.`);
-    }
-  }
-  let initialPrompt = `
-Voc\xEA \xE9 o **Shark Spec**, um Arquiteto de Software S\xEAnior e Tech Lead.
-Seu objetivo final \xE9 produzir uma especifica\xE7\xE3o t\xE9cnica precisa para a tarefa no arquivo \`_sharkrc/tech-spec.md\`.
-
-\u26A0\uFE0F O SEU WORKFLOW \xC9 GUIADO POR FASES.
-N\xC3O TENTE ADIANTAR O TRABALHO (ex: investigar c\xF3digo ou preencher template agora).
+        document.getElementById('btnBoxes').addEventListener('click', () => {
+            currentMode = 'boxes';
+            lastDataString = '';
+            document.getElementById('btnBoxes').className = 'px-4 py-1.5 rounded-md text-xs font-medium bg-blue-600 text-white transition-all';
+            document.getElementById('btnTimeline').className = 'px-4 py-1.5 rounded-md text-xs font-medium text-gray-400 hover:text-white transition-all';
+            fetchGraphData();
+        });
 
-**VOC\xCA EST\xC1 NA FASE 1: ENTENDIMENTO DA TAREFA**
-- Use \`talk_with_user\` para perguntar ao usu\xE1rio qual tarefa espec\xEDfica, funcionalidade ou bug ele precisa especificar.
-- Confirme o escopo e os limites com o usu\xE1rio.
-- Se o escopo estiver perfeitamente claro e confirmado (com o usu\xE1rio), emita "PHASE_COMPLETED" no campo "summary" do JSON para avan\xE7ar.
+        document.getElementById('btnTimeline').addEventListener('click', () => {
+            currentMode = 'timeline';
+            lastDataString = '';
+            document.getElementById('btnTimeline').className = 'px-4 py-1.5 rounded-md text-xs font-medium bg-blue-600 text-white transition-all';
+            document.getElementById('btnBoxes').className = 'px-4 py-1.5 rounded-md text-xs font-medium text-gray-400 hover:text-white transition-all';
+            fetchGraphData();
+        });
 
-IMPORTANTE: Toda a sua comunica\xE7\xE3o DEVE ser em Portugu\xEAs.
-`;
-  if (briefingContent) {
-    initialPrompt += `
-\u2139\uFE0F Um documento de briefing foi encontrado. Ele define parcialmente a tarefa para a Fase 1.
-Confirme seu entendimento com o usu\xE1rio via \`talk_with_user\` antes de prosseguir para a Fase 2.
+        document.getElementById('searchInput').addEventListener('input', (e) => {
+            const val = e.target.value.toLowerCase();
+            if (!val) return;
+            const node = graphData.nodes.find(n => n.label.toLowerCase().includes(val));
+            if (node && network) {
+                network.focus(node.id, { scale: 1.2, animation: true });
+                showSidebar(node.id);
+            }
+        });
 
---- BRIEFING ---
-${briefingContent}
-----------------
-`;
-  } else {
-    initialPrompt += `
-\u2139\uFE0F Nenhum documento de briefing foi encontrado. Inicie a Fase 1 imediatamente: use \`talk_with_user\` para perguntar ao usu\xE1rio o que precisa ser especificado.
-`;
-  }
-  if (options.initialContext) {
-    initialPrompt += `
---- CONTEXTO DE EXECU\xC7\xC3O ANTERIOR (HANDOVER/FEEDBACK) ---
-${options.initialContext}
------------------------------------------------------
+        fetchGraphData();
+        setInterval(fetchGraphData, 3000);
+    </script>
+</body>
+</html>
 `;
-  }
-  if (contextContent) {
-    initialPrompt += `
-\u2139\uFE0F O contexto do projeto est\xE1 dispon\xEDvel para refer\xEAncia. Use-o na Fase 2 para se alinhar com os padr\xF5es de arquitetura existentes, mas N\xC3O o use para preencher as se\xE7\xF5es de forma gen\xE9rica.
 
---- PROJECT CONTEXT ---
-${contextContent}
------------------------
-`;
+// src/commands/graph.ts
+var graphCommand = new Command6("graph").description("Visualize episodic memory and trace graphs in your browser").addArgument(new Argument("[mode]", "Default view mode (boxes or timeline)").choices(["boxes", "timeline"]).default("boxes")).option("-p, --port <number>", "Port to host the server", "4200").action(async (mode, options) => {
+  let port = parseInt(options.port, 10);
+  if (isNaN(port)) {
+    console.error(colors.error("\u274C Invalid port number."));
+    process.exit(1);
   }
-  await runSpecLoop(initialPrompt.trim(), outputFile, options.agentId);
-}
-async function runSpecLoop(initialMessage, targetPath, overrideAgentId) {
-  let nextPrompt = initialMessage;
-  let keepGoing = true;
-  let stepCount = 0;
-  let currentPhase = 1;
-  const MAX_STEPS = 30;
-  while (keepGoing && stepCount < MAX_STEPS) {
-    stepCount++;
-    const spinner = tui.spinner();
-    spinner.start(`\u{1F3D7}\uFE0F  Spec Agent working (Step ${stepCount}/${MAX_STEPS})...`);
-    let pendingSections = [];
-    if (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");
+  let activeNodes = [];
+  let activeNodesTimestamp = 0;
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url || "", `http://localhost:${port}`);
+    if (url.pathname === "/") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(GRAPH_HTML_TEMPLATE);
+      return;
     }
-    if (pendingSections.length === 0 && stepCount > 1) {
+    if (req.method === "POST" && url.pathname === "/api/active-nodes") {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      req.on("end", () => {
+        try {
+          const data = JSON.parse(body);
+          activeNodes = data.nodeIds || [];
+          activeNodesTimestamp = Date.now();
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: true }));
+        } catch {
+          res.writeHead(400);
+          res.end("Bad Request");
+        }
+      });
+      return;
     }
-    let responseText = "";
-    let lastResponse = null;
-    try {
-      lastResponse = await callSpecAgentApi(nextPrompt, (chunk) => {
-        responseText += chunk;
-      }, overrideAgentId);
-      spinner.stop("Response received");
-      if (lastResponse && lastResponse.actions) {
-        let executionResults = "";
-        let waitingForUser = false;
-        let specUpdated = false;
-        let hasSystemError = false;
-        let systemErrorContent = "";
-        for (const action of lastResponse.actions) {
-          if (action.type === "talk_with_user") {
-            const isSystemError = action.content?.startsWith("[SYSTEM ERROR]");
-            if (isSystemError) {
-              tui.log.error(`\u26A0\uFE0F Detectado erro na resposta do Agente (truncado ou inv\xE1lido).`);
-              tui.log.info(colors.dim(action.content || ""));
-              const approved = await tui.confirm({ message: `Enviar notifica\xE7\xE3o de erro para o agente tentar se recuperar automaticamente?` });
-              if (approved) {
-                hasSystemError = true;
-                systemErrorContent = action.content || "";
-              } else {
-                const userReply = await tui.text({ message: "Seu prompt alternativo para o agente:" });
-                if (tui.isCancel(userReply)) {
-                  keepGoing = false;
-                  return;
+    if (url.pathname === "/api/graph") {
+      const graphMode = url.searchParams.get("mode") || "boxes";
+      const runDir = path11.join(process.cwd(), ".shark", "membox");
+      const boxesFile = path11.join(runDir, "boxes.jsonl");
+      const tracesFile = path11.join(runDir, "traces.jsonl");
+      const nodes = [];
+      const edges = [];
+      try {
+        if (fs11.existsSync(boxesFile)) {
+          const fileContent = await fs11.promises.readFile(boxesFile, "utf-8");
+          const lines = fileContent.trim().split("\n").filter(Boolean);
+          lines.forEach((line) => {
+            try {
+              const box = JSON.parse(line);
+              if (graphMode === "boxes") {
+                const history = [];
+                if (box.content_text) {
+                  const turns = box.content_text.split(/\n(?=user:|assistant:)/i);
+                  turns.forEach((turn) => {
+                    const match = turn.match(/^(user|assistant):\s*([\s\S]*)$/i);
+                    if (match) {
+                      const role = match[1].toLowerCase();
+                      let content = match[2].trim();
+                      if (content.startsWith("{")) {
+                        try {
+                          const parsed = JSON.parse(content);
+                          if (parsed.action && parsed.action.content) {
+                            content = parsed.action.content;
+                          } else if (parsed.summary) {
+                            content = parsed.summary;
+                          }
+                        } catch {
+                        }
+                      }
+                      history.push({ role, content: content.replace(/\n/g, "<br>") });
+                    } else {
+                      history.push({ role: "log", content: turn.trim().replace(/\n/g, "<br>") });
+                    }
+                  });
                 }
-                hasSystemError = true;
-                systemErrorContent = userReply;
-              }
-            } else {
-              tui.log.info(colors.primary("\u{1F916} Architect:"));
-              console.log(action.content);
-              waitingForUser = true;
-            }
-          } else if (action.type === "list_files") {
-            tui.log.info(`\u{1F4C2} Scanning: ${colors.dim(action.path || ".")}`);
-            const result = handleListFiles(action.path || ".");
-            executionResults += `[Action list_files(${action.path}) Result]:
-${result}
-
-`;
-          } else if (action.type === "read_file") {
-            tui.log.info(`\u{1F4D6} Reading: ${colors.dim(action.path || "")}`);
-            const result = handleReadFile(action.path || "");
-            executionResults += `[Action read_file(${action.path}) Result]:
-${result}
-
-`;
-          } else if (action.type === "search_file") {
-            tui.log.info(`\u{1F50D} Searching: ${colors.dim(action.path || "")}`);
-            const result = handleSearchFile(action.path || "");
-            executionResults += `[Action search_file(${action.path}) Result]:
-${result}
-
-`;
-          } else if (action.type === "search_code") {
-            const glob = action.path || "src/**/*";
-            const query = action.query || "";
-            const isRegex = action.is_regex === true;
-            tui.log.info(`\u{1F50E} Search code: ${colors.dim(`"${query}" in ${glob}`)}`);
-            const result = handleSearchCode(glob, query, isRegex);
-            executionResults += `[Action search_code("${query}" in "${glob}") Result]:
-${result}
-
-`;
-          } else if (["create_file", "modify_file"].includes(action.type)) {
-            let actionPath = path13.resolve(action.path || "");
-            const resolvedTargetPath = path13.resolve(targetPath);
-            let isTarget = actionPath === resolvedTargetPath;
-            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;
-            }
-            if (!isTarget && action.type === "create_file") {
-              const confirm = await tui.confirm({ message: `Agent wants to create ${action.path}. Allow?` });
-              if (!confirm) {
-                executionResults += `[Action create_file]: User denied.
-`;
-                continue;
+                nodes.push({
+                  id: `box_${box.box_id}`,
+                  label: box.features?.topic || `Topic ${box.box_id}`,
+                  type: "box",
+                  size: 15 + Math.min((box.features?.events?.length || 0) * 2, 20),
+                  details: {
+                    topic: box.features?.topic,
+                    keywords: box.features?.keywords,
+                    history
+                  }
+                });
+              } else {
+                box.features?.events?.forEach((ev, idx) => {
+                  nodes.push({
+                    id: `ev_${box.box_id}_${idx}`,
+                    label: ev.length > 30 ? ev.substring(0, 30) + "..." : ev,
+                    type: "event",
+                    details: { event: ev }
+                  });
+                });
               }
+            } catch (e) {
             }
+          });
+        }
+        if (fs11.existsSync(tracesFile)) {
+          const fileContent = await fs11.promises.readFile(tracesFile, "utf-8");
+          const lines = fileContent.trim().split("\n").filter(Boolean);
+          lines.forEach((line) => {
             try {
-              if (action.type === "create_file") {
-                const BOM = "\uFEFF";
-                fs12.writeFileSync(action.path, BOM + (action.content || ""), "utf-8");
-                tui.log.success(`\u2705 Created: ${action.path}`);
-                executionResults += `[Action create_file]: Success.
-`;
-              } else if (action.type === "modify_file") {
-                if (action.target_content) {
-                  const success = startSmartReplace(action.path, action.content || "", action.target_content, tui);
-                  if (success) {
-                    executionResults += `[Action modify_file]: Success.
-`;
-                    specUpdated = true;
-                  } else {
-                    executionResults += `[Action modify_file]: Failed. Target content not found or ambiguous.
-`;
+              const trace = JSON.parse(line);
+              if (graphMode === "boxes") {
+                const boxIds = trace.box_ids || [];
+                const entries = trace.entries || [];
+                for (let i = 0; i < boxIds.length - 1; i++) {
+                  const entry = entries.find((e) => e.box_id === boxIds[i + 1]);
+                  edges.push({
+                    from: `box_${boxIds[i]}`,
+                    to: `box_${boxIds[i + 1]}`,
+                    label: `Trace ${trace.trace_id}`,
+                    arrows: "to",
+                    similarity: entry?.similarity ?? 1
+                  });
+                }
+              } else {
+                const traceEventIds = [];
+                const entries = trace.entries || [];
+                const eventSimilarities = [];
+                entries.forEach((entry) => {
+                  if (entry?.events) {
+                    entry.events.forEach((_, idx) => {
+                      traceEventIds.push(`ev_${entry.box_id}_${idx}`);
+                      eventSimilarities.push(entry.similarity ?? 1);
+                    });
                   }
-                } else {
-                  executionResults += `[Action modify_file]: Failed. 'target_content' is required.
-`;
+                });
+                for (let i = 0; i < traceEventIds.length - 1; i++) {
+                  edges.push({
+                    from: traceEventIds[i],
+                    to: traceEventIds[i + 1],
+                    label: `Trace ${trace.trace_id}`,
+                    arrows: "to",
+                    similarity: eventSimilarities[i + 1] ?? 1
+                  });
                 }
               }
             } catch (e) {
-              executionResults += `[Action ${action.type}]: Error: ${e.message}
-`;
             }
-          }
-        }
-        if (lastResponse.message && lastResponse.message.includes("PHASE_COMPLETED")) {
-          const extraContext = executionResults ? `
-
-Resultados das \xFAltimas a\xE7\xF5es executadas antes da conclus\xE3o:
-${executionResults}` : "";
-          if (currentPhase === 1) {
-            currentPhase = 2;
-            tui.log.success(`\u2705 Fase 1 Conclu\xEDda. Iniciando Fase 2 (Investiga\xE7\xE3o).`);
-            nextPrompt = `[System Message]
-Voc\xEA completou a FASE 1 com sucesso.
-
-**VOC\xCA AGORA EST\xC1 NA FASE 2: INVESTIGA\xC7\xC3O**
-- Use \`search_code\` e \`list_files\` para explorar os arquivos relevantes \xE0 tarefa.
-- Prefira \`search_code\` em vez de \`read_file\` para buscar c\xF3digo sem inflar o contexto.
-- N\xC3O leia o projeto inteiro de forma gen\xE9rica.
-- REGRA DE OURO (READ-FIRST): Voc\xEA N\xC3O PODE referenciar um arquivo na especifica\xE7\xE3o t\xE9cnica que n\xE3o tenha investigado nesta fase.
-- Quando achar que possui toda a clareza t\xE9cnica sobre onde e o que deve ser feito no c\xF3digo, emita "PHASE_COMPLETED" no summary.${extraContext}`;
-            continue;
-          } else if (currentPhase === 2) {
-            currentPhase = 3;
-            tui.log.success(`\u2705 Fase 2 Conclu\xEDda. Iniciando Fase 3 (Preenchimento).`);
-            nextPrompt = `[System Message]
-Voc\xEA completou a FASE 2 com sucesso.
-
-**VOC\xCA AGORA EST\xC1 NA FASE 3: PREENCHIMENTO DO TEMPLATE**
-- Use \`modify_file\` no arquivo \`${targetPath}\` para substituir os placeholders pelo conte\xFAdo real levantado na fase de investiga\xE7\xE3o.
-- As se\xE7\xF5es 1-4 devem descrever o contexto da TAREFA, e n\xE3o o projeto como um todo.
-- Passos de Implementa\xE7\xE3o (Implementation Steps): APENAS checkboxes markdown: \`- [ ] [Verbo de A\xE7\xE3o] [O Que] em [Caminho Relativo]\`.
-- Quando TODOS os placeholders ([TO BE ANALYZED...] ou [TO BE FILLED]) forem substitu\xEDdos e o trabalho conclu\xEDdo, emita "SPEC_UPDATED: Complete" no summary para finalizar.${extraContext}`;
-            continue;
-          }
-        }
-        if (lastResponse.message && lastResponse.message.includes("SPEC_UPDATED:")) {
-          if (currentPhase < 3) {
-            tui.log.warning(`O agente tentou finalizar prematuramente. For\xE7ando retorno para a fase atual...`);
-            nextPrompt = `[System Error]: Voc\xEA tentou finalizar a especifica\xE7\xE3o prematuramente emitindo SPEC_UPDATED, mas ainda est\xE1 na Fase ${currentPhase}. Voc\xEA s\xF3 pode finalizar quando estiver na Fase 3.
-
-Continue seu trabalho na Fase ${currentPhase} ou emita "PHASE_COMPLETED" se terminou esta etapa atual.`;
-            continue;
-          }
-          const content = 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";
-            tui.log.warning(`O agente tentou concluir prematuramente, mas h\xE1 placeholders pendentes. For\xE7ando retorno...`);
-            nextPrompt = `[System Error]: A valida\xE7\xE3o falhou e o bloqueio autom\xE1tico foi acionado.
-Voc\xEA tentou concluir a tarefa, mas o arquivo AINDA possui placeholders '[TO BE ANALYZED...]' ou '[TO BE FILLED]'.
-As seguintes se\xE7\xF5es ainda cont\xEAm estes placeholders: ${missing}.
-Voc\xEA \xE9 OBRIGADO a usar a action \`modify_file\` para preencher o conte\xFAdo de cada uma dessas se\xE7\xF5es. Use o placeholder exato no campo \`target_content\`. N\xC3O repita a conclus\xE3o da tarefa at\xE9 corrigir todas as pend\xEAncias.`;
-            continue;
-          } else {
-            const updateSummary = lastResponse.message.split("SPEC_UPDATED:")[1].trim();
-            tui.log.success(`\u2705 Spec Finalized: ${updateSummary}`);
-            return;
-          }
-        }
-        if (executionResults) {
-          FileLogger.log("TOOL_EXECUTION", "Specification Agent Actions Output", { executionResults });
-        }
-        if (hasSystemError) {
-          nextPrompt = systemErrorContent;
-        } else if (waitingForUser) {
-          const userReply = await tui.text({ message: "Your answer", placeholder: "Type your answer..." });
-          if (tui.isCancel(userReply)) {
-            keepGoing = false;
-            return;
-          }
-          FileLogger.log("USER_INPUT", "User response to specification agent", { userReply });
-          nextPrompt = `${executionResults}
-
-User Reply: ${userReply}`;
-        } else if (executionResults) {
-          const content = fs12.existsSync(targetPath) ? fs12.readFileSync(targetPath, "utf-8") : "";
-          let systemMsg = "Execu\xE7\xE3o da ferramenta conclu\xEDda.";
-          if (specUpdated) {
-            if (content.includes("[TO BE")) {
-              const pendingMatches = [...content.matchAll(/## ([^\n]+)[\s\S]*?\[TO BE/g)].map((m) => m[1]);
-              let missing = pendingMatches.length > 0 ? pendingMatches.join(", ") : "v\xE1rias se\xE7\xF5es";
-              systemMsg += `
-[System]: Se\xE7\xE3o atualizada com sucesso. A valida\xE7\xE3o detectou que AINDA H\xC1 placeholders pendentes ('[TO BE...]') nas seguintes se\xE7\xF5es: ${missing}.
-Por favor, envie uma nova action \`modify_file\` focada em uma destas se\xE7\xF5es obrigatoriamente. USE o respectivo placeholder no campo \`target_content\` para que o replace funcione.`;
-            } else {
-              systemMsg += "\n[System]: O arquivo parece completo! Se estiver satisfeito e possuir TODAS as implementa\xE7\xF5es descritas, retorne 'SPEC_UPDATED: Complete'.";
-            }
-          } else {
-            systemMsg += "\n[System]: A modifica\xE7\xE3o do arquivo falhou. Verifique se o `target_content` que voc\xEA usou existe EXATAMENTE como no arquivo e se ele \xE9 \xDANICO na hora de usar a action `modify_file`.";
-          }
-          nextPrompt = `${executionResults}
-
-${systemMsg}`;
-        } else {
-          if (lastResponse.message) {
-            tui.log.info(colors.primary("\u{1F916} Architect (Message only):"));
-            console.log(lastResponse.message);
-            const userReply = await tui.text({ message: "Your answer:" });
-            if (tui.isCancel(userReply)) {
-              keepGoing = false;
-              break;
-            }
-            FileLogger.log("USER_INPUT", "User response to specification agent (Message only)", { userReply });
-            nextPrompt = userReply;
-          } else {
-            keepGoing = false;
-          }
+          });
         }
-      } else {
-        tui.log.warning("No actions received.");
-        keepGoing = false;
+      } catch (e) {
+        console.error("Error parsing memory graph files:", e);
       }
-    } catch (error) {
-      spinner.stop("Error");
-      tui.log.error(error.message);
-      keepGoing = false;
+      const activeNodeList = Date.now() - activeNodesTimestamp < 15e3 ? activeNodes : [];
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ nodes, edges, activeNodes: activeNodeList }));
+      return;
     }
-  }
-}
-async function callSpecAgentApi(prompt, onChunk, agentId) {
-  const conversationId = await conversationManager.getConversationId(AGENT_TYPE2);
-  FileLogger.log("AGENT", "Calling Agent API", { agentId, conversationId });
-  const provider = ProviderResolver.getProvider("specification_agent");
-  if (agentId && "agentId" in provider) {
-    provider.agentId = agentId;
-  }
-  const parsed = await provider.streamChat(prompt, {
-    conversationId,
-    agentType: "specification_agent",
-    onChunk
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found");
   });
-  if (parsed.conversation_id) {
-    await conversationManager.saveConversationId(AGENT_TYPE2, parsed.conversation_id);
-  }
-  return parsed;
-}
-
-// src/commands/legacy.ts
-var legacyCommand = new Command3("legacy").description("Starts the Legacy Developer Agent task orchestration loop").option("-t, --task <type>", "Initial task description (Quick Mode)").option("-c, --context <path>", "Path to custom context file").action(async (options) => {
-  const taskManager = new TaskManager(process.cwd());
-  let state = taskManager.analyzeSpecState();
-  if (state.status === "MISSING") {
-    tui.log.warning("\u{1F4CB} No tech-spec.md found.");
-    const confirm = await tui.confirm({ message: "Create a new Specification (Tech Spec)?" });
-    if (confirm) {
-      await interactiveSpecificationAgent({
-        briefingPath: options.task ? void 0 : void 0
-      });
-      state = taskManager.analyzeSpecState();
-      if (state.status === "MISSING") {
-        tui.log.error("\u274C Spec creation aborted or failed.");
-        return;
+  const startServer = (p) => {
+    server.listen(p, () => {
+      const url = `http://localhost:${p}/?mode=${mode}`;
+      console.log(colors.success(`\u{1F680} Memory Graph Server active at: ${url}`));
+      const runDir = path11.join(process.cwd(), ".shark", "membox");
+      if (!fs11.existsSync(runDir)) {
+        fs11.mkdirSync(runDir, { recursive: true });
       }
-    } else {
-      return;
-    }
-  }
-  let keepOrchestrating = true;
-  let burnMode = false;
-  let contextHistory = "";
-  tui.intro("\u{1F988} Shark Legacy Orchestrator");
-  while (keepOrchestrating) {
-    state = taskManager.analyzeSpecState();
-    if (state.status === "COMPLETED") {
-      tui.log.success("\u{1F389} All tasks in tech-spec.md are COMPLETED!");
-      const choice = await tui.select({
-        message: "What next?",
-        options: [
-          { value: "exit", label: "Exit" },
-          { value: "new_spec", label: "New Specification (Reset)" }
-        ]
-      });
-      if (choice === "new_spec") {
-        await interactiveSpecificationAgent();
-        contextHistory = "";
-        continue;
+      fs11.writeFileSync(
+        path11.join(runDir, "graph-server.json"),
+        JSON.stringify({ active: true, port: p, timestamp: Date.now() }),
+        "utf-8"
+      );
+      if (process.platform === "win32") {
+        exec3(`start "" "${url}"`);
+      } else if (process.platform === "darwin") {
+        exec3(`open "${url}"`);
       } else {
-        keepOrchestrating = false;
-        break;
+        exec3(`xdg-open "${url}"`);
       }
-    }
-    const currentTask = state.nextTask;
-    if (!currentTask) {
-      tui.log.error("Something went wrong. Status is not completed but no next task found.");
-      break;
-    }
-    tui.log.info(`
-\u{1F449} **NEXT TASK**: ${colors.bold(currentTask.description)}`);
-    if (!burnMode) {
-      const action = await tui.select({
-        message: "Orchestration Checkpoint:",
-        options: [
-          { value: "execute", label: "\u{1F680} Execute Task (Start)" },
-          { value: "burn", label: "\u{1F525} Burn Mode (Auto-Execute Remaining)" },
-          { value: "pivot", label: "\u{1F527} Pivot/Correct (Edit Spec)" },
-          { value: "skip", label: "\u23ED\uFE0F Skip Task (Mark Done without Executing)" },
-          { value: "stop", label: "\u{1F6D1} Stop Session" }
-        ]
-      });
-      if (action === "stop") {
-        keepOrchestrating = false;
-        break;
-      } else if (action === "burn") {
-        burnMode = true;
-      } else if (action === "skip") {
-        taskManager.markTaskAsDone(currentTask.id);
-        tui.log.info("Task skipped.");
-        continue;
-      } else if (action === "pivot") {
-        tui.log.info("Transferring control to Specification Agent...");
-        await interactiveSpecificationAgent({
-          initialContext: `User requested pivot after tasks:
-${contextHistory}`
-        });
-        continue;
-      }
-    }
-    taskManager.markTaskInProgress(currentTask.id);
-    tui.log.info(`\u26A1 Starting Micro-Context for Task: "${currentTask.description}"`);
-    const result = await interactiveDeveloperAgent2({
-      taskId: currentTask.id,
-      taskInstruction: currentTask.description,
-      history: contextHistory,
-      context: options.context
     });
-    if (result.success) {
-      tui.log.success(`\u2705 Task Completed: ${currentTask.description}`);
-      taskManager.markTaskAsDone(currentTask.id);
-      contextHistory += `
-[Task "${currentTask.description}" completed]: ${result.summary}`;
+  };
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.log(colors.secondary(`\u26A0\uFE0F Port ${port} is busy. Retrying next port...`));
+      port++;
+      startServer(port);
     } else {
-      tui.log.error(`\u274C Task Failed: ${result.summary}`);
-      burnMode = false;
-      const recovery = await tui.select({
-        message: "Task Failed. Recovery Action:",
-        options: [
-          { value: "retry", label: "Retry (Run Agent Again)" },
-          { value: "pivot", label: "Pivot (Adjust Spec/Instructions)" },
-          { value: "ignore", label: "Ignore (Mark Done anyway)" },
-          { value: "stop", label: "Stop" }
-        ]
-      });
-      if (recovery === "stop") break;
-      if (recovery === "ignore") taskManager.markTaskAsDone(currentTask.id);
-      if (recovery === "pivot") {
-        await interactiveSpecificationAgent({
-          initialContext: `Task "${currentTask.description}" FAILED.
-Error: ${result.summary}
-History:
-${contextHistory}`
-        });
-      }
+      console.error(colors.error("\u274C Server startup error:"), err);
     }
-  }
-  tui.outro("\u{1F988} Legacy Orchestration Finished.");
-});
-
-// src/commands/export-schema.ts
-import { Command as Command4 } from "commander";
-var exportSchemaCommand = new Command4("export-schema").description("Outputs the agent response JSON Schema").action(() => {
-  console.log(JSON.stringify(AGENT_RESPONSE_JSON_SCHEMA, null, 2));
-});
-
-// src/commands/export-prompt.ts
-import { Command as Command5 } from "commander";
-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 = 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 {
+  });
+  const cleanup = () => {
     try {
-      await fs13.rm(targetPath, { recursive: true, force: true });
+      const runDir = path11.join(process.cwd(), ".shark", "membox");
+      const file = path11.join(runDir, "graph-server.json");
+      if (fs11.existsSync(file)) {
+        fs11.unlinkSync(file);
+      }
     } catch {
     }
-    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 Command6("super").description("Install Superpowers skills globally or locally").option("-l, --local", "Install skills locally in the current project under .agents/skills").action(superCommandAction);
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  startServer(port);
+});
 
 // src/bin/shark.ts
 crashHandler.init();
@@ -5650,10 +4577,10 @@ program.name("shark").description("Shark CLI: AI-Native Collaborative Developmen
 program.addCommand(loginCommand);
 program.addCommand(initCommand);
 program.addCommand(devCommand);
-program.addCommand(legacyCommand);
 program.addCommand(exportSchemaCommand);
 program.addCommand(exportPromptCommand);
 program.addCommand(superCommand);
+program.addCommand(graphCommand);
 program.command("config").description("Manage global configuration").action(configCommand.action);
 process.on("unhandledRejection", (err) => {
   console.error(colors.error("\u274C Unhandled Error:"), err);