openfox 0.1.0 → 0.2.1

package/dist/{chunk-IKAWIOXM.js → chunk-FUUYYDVG.js}

@@ -9,7 +9,7 @@ import {
 import {
   createServerMessage,
   isClientMessage
-} from "./chunk-IVHCPQO2.js";
+} from "./chunk-ARFK3RZW.js";
 import {
   streamWithSegments
 } from "./chunk-26NRL3HX.js";
@@ -237,7 +237,8 @@ function storedEventToServerMessage(event) {
         ...data.subAgentType ? { subAgentType: data.subAgentType } : {},
         ...data.isSystemGenerated ? { isSystemGenerated: data.isSystemGenerated } : {},
         ...data.messageKind ? { messageKind: data.messageKind } : {},
-        ...data.isCompactionSummary ? { isCompactionSummary: data.isCompactionSummary } : {}
+        ...data.isCompactionSummary ? { isCompactionSummary: data.isCompactionSummary } : {},
+        ...data.attachments ? { attachments: data.attachments } : {}
       };
       return createChatMessageMessage(message);
     }
@@ -584,8 +585,8 @@ var PathAccessDeniedError = class extends Error {
 };
 var pendingConfirmations = /* @__PURE__ */ new Map();
 function registerPathConfirmation(callId, paths, sessionId) {
-  return new Promise((resolve7, reject) => {
-    pendingConfirmations.set(callId, { resolve: resolve7, reject, paths, sessionId });
+  return new Promise((resolve8, reject) => {
+    pendingConfirmations.set(callId, { resolve: resolve8, reject, paths, sessionId });
   });
 }
 function providePathConfirmation(callId, approved) {
@@ -829,21 +830,24 @@ var readFileTool = createTool(
     const mimeType = detectImageType(rawBuffer, args.path);
     if (mimeType) {
       const base64Data = rawBuffer.toString("base64");
+      const dataUrl = `data:${mimeType};base64,${base64Data}`;
       const contentHash2 = await computeFileHash(fullPath);
       if (contentHash2) {
         context.sessionManager.recordFileRead(context.sessionId, fullPath, contentHash2);
       }
-      return {
-        success: true,
-        durationMs: Date.now() - startTime,
-        truncated: false,
-        metadata: {
-          mimeType,
-          size: rawBuffer.length,
-          base64Data,
-          path: fullPath
+      return helpers.success(
+        `[Image: ${args.path} (${mimeType}, ${rawBuffer.length} bytes)]`,
+        false,
+        {
+          metadata: {
+            mimeType,
+            size: rawBuffer.length,
+            base64Data,
+            dataUrl,
+            path: fullPath
+          }
         }
-      };
+      );
     }
     const content = rawBuffer.toString("utf-8");
     const lines = content.split("\n");
@@ -1178,13 +1182,13 @@ async function terminateProcessTree(proc, options) {
     return;
   }
   if (process.platform === "win32") {
-    await new Promise((resolve7) => {
+    await new Promise((resolve8) => {
       const killer = spawn("taskkill", ["/pid", String(pid), "/f", "/t"], {
         stdio: "ignore",
         windowsHide: true
       });
-      killer.once("exit", () => resolve7());
-      killer.once("error", () => resolve7());
+      killer.once("exit", () => resolve8());
+      killer.once("error", () => resolve8());
     });
     return;
   }
@@ -1301,7 +1305,7 @@ ${result.stderr}`;
   }
 );
 function executeCommand(command, cwd, timeout, signal, onProgress) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     if (signal?.aborted) {
       reject(new Error("Command aborted before execution"));
       return;
@@ -1351,7 +1355,7 @@ function executeCommand(command, cwd, timeout, signal, onProgress) {
         let output = stdout.trim();
         if (output) output += "\n\n";
         output += "[interrupted by user]";
-        resolve7({
+        resolve8({
           stdout: output,
           stderr: stderr.trim(),
           exitCode: 130
@@ -1359,7 +1363,7 @@ function executeCommand(command, cwd, timeout, signal, onProgress) {
         });
         return;
       }
-      resolve7({
+      resolve8({
         stdout: stdout.trim(),
         stderr: stderr.trim(),
         exitCode: code ?? 1
@@ -1661,7 +1665,7 @@ ${result.stderr}`;
   }
 };
 function executeGitCommand(command, cwd, signal) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     if (signal?.aborted) {
       reject(new Error("Git command aborted before execution"));
       return;
@@ -1693,14 +1697,14 @@ function executeGitCommand(command, cwd, signal) {
       exited = true;
       signal?.removeEventListener("abort", onAbort);
       if (aborted) {
-        resolve7({
+        resolve8({
           stdout: stdout.trim() + "\n[interrupted by user]",
           stderr: stderr.trim(),
           exitCode: 130
         });
         return;
       }
-      resolve7({
+      resolve8({
         stdout: stdout.trim(),
         stderr: stderr.trim(),
         exitCode: code ?? 1
@@ -1715,13 +1719,13 @@ function executeGitCommand(command, cwd, signal) {
 
 // src/server/utils/async.ts
 function createDeferred() {
-  let resolve7;
+  let resolve8;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve7 = res;
+    resolve8 = res;
     reject = rej;
   });
-  return { promise, resolve: resolve7, reject };
+  return { promise, resolve: resolve8, reject };
 }
 var EventEmitter = class {
   listeners = /* @__PURE__ */ new Map();
@@ -2416,7 +2420,8 @@ function parseAgentFile(raw, filename) {
     description: String(meta["description"] ?? ""),
     subagent: meta["subagent"] === true,
     tools: Array.isArray(meta["tools"]) ? meta["tools"].map(String) : [],
-    ...typeof meta["color"] === "string" ? { color: meta["color"] } : {}
+    ...typeof meta["color"] === "string" ? { color: meta["color"] } : {},
+    ...Array.isArray(meta["results"]) ? { results: meta["results"].map(String) } : {}
   };
   return { metadata, prompt: content.trim() };
 }
@@ -2733,6 +2738,8 @@ var COMPACTION_PROMPT = `Summarize the conversation history concisely, preservin
 2. All errors encountered and how they were resolved
 3. Current progress on each task
 4. Any important decisions or learnings
+5. Next steps or pending actions that should be continued after compaction
+6. The user's current question, prompt, or active request
 
 Be thorough but concise. Output as a structured summary.
 
@@ -3239,8 +3246,8 @@ var EventStore = class {
         if (queued) {
           return { value: queued, done: false };
         }
-        return new Promise((resolve7) => {
-          resolveNext = resolve7;
+        return new Promise((resolve8) => {
+          resolveNext = resolve8;
         });
       },
       async return() {
@@ -3741,14 +3748,25 @@ function buildContextMessagesFromStoredEvents(events, windowId, options) {
       case "tool.result": {
         const data = event.data;
         if (messageMap.has(data.messageId)) {
-          messages.push({
+          const imageMeta = data.result.metadata;
+          const msg = {
             id: `tool-${data.toolCallId}`,
             role: "tool",
             content: data.result.success ? data.result.output ?? "Success" : data.result.output ? `${data.result.output}
 
 Error: ${data.result.error}` : `Error: ${data.result.error}`,
             toolCallId: data.toolCallId
-          });
+          };
+          if (imageMeta?.dataUrl && imageMeta?.mimeType?.startsWith("image/")) {
+            msg.attachments = [{
+              id: crypto.randomUUID(),
+              filename: imageMeta.path ?? "image",
+              mimeType: imageMeta.mimeType,
+              size: imageMeta.size ?? 0,
+              data: imageMeta.dataUrl
+            }];
+          }
+          messages.push(msg);
         }
         break;
       }
@@ -4430,26 +4448,6 @@ function assembleAgentRequest(input) {
 }
 
 // src/server/context/auto-compaction.ts
-var MIN_SUMMARY_LENGTH = 50;
-var compactionCooldowns = /* @__PURE__ */ new Map();
-var COOLDOWN_BASE_MS = 3e4;
-var MAX_COOLDOWN_MS = 3e5;
-function isInCooldown(sessionId) {
-  const cooldown = compactionCooldowns.get(sessionId);
-  if (!cooldown) return false;
-  const backoff = Math.min(COOLDOWN_BASE_MS * Math.pow(2, cooldown.attempts - 1), MAX_COOLDOWN_MS);
-  return Date.now() - cooldown.failedAt < backoff;
-}
-function recordCooldown(sessionId) {
-  const prev = compactionCooldowns.get(sessionId);
-  compactionCooldowns.set(sessionId, {
-    failedAt: Date.now(),
-    attempts: (prev?.attempts ?? 0) + 1
-  });
-}
-function clearCooldown(sessionId) {
-  compactionCooldowns.delete(sessionId);
-}
 function getCurrentWindowMessageOptions(sessionId) {
   const contextWindowId = getCurrentContextWindowId(sessionId);
   return contextWindowId ? { contextWindowId } : void 0;
@@ -4470,20 +4468,12 @@ async function maybeAutoCompactContext(options) {
   if (!shouldCompact(contextState.currentTokens, contextState.maxTokens, config.context.compactionThreshold)) {
     return false;
   }
-  if (isInCooldown(options.sessionId)) {
-    logger.warn("Skipping auto-compaction (in cooldown after previous failure)", {
-      sessionId: options.sessionId,
-      currentTokens: contextState.currentTokens
-    });
-    return false;
-  }
   try {
     await performContextCompaction({
       ...options,
       tokenCountAtClose: contextState.currentTokens,
       trigger: "auto"
     });
-    clearCooldown(options.sessionId);
     return true;
   } catch (error) {
     if (error instanceof Error && error.message === "Aborted") {
@@ -4495,7 +4485,6 @@ async function maybeAutoCompactContext(options) {
       currentTokens: contextState.currentTokens,
       maxTokens: contextState.maxTokens
     });
-    recordCooldown(options.sessionId);
     const eventStore = getEventStore();
     eventStore.append(options.sessionId, {
       type: "chat.error",
@@ -4548,7 +4537,6 @@ async function performContextCompaction(options) {
     subAgentDefs,
     workdir: session.workdir,
     messages: requestMessages,
-    includeRuntimeReminder: false,
     injectedFiles,
     promptTools: [],
     requestTools: [],
@@ -4556,6 +4544,13 @@ async function performContextCompaction(options) {
     disableThinking: true,
     ...instructions ? { customInstructions: instructions } : {}
   });
+  const compactionReminder = `<system-reminder>
+${COMPACTION_PROMPT}
+</system-reminder>`;
+  const llmMessages = [
+    ...assembledRequest.messages,
+    { role: "user", content: compactionReminder }
+  ];
   const compactPromptMsgId = crypto.randomUUID();
   eventStore.append(sessionId, createMessageStartEvent(compactPromptMsgId, "user", COMPACTION_PROMPT, {
     ...getCurrentWindowMessageOptions(sessionId) ?? {},
@@ -4573,7 +4568,7 @@ async function performContextCompaction(options) {
       messageId: assistantMsgId,
       systemPrompt: assembledRequest.systemPrompt,
       llmClient,
-      messages: [...assembledRequest.messages, ...correctionMessages],
+      messages: [...llmMessages, ...correctionMessages],
       tools: [],
       toolChoice: "none",
       disableThinking: true,
@@ -4611,10 +4606,8 @@ async function performContextCompaction(options) {
     logger.info("Using thinking content as compaction summary (text content was empty)", { sessionId });
     summary = result.thinkingContent.trim();
   }
-  if (!summary || summary.length < MIN_SUMMARY_LENGTH) {
-    throw new Error(
-      `Compaction produced insufficient summary (length=${summary.length}, completionTokens=${result.usage.completionTokens}). The model may not support the required context size.`
-    );
+  if (!summary) {
+    throw new Error("Compaction produced empty summary");
   }
   sessionManager.compactContext(sessionId, summary, tokenCountAtClose);
   logger.info(`${trigger === "auto" ? "Auto" : "Manual"} compaction complete`, {
@@ -4816,6 +4809,7 @@ async function executeToolBatch(assistantMsgId, toolCalls, ctx) {
   const toolMessages = [];
   let criteriaChanged = false;
   let returnValueContent;
+  let returnValueResult;
   let session = ctx.sessionManager.requireSession(ctx.sessionId);
   for (const toolCall of toolCalls) {
     if (ctx.signal?.aborted) {
@@ -4870,6 +4864,7 @@ async function executeToolBatch(assistantMsgId, toolCalls, ctx) {
     ctx.onToolExecuted?.(toolCall, toolResult);
     if (toolCall.name === "return_value" && !toolCall.parseError) {
       returnValueContent = toolCall.arguments["content"];
+      returnValueResult = toolCall.arguments["result"];
     }
     toolMessages.push({
       role: "tool",
@@ -4886,7 +4881,7 @@ Error: ${toolResult.error}` : `Error: ${toolResult.error}`,
       criteriaChanged = true;
     }
   }
-  return { toolMessages, criteriaChanged, returnValueContent };
+  return { toolMessages, criteriaChanged, returnValueContent, returnValueResult };
 }
 var MAX_FORMAT_RETRIES2 = 10;
 var FORMAT_CORRECTION_PROMPT2 = `IMPORTANT: You MUST use the JSON function calling API. Do NOT output XML tags like <tool_call>, <function=>, or <parameter=>. Your previous attempt was stopped because you used the wrong format. Use the proper tool_calls format.`;
@@ -4904,6 +4899,8 @@ async function runTopLevelAgentLoop(config, turnMetrics) {
   const { mode, sessionManager, sessionId, llmClient, signal, onMessage, statsIdentity } = config;
   const eventStore = getEventStore();
   let formatRetryCount = 0;
+  let returnValueContent;
+  let returnValueResult;
   for (; ; ) {
     await maybeAutoCompactContext({
       sessionManager,
@@ -4912,11 +4909,13 @@ async function runTopLevelAgentLoop(config, turnMetrics) {
       statsIdentity,
       ...signal ? { signal } : {}
     });
+    if (signal?.aborted) throw new Error("Aborted");
     const session = sessionManager.requireSession(sessionId);
     if (formatRetryCount === 0) {
       config.injectKickoff?.();
     }
     const { content: instructionContent, files } = await getAllInstructions(session.workdir, session.projectId);
+    if (signal?.aborted) throw new Error("Aborted");
     const injectedFiles = files.map((f) => ({
       path: f.path,
       content: f.content ?? "",
@@ -4937,6 +4936,7 @@ async function runTopLevelAgentLoop(config, turnMetrics) {
     }
     const configDir = getGlobalConfigDir(getRuntimeConfig().mode ?? "production");
     const skills = await getEnabledSkillMetadata(configDir);
+    if (signal?.aborted) throw new Error("Aborted");
     const assembledRequest = config.assembleRequest({
       workdir: session.workdir,
       messages: requestMessages,
@@ -4991,7 +4991,7 @@ async function runTopLevelAgentLoop(config, turnMetrics) {
         promptContext: assembledRequest.promptContext
       }));
       try {
-        await executeToolBatch(assistantMsgId, result.toolCalls, {
+        const batchResult = await executeToolBatch(assistantMsgId, result.toolCalls, {
           toolRegistry,
           sessionManager,
           sessionId,
@@ -5003,6 +5003,12 @@ async function runTopLevelAgentLoop(config, turnMetrics) {
           statsIdentity,
           onToolExecuted: config.onToolExecuted
         });
+        if (batchResult.returnValueContent) {
+          returnValueContent = batchResult.returnValueContent;
+        }
+        if (batchResult.returnValueResult) {
+          returnValueResult = batchResult.returnValueResult;
+        }
       } catch (error) {
         if (error instanceof Error && error.message === "Aborted") {
           const stats2 = turnMetrics.buildStats(statsIdentity, mode);
@@ -5050,13 +5056,17 @@ async function runTopLevelAgentLoop(config, turnMetrics) {
     eventStore.append(sessionId, createChatDoneEvent(assistantMsgId, "complete", stats));
     break;
   }
+  return {
+    ...returnValueContent ? { returnValueContent } : {},
+    ...returnValueResult ? { returnValueResult } : {}
+  };
 }
 
 // src/server/sub-agents/manager.ts
 var RETURN_VALUE_INSTRUCTION = `
 
 ## RETURN VALUE
-As the very last thing you do, call \`return_value\` with a structured summary of your work. This is how your findings get passed back to the calling agent. Do not finish without calling return_value.`;
+As the very last thing you do, call \`return_value\` ONCE with a structured summary of your work. This is how your findings get passed back to the calling agent. Do not finish without calling return_value.`;
 var RETURN_VALUE_NUDGE = "You must call return_value with a summary of your findings before finishing. Call return_value now.";
 async function resolveAgentDef(agentId) {
   const allAgents = await loadAllAgentsDefault();
@@ -5133,6 +5143,7 @@ async function executeSubAgent(options) {
   let consecutiveEmptyStops = 0;
   let finalContent = "";
   let returnValueContent = null;
+  let returnValueResult = void 0;
   let returnValueNudged = false;
   for (; ; ) {
     if (signal?.aborted) {
@@ -5266,6 +5277,9 @@ async function executeSubAgent(options) {
     if (batchResult.returnValueContent) {
       returnValueContent = batchResult.returnValueContent;
     }
+    if (batchResult.returnValueResult) {
+      returnValueResult = batchResult.returnValueResult;
+    }
     customMessages = [...customMessages, ...batchResult.toolMessages];
     session = sessionManager.requireSession(sessionId);
     if (nudgeConfig) {
@@ -5286,11 +5300,12 @@ async function executeSubAgent(options) {
     }));
     return {
       content: returnValueContent ?? finalContent,
+      ...returnValueResult ? { result: returnValueResult } : {},
       allPassed: failed.length === 0 && remaining.length === 0,
       failed
     };
   }
-  return { content: returnValueContent ?? finalContent };
+  return { content: returnValueContent ?? finalContent, ...returnValueResult ? { result: returnValueResult } : { result: "success" } };
 }
 
 // src/server/tools/sub-agent.ts
@@ -5358,7 +5373,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-R4YQAYUF.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-QMIIDJTV.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -5450,6 +5465,10 @@ var returnValueTool = {
           content: {
             type: "string",
             description: "The return value content \u2014 a structured summary of findings, results, or recommendations"
+          },
+          result: {
+            type: "string",
+            description: 'Result classification (e.g. "passed", "failed", "error"). Used for workflow routing.'
           }
         },
         required: ["content"]
@@ -5604,6 +5623,297 @@ var webFetchTool = createTool(
   }
 );
 
+// src/server/dev-server/manager.ts
+import { spawn as spawn4 } from "child_process";
+import { readFile as readFile8, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
+import { resolve as resolve7, join as join5 } from "path";
+var MAX_LOG_LINES = 2e3;
+var MAX_LOG_BYTES = 1e5;
+var CONFIG_PATH = ".openfox/dev.json";
+var ERROR_PATTERNS = [
+  /EADDRINUSE/,
+  /EACCES/,
+  /ENOENT/,
+  /Error: listen/,
+  /Unhandled 'error' event/,
+  /throw er;.*Unhandled/s,
+  /Cannot find module/,
+  /SyntaxError:/,
+  /MODULE_NOT_FOUND/
+];
+function createInstance() {
+  return {
+    process: null,
+    state: "off",
+    config: null,
+    logs: [],
+    totalLogBytes: 0,
+    errorMessage: void 0,
+    exited: true
+  };
+}
+var DevServerManager = class {
+  instances = /* @__PURE__ */ new Map();
+  outputListeners = /* @__PURE__ */ new Set();
+  stateListeners = /* @__PURE__ */ new Set();
+  resolveWorkdir(workdir) {
+    return resolve7(workdir);
+  }
+  getInstance(workdir) {
+    const key = this.resolveWorkdir(workdir);
+    let instance = this.instances.get(key);
+    if (!instance) {
+      instance = createInstance();
+      this.instances.set(key, instance);
+    }
+    return instance;
+  }
+  emitOutput(workdir, chunk) {
+    const resolved = this.resolveWorkdir(workdir);
+    for (const listener of this.outputListeners) {
+      listener(resolved, chunk);
+    }
+  }
+  emitStateChange(workdir, state, errorMessage) {
+    const resolved = this.resolveWorkdir(workdir);
+    for (const listener of this.stateListeners) {
+      listener(resolved, state, errorMessage);
+    }
+  }
+  async loadConfig(workdir) {
+    try {
+      const configPath = join5(this.resolveWorkdir(workdir), CONFIG_PATH);
+      const raw = await readFile8(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!parsed.command || !parsed.url) return null;
+      return {
+        command: parsed.command,
+        url: parsed.url,
+        hotReload: parsed.hotReload ?? false
+      };
+    } catch {
+      return null;
+    }
+  }
+  async saveConfig(workdir, config) {
+    const resolved = this.resolveWorkdir(workdir);
+    const dirPath = join5(resolved, ".openfox");
+    await mkdir4(dirPath, { recursive: true });
+    const configPath = join5(resolved, CONFIG_PATH);
+    await writeFile5(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  }
+  async start(workdir) {
+    const instance = this.getInstance(workdir);
+    if (instance.state === "running" && instance.process && !instance.exited) {
+      await this.stop(workdir);
+    }
+    const config = await this.loadConfig(workdir);
+    if (!config) {
+      return this.getStatus(workdir);
+    }
+    instance.config = config;
+    instance.logs = [];
+    instance.totalLogBytes = 0;
+    instance.errorMessage = void 0;
+    instance.exited = false;
+    const resolved = this.resolveWorkdir(workdir);
+    const proc = spawn4("sh", ["-c", config.command], {
+      cwd: resolved,
+      env: { ...process.env, FORCE_COLOR: "1" },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true
+    });
+    instance.process = proc;
+    const appendLog = (line) => {
+      instance.logs.push(line);
+      instance.totalLogBytes += line.length;
+      while (instance.logs.length > MAX_LOG_LINES || instance.totalLogBytes > MAX_LOG_BYTES) {
+        const removed = instance.logs.shift();
+        if (removed) instance.totalLogBytes -= removed.length;
+      }
+    };
+    proc.stdout?.on("data", (data) => {
+      const content = data.toString();
+      appendLog(content);
+      this.emitOutput(workdir, { stream: "stdout", content });
+    });
+    proc.stderr?.on("data", (data) => {
+      const content = data.toString();
+      appendLog(content);
+      this.emitOutput(workdir, { stream: "stderr", content });
+      if (instance.state === "running" && ERROR_PATTERNS.some((p) => p.test(content))) {
+        instance.state = "warning";
+        instance.errorMessage = content.trim().slice(0, 500);
+        this.emitStateChange(workdir, "warning", instance.errorMessage);
+      }
+    });
+    proc.on("close", (code) => {
+      instance.exited = true;
+      instance.process = null;
+      if (code !== 0 && code !== null) {
+        const recentLogs = instance.logs.slice(-10).join("");
+        const errorMessage = `Process exited with code ${code}
+${recentLogs}`.trim();
+        instance.state = "error";
+        instance.errorMessage = errorMessage;
+        this.emitStateChange(workdir, "error", errorMessage);
+      } else {
+        instance.state = "off";
+        instance.errorMessage = void 0;
+        this.emitStateChange(workdir, "off", void 0);
+      }
+    });
+    proc.on("error", (err) => {
+      instance.exited = true;
+      instance.process = null;
+      instance.state = "error";
+      instance.errorMessage = err.message;
+      this.emitStateChange(workdir, "error", err.message);
+    });
+    instance.state = "running";
+    instance.errorMessage = void 0;
+    this.emitStateChange(workdir, "running", void 0);
+    logger.info("Dev server started", { workdir, command: config.command });
+    return this.getStatus(workdir);
+  }
+  async stop(workdir) {
+    const instance = this.getInstance(workdir);
+    if (instance.process && !instance.exited) {
+      await terminateProcessTree(instance.process, { exited: () => instance.exited });
+      instance.process = null;
+      instance.exited = true;
+      instance.state = "off";
+      instance.errorMessage = void 0;
+      this.emitStateChange(workdir, "off", void 0);
+      logger.info("Dev server stopped", { workdir });
+    }
+    return this.getStatus(workdir);
+  }
+  async restart(workdir) {
+    await this.stop(workdir);
+    return this.start(workdir);
+  }
+  getStatus(workdir) {
+    const instance = this.getInstance(workdir);
+    return {
+      state: instance.state,
+      url: instance.config?.url ?? null,
+      hotReload: instance.config?.hotReload ?? false,
+      config: instance.config,
+      errorMessage: instance.errorMessage
+    };
+  }
+  getLogs(workdir) {
+    const instance = this.getInstance(workdir);
+    return [...instance.logs];
+  }
+  /** Register a global listener for output from any dev server */
+  onOutput(callback) {
+    this.outputListeners.add(callback);
+    return () => {
+      this.outputListeners.delete(callback);
+    };
+  }
+  /** Register a global listener for state changes from any dev server */
+  onStateChange(callback) {
+    this.stateListeners.add(callback);
+    return () => {
+      this.stateListeners.delete(callback);
+    };
+  }
+  async stopAll() {
+    const stops = Array.from(this.instances.keys()).map((workdir) => this.stop(workdir));
+    await Promise.allSettled(stops);
+    this.instances.clear();
+  }
+};
+var devServerManager = new DevServerManager();
+
+// src/server/tools/dev-server.ts
+var devServerTool = createTool(
+  "dev_server",
+  {
+    type: "function",
+    function: {
+      name: "dev_server",
+      description: "Control the project dev server. Start, stop, restart, or check status. The dev server command and URL are configured in .openfox/dev.json.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["start", "stop", "restart", "status"],
+            description: "The action to perform on the dev server"
+          }
+        },
+        required: ["action"]
+      }
+    }
+  },
+  async (args, context, helpers) => {
+    const workdir = context.workdir;
+    let status;
+    switch (args.action) {
+      case "start":
+        status = await devServerManager.start(workdir);
+        break;
+      case "stop":
+        status = await devServerManager.stop(workdir);
+        break;
+      case "restart":
+        status = await devServerManager.restart(workdir);
+        break;
+      case "status":
+        status = devServerManager.getStatus(workdir);
+        if (!status.config) {
+          const config = await devServerManager.loadConfig(workdir);
+          if (config) {
+            status.config = config;
+            status.url = config.url;
+            status.hotReload = config.hotReload;
+          }
+        }
+        break;
+    }
+    if (!status.config) {
+      return helpers.error(
+        'No .openfox/dev.json config found. Create one with:\n\n{\n  "command": "npm run dev",\n  "url": "http://localhost:3000",\n  "hotReload": true\n}'
+      );
+    }
+    return helpers.success(JSON.stringify({
+      state: status.state,
+      url: status.url,
+      hotReload: status.hotReload,
+      ...status.errorMessage ? { error: status.errorMessage } : {}
+    }, null, 2));
+  }
+);
+
+// src/server/tools/step-done.ts
+var stepDoneTool = {
+  name: "step_done",
+  definition: {
+    type: "function",
+    function: {
+      name: "step_done",
+      description: "Signal that you have completed the current workflow step. Call this exactly once when you have finished all work for this step. After calling this, no further tool calls should be made.",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    }
+  },
+  async execute(_args, _context) {
+    return {
+      success: true,
+      output: "Step completion signal recorded.",
+      durationMs: 0,
+      truncated: false
+    };
+  }
+};
+
 // src/server/tools/index.ts
 function createRegistryFromTools(tools) {
   const toolMap = /* @__PURE__ */ new Map();
@@ -5671,7 +5981,9 @@ var allToolsByName = new Map([
     callSubAgentTool,
     loadSkillTool,
     returnValueTool,
-    webFetchTool
+    webFetchTool,
+    devServerTool,
+    stepDoneTool
   ].map((t) => [t.name, t])
 ]);
 function getToolRegistryForSubAgent(toolNames) {
@@ -5810,8 +6122,10 @@ export {
   deleteSkill,
   runTopLevelAgentLoop,
   executeSubAgent,
+  devServerManager,
+  stepDoneTool,
   getToolRegistryForSubAgent,
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-IKAWIOXM.js.map
+//# sourceMappingURL=chunk-FUUYYDVG.js.map