shark-ai 0.4.26 → 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",
@@ -370,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(),
@@ -538,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));
@@ -589,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;
@@ -617,7 +662,11 @@ function extractFirstJson(str) {
             try {
               return JSON.parse(potentialJson);
             } catch (innerE) {
-              throw e;
+              try {
+                return JSON.parse(jsonrepair(potentialJson));
+              } catch {
+                throw e;
+              }
             }
           }
         }
@@ -921,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();
@@ -1003,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) {
@@ -1054,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) => {
@@ -1064,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);
     }
@@ -1071,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;
@@ -1119,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({
@@ -1128,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
     };
@@ -1140,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 {
@@ -1326,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;
@@ -1395,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;
@@ -1404,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 {
@@ -1499,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();
@@ -2515,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();
@@ -2531,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);
@@ -2548,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;
@@ -2559,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);
@@ -2605,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) => {
@@ -3065,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 });
@@ -3139,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");
@@ -3165,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 {
@@ -3238,458 +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();
-  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";
-      }
-    }
-  }
-  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 seq = (this.messageSeq++).toString().padStart(6, "0");
-    const filePath = path9.join(mailboxDir, `${Date.now()}-${seq}-${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) {
       }
@@ -3712,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);
       }
@@ -3760,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.
 `;
@@ -3818,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);
           }
@@ -3844,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);
             }
@@ -3947,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}`,
@@ -3976,7 +3204,7 @@ async function waitForInputOrNotification(queue, promptMessage = "Your answer:",
   let cancelled = false;
   let resolvePromptPromise = null;
   let timerId = null;
-  const promises = [];
+  const promises2 = [];
   if (!isAuto) {
     const promptPromise = new Promise((resolve2) => {
       resolvePromptPromise = resolve2;
@@ -3995,10 +3223,10 @@ async function waitForInputOrNotification(queue, promptMessage = "Your answer:",
       }
     };
     runPrompt();
-    promises.push(promptPromise);
+    promises2.push(promptPromise);
   }
   const queuePromise = queue.next();
-  promises.push(queuePromise);
+  promises2.push(queuePromise);
   if (timeoutMs !== void 0 && timeoutMs !== null) {
     const timeoutPromise = new Promise((resolve2) => {
       timerId = setTimeout(() => {
@@ -4012,9 +3240,9 @@ 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);
   }
@@ -4071,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}`);
     }
@@ -4121,6 +3349,41 @@ Your goal is to address the user's request:
   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";
@@ -4171,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: () => {
           }
         });
@@ -4351,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}`;
@@ -4373,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) {
@@ -4704,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";
@@ -4718,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,
@@ -4740,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/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/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/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 += `
-
---- PREVIOUS EXECUTION SUMMARY ---
-${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";
 
-\u{1F7E2} EXECUTION MODE
+// 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>
 
-You are a highly skilled Developer Agent.
-\u{1F449} **CURRENT TASK**: "${currentTask}"
+    <!-- Main Content -->
+    <div class="flex-1 flex relative">
+        <!-- Canvas -->
+        <div id="network" class="flex-1 h-full"></div>
 
-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}
+        <!-- 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>
 
-`;
-          } 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}
+        <!-- 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 === "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
+        }
 
-` : `[Action modify_file]: Failed
+        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 }
+                };
+            }));
 
-`;
-              }
-              const val = await validateTypeScript(path11.resolve(projectRoot, filePath));
-              if (!val.valid) executionResults += `[Validation Failed]: ${val.error}
+            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 }
+                };
+            }));
 
-`;
+            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;
-      }
-    }
-    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;
+        exec3(`xdg-open "${url}"`);
       }
-    }
-    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();
@@ -5738,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);