openfox 2.0.84 → 2.0.85

package/dist/{chunk-G4PVYDVM.js → chunk-FTJ7U3VN.js}

@@ -1,18 +1,15 @@
 import {
   createAssemblyResult,
-  findAgentById,
   getAllInstructions,
   getConversationMessages,
   getEnabledSkillMetadata,
-  getSubAgents,
   getToolRegistryForAgent,
-  loadAllAgentsDefault,
   processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-CKWD5V4W.js";
+} from "./chunk-RSO2HKNH.js";
 import {
   PathAccessDeniedError
-} from "./chunk-3D3N2PXI.js";
+} from "./chunk-2KKFOVK7.js";
 import {
   TurnMetrics,
   buildAgentReminder,
@@ -20,16 +17,22 @@ import {
   buildTopLevelSystemPrompt,
   createChatDoneEvent,
   createMessageStartEvent
-} from "./chunk-FVY2JOTO.js";
+} from "./chunk-H765CIHN.js";
 import {
   getCurrentContextWindowId,
   getCurrentWindowMessageOptions,
-  getEventStore,
-  getRuntimeConfig
-} from "./chunk-BUXIESO5.js";
+  getEventStore
+} from "./chunk-V5LOH363.js";
 import {
   buildSnapshotFromSessionState
-} from "./chunk-A2IZ4PWQ.js";
+} from "./chunk-OHKBGMLO.js";
+import {
+  findAgentById,
+  getRuntimeConfig,
+  getSubAgents,
+  loadAllAgentsDefault,
+  resolveDefaultAgentId
+} from "./chunk-FYYPQ27K.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -61,12 +64,12 @@ async function loadSessionContext(sessionManager, sessionId) {
 function resolveAgentDef(sessionManager, sessionId) {
   return loadAllAgentsDefault().then((allAgents) => {
     const session = sessionManager.requireSession(sessionId);
-    return findAgentById(session.mode, allAgents) ?? findAgentById("planner", allAgents);
+    return findAgentById(session.mode, allAgents) ?? findAgentById(resolveDefaultAgentId(), allAgents);
   });
 }
 async function buildCachedPrompt(sessionManager, sessionId, agentDef) {
   const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
-  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-6NVILBHW.js");
+  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-ZUTPBREL.js");
   const tools = getToolRegistryForAgent2(agentDef).definitions;
   const toolFingerprint = getToolFingerprint(tools);
   const allAgents = await loadAllAgentsDefault();
@@ -79,7 +82,7 @@ async function buildCachedPrompt(sessionManager, sessionId, agentDef) {
 async function computeSessionHash(sessionManager, sessionId) {
   const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
   const agentDef = await resolveAgentDef(sessionManager, sessionId);
-  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-6NVILBHW.js");
+  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-ZUTPBREL.js");
   const tools = getToolRegistryForAgent2(agentDef).definitions;
   const toolFingerprint = getToolFingerprint(tools);
   return computeDynamicContextHash(instructionContent, skills, toolFingerprint);
@@ -87,7 +90,7 @@ async function computeSessionHash(sessionManager, sessionId) {
 async function applyDynamicContext(sessionManager, sessionId) {
   const session = sessionManager.requireSession(sessionId);
   const allAgents = await loadAllAgentsDefault();
-  const agentDef = findAgentById(session.mode, allAgents) ?? findAgentById("planner", allAgents);
+  const agentDef = findAgentById(session.mode, allAgents) ?? findAgentById(resolveDefaultAgentId(), allAgents);
   const { systemPrompt, tools, hash } = await buildCachedPrompt(sessionManager, sessionId, agentDef);
   sessionManager.setCachedPrompt(sessionId, systemPrompt, tools, hash);
   sessionManager.setDynamicContextChanged(sessionId, false);
@@ -97,7 +100,7 @@ async function applyDynamicContext(sessionManager, sessionId) {
 
 // src/server/chat/orchestrator.ts
 async function buildRetryPatterns() {
-  const { getSetting, SETTINGS_KEYS } = await import("./settings-6TJIHDVX.js");
+  const { getSetting, SETTINGS_KEYS } = await import("./settings-AGNYWEIE.js");
   const raw = getSetting(SETTINGS_KEYS.RETRY_PATTERNS);
   if (!raw) {
     const oldXmlProtection = getSetting("llm.disableXmlProtection");
@@ -274,7 +277,7 @@ function injectAgentReminder(sessionId, agentDef) {
 async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
   const statsIdentity = resolveStatsIdentity(options);
   const allAgents = await loadAllAgentsDefault();
-  const agentDef = findAgentById(agentId, allAgents) ?? findAgentById("planner", allAgents);
+  const agentDef = findAgentById(agentId, allAgents) ?? findAgentById(resolveDefaultAgentId(), allAgents);
   if (!options.warmup) {
     injectAgentReminder(options.sessionId, agentDef);
   }
@@ -359,4 +362,4 @@ export {
   runChatTurn,
   runAgentTurn
 };
-//# sourceMappingURL=chunk-G4PVYDVM.js.map
+//# sourceMappingURL=chunk-FTJ7U3VN.js.map

package/dist/chunk-FYYPQ27K.js

@@ -0,0 +1,399 @@
+import {
+  SETTINGS_KEYS,
+  getSetting
+} from "./chunk-STFIEU5F.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+import {
+  getGlobalConfigDir
+} from "./chunk-CQGTEGKL.js";
+
+// src/server/config.ts
+import { z } from "zod";
+var backendSchema = z.enum(["vllm", "sglang", "ollama", "llamacpp", "unknown"]).default("unknown");
+var envSchema = z.object({
+  // New env var name, with fallback to old name for backward compatibility
+  OPENFOX_LLM_URL: z.string().url().optional(),
+  OPENFOX_VLLM_URL: z.string().url().optional(),
+  OPENFOX_BACKEND: backendSchema,
+  OPENFOX_MODEL_NAME: z.string().default(""),
+  OPENFOX_MAX_CONTEXT: z.coerce.number().default(2e5),
+  OPENFOX_PORT: z.coerce.number().default(10369),
+  OPENFOX_HOST: z.string().optional(),
+  OPENFOX_WORKDIR: z.string().optional(),
+  OPENFOX_DB_PATH: z.string().default("./openfox.db"),
+  OPENFOX_LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  OPENFOX_REASONING_EFFORT: z.string().optional(),
+  // Deprecated: use OPENFOX_REASONING_EFFORT=none instead
+  OPENFOX_DISABLE_THINKING: z.coerce.boolean().default(false),
+  OPENFOX_LLM_TIMEOUT: z.coerce.number().default(3e5),
+  OPENFOX_LLM_IDLE_TIMEOUT: z.coerce.number().default(3e5),
+  OPENFOX_DEV: z.coerce.boolean().default(false),
+  OPENFOX_DISABLE_AUTO_SESSION_TITLE: z.coerce.boolean().optional(),
+  OPENFOX_DEFAULT_AGENT: z.string().optional()
+});
+function loadConfig() {
+  const env = envSchema.parse(process.env);
+  const llmUrl = env.OPENFOX_LLM_URL ?? env.OPENFOX_VLLM_URL ?? "http://localhost:8000/v1";
+  const workdir = env.OPENFOX_WORKDIR ?? process.cwd();
+  return {
+    llm: {
+      baseUrl: llmUrl,
+      model: env.OPENFOX_MODEL_NAME,
+      timeout: env.OPENFOX_LLM_TIMEOUT,
+      idleTimeout: env.OPENFOX_LLM_IDLE_TIMEOUT,
+      backend: env.OPENFOX_BACKEND,
+      ...env.OPENFOX_REASONING_EFFORT ? { reasoningEffort: env.OPENFOX_REASONING_EFFORT } : env.OPENFOX_DISABLE_THINKING ? { reasoningEffort: "none" } : {}
+    },
+    context: {
+      maxTokens: env.OPENFOX_MAX_CONTEXT,
+      compactionThreshold: 0.85,
+      compactionTarget: 0.6
+    },
+    agent: {
+      maxIterations: 10,
+      maxConsecutiveFailures: 3,
+      toolTimeout: 3e5
+    },
+    server: {
+      port: env.OPENFOX_PORT,
+      ...env.OPENFOX_HOST !== void 0 ? { host: env.OPENFOX_HOST } : {}
+    },
+    database: {
+      path: env.OPENFOX_DB_PATH
+    },
+    mode: env.OPENFOX_DEV ? "development" : "production",
+    workdir,
+    ...env.OPENFOX_DISABLE_AUTO_SESSION_TITLE !== void 0 ? { disableAutoSessionTitle: env.OPENFOX_DISABLE_AUTO_SESSION_TITLE } : {},
+    ...env.OPENFOX_DEFAULT_AGENT !== void 0 ? { defaultAgent: env.OPENFOX_DEFAULT_AGENT } : {}
+  };
+}
+
+// src/server/runtime-config.ts
+var runtimeConfig = null;
+function setRuntimeConfig(config) {
+  runtimeConfig = config;
+}
+function getRuntimeConfig() {
+  return runtimeConfig ?? loadConfig();
+}
+
+// src/server/agents/registry.ts
+import { readdir as readdir2, readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access as access2, unlink as unlink2 } from "fs/promises";
+import { join as join2, dirname } from "path";
+import { constants as constants2 } from "fs";
+import { fileURLToPath } from "url";
+import matter2 from "gray-matter";
+
+// src/server/shared/item-loader.ts
+import { readdir, readFile, access, writeFile, mkdir, unlink } from "fs/promises";
+import { join } from "path";
+import { constants } from "fs";
+import matter from "gray-matter";
+async function pathExists(path) {
+  try {
+    await access(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDefaultIds(dir, extension) {
+  try {
+    const files = (await readdir(dir)).filter((f) => f.endsWith(extension));
+    return files.map((f) => f.replace(extension, ""));
+  } catch {
+    return [];
+  }
+}
+async function loadItemsFromDir(dir, options) {
+  if (!await pathExists(dir)) {
+    return [];
+  }
+  let files;
+  try {
+    files = (await readdir(dir)).filter((f) => f.endsWith(options.extension));
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const file of files) {
+    try {
+      const raw = await readFile(join(dir, file), "utf-8");
+      const { data, content } = matter(raw);
+      if (data.id && content.trim()) {
+        items.push({
+          metadata: data,
+          prompt: content.trim()
+        });
+      } else {
+        logger.warn(`Skipping invalid ${options.logName} file`, { file });
+      }
+    } catch (err) {
+      logger.warn(`Failed to parse ${options.logName} file`, {
+        file,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return items;
+}
+async function saveItemToDir(dir, item, ext, serialize) {
+  if (!await pathExists(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  const meta = item.metadata;
+  const filePath = join(dir, `${meta.id}${ext}`);
+  await writeFile(filePath, serialize(item), "utf-8");
+}
+var jsonSerializer = (item) => JSON.stringify(item, null, 2) + "\n";
+async function deleteItemFromDir(dir, id, ext) {
+  const filePath = join(dir, `${id}${ext}`);
+  try {
+    await unlink(filePath);
+    return { success: true };
+  } catch {
+    return { success: false };
+  }
+}
+
+// src/server/agents/registry.ts
+var __bundleDir = dirname(fileURLToPath(import.meta.url));
+var DEFAULTS_DIR = join2(__bundleDir, "defaults");
+var DEFAULTS_DIR_ALT = join2(__bundleDir, "agent-defaults");
+var AGENT_EXTENSION = ".agent.md";
+function getAgentsDir(configDir) {
+  return join2(configDir, "agents");
+}
+function getProjectAgentsDir(projectDir) {
+  return join2(projectDir, ".openfox", "agents");
+}
+async function pathExists2(path) {
+  try {
+    await access2(path, constants2.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseAgentFile(raw, filename) {
+  const { data, content } = matter2(raw);
+  const meta = data;
+  if (!meta["id"] || !content.trim()) {
+    logger.warn("Skipping invalid agent file", { filename });
+    return void 0;
+  }
+  const metadata = {
+    id: String(meta["id"]),
+    name: String(meta["name"] ?? meta["id"]),
+    description: String(meta["description"] ?? ""),
+    subagent: meta["subagent"] === true,
+    allowedTools: Array.isArray(meta["allowedTools"]) ? meta["allowedTools"].map(String) : [],
+    ...typeof meta["color"] === "string" ? { color: meta["color"] } : {},
+    ...Array.isArray(meta["results"]) ? { results: meta["results"].map(String) } : {}
+  };
+  return { metadata, prompt: content.trim() };
+}
+async function loadAgentsFromDir(dir) {
+  if (!await pathExists2(dir)) {
+    return [];
+  }
+  let files;
+  try {
+    files = (await readdir2(dir)).filter((f) => f.endsWith(AGENT_EXTENSION));
+  } catch {
+    return [];
+  }
+  const agents = [];
+  for (const file of files) {
+    try {
+      const raw = await readFile2(join2(dir, file), "utf-8");
+      const agent = parseAgentFile(raw, file);
+      if (agent) {
+        agents.push(agent);
+      }
+    } catch (err) {
+      logger.warn("Failed to parse agent file", { file, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return agents;
+}
+async function loadDefaultAgents() {
+  const agents = await loadAgentsFromDir(DEFAULTS_DIR);
+  if (agents.length > 0) return agents;
+  return loadAgentsFromDir(DEFAULTS_DIR_ALT);
+}
+async function loadUserAgents(configDir) {
+  return loadAgentsFromDir(getAgentsDir(configDir));
+}
+async function loadProjectAgents(projectDir) {
+  return loadAgentsFromDir(getProjectAgentsDir(projectDir));
+}
+async function loadAllAgents(configDir, projectDir) {
+  const [defaultAgents, userAgents] = await Promise.all([loadDefaultAgents(), loadUserAgents(configDir)]);
+  const agentMap = /* @__PURE__ */ new Map();
+  for (const agent of defaultAgents) {
+    agentMap.set(agent.metadata.id, agent);
+  }
+  for (const agent of userAgents) {
+    agentMap.set(agent.metadata.id, agent);
+  }
+  if (projectDir) {
+    const projectAgents = await loadProjectAgents(projectDir);
+    for (const agent of projectAgents) {
+      agentMap.set(agent.metadata.id, agent);
+    }
+  }
+  return Array.from(agentMap.values());
+}
+async function saveAgentToProject(projectDir, agent) {
+  await saveItemToDir(
+    getProjectAgentsDir(projectDir),
+    agent,
+    AGENT_EXTENSION,
+    (a) => matter2.stringify(a.prompt, a.metadata)
+  );
+}
+async function deleteProjectAgent(projectDir, agentId) {
+  const agentsDir = getProjectAgentsDir(projectDir);
+  const paths = getAgentFilePaths(agentsDir, agentId);
+  for (const filePath of paths) {
+    try {
+      await unlink2(filePath);
+      return { success: true };
+    } catch {
+      continue;
+    }
+  }
+  return { success: false };
+}
+async function loadAllAgentsDefault() {
+  try {
+    const config = getRuntimeConfig();
+    const configDir = getGlobalConfigDir(config.mode ?? "production");
+    return await loadAllAgents(configDir, config.workdir);
+  } catch {
+    return loadDefaultAgents();
+  }
+}
+async function getDefaultAgentIds() {
+  for (const dir of [DEFAULTS_DIR, DEFAULTS_DIR_ALT]) {
+    try {
+      const files = (await readdir2(dir)).filter((f) => f.endsWith(AGENT_EXTENSION));
+      return files.map((f) => f.replace(AGENT_EXTENSION, ""));
+    } catch {
+    }
+  }
+  return [];
+}
+async function isDefaultAgent(agentId) {
+  const defaultIds = await getDefaultAgentIds();
+  return defaultIds.includes(agentId);
+}
+function getAgentFilePaths(agentsDir, agentId) {
+  const hyphenated = agentId.replace(/_/g, "-");
+  return [join2(agentsDir, `${agentId}${AGENT_EXTENSION}`), join2(agentsDir, `${hyphenated}${AGENT_EXTENSION}`)];
+}
+function findAgentById(agentId, agents) {
+  return agents.find((a) => a.metadata.id === agentId);
+}
+function getSubAgents(agents) {
+  return agents.filter((a) => a.metadata.subagent);
+}
+function getTopLevelAgents(agents) {
+  return agents.filter((a) => !a.metadata.subagent);
+}
+async function agentExists(configDir, agentId, projectDir) {
+  const agentsDir = getAgentsDir(configDir);
+  const paths = getAgentFilePaths(agentsDir, agentId);
+  for (const filePath of paths) {
+    if (await pathExists2(filePath)) {
+      return true;
+    }
+  }
+  if (projectDir) {
+    const projectPaths = getAgentFilePaths(getProjectAgentsDir(projectDir), agentId);
+    for (const filePath of projectPaths) {
+      if (await pathExists2(filePath)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function saveAgent(configDir, agent) {
+  const agentsDir = getAgentsDir(configDir);
+  if (!await pathExists2(agentsDir)) {
+    await mkdir2(agentsDir, { recursive: true });
+  }
+  const filePath = join2(agentsDir, `${agent.metadata.id}${AGENT_EXTENSION}`);
+  const content = matter2.stringify(agent.prompt, agent.metadata);
+  await writeFile2(filePath, content, "utf-8");
+}
+async function deleteAgent(configDir, agentId) {
+  const isDefault = await isDefaultAgent(agentId);
+  if (isDefault) {
+    return { success: false, reason: "Cannot delete built-in defaults" };
+  }
+  const agentsDir = getAgentsDir(configDir);
+  const paths = getAgentFilePaths(agentsDir, agentId);
+  for (const filePath of paths) {
+    try {
+      await unlink2(filePath);
+      return { success: true };
+    } catch {
+      continue;
+    }
+  }
+  return { success: false };
+}
+function resolveDefaultAgentId() {
+  try {
+    const dbSetting = getSetting(SETTINGS_KEYS.DEFAULT_AGENT);
+    if (dbSetting && dbSetting.trim().length > 0) {
+      return dbSetting.trim();
+    }
+  } catch (err) {
+    logger.debug("Failed to read defaultAgent from DB settings", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  try {
+    const config = getRuntimeConfig();
+    if (config.defaultAgent && config.defaultAgent.trim().length > 0) {
+      return config.defaultAgent.trim();
+    }
+  } catch {
+  }
+  return "planner";
+}
+
+export {
+  pathExists,
+  getDefaultIds,
+  loadItemsFromDir,
+  saveItemToDir,
+  jsonSerializer,
+  deleteItemFromDir,
+  loadConfig,
+  setRuntimeConfig,
+  getRuntimeConfig,
+  loadDefaultAgents,
+  loadUserAgents,
+  loadProjectAgents,
+  loadAllAgents,
+  saveAgentToProject,
+  deleteProjectAgent,
+  loadAllAgentsDefault,
+  getDefaultAgentIds,
+  isDefaultAgent,
+  findAgentById,
+  getSubAgents,
+  getTopLevelAgents,
+  agentExists,
+  saveAgent,
+  deleteAgent,
+  resolveDefaultAgentId
+};
+//# sourceMappingURL=chunk-FYYPQ27K.js.map

package/dist/{chunk-XIVQNOXU.js → chunk-GLRTJJOB.js}

@@ -3,22 +3,17 @@ import {
   computeSessionHash,
   runAgentTurn,
   runChatTurn
-} from "./chunk-G4PVYDVM.js";
+} from "./chunk-FTJ7U3VN.js";
 import {
-  deleteItemFromDir,
   devServerManager,
   executeSubAgent,
-  findAgentById,
-  getToolRegistryForAgent,
-  jsonSerializer,
-  loadAllAgentsDefault,
-  saveItemToDir
-} from "./chunk-CKWD5V4W.js";
+  getToolRegistryForAgent
+} from "./chunk-RSO2HKNH.js";
 import {
   checkAborted,
   onProcessEvent,
   spawnShellProcess
-} from "./chunk-JKZPMRH2.js";
+} from "./chunk-3JYPDZT2.js";
 import {
   gitSpawnEnv
 } from "./chunk-J7GAZGZT.js";
@@ -43,14 +38,14 @@ import {
 } from "./chunk-EU3WWTFH.js";
 import {
   appendCompactionPrompt
-} from "./chunk-DQP5HSDS.js";
+} from "./chunk-WVMOGE7U.js";
 import {
   TurnMetrics,
   createMessageStartEvent
-} from "./chunk-FVY2JOTO.js";
+} from "./chunk-H765CIHN.js";
 import {
   getPlatformShell
-} from "./chunk-5ZHVQOI3.js";
+} from "./chunk-W23S3TU5.js";
 import {
   killProcessTree,
   terminateProcessTree
@@ -58,16 +53,24 @@ import {
 import {
   combineEventsWithSnapshot,
   getCurrentContextWindowId,
-  getEventStore,
-  getRuntimeConfig
-} from "./chunk-BUXIESO5.js";
+  getEventStore
+} from "./chunk-V5LOH363.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
-} from "./chunk-A2IZ4PWQ.js";
+} from "./chunk-OHKBGMLO.js";
+import {
+  deleteItemFromDir,
+  findAgentById,
+  getRuntimeConfig,
+  jsonSerializer,
+  loadAllAgentsDefault,
+  resolveDefaultAgentId,
+  saveItemToDir
+} from "./chunk-FYYPQ27K.js";
 import {
   getMaxVisibleItems
-} from "./chunk-CNJ63FXJ.js";
+} from "./chunk-STFIEU5F.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -818,7 +821,7 @@ async function executeWorkflow(workflow, options, subGroup) {
     sessionManager.setPhase(sessionId, step.phase);
     if (step.type === "agent") {
       const agentStep = step;
-      sessionManager.setMode(sessionId, agentStep.agentId ?? "planner");
+      sessionManager.setMode(sessionId, agentStep.agentId ?? resolveDefaultAgentId());
     }
     logger.debug("Workflow step executing", { sessionId, iteration: iterations, stepId: step.id, stepType: step.type });
     let stepOutcome = null;
@@ -881,7 +884,7 @@ async function executeWorkflow(workflow, options, subGroup) {
             ...onMessage ? { onMessage } : {}
           },
           turnMetrics,
-          agentStep.agentId ?? "planner",
+          agentStep.agentId ?? resolveDefaultAgentId(),
           append,
           {
             ...!firstEntryForStep.has(step.id) && !agentStep.prompt ? { injectKickoff: () => injectGenericKickoff(sessionId) } : {},
@@ -2217,4 +2220,4 @@ export {
   signalMcpReady,
   createWebSocketServer
 };
-//# sourceMappingURL=chunk-XIVQNOXU.js.map
+//# sourceMappingURL=chunk-GLRTJJOB.js.map

package/dist/{chunk-FVY2JOTO.js → chunk-H765CIHN.js}

@@ -1,6 +1,6 @@
 import {
   getPlatformShell
-} from "./chunk-5ZHVQOI3.js";
+} from "./chunk-W23S3TU5.js";
 import {
   streamWithSegments
 } from "./chunk-J2GP3J3X.js";
@@ -680,4 +680,4 @@ export {
   createChatDoneEvent,
   consumeStreamGenerator
 };
-//# sourceMappingURL=chunk-FVY2JOTO.js.map
+//# sourceMappingURL=chunk-H765CIHN.js.map

package/dist/{chunk-AANVMTYU.js → chunk-L4S5N3WV.js}

@@ -1,3 +1,6 @@
+import {
+  resolveDefaultAgentId
+} from "./chunk-FYYPQ27K.js";
 import {
   getDatabase
 } from "./chunk-RGUUZD5B.js";
@@ -17,10 +20,11 @@ function createSession(projectId, workdir, title, providerId, providerModel, wor
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const id = crypto.randomUUID();
   const dangerLevel = getProjectDangerLevel(projectId);
+  const defaultAgent = resolveDefaultAgentId();
   db.prepare(
     `
     INSERT INTO sessions (id, project_id, workdir, workspace, branch, phase, mode, workflow_phase, is_running, created_at, updated_at, title, provider_id, provider_model, danger_level)
-    VALUES (?, ?, ?, ?, ?, 'idle', 'planner', 'plan', 0, ?, ?, ?, ?, ?, ?)
+    VALUES (?, ?, ?, ?, ?, 'idle', ?, 'plan', 0, ?, ?, ?, ?, ?, ?)
   `
   ).run(
     id,
@@ -28,6 +32,7 @@ function createSession(projectId, workdir, title, providerId, providerModel, wor
     workdir,
     workspace ?? null,
     branch ?? null,
+    defaultAgent,
     now,
     now,
     title ?? null,
@@ -41,7 +46,7 @@ function createSession(projectId, workdir, title, providerId, providerModel, wor
     workdir,
     ...workspace ? { workspace } : {},
     ...branch ? { branch } : {},
-    mode: "planner",
+    mode: defaultAgent,
     phase: "plan",
     isRunning: false,
     providerId: providerId ?? null,
@@ -324,4 +329,4 @@ export {
   updateSessionBranch,
   deleteSession
 };
-//# sourceMappingURL=chunk-AANVMTYU.js.map
+//# sourceMappingURL=chunk-L4S5N3WV.js.map

package/dist/{chunk-VB23QPW3.js → chunk-M6X72DYZ.js}

@@ -1,6 +1,6 @@
 import {
   createLLMClient
-} from "./chunk-SBSQD7MG.js";
+} from "./chunk-MTZ3PC6K.js";
 import {
   getModelProfile
 } from "./chunk-V4IE7HJY.js";
@@ -17,7 +17,7 @@ import {
 } from "./chunk-RMXPVQP4.js";
 import {
   proxyFetch
-} from "./chunk-IIRXKSB5.js";
+} from "./chunk-ACL4YUJH.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -810,4 +810,4 @@ export {
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-VB23QPW3.js.map
+//# sourceMappingURL=chunk-M6X72DYZ.js.map

package/dist/{chunk-SBSQD7MG.js → chunk-MTZ3PC6K.js}

@@ -17,7 +17,7 @@ import {
 import {
   LLMError,
   OpenAIHttpClient
-} from "./chunk-IIRXKSB5.js";
+} from "./chunk-ACL4YUJH.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -268,4 +268,4 @@ function createLLMClient(config, initialBackend = "unknown") {
 export {
   createLLMClient
 };
-//# sourceMappingURL=chunk-SBSQD7MG.js.map
+//# sourceMappingURL=chunk-MTZ3PC6K.js.map