@mindstudio-ai/local-model-tunnel 0.5.26 → 0.5.28

package/dist/{chunk-KAGWWCYB.js → chunk-WECAPRKN.js}

@@ -88,6 +88,7 @@ function deleteLocalInterfacePath(key) {
 
 // src/dev/logging/logger.ts
 import fs from "fs";
+import { join } from "path";
 var LEVELS = {
   error: 0,
   warn: 1,
@@ -97,31 +98,28 @@ var LEVELS = {
 var currentLevel = LEVELS.error;
 var writeFn = () => {
 };
-function timestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function write(level, msg, data) {
+function write(level, module, msg, data) {
   if (LEVELS[level] > currentLevel) {
     return;
   }
-  const parts = [`[${timestamp()}]`, level.toUpperCase().padEnd(5), msg];
+  const entry = { ts: Date.now(), level, module, msg };
   if (data) {
-    parts.push(JSON.stringify(data));
+    Object.assign(entry, data);
   }
-  writeFn(parts.join(" "));
+  writeFn(JSON.stringify(entry));
 }
 var log = {
-  error(msg, data) {
-    write("error", msg, data);
+  error(module, msg, data) {
+    write("error", module, msg, data);
   },
-  warn(msg, data) {
-    write("warn", msg, data);
+  warn(module, msg, data) {
+    write("warn", module, msg, data);
   },
-  info(msg, data) {
-    write("info", msg, data);
+  info(module, msg, data) {
+    write("info", module, msg, data);
   },
-  debug(msg, data) {
-    write("debug", msg, data);
+  debug(module, msg, data) {
+    write("debug", module, msg, data);
   }
 };
 function initLoggerHeadless(level = "info") {
@@ -136,7 +134,9 @@ function initLoggerInteractive(level = "error") {
   writeFn = (line) => {
     try {
       if (fd === null) {
-        fd = fs.openSync(".mindstudio-dev.log", "a");
+        const logsDir = join(process.cwd(), ".logs");
+        fs.mkdirSync(logsDir, { recursive: true });
+        fd = fs.openSync(join(logsDir, "tunnel.ndjson"), "a");
       }
       fs.writeSync(fd, line + "\n");
     } catch {
@@ -162,7 +162,8 @@ function basePath(appId) {
 }
 async function apiRequest(method, url, headers, body) {
   const start = Date.now();
-  const logTag = `${method} ${url.replace(getApiBaseUrl(), "")}`;
+  const httpMethod = method;
+  const path2 = url.replace(getApiBaseUrl(), "").replace(/^\/_internal\/v2\/apps\/[^/]+\/dev/, "");
   const response = await fetch(url, {
     method,
     headers,
@@ -170,16 +171,16 @@ async function apiRequest(method, url, headers, body) {
   });
   const duration = Date.now() - start;
   if (response.status === 204) {
-    log.debug(`api ${logTag} \u2192 204 (${duration}ms)`);
+    log.debug("api", "Request complete", { method: httpMethod, path: path2, status: 204, duration });
     return null;
   }
   if (!response.ok) {
     const error = await response.text();
-    log.error(`api ${logTag} \u2192 ${response.status} (${duration}ms)`, { error });
-    throw new ApiError(`${logTag} failed: ${response.status} ${error}`, response.status);
+    log.error("api", "Request failed", { method: httpMethod, path: path2, status: response.status, duration, error });
+    throw new ApiError(`${httpMethod} ${path2} failed: ${response.status} ${error}`, response.status);
   }
   const data = await response.json();
-  log.info(`api ${logTag} \u2192 ${response.status} (${duration}ms)`);
+  log.info("api", "Request complete", { method: httpMethod, path: path2, status: response.status, duration });
   return data;
 }
 async function startDevSession(appId, opts) {
@@ -276,7 +277,7 @@ var DevPollError = class extends Error {
 
 // src/dev/logging/ndjson-log.ts
 import fs2 from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 var NdjsonLog = class {
   constructor(filename, maxLines = 500, keepLines = 300, maxBytes = 2 * 1024 * 1024) {
     this.filename = filename;
@@ -291,9 +292,9 @@ var NdjsonLog = class {
   init(projectRoot) {
     this.close();
     try {
-      const logsDir = join(projectRoot, ".logs");
+      const logsDir = join2(projectRoot, ".logs");
       fs2.mkdirSync(logsDir, { recursive: true });
-      this.logPath = join(logsDir, this.filename);
+      this.logPath = join2(logsDir, this.filename);
       if (fs2.existsSync(this.logPath)) {
         const content = fs2.readFileSync(this.logPath, "utf-8");
         this.lineCount = content.split("\n").filter((l) => l.trim()).length;
@@ -301,12 +302,12 @@ var NdjsonLog = class {
         this.lineCount = 0;
       }
       this.fd = fs2.openSync(this.logPath, "a");
-      log.info(`${this.filename} log initialized`, {
+      log.debug("logging", `${this.filename} log initialized`, {
         path: this.logPath,
         existingEntries: this.lineCount
       });
     } catch (err) {
-      log.warn(`Failed to initialize ${this.filename} log`, {
+      log.warn("logging", `Failed to initialize ${this.filename} log`, {
         error: err instanceof Error ? err.message : String(err)
       });
       this.fd = null;
@@ -320,10 +321,7 @@ var NdjsonLog = class {
       fs2.writeSync(this.fd, line);
       this.lineCount++;
       this.maybeRotate();
-    } catch (err) {
-      log.debug(`Failed to write ${this.filename} log entry`, {
-        error: err instanceof Error ? err.message : String(err)
-      });
+    } catch {
     }
   }
   close() {
@@ -355,11 +353,7 @@ var NdjsonLog = class {
       fs2.writeFileSync(this.logPath, kept.join("\n") + "\n", "utf-8");
       this.fd = fs2.openSync(this.logPath, "a");
       this.lineCount = kept.length;
-      log.debug(`${this.filename} log rotated`, { kept: this.lineCount });
-    } catch (err) {
-      log.debug(`${this.filename} log rotation failed`, {
-        error: err instanceof Error ? err.message : String(err)
-      });
+    } catch {
     } finally {
       this.rotating = false;
     }
@@ -373,8 +367,11 @@ function initRequestLog(projectRoot) {
 }
 function logMethodExecution(entry) {
   ndjsonLog.append({
+    ts: Date.now(),
+    level: "info",
+    module: "execution",
+    msg: entry.result.success ? "Method complete" : "Method failed",
     type: "method",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     requestId: entry.requestId,
     sessionId: entry.sessionId,
     method: entry.methodExport,
@@ -393,8 +390,11 @@ function logMethodExecution(entry) {
 }
 function logScenarioExecution(entry) {
   ndjsonLog.append({
+    ts: Date.now(),
+    level: "info",
+    module: "execution",
+    msg: entry.result?.success ?? false ? "Scenario complete" : "Scenario failed",
     type: "scenario",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: entry.sessionId,
     scenario: {
       id: entry.scenario.id,
@@ -480,7 +480,7 @@ var devRequestEvents = new DevEventEmitter();
 // src/dev/execution/transpiler.ts
 import { unlink, mkdir, readdir } from "fs/promises";
 import { existsSync } from "fs";
-import { resolve, dirname, basename, join as join2 } from "path";
+import { resolve, dirname, basename, join as join3 } from "path";
 import { build } from "esbuild";
 var Transpiler = class {
   projectRoot;
@@ -506,18 +506,16 @@ var Transpiler = class {
     const start = Date.now();
     const absolutePath = resolve(this.projectRoot, methodPath);
     const name = basename(absolutePath).replace(/\.[^.]+$/, "");
-    log.debug("Transpiling method", { methodPath });
     const nodeModulesDir = findNearestNodeModules(dirname(absolutePath));
     if (!nodeModulesDir) {
-      log.error("Cannot find node_modules for method", { methodPath, searchStart: dirname(absolutePath) });
+      log.error("transpiler", "Cannot find node_modules for method", { methodPath, searchStart: dirname(absolutePath) });
       throw new Error(
         `No node_modules found near ${methodPath}. Run npm install first.`
       );
     }
-    log.debug("Found node_modules", { path: nodeModulesDir });
-    const outDir = join2(nodeModulesDir, ".cache", "mindstudio-dev");
+    const outDir = join3(nodeModulesDir, ".cache", "mindstudio-dev");
     await mkdir(outDir, { recursive: true });
-    const outfile = join2(outDir, `${name}.__ms_dev__.mjs`);
+    const outfile = join3(outDir, `${name}.__ms_dev__.mjs`);
     await build({
       entryPoints: [absolutePath],
       bundle: true,
@@ -530,14 +528,13 @@ var Transpiler = class {
       logLevel: "silent"
     });
     this.outputFiles.add(outfile);
-    log.info(`Method transpiled in ${Date.now() - start}ms`, { methodPath, outfile });
+    log.info("transpiler", "Method transpiled", { duration: Date.now() - start, methodPath, outfile });
     return outfile;
   }
   /**
    * Clean up all transpiled output files.
    */
   async cleanup() {
-    log.debug("Cleaning up transpiled files", { fileCount: this.outputFiles.size });
     for (const file of this.outputFiles) {
       await unlink(file).catch(() => {
       });
@@ -549,11 +546,10 @@ async function removeOrphanedDevFiles(dir) {
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name === ".git") continue;
-    const fullPath = join2(dir, entry.name);
+    const fullPath = join3(dir, entry.name);
     if (entry.isDirectory()) {
       await removeOrphanedDevFiles(fullPath);
     } else if (entry.name.endsWith(".__ms_dev__.mjs")) {
-      log.debug("Removing orphaned transpiled file", { path: fullPath });
       await unlink(fullPath).catch(() => {
       });
     }
@@ -562,7 +558,7 @@ async function removeOrphanedDevFiles(dir) {
 function findNearestNodeModules(startDir) {
   let dir = startDir;
   while (true) {
-    const candidate = join2(dir, "node_modules");
+    const candidate = join3(dir, "node_modules");
     if (existsSync(candidate)) {
       return candidate;
     }
@@ -576,7 +572,7 @@ function findNearestNodeModules(startDir) {
 // src/dev/execution/executor.ts
 import { fork } from "child_process";
 import { writeFile, unlink as unlink2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { tmpdir } from "os";
 import { randomBytes } from "crypto";
 var EXECUTION_TIMEOUT_MS = 30 * 60 * 1e3;
@@ -675,6 +671,10 @@ async function ensureWorker(projectRoot) {
   if (worker?.connected && workerProjectRoot === projectRoot) {
     return worker;
   }
+  if (worker || workerProjectRoot) {
+    const reason = workerProjectRoot !== projectRoot ? "project-root-changed" : "disconnected";
+    log.info("executor", "Respawning worker process", { reason });
+  }
   if (worker) {
     worker.removeAllListeners();
     worker.kill();
@@ -685,14 +685,14 @@ async function ensureWorker(projectRoot) {
     });
     workerScriptPath = null;
   }
-  const scriptPath = join3(
+  const scriptPath = join4(
     tmpdir(),
     `ms-dev-worker-${randomBytes(4).toString("hex")}.mjs`
   );
   await writeFile(scriptPath, buildWorkerScript(), "utf-8");
   workerScriptPath = scriptPath;
   workerProjectRoot = projectRoot;
-  log.debug("Spawning method execution process", { cwd: projectRoot, scriptPath });
+  log.debug("executor", "Spawning method execution process", { cwd: projectRoot, scriptPath });
   const child = fork(scriptPath, [], {
     cwd: projectRoot,
     stdio: ["ignore", "pipe", "pipe", "ipc"],
@@ -718,7 +718,7 @@ async function ensureWorker(projectRoot) {
     req.resolve(msg);
   });
   child.on("exit", (code) => {
-    log.warn("Method execution process exited unexpectedly", { code });
+    log.warn("executor", "Method execution process exited unexpectedly", { code });
     for (const [id, req] of pending) {
       clearTimeout(req.timer);
       req.resolve({ success: false, error: { message: `Worker process exited with code ${code}` } });
@@ -728,10 +728,10 @@ async function ensureWorker(projectRoot) {
   });
   child.stderr?.on("data", (chunk) => {
     const text = chunk.toString().trim();
-    if (text) log.warn("Method process stderr", { text: text.slice(0, 500) });
+    if (text) log.warn("executor", "Method process stderr", { text: text.slice(0, 500) });
   });
   worker = child;
-  log.info("Method execution process ready", { pid: child.pid });
+  log.info("executor", "Method execution process ready", { pid: child.pid });
   return child;
 }
 var queueTail = Promise.resolve();
@@ -747,14 +747,14 @@ function executeMethod(opts) {
 async function executeMethodInWorker(opts) {
   const w = await ensureWorker(opts.projectRoot);
   const id = randomBytes(8).toString("hex");
-  log.debug("Sending method to execution process", { id, methodExport: opts.methodExport });
+  log.debug("executor", "Sending method to execution process", { id, methodExport: opts.methodExport });
   return new Promise((resolve2) => {
     const timer = setTimeout(() => {
       pending.delete(id);
-      log.warn("Method execution timed out", { id, methodExport: opts.methodExport });
+      log.warn("executor", "Method execution timed out", { id, methodExport: opts.methodExport });
       resolve2({
         success: false,
-        error: { message: "Method execution timed out after 30s" }
+        error: { message: "Method execution timed out after 30m" }
       });
     }, EXECUTION_TIMEOUT_MS);
     pending.set(id, { resolve: resolve2, timer });
@@ -977,6 +977,63 @@ function formatErrorForDisplay(error) {
   return parts.join("\n");
 }
 
+// src/dev/execution/agent-config.ts
+import { readFileSync } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
+function readAgentConfig(projectRoot, appConfig) {
+  const agentInterface = appConfig.interfaces.find(
+    (i) => i.type === "agent" && i.enabled !== false
+  );
+  if (!agentInterface) {
+    throw new Error("No agent interface configured in mindstudio.json");
+  }
+  const configPath = join5(projectRoot, agentInterface.path);
+  let raw;
+  try {
+    raw = readFileSync(configPath, "utf-8");
+  } catch {
+    throw new Error(
+      `Agent config not found at ${agentInterface.path} \u2014 run your build command`
+    );
+  }
+  const parsed = JSON.parse(raw);
+  const config2 = parsed.agent ?? parsed;
+  const agentDir = dirname2(configPath);
+  const systemPromptPath = join5(agentDir, config2.systemPrompt);
+  let systemPrompt;
+  try {
+    systemPrompt = readFileSync(systemPromptPath, "utf-8");
+  } catch {
+    throw new Error(
+      `Agent system prompt not found at ${config2.systemPrompt} \u2014 run your build command`
+    );
+  }
+  const tools = (config2.tools ?? []).map(
+    (tool) => {
+      const descPath = join5(agentDir, tool.description);
+      let description;
+      try {
+        description = readFileSync(descPath, "utf-8");
+      } catch {
+        throw new Error(
+          `Agent tool description not found at ${tool.description} for method "${tool.method}" \u2014 run your build command`
+        );
+      }
+      return {
+        name: tool.method,
+        description
+      };
+    }
+  );
+  return {
+    model: config2.model,
+    temperature: config2.temperature,
+    maxTokens: config2.maxTokens,
+    systemPrompt,
+    tools
+  };
+}
+
 // src/dev/execution/runner.ts
 var DevRunner = class {
   constructor(appId, projectRoot, startOpts = {}) {
@@ -991,6 +1048,8 @@ var DevRunner = class {
   hadConnectionWarning = false;
   proxyUrl;
   proxy = null;
+  appConfig = null;
+  roleOverride = null;
   // proxyUrl is sent on every poll request so the platform dashboard can
   // show the developer's preview URL. Also included in the start request
   // so the dashboard sees it immediately without waiting for the first poll.
@@ -1001,17 +1060,20 @@ var DevRunner = class {
   setProxy(proxy) {
     this.proxy = proxy;
   }
+  setAppConfig(appConfig) {
+    this.appConfig = appConfig;
+  }
   async start() {
     if (this.isRunning) {
       throw new Error("DevRunner is already running");
     }
-    log.info("Dev session starting", { appId: this.appId, branch: this.startOpts.branch });
+    log.info("runner", "Dev session starting", { appId: this.appId, branch: this.startOpts.branch });
     const session = await startDevSession(this.appId, this.startOpts);
     this.session = session;
     this.transpiler = new Transpiler(this.projectRoot);
     this.isRunning = true;
     this.backoffMs = 1e3;
-    log.info("Dev session started", { sessionId: session.sessionId, branch: session.branch });
+    log.info("runner", "Dev session started", { sessionId: session.sessionId, branch: session.branch });
     return session;
   }
   // Begin polling for platform method requests. Call this after all
@@ -1021,16 +1083,17 @@ var DevRunner = class {
     this.pollLoop();
   }
   async stop() {
-    log.info("Dev session stopping");
+    log.info("runner", "Dev session stopping");
     this.isRunning = false;
     if (this.session) {
       try {
         await stopDevSession(this.appId, this.session.sessionId);
       } catch (err) {
-        log.warn("Failed to stop dev session cleanly", { error: err instanceof Error ? err.message : String(err) });
+        log.warn("runner", "Failed to stop dev session cleanly", { error: err instanceof Error ? err.message : String(err) });
       }
       this.session = null;
     }
+    this.roleOverride = null;
     await cleanupWorker();
     if (this.transpiler) {
       await this.transpiler.cleanup();
@@ -1043,15 +1106,17 @@ var DevRunner = class {
   // Set role override for subsequent method executions.
   async setImpersonation(roles) {
     if (!this.session) return;
-    log.info("Setting role override", { roles });
+    log.info("runner", "Setting role override", { roles });
     await impersonate(this.appId, this.session.sessionId, roles);
+    this.roleOverride = roles;
     await this.refreshClientContext();
   }
   // Clear role override — revert to session's default roles.
   async clearImpersonation() {
     if (!this.session) return;
-    log.info("Clearing role override");
+    log.info("runner", "Clearing role override");
     await impersonate(this.appId, this.session.sessionId, null);
+    this.roleOverride = null;
     await this.refreshClientContext();
   }
   // Fetch fresh clientContext from platform and update the proxy.
@@ -1063,7 +1128,7 @@ var DevRunner = class {
       this.session.clientContext = context;
       this.proxy.updateClientContext(context);
     } catch (err) {
-      log.warn("Failed to refresh session context after role change", { error: err instanceof Error ? err.message : String(err) });
+      log.warn("runner", "Failed to refresh session context after role change", { error: err instanceof Error ? err.message : String(err) });
     }
   }
   // Run a method directly (not via poll loop). Used by headless stdin commands
@@ -1074,15 +1139,22 @@ var DevRunner = class {
     }
     const requestId = randomBytes2(8).toString("hex");
     const startTime = Date.now();
-    log.info("Method received (direct)", { requestId, method: opts.methodExport });
+    log.info("runner", "Method received", { requestId, method: opts.methodExport, source: "direct", sessionId: this.session.sessionId });
     try {
       const authorizationToken = await fetchCallbackToken(this.appId, this.session.sessionId);
       const transpiledPath = await this.transpiler.transpile(opts.methodPath);
+      const auth = this.roleOverride ? {
+        userId: this.session.auth.userId,
+        roleAssignments: this.roleOverride.map((roleName) => ({
+          userId: this.session.auth.userId,
+          roleName
+        }))
+      } : this.session.auth;
       const result = await executeMethod({
         transpiledPath,
         methodExport: opts.methodExport,
         input: opts.input,
-        auth: this.session.auth,
+        auth,
         databases: this.session.databases,
         authorizationToken,
         apiBaseUrl: getApiBaseUrl(),
@@ -1090,13 +1162,14 @@ var DevRunner = class {
       });
       const duration = Date.now() - startTime;
       if (result.success) {
-        log.info("Method complete", { requestId, method: opts.methodExport, duration });
+        log.info("runner", "Method complete", { requestId, method: opts.methodExport, duration, sessionId: this.session.sessionId });
       } else {
-        log.warn("Method failed", {
+        log.warn("runner", "Method failed", {
           requestId,
           method: opts.methodExport,
           duration,
-          error: result.error ? formatErrorForDisplay(result.error) : void 0
+          error: result.error ? formatErrorForDisplay(result.error) : void 0,
+          sessionId: this.session.sessionId
         });
       }
       logMethodExecution({
@@ -1120,7 +1193,7 @@ var DevRunner = class {
     } catch (err) {
       const message = err instanceof Error ? err.message : "Unknown error";
       const duration = Date.now() - startTime;
-      log.error("Method error", { requestId, method: opts.methodExport, duration, error: message });
+      log.error("runner", "Method execution error", { requestId, method: opts.methodExport, duration, error: message, sessionId: this.session.sessionId });
       logMethodExecution({
         requestId,
         sessionId: this.session.sessionId,
@@ -1143,15 +1216,15 @@ var DevRunner = class {
     }
     const startTime = Date.now();
     const scenarioName = scenario.name ?? scenario.export;
-    log.info("Scenario starting", { id: scenario.id, name: scenarioName });
+    log.info("runner", "Scenario starting", { id: scenario.id, name: scenarioName });
     try {
-      log.info("Resetting database for scenario");
+      log.debug("runner", "Resetting database for scenario");
       const databases = await resetDevDatabase(this.appId, this.session.sessionId, "truncate");
       this.session.databases = databases;
-      log.info("Transpiling scenario", { path: scenario.path });
+      log.debug("runner", "Transpiling scenario", { path: scenario.path });
       const transpiledPath = await this.transpiler.transpile(scenario.path);
       const authorizationToken = await fetchCallbackToken(this.appId, this.session.sessionId);
-      log.info("Running scenario seed function", { export: scenario.export });
+      log.debug("runner", "Running scenario seed function", { export: scenario.export });
       const result = await executeMethod({
         transpiledPath,
         methodExport: scenario.export,
@@ -1164,7 +1237,7 @@ var DevRunner = class {
       });
       if (!result.success) {
         const error = result.error?.message ?? "Scenario seed failed";
-        log.error("Scenario seed function failed", { id: scenario.id, error });
+        log.error("runner", "Scenario seed function failed", { id: scenario.id, name: scenarioName, duration: Date.now() - startTime, error });
         logScenarioExecution({
           sessionId: this.session.sessionId,
           scenario,
@@ -1175,12 +1248,12 @@ var DevRunner = class {
         return { success: false, databases, error };
       }
       if (scenario.roles.length > 0) {
-        log.info("Setting role override for scenario", { roles: scenario.roles });
+        log.debug("runner", "Setting role override for scenario", { roles: scenario.roles });
         await impersonate(this.appId, this.session.sessionId, scenario.roles);
         await this.refreshClientContext();
       }
       const duration = Date.now() - startTime;
-      log.info("Scenario complete", { id: scenario.id, duration, roles: scenario.roles });
+      log.info("runner", "Scenario complete", { id: scenario.id, name: scenarioName, duration, roles: scenario.roles });
       logScenarioExecution({
         sessionId: this.session.sessionId,
         scenario,
@@ -1191,7 +1264,7 @@ var DevRunner = class {
       return { success: true, databases };
     } catch (err) {
       const error = err instanceof Error ? err.message : "Unknown error";
-      log.error("Scenario failed", { id: scenario.id, error });
+      log.error("runner", "Scenario failed", { id: scenario.id, name: scenarioName, duration: Date.now() - startTime, error });
       logScenarioExecution({
         sessionId: this.session.sessionId,
         scenario,
@@ -1213,7 +1286,7 @@ var DevRunner = class {
         );
         if (this.hadConnectionWarning) {
           this.hadConnectionWarning = false;
-          log.info("Connection to platform restored");
+          log.info("runner", "Connection to platform restored");
           devRequestEvents.emitConnectionRestored();
         }
         if (request) {
@@ -1222,37 +1295,39 @@ var DevRunner = class {
         this.backoffMs = 1e3;
       } catch (error) {
         if (error instanceof DevPollError && error.statusCode === 404) {
-          log.error("Dev session expired", { statusCode: 404 });
+          log.error("runner", "Dev session expired", { statusCode: 404 });
           devRequestEvents.emitSessionExpired();
           this.isRunning = false;
           return;
         }
         if ((error instanceof DevPollError || error instanceof ApiError) && error.statusCode === 401) {
-          log.warn("Session token expired, re-authenticating");
           const refreshed = await this.refreshAuth();
           if (refreshed) {
             this.backoffMs = 1e3;
             continue;
           }
-          log.error("Re-authentication failed");
+          log.error("runner", "Re-authentication failed");
           devRequestEvents.emitSessionExpired();
           this.isRunning = false;
           return;
         }
         if (!this.hadConnectionWarning) {
           this.hadConnectionWarning = true;
-          log.warn("Lost connection to platform, retrying");
+          log.warn("runner", "Lost connection to platform, retrying");
           devRequestEvents.emitConnectionWarning(
             "Lost connection to platform, retrying..."
           );
         }
-        log.debug("Backing off", { ms: this.backoffMs });
         await this.sleep(this.backoffMs);
         this.backoffMs = Math.min(this.backoffMs * 2, 3e4);
       }
     }
   }
   async handleRequest(request) {
+    if (request.type === "get-agent-config") {
+      await this.handleGetAgentConfig(request);
+      return;
+    }
     const startTime = Date.now();
     devRequestEvents.emitStart({
       id: request.requestId,
@@ -1260,9 +1335,8 @@ var DevRunner = class {
       method: request.methodExport,
       timestamp: startTime
     });
-    log.info("Method received", { requestId: request.requestId, method: request.methodExport });
+    log.info("runner", "Method received", { requestId: request.requestId, method: request.methodExport, source: "poll", sessionId: this.session.sessionId });
     try {
-      log.debug("Transpiling method", { path: request.methodPath });
       const transpiledPath = await this.transpiler.transpile(request.methodPath);
       const auth = request.roleOverride ? {
         userId: this.session.auth.userId,
@@ -1298,13 +1372,14 @@ var DevRunner = class {
       );
       const duration = Date.now() - startTime;
       if (result.success) {
-        log.info("Method complete", { requestId: request.requestId, method: request.methodExport, duration });
+        log.info("runner", "Method complete", { requestId: request.requestId, method: request.methodExport, duration, sessionId: this.session.sessionId });
       } else {
-        log.warn("Method failed", {
+        log.warn("runner", "Method failed", {
           requestId: request.requestId,
           method: request.methodExport,
           duration,
-          error: result.error ? formatErrorForDisplay(result.error) : void 0
+          error: result.error ? formatErrorForDisplay(result.error) : void 0,
+          sessionId: this.session.sessionId
         });
       }
       logMethodExecution({
@@ -1328,7 +1403,7 @@ var DevRunner = class {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       const duration = Date.now() - startTime;
-      log.error("Method error", { requestId: request.requestId, method: request.methodExport, duration, error: message });
+      log.error("runner", "Method execution error", { requestId: request.requestId, method: request.methodExport, duration, error: message, sessionId: this.session.sessionId });
       try {
         await submitDevResult(
           this.appId,
@@ -1341,7 +1416,7 @@ var DevRunner = class {
           }
         );
       } catch (submitErr) {
-        log.error("Failed to report method error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
+        log.error("runner", "Failed to report method error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
       }
       logMethodExecution({
         requestId: request.requestId,
@@ -1363,6 +1438,44 @@ var DevRunner = class {
       });
     }
   }
+  async handleGetAgentConfig(request) {
+    const startTime = Date.now();
+    log.info("runner", "Agent config requested", { requestId: request.requestId, sessionId: this.session.sessionId });
+    try {
+      if (!this.appConfig) {
+        throw new Error("App config not available");
+      }
+      const bundle = readAgentConfig(this.projectRoot, this.appConfig);
+      await submitDevResult(
+        this.appId,
+        this.session.sessionId,
+        request.requestId,
+        {
+          type: "get-agent-config",
+          success: true,
+          output: bundle
+        }
+      );
+      log.info("runner", "Agent config sent", { requestId: request.requestId, duration: Date.now() - startTime });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      log.error("runner", "Agent config failed", { requestId: request.requestId, error: message });
+      try {
+        await submitDevResult(
+          this.appId,
+          this.session.sessionId,
+          request.requestId,
+          {
+            type: "get-agent-config",
+            success: false,
+            error: { message }
+          }
+        );
+      } catch (submitErr) {
+        log.error("runner", "Failed to report agent config error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
+      }
+    }
+  }
   /**
    * Attempt to refresh expired auth credentials via the device auth flow.
    * Opens the browser for the user to re-authorize, polls for the new token.
@@ -1372,14 +1485,14 @@ var DevRunner = class {
     const POLL_INTERVAL = 2e3;
     const MAX_ATTEMPTS = 30;
     try {
-      log.info("Session token expired, requesting re-authentication");
+      log.info("runner", "Session token expired, requesting re-authentication");
       const { url, token } = await requestDeviceAuth();
       devRequestEvents.emitAuthRefreshStart(url);
       try {
         const open = (await import("open")).default;
         await open(url);
       } catch {
-        log.warn("Could not open browser \u2014 visit URL to re-authenticate");
+        log.warn("runner", "Could not open browser \u2014 visit URL to re-authenticate");
       }
       for (let i = 0; i < MAX_ATTEMPTS; i++) {
         await this.sleep(POLL_INTERVAL);
@@ -1390,7 +1503,7 @@ var DevRunner = class {
           if (result.userId) {
             setUserId(result.userId);
           }
-          log.info("Re-authentication successful");
+          log.info("runner", "Re-authentication successful");
           devRequestEvents.emitAuthRefreshSuccess();
           return true;
         }
@@ -1398,11 +1511,11 @@ var DevRunner = class {
           break;
         }
       }
-      log.error("Re-authentication timed out or was denied");
+      log.error("runner", "Re-authentication timed out or was denied");
       devRequestEvents.emitAuthRefreshFailed();
       return false;
     } catch (err) {
-      log.error("Re-authentication failed", { error: err instanceof Error ? err.message : String(err) });
+      log.error("runner", "Re-authentication failed", { error: err instanceof Error ? err.message : String(err) });
       devRequestEvents.emitAuthRefreshFailed();
       return false;
     }
@@ -1417,10 +1530,19 @@ var ndjsonLog2 = new NdjsonLog("browser.ndjson");
 function initBrowserLog(projectRoot) {
   ndjsonLog2.init(projectRoot);
 }
+function inferLevel(entry) {
+  const type = entry.type;
+  if (type === "error") return "error";
+  const level = entry.level;
+  if (level === "warn" || level === "error" || level === "debug") return level;
+  return "info";
+}
 function appendBrowserLogEntries(entries) {
   for (const entry of entries) {
     ndjsonLog2.append({
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ts: Date.now(),
+      level: inferLevel(entry),
+      module: "browser",
       ...entry
     });
   }
@@ -1450,14 +1572,14 @@ var ClientRegistry = class {
       alive: true,
       activeCommandId: null
     });
-    log.info("Browser client connected", { clientId: id, mode: hello.mode, url: hello.url });
+    log.info("proxy", "Browser client connected", { clientId: id, mode: hello.mode, url: hello.url });
     return id;
   }
   remove(id) {
     const client = this.clients.get(id);
     if (client) {
       this.clients.delete(id);
-      log.info("Browser client disconnected", { clientId: id, mode: client.mode });
+      log.info("proxy", "Browser client disconnected", { clientId: id, mode: client.mode });
     }
     return client;
   }
@@ -1473,11 +1595,16 @@ var ClientRegistry = class {
     let fallback = null;
     for (const client of this.clients.values()) {
       if (client.activeCommandId) continue;
+      if (client.mode === "mirror") continue;
       if (client.mode === "iframe") return client;
       if (!fallback) fallback = client;
     }
     return fallback;
   }
+  /** Get all connected mirror-mode clients (for relaying mirror events). */
+  getMirrorClients() {
+    return [...this.clients.values()].filter((c) => c.mode === "mirror");
+  }
   getAll() {
     return [...this.clients.values()];
   }
@@ -1513,7 +1640,7 @@ var ClientRegistry = class {
     const removed = [];
     for (const client of this.clients.values()) {
       if (!client.alive) {
-        log.warn("Browser client timed out (no pong)", { clientId: client.id, activeCommandId: client.activeCommandId });
+        log.warn("proxy", "Browser client timed out (no pong)", { clientId: client.id, activeCommandId: client.activeCommandId });
         removed.push({ clientId: client.id, activeCommandId: client.activeCommandId });
         this.clients.delete(client.id);
         client.ws.terminate();
@@ -1548,7 +1675,6 @@ var DevProxy = class _DevProxy {
   static HELLO_TIMEOUT = 5e3;
   updateClientContext(context) {
     this.clientContext = context;
-    log.info("Dev proxy context updated after role change");
   }
   /**
    * Whether any browser agent is actively connected via WebSocket.
@@ -1563,13 +1689,26 @@ var DevProxy = class _DevProxy {
   dispatchBrowserCommand(steps, timeoutMs = 12e4) {
     if (!this.clients.hasConnected()) {
       return Promise.reject(
-        new Error("No browser connected, please refresh the MindStudio preview")
+        new Error(
+          "No browser connected, please refresh the MindStudio preview"
+        )
       );
     }
     const id = randomBytes4(4).toString("hex");
     return new Promise((resolve2, reject) => {
-      this.commandQueue.push({ id, steps, timeoutMs, resolve: resolve2, reject, queuedAt: Date.now() });
-      log.info("Browser command queued", { id, queueLength: this.commandQueue.length, commands: steps.map((s) => s.command) });
+      this.commandQueue.push({
+        id,
+        steps,
+        timeoutMs,
+        resolve: resolve2,
+        reject,
+        queuedAt: Date.now()
+      });
+      log.debug("proxy", "Browser command queued", {
+        id,
+        queueLength: this.commandQueue.length,
+        commands: steps.map((s) => s.command)
+      });
       this.drainCommandQueue();
     });
   }
@@ -1582,12 +1721,22 @@ var DevProxy = class _DevProxy {
       if (!target) break;
       const queued = this.commandQueue.shift();
       const { id, steps, timeoutMs, resolve: resolve2, reject } = queued;
-      log.info("Browser command sent", { id, clientId: target.id, mode: target.mode, stepCount: steps.length, commands: steps.map((s) => s.command) });
+      log.info("proxy", "Browser command sent", {
+        id,
+        clientId: target.id,
+        mode: target.mode,
+        stepCount: steps.length,
+        commands: steps.map((s) => s.command),
+        queueWaitMs: Date.now() - queued.queuedAt
+      });
       const timeout = setTimeout(() => {
         this.pendingResults.delete(id);
         const client = this.clients.findByCommandId(id);
         if (client) client.activeCommandId = null;
-        log.warn("Browser command timed out", { id, pendingCount: this.pendingResults.size });
+        log.warn("proxy", "Browser command timed out", {
+          id,
+          pendingCount: this.pendingResults.size
+        });
         reject(new Error("Browser command timed out"));
         this.drainCommandQueue();
       }, timeoutMs);
@@ -1599,6 +1748,10 @@ var DevProxy = class _DevProxy {
         this.pendingResults.delete(id);
         clearTimeout(timeout);
         target.activeCommandId = null;
+        log.warn("proxy", "Browser command send failed", {
+          id,
+          clientId: target.id
+        });
         reject(new Error("Failed to send command to browser"));
       }
     }
@@ -1609,7 +1762,10 @@ var DevProxy = class _DevProxy {
   broadcastToClients(action, payload) {
     const msg = JSON.stringify({ type: "broadcast", action, payload });
     const clients = this.clients.getAll();
-    log.info("Broadcasting to browser clients", { action, clientCount: clients.length });
+    log.info("proxy", "Broadcasting to browser clients", {
+      action,
+      clientCount: clients.length
+    });
     for (const client of clients) {
       try {
         client.ws.send(msg);
@@ -1640,10 +1796,13 @@ var DevProxy = class _DevProxy {
         this.proxyPort = assignedPort;
         this.startHealthCheck();
         this.startPingTimer();
-        log.info("Dev proxy started", { port: assignedPort, bind: this.bindAddress });
+        log.info("proxy", "Dev proxy started", {
+          port: assignedPort,
+          bind: this.bindAddress
+        });
         return assignedPort;
       } catch {
-        log.warn("Proxy port in use, trying next", { port });
+        log.warn("proxy", "Proxy port in use, trying next", { port });
       }
     }
     throw new Error("Failed to start proxy server");
@@ -1681,7 +1840,7 @@ var DevProxy = class _DevProxy {
       this.wss = null;
     }
     if (this.server) {
-      log.info("Dev proxy stopping");
+      log.info("proxy", "Dev proxy stopping");
       this.server.close();
       this.server = null;
       this.proxyPort = null;
@@ -1706,7 +1865,10 @@ var DevProxy = class _DevProxy {
     let clientId = null;
     const helloTimeout = setTimeout(() => {
       if (!clientId) {
-        log.warn("Browser WS client did not send hello in time, closing");
+        log.warn(
+          "proxy",
+          "Browser WS client did not send hello in time, closing"
+        );
         ws.close(4e3, "Hello timeout");
       }
     }, _DevProxy.HELLO_TIMEOUT);
@@ -1723,8 +1885,11 @@ var DevProxy = class _DevProxy {
           return;
         }
         clearTimeout(helloTimeout);
-        const mode = msg.mode === "iframe" ? "iframe" : "standalone";
-        const viewport = msg.viewport || { w: 0, h: 0 };
+        const mode = msg.mode === "iframe" ? "iframe" : msg.mode === "mirror" ? "mirror" : "standalone";
+        const viewport = msg.viewport || {
+          w: 0,
+          h: 0
+        };
         clientId = this.clients.add(ws, {
           mode,
           url: String(msg.url || ""),
@@ -1742,6 +1907,9 @@ var DevProxy = class _DevProxy {
             appendBrowserLogEntries(msg.entries);
           }
           break;
+        case "mirror":
+          this.relayMirrorEvents(data.toString());
+          break;
       }
     });
     ws.on("pong", () => {
@@ -1752,7 +1920,10 @@ var DevProxy = class _DevProxy {
       if (clientId) {
         const client = this.clients.remove(clientId);
         if (client?.activeCommandId) {
-          this.rejectPendingCommand(client.activeCommandId, "Browser disconnected during command execution");
+          this.rejectPendingCommand(
+            client.activeCommandId,
+            "Browser disconnected during command execution"
+          );
         }
       }
     });
@@ -1762,12 +1933,16 @@ var DevProxy = class _DevProxy {
   handleCommandResult(msg) {
     const id = msg.id;
     if (!id) {
-      log.warn("Browser command result received with no id");
+      log.warn("proxy", "Browser command result received with no id");
       return;
     }
     const pending2 = this.pendingResults.get(id);
     if (pending2) {
-      log.info("Browser command result received", { id, stepCount: msg.steps?.length, duration: msg.duration });
+      log.info("proxy", "Browser command result received", {
+        id,
+        stepCount: msg.steps?.length,
+        duration: msg.duration
+      });
       clearTimeout(pending2.timeout);
       this.pendingResults.delete(id);
       const client = this.clients.findByCommandId(id);
@@ -1775,7 +1950,11 @@ var DevProxy = class _DevProxy {
       pending2.resolve(msg);
       this.drainCommandQueue();
     } else {
-      log.warn("Browser command result received but no pending command found", { id, pendingIds: [...this.pendingResults.keys()] });
+      log.warn(
+        "proxy",
+        "Browser command result received but no pending command found",
+        { id, pendingIds: [...this.pendingResults.keys()] }
+      );
     }
   }
   rejectPendingCommand(commandId, reason) {
@@ -1784,7 +1963,7 @@ var DevProxy = class _DevProxy {
       clearTimeout(pending2.timeout);
       this.pendingResults.delete(commandId);
       pending2.resolve({ id: commandId, steps: [], error: reason });
-      log.warn("Pending command rejected", { id: commandId, reason });
+      log.warn("proxy", "Pending command rejected", { id: commandId, reason });
       this.drainCommandQueue();
     }
   }
@@ -1796,7 +1975,10 @@ var DevProxy = class _DevProxy {
       const removed = this.clients.sweepDead();
       for (const { activeCommandId } of removed) {
         if (activeCommandId) {
-          this.rejectPendingCommand(activeCommandId, "Browser client timed out");
+          this.rejectPendingCommand(
+            activeCommandId,
+            "Browser client timed out"
+          );
         }
       }
       this.clients.pingAll();
@@ -1820,7 +2002,7 @@ var DevProxy = class _DevProxy {
   markUpstreamDown() {
     if (!this.upstreamUp) return;
     this.upstreamUp = false;
-    log.info("Upstream dev server marked as down (explicit signal)");
+    log.info("proxy", "Upstream dev server marked as down (explicit signal)");
     this.scheduleHealthCheck(_DevProxy.HEALTH_CHECK_INTERVAL_DOWN);
   }
   startHealthCheck() {
@@ -1847,9 +2029,9 @@ var DevProxy = class _DevProxy {
       this.upstreamUp = false;
     }
     if (wasUp && !this.upstreamUp) {
-      log.warn("Upstream dev server is down");
+      log.warn("proxy", "Upstream dev server is down");
     } else if (!wasUp && this.upstreamUp) {
-      log.info("Upstream dev server is back up, reloading browser");
+      log.info("proxy", "Upstream dev server is back up, reloading browser");
       this.broadcastToClients("reload");
     }
     const interval = this.upstreamUp ? _DevProxy.HEALTH_CHECK_INTERVAL : _DevProxy.HEALTH_CHECK_INTERVAL_DOWN;
@@ -1879,6 +2061,10 @@ var DevProxy = class _DevProxy {
         this.handleFontProxy(clientReq, clientRes);
         return;
       }
+      if (clientReq.url === "/__mindstudio_dev__/mirror" && clientReq.method === "GET") {
+        this.serveMirrorPage(clientRes);
+        return;
+      }
     }
     if (clientReq.method === "OPTIONS" && clientReq.headers.origin) {
       clientRes.writeHead(204, {
@@ -1902,7 +2088,10 @@ var DevProxy = class _DevProxy {
         port: this.upstreamPort,
         path: clientReq.url,
         method: clientReq.method,
-        headers: { ...clientReq.headers, host: `localhost:${this.upstreamPort}` }
+        headers: {
+          ...clientReq.headers,
+          host: `localhost:${this.upstreamPort}`
+        }
       },
       (upstreamRes) => {
         const contentType = upstreamRes.headers["content-type"] ?? "";
@@ -1921,7 +2110,6 @@ var DevProxy = class _DevProxy {
             };
             delete headers["content-encoding"];
             delete headers["etag"];
-            log.debug("Dev proxy injected context into HTML", { path: clientReq.url, size: html.length });
             clientRes.writeHead(upstreamRes.statusCode ?? 200, headers);
             clientRes.end(html);
           });
@@ -1938,7 +2126,10 @@ var DevProxy = class _DevProxy {
       }
     );
     upstreamReq.on("error", (err) => {
-      log.warn("Dev proxy cannot reach dev server", { path: clientReq.url, error: err.message });
+      log.warn("proxy", "Dev proxy cannot reach dev server", {
+        path: clientReq.url,
+        error: err.message
+      });
       clientRes.writeHead(502);
       clientRes.end(`Proxy error: ${err.message}`);
     });
@@ -1964,6 +2155,91 @@ var DevProxy = class _DevProxy {
       clientRes.end();
     });
   }
+  /** Relay a raw mirror message (already JSON-stringified) to all mirror viewers. */
+  relayMirrorEvents(raw) {
+    const mirrors = this.clients.getMirrorClients();
+    for (const client of mirrors) {
+      try {
+        client.ws.send(raw);
+      } catch {
+      }
+    }
+  }
+  /** Serve the mirror replay page — an rrweb Replayer in live mode. */
+  serveMirrorPage(res) {
+    const html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Mobile Mirror</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    html, body { height: 100%; background: #111; overflow: hidden; }
+    #player { width: 100%; height: 100%; display: flex; align-items: center; justify-content: center; }
+    .replayer-wrapper { box-shadow: 0 0 40px rgba(0,0,0,0.5); border-radius: 4px; overflow: hidden; }
+    #status { position: fixed; bottom: 16px; left: 50%; transform: translateX(-50%); color: #666; font-family: -apple-system, system-ui, sans-serif; font-size: 13px; }
+  </style>
+</head>
+<body>
+  <div id="player"></div>
+  <div id="status">Waiting for mobile device...</div>
+  <script src="https://cdn.jsdelivr.net/npm/rrweb@2.0.0-alpha.13/dist/rrweb.umd.cjs.js"></script>
+  <script>
+    (function() {
+      var proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+      var ws = new WebSocket(proto + '//' + location.host + '/__mindstudio_dev__/ws');
+      var replayer = null;
+      var status = document.getElementById('status');
+
+      ws.onopen = function() {
+        ws.send(JSON.stringify({
+          type: 'hello',
+          mode: 'mirror',
+          url: location.href,
+          viewport: { w: window.innerWidth, h: window.innerHeight }
+        }));
+      };
+
+      ws.onmessage = function(e) {
+        var msg;
+        try { msg = JSON.parse(e.data); } catch(e) { return; }
+
+        if (msg.type !== 'mirror' || !Array.isArray(msg.events)) return;
+
+        for (var i = 0; i < msg.events.length; i++) {
+          var event = msg.events[i];
+          if (!replayer) {
+            replayer = new rrweb.Replayer([], {
+              root: document.getElementById('player'),
+              liveMode: true,
+              insertStyleRules: [
+                '.replayer-wrapper { position: relative !important; }',
+              ],
+            });
+            replayer.startLive(Date.now() - 500);
+            status.textContent = 'Connected';
+            setTimeout(function() { status.style.opacity = '0'; }, 2000);
+          }
+          replayer.addEvent(event);
+        }
+      };
+
+      ws.onclose = function() {
+        status.style.opacity = '1';
+        status.textContent = 'Disconnected \u2014 reconnecting...';
+        setTimeout(function() { location.reload(); }, 2000);
+      };
+    })();
+  </script>
+</body>
+</html>`;
+    res.writeHead(200, {
+      "content-type": "text/html; charset=utf-8",
+      "cache-control": "no-store"
+    });
+    res.end(html);
+  }
   /**
    * Proxy a cross-origin font stylesheet or font file through our server,
    * adding CORS headers so the browser agent can read the @font-face rules.
@@ -2005,7 +2281,9 @@ var DevProxy = class _DevProxy {
       clientRes.end(body);
     } catch (err) {
       clientRes.writeHead(502, cors);
-      clientRes.end(`Font proxy error: ${err instanceof Error ? err.message : String(err)}`);
+      clientRes.end(
+        `Font proxy error: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
   }
   /**
@@ -2027,7 +2305,6 @@ ${agentScript}`;
   // Upstream WebSocket forwarding (HMR etc.)
   // ---------------------------------------------------------------------------
   handleUpstreamUpgrade(clientReq, clientSocket, head) {
-    log.debug("Dev proxy WebSocket upgrade (upstream)", { path: clientReq.url });
     const options = {
       hostname: "127.0.0.1",
       port: this.upstreamPort,
@@ -2066,16 +2343,13 @@ ${agentScript}`;
 };
 
 // src/dev/config/app-config.ts
-import { readFileSync, existsSync as existsSync2 } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
 function detectAppConfig(cwd = process.cwd()) {
-  const appJsonPath = join4(cwd, "mindstudio.json");
-  if (!existsSync2(appJsonPath)) {
-    log.debug("mindstudio.json not found", { path: appJsonPath });
-    return null;
-  }
+  const appJsonPath = join6(cwd, "mindstudio.json");
+  if (!existsSync2(appJsonPath)) return null;
   try {
-    const raw = readFileSync(appJsonPath, "utf-8");
+    const raw = readFileSync2(appJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.name || !Array.isArray(parsed.methods)) {
       return null;
@@ -2090,7 +2364,7 @@ function detectAppConfig(cwd = process.cwd()) {
       scenarios: parsed.scenarios ?? [],
       interfaces: parsed.interfaces ?? []
     };
-    log.info("Loaded mindstudio.json", {
+    log.info("config", "Loaded mindstudio.json", {
       appId: config2.appId,
       roles: config2.roles.length,
       methods: config2.methods.length,
@@ -2100,7 +2374,7 @@ function detectAppConfig(cwd = process.cwd()) {
     });
     return config2;
   } catch (err) {
-    log.warn("Failed to parse mindstudio.json", { error: err instanceof Error ? err.message : String(err) });
+    log.warn("config", "Failed to parse mindstudio.json", { error: err instanceof Error ? err.message : String(err) });
     return null;
   }
 }
@@ -2111,12 +2385,12 @@ function getWebInterfaceConfig(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  const configPath = join4(cwd, webInterface.path);
+  const configPath = join6(cwd, webInterface.path);
   if (!existsSync2(configPath)) {
     return null;
   }
   try {
-    const raw = readFileSync(configPath, "utf-8");
+    const raw = readFileSync2(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     const web = parsed.web;
     if (!web || typeof web !== "object") {
@@ -2137,26 +2411,26 @@ function getWebProjectDir(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  return dirname2(join4(cwd, webInterface.path));
+  return dirname3(join6(cwd, webInterface.path));
 }
 function readTableSources(appConfig, cwd = process.cwd()) {
   const results = [];
   for (const table of appConfig.tables) {
-    const filePath = join4(cwd, table.path);
+    const filePath = join6(cwd, table.path);
     if (!existsSync2(filePath)) {
-      log.warn("Table source file not found", { table: table.export, path: table.path });
+      log.warn("config", "Table source file not found", { table: table.export, path: table.path });
       continue;
     }
     try {
-      const source = readFileSync(filePath, "utf-8");
+      const source = readFileSync2(filePath, "utf-8");
       const name = table.export;
       results.push({ name, source });
     } catch (err) {
-      log.warn("Table source file unreadable", { table: table.export, path: table.path, error: err instanceof Error ? err.message : String(err) });
+      log.warn("config", "Table source file unreadable", { table: table.export, path: table.path, error: err instanceof Error ? err.message : String(err) });
     }
   }
   if (results.length < appConfig.tables.length) {
-    log.warn("Missing " + (appConfig.tables.length - results.length) + " table source file(s)", { found: results.length, expected: appConfig.tables.length });
+    log.warn("config", "Table source files missing", { missing: appConfig.tables.length - results.length, found: results.length, expected: appConfig.tables.length });
   }
   return results;
 }
@@ -2166,9 +2440,9 @@ function findDirsNeedingInstall(appConfig, cwd = process.cwd()) {
     const firstMethodPath = appConfig.methods[0].path;
     const parts = firstMethodPath.split("/");
     for (let i = parts.length - 1; i >= 1; i--) {
-      const candidate = join4(cwd, ...parts.slice(0, i));
-      if (existsSync2(join4(candidate, "package.json"))) {
-        if (!existsSync2(join4(candidate, "node_modules"))) {
+      const candidate = join6(cwd, ...parts.slice(0, i));
+      if (existsSync2(join6(candidate, "package.json"))) {
+        if (!existsSync2(join6(candidate, "node_modules"))) {
           dirs.push(candidate);
         }
         break;
@@ -2176,8 +2450,8 @@ function findDirsNeedingInstall(appConfig, cwd = process.cwd()) {
     }
   }
   const webProjectDir = getWebProjectDir(appConfig, cwd);
-  if (webProjectDir && existsSync2(join4(webProjectDir, "package.json"))) {
-    if (!existsSync2(join4(webProjectDir, "node_modules"))) {
+  if (webProjectDir && existsSync2(join6(webProjectDir, "package.json"))) {
+    if (!existsSync2(join6(webProjectDir, "node_modules"))) {
       dirs.push(webProjectDir);
     }
   }
@@ -2206,11 +2480,11 @@ function detectGitBranch() {
 
 // src/dev/config/table-watcher.ts
 import { watch } from "chokidar";
-import { join as join5, dirname as dirname3, basename as basename2 } from "path";
+import { join as join7, dirname as dirname4, basename as basename2 } from "path";
 function watchTableFiles(tables, cwd, onChanged) {
   if (tables.length === 0) return () => {
   };
-  const filePaths = tables.map((t) => join5(cwd, t.path));
+  const filePaths = tables.map((t) => join7(cwd, t.path));
   let syncTimer;
   const watcher = watch(filePaths, {
     ignoreInitial: true,
@@ -2223,13 +2497,13 @@ function watchTableFiles(tables, cwd, onChanged) {
   });
   const dirToFiles = /* @__PURE__ */ new Map();
   for (const table of tables) {
-    const absPath = join5(cwd, table.path);
-    const dir = dirname3(absPath);
+    const absPath = join7(cwd, table.path);
+    const dir = dirname4(absPath);
     const file = basename2(absPath);
     if (!dirToFiles.has(dir)) dirToFiles.set(dir, /* @__PURE__ */ new Set());
     dirToFiles.get(dir).add(file);
   }
-  log.info("Watching table source files", {
+  log.info("config", "Watching table source files", {
     dirs: dirToFiles.size,
     tables: tables.length
   });
@@ -2241,9 +2515,9 @@ function watchTableFiles(tables, cwd, onChanged) {
 
 // src/dev/config/config-watcher.ts
 import { watch as watch2 } from "chokidar";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 function watchConfigFile(cwd, onChanged) {
-  const configPath = join6(cwd, "mindstudio.json");
+  const configPath = join8(cwd, "mindstudio.json");
   let debounceTimer;
   const watcher = watch2(configPath, {
     ignoreInitial: true,
@@ -2255,7 +2529,7 @@ function watchConfigFile(cwd, onChanged) {
       onChanged();
     }, 500);
   });
-  log.info("Watching mindstudio.json for changes", { path: configPath });
+  log.info("config", "Watching mindstudio.json for changes", { path: configPath });
   return () => {
     clearTimeout(debounceTimer);
     watcher.close();
@@ -2310,4 +2584,4 @@ export {
   watchTableFiles,
   watchConfigFile
 };
-//# sourceMappingURL=chunk-KAGWWCYB.js.map
+//# sourceMappingURL=chunk-WECAPRKN.js.map