@rubytech/create-realagent 1.0.406 → 1.0.424

package/payload/maxy/server.js

@@ -2845,7 +2845,7 @@ var serveStatic = (options = { root: "" }) => {
 };
 
 // server/index.ts
-import { readFileSync as readFileSync17, existsSync as existsSync16, watchFile } from "fs";
+import { readFileSync as readFileSync17, existsSync as existsSync17, watchFile } from "fs";
 import { resolve as resolve15, join as join5 } from "path";
 import { homedir as homedir2 } from "os";
 
@@ -3666,6 +3666,24 @@ var VALID_CATEGORIES = /* @__PURE__ */ new Set([
   "content",
   "interaction"
 ]);
+async function getUserTimezone(accountId) {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (up:UserProfile {accountId: $accountId})
+       RETURN up.timezone AS timezone`,
+      { accountId }
+    );
+    if (result.records.length === 0) return null;
+    const tz = result.records[0].get("timezone");
+    return tz && tz.trim().length > 0 ? tz : null;
+  } catch (err) {
+    console.error(`[datetime] getUserTimezone failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  } finally {
+    await session.close();
+  }
+}
 async function loadUserProfile(accountId) {
   const session = getSession();
   try {
@@ -3804,7 +3822,7 @@ async function loadSessionContext(accountId) {
   try {
     const summaryResult = await session.run(
       `MATCH (n:CreativeWork {accountId: $accountId})
-       WHERE n.title STARTS WITH 'Session Summary'
+       WHERE n.title STARTS WITH 'Session Summary' OR n.title = 'Session Snapshot'
        RETURN n.title AS title, n.createdAt AS createdAt, n.abstract AS abstract
        ORDER BY n.createdAt DESC LIMIT 1`,
       { accountId }
@@ -3831,17 +3849,27 @@ async function loadSessionContext(accountId) {
          END,
          t.createdAt DESC
        LIMIT $limit`,
-      { accountId, limit: MAX_SESSION_TASKS }
+      { accountId, limit: neo4j.int(MAX_SESSION_TASKS) }
     );
     const sections = [];
+    const STALENESS_LIMIT_MS = 48 * 60 * 60 * 1e3;
     if (summaryResult.records.length > 0) {
       const rec = summaryResult.records[0];
       const title = rec.get("title");
       const createdAt = rec.get("createdAt");
       const abstract = rec.get("abstract");
-      const dateSuffix = createdAt ? ` (${createdAt.slice(0, 10)})` : "";
-      sections.push(`## Last Session${dateSuffix}
+      let isStale = false;
+      if (createdAt) {
+        const ageMs = Date.now() - new Date(createdAt).getTime();
+        isStale = !isNaN(ageMs) && ageMs > STALENESS_LIMIT_MS;
+      }
+      if (isStale) {
+        console.error(`[session-context] Skipped stale summary for ${accountId.slice(0, 8)}\u2026: title="${title}" createdAt=${createdAt}`);
+      } else {
+        const dateSuffix = createdAt ? ` (${createdAt.slice(0, 10)})` : "";
+        sections.push(`## Last Session${dateSuffix}
 ${abstract}`);
+      }
     }
     if (digestResult.records.length > 0) {
       const rec = digestResult.records[0];
@@ -3867,8 +3895,9 @@ ${abstract}`);
 ${taskLines.join("\n")}`);
     }
     if (sections.length === 0) return null;
+    const summaryCreatedAt = summaryResult.records.length > 0 ? summaryResult.records[0].get("createdAt") ?? "unknown" : "n/a";
     console.error(
-      `[session-context] Loaded for ${accountId.slice(0, 8)}\u2026: summary=${summaryResult.records.length > 0 ? "yes" : "no"}, digest=${digestResult.records.length > 0 ? "yes" : "no"}, tasks=${tasksResult.records.length}`
+      `[session-context] Loaded for ${accountId.slice(0, 8)}\u2026: summary=${summaryResult.records.length > 0 ? "yes" : "no"}, summaryDate=${summaryCreatedAt}, digest=${digestResult.records.length > 0 ? "yes" : "no"}, tasks=${tasksResult.records.length}`
     );
     return `<previous-context>
 ${sections.join("\n\n")}
@@ -3880,6 +3909,22 @@ ${sections.join("\n\n")}
     await session.close();
   }
 }
+async function writeSessionSummary(accountId, summary) {
+  const session = getSession();
+  try {
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    await session.run(
+      `MERGE (n:CreativeWork {accountId: $accountId, title: 'Session Snapshot'})
+       SET n.abstract = $summary, n.createdAt = $createdAt, n.scope = 'admin'`,
+      { accountId, summary, createdAt }
+    );
+    console.error(`[session-summary] Written for ${accountId.slice(0, 8)}\u2026`);
+  } catch (err) {
+    console.error(`[session-summary] Failed for ${accountId.slice(0, 8)}\u2026: ${err instanceof Error ? err.message : String(err)}`);
+  } finally {
+    await session.close();
+  }
+}
 async function loadOnboardingStep(accountId) {
   const session = getSession();
   try {
@@ -4076,19 +4121,20 @@ async function writeReflectionPreferences(accountId, conversationId, updates) {
 
 // app/lib/claude-agent.ts
 var LOG_RETENTION_DAYS = 7;
-function agentLogStream(name) {
-  mkdirSync2(LOG_DIR, { recursive: true });
+function agentLogStream(name, accountDir) {
+  const logDir = resolve4(accountDir, "logs");
+  mkdirSync2(logDir, { recursive: true });
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const cutoff = Date.now() - LOG_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
   try {
-    for (const file of readdirSync(LOG_DIR)) {
+    for (const file of readdirSync(logDir)) {
       if (!file.startsWith(`${name}-`)) continue;
-      const filePath = resolve4(LOG_DIR, file);
+      const filePath = resolve4(logDir, file);
       if (statSync2(filePath).mtimeMs < cutoff) unlinkSync(filePath);
     }
   } catch {
   }
-  return createWriteStream(resolve4(LOG_DIR, `${name}-${date}.log`), { flags: "a" });
+  return createWriteStream(resolve4(logDir, `${name}-${date}.log`), { flags: "a" });
 }
 var PLATFORM_ROOT3 = process.env.MAXY_PLATFORM_ROOT ?? resolve4(process.cwd(), "..");
 var ACCOUNTS_DIR = resolve4(PLATFORM_ROOT3, "config/accounts");
@@ -4299,6 +4345,7 @@ function parsePluginFrontmatter(pluginDir) {
     return items;
   }
   const tools = parseYamlList("tools");
+  const hidden = parseYamlList("hidden");
   const requires = parseYamlList("requires");
   let taskmaster = {};
   const metaMatch = fm.match(/^metadata:\s*(.+)$/m);
@@ -4316,10 +4363,105 @@ function parsePluginFrontmatter(pluginDir) {
     name: nameMatch?.[1]?.trim() ?? pluginDir,
     description,
     tools,
+    hidden,
     requires,
     taskmaster
   };
 }
+function assemblePublicPluginContent(pluginDir) {
+  const pluginRoot = resolve4(PLATFORM_ROOT3, "plugins", pluginDir);
+  const pluginPath = resolve4(pluginRoot, "PLUGIN.md");
+  let raw2;
+  try {
+    raw2 = readFileSync5(pluginPath, "utf-8");
+  } catch {
+    return null;
+  }
+  const pluginBody = raw2.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
+  if (!pluginBody) return null;
+  const parts = [pluginBody];
+  let skillCount = 0;
+  let refCount = 0;
+  const skillsDir = resolve4(pluginRoot, "skills");
+  let skillDirs;
+  try {
+    skillDirs = readdirSync(skillsDir).sort();
+  } catch {
+    return { body: pluginBody, skillCount: 0, refCount: 0 };
+  }
+  for (const skillName of skillDirs) {
+    const skillDir = resolve4(skillsDir, skillName);
+    const skillMdPath = resolve4(skillDir, "SKILL.md");
+    let skillRaw;
+    try {
+      skillRaw = readFileSync5(skillMdPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const fmMatch = skillRaw.match(/^---\n([\s\S]*?)\n---/);
+    let publicEmbed = true;
+    const publicExcludeReferences = [];
+    if (fmMatch) {
+      const fm = fmMatch[1];
+      const embedMatch = fm.match(/^publicEmbed:\s*(.+)$/m);
+      if (embedMatch && embedMatch[1].trim() === "false") {
+        publicEmbed = false;
+      }
+      const fmLines = fm.split("\n");
+      let insideExclude = false;
+      for (const line of fmLines) {
+        if (/^publicExcludeReferences:/.test(line)) {
+          if (/^publicExcludeReferences:\s*\[]/.test(line)) break;
+          insideExclude = true;
+          continue;
+        }
+        if (insideExclude) {
+          const m = line.match(/^  - (.+)/);
+          if (m) {
+            publicExcludeReferences.push(m[1].trim());
+          } else {
+            break;
+          }
+        }
+      }
+    }
+    if (!publicEmbed) {
+      console.log(`[plugins] ${pluginDir}/skills/${skillName}: publicEmbed=false \u2014 skipping for public`);
+      continue;
+    }
+    const skillBody = skillRaw.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
+    if (!skillBody) continue;
+    parts.push(`
+<!-- skill: ${skillName} -->`);
+    parts.push(skillBody);
+    const refsDir = resolve4(skillDir, "references");
+    let refFiles;
+    try {
+      refFiles = readdirSync(refsDir).filter((f) => f.endsWith(".md")).filter((f) => !publicExcludeReferences.includes(f)).sort();
+    } catch {
+      parts.push(`<!-- /skill: ${skillName} -->`);
+      skillCount++;
+      continue;
+    }
+    for (const refFile of refFiles) {
+      try {
+        const refContent = readFileSync5(resolve4(refsDir, refFile), "utf-8").trim();
+        if (refContent) {
+          parts.push(`
+<!-- reference: ${refFile} -->`);
+          parts.push(refContent);
+          parts.push(`<!-- /reference: ${refFile} -->`);
+          refCount++;
+        }
+      } catch {
+        console.warn(`[plugins] ${pluginDir}/skills/${skillName}/references/${refFile}: unreadable \u2014 skipping`);
+      }
+    }
+    parts.push(`<!-- /skill: ${skillName} -->`);
+    skillCount++;
+  }
+  return { body: parts.join("\n"), skillCount, refCount };
+}
 function loadEmbeddedPlugins(agentType, selectedPlugins, enabledPlugins) {
   const pluginsDir = resolve4(PLATFORM_ROOT3, "plugins");
   let dirs;
@@ -4362,25 +4504,129 @@ function loadEmbeddedPlugins(agentType, selectedPlugins, enabledPlugins) {
       }
     }
     if (selectedPlugins && !selectedPlugins.includes(dir)) continue;
-    const pluginPath = resolve4(pluginsDir, dir, "PLUGIN.md");
-    let raw2;
-    try {
-      raw2 = readFileSync5(pluginPath, "utf-8");
-    } catch {
-      continue;
-    }
-    const body = raw2.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
-    if (body) {
-      results.push({ name: dir, chars: body.length, body });
-      console.log(`[plugins] loaded ${dir} for ${agentType} (${body.length} chars)`);
+    if (agentType === "public") {
+      const assembled = assemblePublicPluginContent(dir);
+      if (assembled) {
+        results.push({ name: dir, chars: assembled.body.length, body: assembled.body });
+        console.log(`[plugins] loaded ${dir} for public (${assembled.body.length} chars, ${assembled.skillCount} skills, ${assembled.refCount} refs)`);
+      }
+    } else {
+      const pluginPath = resolve4(pluginsDir, dir, "PLUGIN.md");
+      let raw2;
+      try {
+        raw2 = readFileSync5(pluginPath, "utf-8");
+      } catch {
+        continue;
+      }
+      const body = raw2.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
+      if (body) {
+        results.push({ name: dir, chars: body.length, body });
+        console.log(`[plugins] loaded ${dir} for ${agentType} (${body.length} chars)`);
+      }
     }
   }
   if (results.length === 0) {
     console.log(`[plugins] no embedded plugins for agentType=${agentType}`);
+  } else if (agentType === "public") {
+    const totalChars = results.reduce((sum, r) => sum + r.chars, 0);
+    console.log(`[plugins] total embedded for public: ${totalChars} chars across ${results.length} plugins`);
   }
   return results;
 }
-function buildPluginManifest(enabledPlugins) {
+var mcpToolsCache = /* @__PURE__ */ new Map();
+function fetchMcpToolsList(pluginDir) {
+  const cached = mcpToolsCache.get(pluginDir);
+  if (cached) return Promise.resolve(cached);
+  const serverPath = resolve4(PLATFORM_ROOT3, "plugins", pluginDir, "mcp/dist/index.js");
+  if (!existsSync5(serverPath)) return Promise.resolve([]);
+  const startMs = Date.now();
+  return new Promise((resolvePromise) => {
+    const proc = spawn(process.execPath, [serverPath], {
+      env: {
+        ...process.env,
+        PLATFORM_ROOT: PLATFORM_ROOT3,
+        ACCOUNT_ID: "__toolslist__"
+      }
+    });
+    let buffer = "";
+    let stderrBuf = "";
+    let settled = false;
+    const TOOLS_LIST_ID = 2;
+    const settle = (tools, reason) => {
+      if (settled) return;
+      settled = true;
+      proc.kill();
+      const elapsed = Date.now() - startMs;
+      if (tools.length > 0) {
+        mcpToolsCache.set(pluginDir, tools);
+        console.error(`[plugin-manifest] ${pluginDir}: ${tools.length} tools via MCP (${elapsed}ms)`);
+      } else {
+        console.error(`[plugin-manifest] ${pluginDir}: tools/list failed (${reason}) (${elapsed}ms)${stderrBuf ? ` stderr: ${stderrBuf.slice(0, 300)}` : ""}`);
+      }
+      resolvePromise(tools);
+    };
+    proc.stdout.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (msg.id === 1) {
+          proc.stdin.write(
+            JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n"
+          );
+          proc.stdin.write(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: TOOLS_LIST_ID,
+              method: "tools/list",
+              params: {}
+            }) + "\n"
+          );
+        } else if (msg.id === TOOLS_LIST_ID) {
+          const result = msg.result;
+          const rawTools = result?.tools;
+          if (Array.isArray(rawTools)) {
+            const tools = rawTools.filter((t) => typeof t.name === "string" && t.name.length > 0).map((t) => ({
+              name: t.name,
+              description: typeof t.description === "string" ? t.description : ""
+            }));
+            settle(tools, "success");
+          } else {
+            settle([], "no tools array in response");
+          }
+        }
+      }
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderrBuf += chunk.toString();
+    });
+    proc.on("error", (err) => settle([], `spawn error: ${err.message}`));
+    proc.on("close", (code) => {
+      if (!settled) settle([], `process exited with code ${code}`);
+    });
+    proc.stdin.write(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "maxy-manifest", version: "1.0" }
+        }
+      }) + "\n"
+    );
+    setTimeout(() => settle([], "timeout (5s)"), 5e3);
+  });
+}
+async function buildPluginManifest(enabledPlugins) {
   const pluginsDir = resolve4(PLATFORM_ROOT3, "plugins");
   let dirs;
   try {
@@ -4389,7 +4635,7 @@ function buildPluginManifest(enabledPlugins) {
     return "";
   }
   const enabled = Array.isArray(enabledPlugins) ? enabledPlugins : [];
-  const lines = ["<plugin-manifest>"];
+  const activePlugins = [];
   for (const dir of dirs.sort()) {
     const parsed = parsePluginFrontmatter(dir);
     if (!parsed) continue;
@@ -4402,6 +4648,19 @@ function buildPluginManifest(enabledPlugins) {
       });
       if (missing.length > 0) continue;
     }
+    activePlugins.push({ dir, parsed });
+  }
+  const mcpResults = await Promise.all(
+    activePlugins.map(({ dir }) => fetchMcpToolsList(dir))
+  );
+  const lines = ["<plugin-manifest>"];
+  let totalTools = 0;
+  let mcpSourced = 0;
+  let fallbackSourced = 0;
+  let noServer = 0;
+  for (let i = 0; i < activePlugins.length; i++) {
+    const { dir, parsed } = activePlugins[i];
+    const mcpTools = mcpResults[i];
     const pluginRoot = resolve4(pluginsDir, dir);
     const skills = [];
     const references = [];
@@ -4429,14 +4688,39 @@ function buildPluginManifest(enabledPlugins) {
     };
     scanDir("skills", "skills/", skills);
     scanDir("references", "references/", references);
+    const hiddenSet = new Set(parsed.hidden);
+    let toolLines = [];
+    if (mcpTools.length > 0) {
+      mcpSourced++;
+      for (const tool of mcpTools) {
+        if (hiddenSet.has(tool.name)) continue;
+        const desc = tool.description ? tool.description.split(/\.\s/)[0].replace(/\.$/, "") : "";
+        toolLines.push(desc ? `  ${tool.name} \u2014 ${desc}` : `  ${tool.name}`);
+      }
+    } else if (parsed.tools.length > 0) {
+      const serverPath = resolve4(PLATFORM_ROOT3, "plugins", dir, "mcp/dist/index.js");
+      if (existsSync5(serverPath)) {
+        fallbackSourced++;
+        console.error(`[plugin-manifest] ${dir}: tools/list empty \u2014 fallback to frontmatter (${parsed.tools.length} tools)`);
+      }
+      for (const name of parsed.tools) {
+        if (hiddenSet.has(name)) continue;
+        toolLines.push(`  ${name}`);
+      }
+    } else {
+      noServer++;
+    }
+    totalTools += toolLines.length;
     lines.push(`
 ## ${dir}`);
     if (parsed.description) lines.push(parsed.description);
-    if (parsed.tools.length > 0) lines.push(`Tools: ${parsed.tools.join(", ")}`);
+    if (toolLines.length > 0) lines.push(`Tools:
+${toolLines.join("\n")}`);
     if (skills.length > 0) lines.push(`Skills: ${skills.join(", ")}`);
     if (references.length > 0) lines.push(`References: ${references.join(", ")}`);
   }
   lines.push("\n</plugin-manifest>");
+  console.error(`[plugin-manifest] plugins=${activePlugins.length} tools=${totalTools} (mcp=${mcpSourced} fallback=${fallbackSourced} no-server=${noServer})`);
   const dormantLines = [];
   for (const dir of dirs.sort()) {
     const parsed = parsePluginFrontmatter(dir);
@@ -4520,7 +4804,16 @@ function validateSession(sessionKey, agentType) {
   if (!session) return false;
   if (session.agentType !== agentType) return false;
   if (Date.now() - session.createdAt > 24 * 60 * 60 * 1e3) {
+    const history = session.messageHistory;
+    const expiredAccountId = session.accountId;
     sessionStore.delete(sessionKey);
+    if (history && history.length >= 2) {
+      writeEndOfTurnSummary(expiredAccountId, history).catch(
+        (err) => console.error(`[session-summary] expiry write failed: ${err instanceof Error ? err.message : String(err)}`)
+      );
+    } else {
+      console.error(`[session-summary] Session ${sessionKey.slice(0, 8)}\u2026 expired without summary \u2014 ${history?.length ?? 0} messages`);
+    }
     return false;
   }
   if (session.grantExpiresAt && Date.now() > session.grantExpiresAt) {
@@ -4804,6 +5097,80 @@ function getAdminAllowedTools(enabledPlugins) {
   }
   return tools;
 }
+var QUERY_CLASSIFIER_MODEL = "claude-haiku-4-5-20251001";
+var QUERY_CLASSIFIER_TIMEOUT_MS = 3e3;
+var QUERY_CLASSIFIER_MSG_CAP = 500;
+var QUERY_CLASSIFIER_HISTORY_TURNS = 4;
+var QUERY_CLASSIFIER_FALLBACK = {
+  search: true,
+  query: null,
+  // null means "use raw message"
+  reason: "classifier-fallback"
+};
+var QUERY_CLASSIFIER_SYSTEM = `You decide whether a user message to a business assistant requires a knowledge base search.
+
+The knowledge base contains the business's products, services, pricing, policies, and domain expertise. It does NOT contain conversation history \u2014 the assistant already has that.
+
+Respond with ONLY a JSON object: {"search": boolean, "query": string | null, "reason": string}
+
+Set search to false when:
+- The message is a greeting, farewell, acknowledgement, or filler ("hello", "thanks", "ok", "bye")
+- The message is about session state ("continue where we left off", "what were we discussing")
+- The conversation history already contains sufficient information to answer the question
+- The message is a conversational response that doesn't require new factual knowledge
+
+Set search to true when:
+- The message asks about products, services, pricing, capabilities, or business information
+- The message introduces a new topic not already covered in the conversation
+- The message requires factual knowledge the assistant wouldn't have from conversation alone
+
+When search is true, set query to a search-optimised phrase that captures the information need. Resolve references from conversation history \u2014 e.g. if the user says "tell me more about the first one" and the history mentions "property valuations", set query to "property valuations details". If the raw message is already a good search query, use it as-is.
+
+When search is false, set query to null and reason to a brief category (e.g. "greeting", "acknowledgement", "session-reference", "context-sufficient").`;
+async function classifyMemoryQuery(message, history) {
+  let apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    try {
+      apiKey = readFileSync5(API_KEY_FILE, "utf-8").trim();
+    } catch {
+    }
+  }
+  if (!apiKey) return QUERY_CLASSIFIER_FALLBACK;
+  const recentHistory = history.slice(-QUERY_CLASSIFIER_HISTORY_TURNS);
+  const transcript = recentHistory.length > 0 ? recentHistory.map((m) => `[${m.role}] ${m.content.slice(0, QUERY_CLASSIFIER_MSG_CAP)}`).join("\n") : "(no conversation history \u2014 this is the first message)";
+  const userContent = [
+    `Conversation history:
+${transcript}`,
+    `
+Current message:
+${message.slice(0, QUERY_CLASSIFIER_MSG_CAP)}`
+  ].join("\n");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), QUERY_CLASSIFIER_TIMEOUT_MS);
+  try {
+    const client = new Anthropic({ apiKey });
+    const response = await client.messages.create({
+      model: QUERY_CLASSIFIER_MODEL,
+      max_tokens: 150,
+      system: QUERY_CLASSIFIER_SYSTEM,
+      messages: [{ role: "user", content: userContent }]
+    }, { signal: controller.signal });
+    const text = response.content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("").trim();
+    if (!text) return QUERY_CLASSIFIER_FALLBACK;
+    const jsonStr = text.replace(/^```json\s*/i, "").replace(/```\s*$/, "").trim();
+    const parsed = JSON.parse(jsonStr);
+    if (typeof parsed.search !== "boolean") return QUERY_CLASSIFIER_FALLBACK;
+    return {
+      search: parsed.search,
+      query: parsed.search && typeof parsed.query === "string" ? parsed.query.slice(0, QUERY_CLASSIFIER_MSG_CAP) : null,
+      reason: typeof parsed.reason === "string" ? parsed.reason.replace(/[\n\r]/g, " ").slice(0, 100) : "unknown"
+    };
+  } catch {
+    return QUERY_CLASSIFIER_FALLBACK;
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function fetchMemoryContext(accountId, query, sessionKey, options) {
   const serverPath = resolve4(PLATFORM_ROOT3, "plugins/memory/mcp/dist/index.js");
   if (!existsSync5(serverPath)) {
@@ -5199,6 +5566,65 @@ Extract preference updates as JSON array.`
     clearTimeout(timer);
   }
 }
+var SESSION_SUMMARY_PROMPT = `You are summarising a conversation between a business assistant and its owner. Write a 3-5 sentence summary covering:
+- What was discussed and accomplished this session
+- Any tasks created, decisions made, or state changes
+- Current state of any ongoing work
+- What the owner is likely to want to continue next
+
+Be factual and specific. Use present tense for current state. Do not include greetings or meta-commentary.`;
+var SESSION_SUMMARY_TIMEOUT_MS = 1e4;
+var lastSummaryWrite = /* @__PURE__ */ new Map();
+var SUMMARY_RATE_LIMIT_MS = 5 * 60 * 1e3;
+async function generateSessionSummary(history) {
+  if (history.length < 2) return null;
+  let apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    try {
+      apiKey = readFileSync5(API_KEY_FILE, "utf-8").trim();
+    } catch {
+      return null;
+    }
+  }
+  if (!apiKey) {
+    console.error("[session-summary] Skipping \u2014 no API key available");
+    return null;
+  }
+  const transcript = history.slice(-20).map((m) => `[${m.role}] ${m.content}`).join("\n\n");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), SESSION_SUMMARY_TIMEOUT_MS);
+  try {
+    const client = new Anthropic({ apiKey });
+    const response = await client.messages.create({
+      model: REFLECTION_MODEL,
+      max_tokens: 500,
+      system: SESSION_SUMMARY_PROMPT,
+      messages: [{ role: "user", content: `Conversation:
+${transcript}` }]
+    }, { signal: controller.signal });
+    return response.content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("");
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      console.error(`[session-summary] Haiku call timed out after ${SESSION_SUMMARY_TIMEOUT_MS}ms`);
+    } else {
+      console.error(`[session-summary] Haiku call failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function writeEndOfTurnSummary(accountId, history) {
+  const now = Date.now();
+  const lastWrite = lastSummaryWrite.get(accountId) ?? 0;
+  if (now - lastWrite < SUMMARY_RATE_LIMIT_MS) {
+    return;
+  }
+  const summary = await generateSessionSummary(history);
+  if (!summary) return;
+  await writeSessionSummary(accountId, summary);
+  lastSummaryWrite.set(accountId, Date.now());
+}
 var MANAGED_WORK_BUDGET_RATIO = 0.5;
 var TOOL_SCHEMA_OVERHEAD_TOKENS = 15e3;
 function estimateTokens(text) {
@@ -5248,7 +5674,7 @@ var COMPACTION_TIMEOUT_MS = 45e3;
 async function* runCompactionTurn(accountDir, accountId, systemPrompt, resumeSessionId, adminModel, enabledPlugins) {
   const mcpConfig = JSON.stringify({ mcpServers: getMcpServers(accountId, enabledPlugins) });
   const specialistsDir = resolve4(accountDir, "specialists");
-  if (!existsSync5(specialistsDir)) agentLogStream("claude-agent-compaction-stream").write(`[${isoTs()}] [warn] specialists plugin dir missing: ${specialistsDir}
+  if (!existsSync5(specialistsDir)) agentLogStream("claude-agent-compaction-stream", accountDir).write(`[${isoTs()}] [warn] specialists plugin dir missing: ${specialistsDir}
 `);
   const args = [
     "--print",
@@ -5278,9 +5704,9 @@ async function* runCompactionTurn(accountDir, accountId, systemPrompt, resumeSes
     stdio: ["ignore", "pipe", "pipe"],
     env: { ...process.env, PLATFORM_ROOT: PLATFORM_ROOT3, ACCOUNT_DIR: accountDir }
   });
-  const stderrLog = agentLogStream("claude-agent-compaction-stderr");
+  const stderrLog = agentLogStream("claude-agent-compaction-stderr", accountDir);
   proc.stderr?.pipe(stderrLog);
-  const streamLog = agentLogStream("claude-agent-compaction-stream");
+  const streamLog = agentLogStream("claude-agent-compaction-stream", accountDir);
   streamLog.write(`[${isoTs()}] [compaction-start] resumeSessionId=${resumeSessionId}
 `);
   proc.on("error", (err) => streamLog.write(`[${isoTs()}] [compaction-spawn-error] ${err.message}
@@ -5848,7 +6274,7 @@ async function* invokeAdminAgent(message, systemPrompt, accountDir, accountId, a
   await ensureCdp();
   const mcpConfig = JSON.stringify({ mcpServers: getMcpServers(accountId, enabledPlugins) });
   const specialistsDir = resolve4(accountDir, "specialists");
-  if (!existsSync5(specialistsDir)) agentLogStream("claude-agent-stream").write(`[${isoTs()}] [warn] specialists plugin dir missing: ${specialistsDir}
+  if (!existsSync5(specialistsDir)) agentLogStream("claude-agent-stream", accountDir).write(`[${isoTs()}] [warn] specialists plugin dir missing: ${specialistsDir}
 `);
   const args = [
     "--print",
@@ -5880,9 +6306,9 @@ async function* invokeAdminAgent(message, systemPrompt, accountDir, accountId, a
     stdio: ["ignore", "pipe", "pipe"],
     env: { ...process.env, PLATFORM_ROOT: PLATFORM_ROOT3, ACCOUNT_DIR: accountDir }
   });
-  const stderrLog = agentLogStream("claude-agent-stderr");
+  const stderrLog = agentLogStream("claude-agent-stderr", accountDir);
   proc.stderr?.pipe(stderrLog);
-  const streamLog = agentLogStream("claude-agent-stream");
+  const streamLog = agentLogStream("claude-agent-stream", accountDir);
   streamLog.write(`[${isoTs()}] [spawn] pid=${proc.pid} resume=${resumeSessionId ?? "none"} sessionKey=${sessionKey ?? "none"} pluginDir=${specialistsDir}
 `);
   streamLog.write(`[${isoTs()}] [stdin] len=${fullMessage.length} preview=${JSON.stringify(fullMessage.slice(0, 80))}
@@ -6070,7 +6496,7 @@ async function* invokeManagedAdminAgent(message, systemPrompt, accountDir, accou
       storePendingTrimmedMessages(sessionKey, pendingTrimmed);
     }
   }
-  const streamLog = agentLogStream("claude-agent-stream");
+  const streamLog = agentLogStream("claude-agent-stream", accountDir);
   const systemPromptTokens = estimateTokens(systemPrompt);
   let historyBudget = managedHistoryBudget(adminModel, systemPromptTokens);
   const session = sessionStore.get(sessionKey);
@@ -6127,7 +6553,7 @@ async function* invokeManagedAdminAgent(message, systemPrompt, accountDir, accou
     stdio: ["ignore", "pipe", "pipe"],
     env: { ...process.env, PLATFORM_ROOT: PLATFORM_ROOT3, ACCOUNT_DIR: accountDir }
   });
-  const stderrLog = agentLogStream("claude-agent-stderr");
+  const stderrLog = agentLogStream("claude-agent-stderr", accountDir);
   proc.stderr?.pipe(stderrLog);
   streamLog.write(`[${isoTs()}] [managed-spawn] pid=${proc.pid} sessionKey=${sessionKey} historyMessages=${history.length} pluginDir=${specialistsDir}
 `);
@@ -6246,6 +6672,9 @@ async function* invokeManagedAdminAgent(message, systemPrompt, accountDir, accou
             if (responseText) persistMessage(convId, "assistant", responseText, accountId, capturedTokens, assistantTimestamp).catch(() => {
             });
           }
+          writeEndOfTurnSummary(accountId, afterHistory).catch(
+            (err) => console.error(`[session-summary] end-of-turn write failed: ${err instanceof Error ? err.message : String(err)}`)
+          );
         }
         yield event;
       }
@@ -6286,7 +6715,7 @@ ${summary}`;
   stderrLog.end();
   streamLog.end();
 }
-async function* invokePublicAgent(message, systemPrompt, accountId, publicModel, sessionKey, pluginInfo, knowledgeBaked = false, agentSlug, liveMemory = false, knowledgeKeywords) {
+async function* invokePublicAgent(message, systemPrompt, accountId, accountDir, publicModel, sessionKey, pluginInfo, knowledgeBaked = false, agentSlug, liveMemory = false, knowledgeKeywords) {
   const userTimestamp = (/* @__PURE__ */ new Date()).toISOString();
   let apiKey = process.env.ANTHROPIC_API_KEY;
   if (!apiKey) {
@@ -6300,7 +6729,7 @@ async function* invokePublicAgent(message, systemPrompt, accountId, publicModel,
     yield { type: "done" };
     return;
   }
-  const streamLog = agentLogStream("public-agent-stream");
+  const streamLog = agentLogStream("public-agent-stream", accountDir);
   streamLog.write(`[${isoTs()}] [public-user-message] ${JSON.stringify(message)}
 `);
   if (sessionKey) {
@@ -6324,18 +6753,32 @@ async function* invokePublicAgent(message, systemPrompt, accountId, publicModel,
       }
     }
   }
+  const history = sessionKey ? getMessageHistory(sessionKey) : [];
   const fetchOptions = {
     ...agentSlug ? { agentSlug } : {},
     ...knowledgeKeywords && knowledgeKeywords.length > 0 ? { knowledgeKeywords } : {}
   };
+  const needsClassification = !(knowledgeBaked && !liveMemory);
+  const classifyStartMs = Date.now();
+  const classification = needsClassification ? await classifyMemoryQuery(message, history) : QUERY_CLASSIFIER_FALLBACK;
+  const classifyMs = Date.now() - classifyStartMs;
+  const effectiveQuery = classification.query ?? message;
+  if (needsClassification) {
+    streamLog.write(`[${isoTs()}] [public-query-classifier] search=${classification.search} effectiveQuery=${JSON.stringify(effectiveQuery.slice(0, 200))} reason=${classification.reason} latencyMs=${classifyMs}
+`);
+  }
   let system;
   if (knowledgeBaked && !liveMemory) {
     streamLog.write(`[${isoTs()}] [public-knowledge-source] baked \u2014 skipping memory-search (liveMemory=false)
+`);
+    system = systemPrompt;
+  } else if (!classification.search) {
+    streamLog.write(`[${isoTs()}] [public-knowledge-source] skipped \u2014 classifier (reason=${classification.reason})
 `);
     system = systemPrompt;
   } else if (knowledgeBaked && liveMemory) {
-    const memoryContext = await fetchMemoryContext(accountId, message, sessionKey, fetchOptions);
-    streamLog.write(`[${isoTs()}] [public-knowledge-source] baked+live agentSlug=${agentSlug ?? "none"} keywords=${knowledgeKeywords?.length ?? 0} result=${memoryContext ? `ok (${memoryContext.length} chars)` : "null"}
+    const memoryContext = await fetchMemoryContext(accountId, effectiveQuery, sessionKey, fetchOptions);
+    streamLog.write(`[${isoTs()}] [public-knowledge-source] baked+live agentSlug=${agentSlug ?? "none"} keywords=${knowledgeKeywords?.length ?? 0} effectiveQuery=${JSON.stringify(effectiveQuery.slice(0, 200))} result=${memoryContext ? `ok (${memoryContext.length} chars)` : "null"}
 `);
     system = memoryContext ? `${systemPrompt}
 
@@ -6343,8 +6786,8 @@ async function* invokePublicAgent(message, systemPrompt, accountId, publicModel,
 ${memoryContext}
 </live-memory>` : systemPrompt;
   } else {
-    const memoryContext = await fetchMemoryContext(accountId, message, sessionKey, fetchOptions);
-    streamLog.write(`[${isoTs()}] [public-knowledge-source] memory-search agentSlug=${agentSlug ?? "none"} keywords=${knowledgeKeywords?.length ?? 0} result=${memoryContext ? `ok (${memoryContext.length} chars)` : "null \u2014 agent has no knowledge"}
+    const memoryContext = await fetchMemoryContext(accountId, effectiveQuery, sessionKey, fetchOptions);
+    streamLog.write(`[${isoTs()}] [public-knowledge-source] memory-search agentSlug=${agentSlug ?? "none"} keywords=${knowledgeKeywords?.length ?? 0} effectiveQuery=${JSON.stringify(effectiveQuery.slice(0, 200))} result=${memoryContext ? `ok (${memoryContext.length} chars)` : "null \u2014 agent has no knowledge"}
 `);
     if (memoryContext) {
       streamLog.write(`[${isoTs()}] [public-memory-context] ${JSON.stringify(memoryContext.slice(0, 500))}${memoryContext.length > 500 ? "\u2026" : ""}
@@ -6356,7 +6799,6 @@ ${memoryContext}
 ${memoryContext}
 </memory>` : systemPrompt;
   }
-  const history = sessionKey ? getMessageHistory(sessionKey) : [];
   const sdkMessages = [
     ...history.map((m) => ({ role: m.role, content: m.content })),
     { role: "user", content: message }
@@ -6577,6 +7019,13 @@ async function* invokeAgent(config, message, sessionKey, attachments = []) {
 ${soul}` : identityPrompt;
   const now = /* @__PURE__ */ new Date();
   const isoTimestamp = now.toISOString();
+  const userTimezone = await getUserTimezone(accountId);
+  const effectiveTimezone = userTimezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+  if (!userTimezone) {
+    console.error(`[datetime] getUserTimezone returned null for ${accountId.slice(0, 8)}\u2026, falling back to server timezone: ${effectiveTimezone}`);
+  } else {
+    console.error(`[datetime] using user timezone: ${effectiveTimezone}`);
+  }
   const humanReadable = new Intl.DateTimeFormat("en-GB", {
     weekday: "long",
     year: "numeric",
@@ -6584,14 +7033,14 @@ ${soul}` : identityPrompt;
     day: "numeric",
     hour: "2-digit",
     minute: "2-digit",
-    timeZoneName: "shortOffset"
+    timeZoneName: "shortOffset",
+    timeZone: effectiveTimezone
   }).format(now);
-  const tzName = Intl.DateTimeFormat().resolvedOptions().timeZone;
   baseSystemPrompt += `
 
 <datetime>
 ${isoTimestamp}
-${humanReadable} (${tzName})
+${humanReadable} (${effectiveTimezone})
 </datetime>`;
   if (agentType === "admin") {
     const [profileSummary, sessionContext, onboardingStep] = await Promise.all([
@@ -6636,7 +7085,7 @@ ${agentConfig.knowledge}
 ${body}`;
   }
   if (agentType === "admin") {
-    const manifest = buildPluginManifest(account.config.enabledPlugins);
+    const manifest = await buildPluginManifest(account.config.enabledPlugins);
     if (manifest) {
       baseSystemPrompt += `
 
@@ -6713,7 +7162,7 @@ Current session key: ${sessionKey}` : systemPromptBase;
     const knowledgeBaked = agentConfig?.knowledgeBaked ?? false;
     const agentLiveMemory = agentConfig?.liveMemory ?? false;
     const agentKeywords = agentConfig?.knowledgeKeywords ?? null;
-    yield* invokePublicAgent(message, systemPrompt, accountId, publicModel, sessionKey, pluginInfo, knowledgeBaked, resolvedAgentName, agentLiveMemory, agentKeywords);
+    yield* invokePublicAgent(message, systemPrompt, accountId, account.accountDir, publicModel, sessionKey, pluginInfo, knowledgeBaked, resolvedAgentName, agentLiveMemory, agentKeywords);
   } else if (account.config.contextMode !== "claude-code" && sessionKey) {
     yield* invokeManagedAdminAgent(message, systemPrompt, account.accountDir, accountId, account.config.adminModel, sessionKey, effortToMaxTurns(effort), attachments, 0, account.config.enabledPlugins);
   } else {
@@ -7084,12 +7533,18 @@ async function POST2(req) {
   }
   const fullMessage = message + uploadNote;
   const encoder = new TextEncoder();
-  const sseLog = agentLogStream("sse-events");
+  const account = resolveAccount();
+  if (!account) {
+    return new Response(
+      JSON.stringify({ error: "No account configured" }),
+      { status: 500, headers: { "Content-Type": "application/json" } }
+    );
+  }
+  const sseLog = agentLogStream("sse-events", account.accountDir);
   const sk = session_key.slice(0, 8);
   let agentName = getAgentNameForSession(session_key);
   if (!agentName) {
-    const account = resolveAccount();
-    agentName = (account ? resolveDefaultAgentSlug(account.accountDir) : null) ?? void 0;
+    agentName = resolveDefaultAgentSlug(account.accountDir) ?? void 0;
   }
   if (!agentName) {
     return new Response(
@@ -7127,21 +7582,35 @@ async function POST2(req) {
         }
       } catch (err) {
         const rawMessage = err instanceof Error ? err.message : String(err);
-        const category = classifyAgentError(err);
         const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
-        sseLog.write(`[${ts}] [${sk}] ${agentName}: ERROR [${category}] ${rawMessage}
+        const controllerClosed = err instanceof TypeError && /Controller is already closed/i.test(rawMessage);
+        if (controllerClosed) {
+          sseLog.write(`[${ts}] [${sk}] ${agentName}: DISCONNECT [client_disconnect] ${rawMessage}
+`);
+        } else {
+          const category = classifyAgentError(err);
+          sseLog.write(`[${ts}] [${sk}] ${agentName}: ERROR [${category}] ${rawMessage}
 `);
-        sseLog.write(`[${ts}] [${sk}] ${agentName}: ${JSON.stringify({ type: "done", subtype: "error", error: rawMessage, error_category: category })}
+          sseLog.write(`[${ts}] [${sk}] ${agentName}: ${JSON.stringify({ type: "done", subtype: "error", error: rawMessage, error_category: category })}
 `);
-        controller.enqueue(
-          encoder.encode(`data: ${JSON.stringify({ error: friendlyAgentError(err, local ? "admin" : "public") })}
+          try {
+            controller.enqueue(
+              encoder.encode(`data: ${JSON.stringify({ error: friendlyAgentError(err, local ? "admin" : "public") })}
 
 `)
-        );
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+            );
+            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+          } catch {
+            sseLog.write(`[${ts}] [${sk}] ${agentName}: DISCONNECT [client_disconnect] could not deliver error \u2014 client disconnected
+`);
+          }
+        }
       } finally {
         sseLog.end();
-        controller.close();
+        try {
+          controller.close();
+        } catch {
+        }
       }
     }
   });
@@ -8843,10 +9312,17 @@ async function POST12(req) {
     }
   } catch {
   }
+  const account = resolveAccount();
+  if (!account) {
+    return new Response(
+      JSON.stringify({ error: "No account configured" }),
+      { status: 500, headers: { "Content-Type": "application/json" } }
+    );
+  }
   try {
     const parsed = JSON.parse(message);
     if (parsed._lifecycle) {
-      const lifecycleLog = agentLogStream("component-lifecycle");
+      const lifecycleLog = agentLogStream("component-lifecycle", account.accountDir);
       const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
       const detail = parsed.filePath ? ` filePath=${parsed.filePath}` : "";
       lifecycleLog.write(`[${ts}] [component:${parsed.component ?? "unknown"}] ${parsed.event ?? "unknown"}${detail}
@@ -8868,7 +9344,7 @@ async function POST12(req) {
   } catch {
   }
   const encoder = new TextEncoder();
-  const sseLog = agentLogStream("sse-events");
+  const sseLog = agentLogStream("sse-events", account.accountDir);
   const sk = session_key.slice(0, 8);
   const readable = new ReadableStream({
     async start(controller) {
@@ -8889,25 +9365,39 @@ async function POST12(req) {
         }
       } catch (err) {
         const rawMessage = err instanceof Error ? err.message : String(err);
-        const category = classifyAgentError(err);
-        const errEvent = JSON.stringify({ type: "text", content: friendlyAgentError(err) });
-        const doneEvent = JSON.stringify({ type: "done", subtype: "error", error: rawMessage, error_category: category });
         const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
-        sseLog.write(`[${ts}] [${sk}] admin: ERROR [${category}] ${rawMessage}
+        const controllerClosed = err instanceof TypeError && /Controller is already closed/i.test(rawMessage);
+        if (controllerClosed) {
+          sseLog.write(`[${ts}] [${sk}] admin: DISCONNECT [client_disconnect] ${rawMessage}
+`);
+        } else {
+          const category = classifyAgentError(err);
+          const errEvent = JSON.stringify({ type: "text", content: friendlyAgentError(err) });
+          const doneEvent = JSON.stringify({ type: "done", subtype: "error", error: rawMessage, error_category: category });
+          sseLog.write(`[${ts}] [${sk}] admin: ERROR [${category}] ${rawMessage}
 `);
-        sseLog.write(`[${ts}] [${sk}] admin: ${errEvent}
+          sseLog.write(`[${ts}] [${sk}] admin: ${errEvent}
 `);
-        sseLog.write(`[${ts}] [${sk}] admin: ${doneEvent}
+          sseLog.write(`[${ts}] [${sk}] admin: ${doneEvent}
 `);
-        controller.enqueue(encoder.encode(`data: ${errEvent}
+          try {
+            controller.enqueue(encoder.encode(`data: ${errEvent}
 
 `));
-        controller.enqueue(encoder.encode(`data: ${doneEvent}
+            controller.enqueue(encoder.encode(`data: ${doneEvent}
 
 `));
+          } catch {
+            sseLog.write(`[${ts}] [${sk}] admin: DISCONNECT [client_disconnect] could not deliver error \u2014 client disconnected
+`);
+          }
+        }
       } finally {
         sseLog.end();
-        controller.close();
+        try {
+          controller.close();
+        } catch {
+        }
       }
     }
   });
@@ -8962,7 +9452,7 @@ async function POST13(req) {
 }
 
 // app/api/admin/logs/route.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync2, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
 import { resolve as resolve9, basename } from "path";
 var TAIL_BYTES = 8192;
 async function GET3(request) {
@@ -8970,17 +9460,22 @@ async function GET3(request) {
   const fileParam = searchParams.get("file");
   const typeParam = searchParams.get("type");
   const download = searchParams.get("download") === "1";
+  const account = resolveAccount();
+  const accountLogDir = account ? resolve9(account.accountDir, "logs") : null;
   if (fileParam) {
     const safe = basename(fileParam);
-    const filePath = resolve9(LOG_DIR, safe);
-    try {
-      const content = readFileSync12(filePath, "utf-8");
-      const headers = { "Content-Type": "text/plain; charset=utf-8" };
-      if (download) headers["Content-Disposition"] = `attachment; filename="${safe}"`;
-      return new Response(content, { headers });
-    } catch {
-      return Response.json({ error: `File not found: ${safe}` }, { status: 404 });
+    for (const dir of [accountLogDir, LOG_DIR]) {
+      if (!dir) continue;
+      const filePath = resolve9(dir, safe);
+      try {
+        const content = readFileSync12(filePath, "utf-8");
+        const headers = { "Content-Type": "text/plain; charset=utf-8" };
+        if (download) headers["Content-Disposition"] = `attachment; filename="${safe}"`;
+        return new Response(content, { headers });
+      } catch {
+      }
     }
+    return Response.json({ error: `File not found: ${safe}` }, { status: 404 });
   }
   if (typeParam) {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -8995,32 +9490,40 @@ async function GET3(request) {
     if (!fileName) {
       return Response.json({ error: `Unknown type: ${typeParam}. Valid: stream, error, session, sse, public` }, { status: 400 });
     }
-    const filePath = resolve9(LOG_DIR, fileName);
-    try {
-      const content = readFileSync12(filePath, "utf-8");
-      const headers = { "Content-Type": "text/plain; charset=utf-8" };
-      if (download) headers["Content-Disposition"] = `attachment; filename="${fileName}"`;
-      return new Response(content, { headers });
-    } catch {
-      return Response.json({ error: `Log not found: ${fileName}` }, { status: 404 });
+    for (const dir of [accountLogDir, LOG_DIR]) {
+      if (!dir) continue;
+      const filePath = resolve9(dir, fileName);
+      try {
+        const content = readFileSync12(filePath, "utf-8");
+        const headers = { "Content-Type": "text/plain; charset=utf-8" };
+        if (download) headers["Content-Disposition"] = `attachment; filename="${fileName}"`;
+        return new Response(content, { headers });
+      } catch {
+      }
     }
+    return Response.json({ error: `Log not found: ${fileName}` }, { status: 404 });
   }
-  let files;
-  try {
-    files = readdirSync2(LOG_DIR).filter((f) => f.endsWith(".log"));
-  } catch {
-    return Response.json({ logs: {} });
-  }
+  const seen = /* @__PURE__ */ new Set();
   const logs = {};
-  files.map((f) => ({ name: f, mtime: statSync3(resolve9(LOG_DIR, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime).forEach(({ name }) => {
+  for (const dir of [accountLogDir, LOG_DIR]) {
+    if (!dir || !existsSync12(dir)) continue;
+    let files;
     try {
-      const content = readFileSync12(resolve9(LOG_DIR, name));
-      const tail = content.length > TAIL_BYTES ? content.subarray(content.length - TAIL_BYTES).toString("utf-8") : content.toString("utf-8");
-      logs[name] = tail.trim() || "(empty)";
+      files = readdirSync2(dir).filter((f) => f.endsWith(".log"));
     } catch {
-      logs[name] = "(unreadable)";
+      continue;
     }
-  });
+    files.filter((f) => !seen.has(f)).map((f) => ({ name: f, mtime: statSync3(resolve9(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime).forEach(({ name }) => {
+      seen.add(name);
+      try {
+        const content = readFileSync12(resolve9(dir, name));
+        const tail = content.length > TAIL_BYTES ? content.subarray(content.length - TAIL_BYTES).toString("utf-8") : content.toString("utf-8");
+        logs[name] = tail.trim() || "(empty)";
+      } catch {
+        logs[name] = "(unreadable)";
+      }
+    });
+  }
   return Response.json({ logs });
 }
 
@@ -9048,7 +9551,7 @@ async function GET4() {
 
 // app/api/admin/attachment/[attachmentId]/route.ts
 import { readFile, readdir } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { resolve as resolve10 } from "path";
 async function GET5(req, attachmentId) {
   const sessionKey = new URL(req.url).searchParams.get("session_key") ?? "";
@@ -9063,11 +9566,11 @@ async function GET5(req, attachmentId) {
     return new Response("Not found", { status: 404 });
   }
   const dir = resolve10(ATTACHMENTS_ROOT, accountId, attachmentId);
-  if (!existsSync12(dir)) {
+  if (!existsSync13(dir)) {
     return new Response("Not found", { status: 404 });
   }
   const metaPath = resolve10(dir, `${attachmentId}.meta.json`);
-  if (!existsSync12(metaPath)) {
+  if (!existsSync13(metaPath)) {
     return new Response("Not found", { status: 404 });
   }
   let meta;
@@ -9133,14 +9636,14 @@ async function PATCH(req) {
 
 // app/api/admin/agents/route.ts
 import { resolve as resolve12 } from "path";
-import { readdirSync as readdirSync3, readFileSync as readFileSync14, existsSync as existsSync13 } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync14, existsSync as existsSync14 } from "fs";
 async function GET6() {
   const account = resolveAccount();
   if (!account) {
     return Response.json({ agents: [] });
   }
   const agentsDir = resolve12(account.accountDir, "agents");
-  if (!existsSync13(agentsDir)) {
+  if (!existsSync14(agentsDir)) {
     return Response.json({ agents: [] });
   }
   const agents = [];
@@ -9150,7 +9653,7 @@ async function GET6() {
       if (!entry.isDirectory()) continue;
       if (entry.name === "admin") continue;
       const configPath = resolve12(agentsDir, entry.name, "config.json");
-      if (!existsSync13(configPath)) continue;
+      if (!existsSync14(configPath)) continue;
       try {
         const config = JSON.parse(readFileSync14(configPath, "utf-8"));
         agents.push({
@@ -9170,13 +9673,13 @@ async function GET6() {
 }
 
 // app/api/admin/version/route.ts
-import { readFileSync as readFileSync15, existsSync as existsSync14 } from "fs";
+import { readFileSync as readFileSync15, existsSync as existsSync15 } from "fs";
 import { resolve as resolve13, join as join3 } from "path";
 var PLATFORM_ROOT6 = process.env.MAXY_PLATFORM_ROOT ?? resolve13(process.cwd(), "..");
 var brandHostname = "maxy";
 var brandNpmPackage = "@rubytech/create-maxy";
 var brandJsonPath = join3(PLATFORM_ROOT6, "config", "brand.json");
-if (existsSync14(brandJsonPath)) {
+if (existsSync15(brandJsonPath)) {
   try {
     const brand = JSON.parse(readFileSync15(brandJsonPath, "utf-8"));
     if (brand.hostname) brandHostname = brand.hostname;
@@ -9191,7 +9694,7 @@ var CACHE_TTL_MS = 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 5e3;
 var latestCache = null;
 function readInstalled() {
-  if (!existsSync14(VERSION_FILE)) return "unknown";
+  if (!existsSync15(VERSION_FILE)) return "unknown";
   const content = readFileSync15(VERSION_FILE, "utf-8").trim();
   return content || "unknown";
 }
@@ -9246,13 +9749,13 @@ async function GET7() {
 
 // app/api/admin/version/upgrade/route.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync15, statSync as statSync4, writeFileSync as writeFileSync9, readFileSync as readFileSync16, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import { existsSync as existsSync16, statSync as statSync4, writeFileSync as writeFileSync9, readFileSync as readFileSync16, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import { resolve as resolve14, join as join4 } from "path";
 var PLATFORM_ROOT7 = process.env.MAXY_PLATFORM_ROOT ?? resolve14(process.cwd(), "..");
 var upgradePkg = "@rubytech/create-maxy";
 var upgradeHostname = "maxy";
 var brandPath = join4(PLATFORM_ROOT7, "config", "brand.json");
-if (existsSync15(brandPath)) {
+if (existsSync16(brandPath)) {
   try {
     const brand = JSON.parse(readFileSync16(brandPath, "utf-8"));
     if (brand.npm?.packageName) upgradePkg = brand.npm.packageName;
@@ -9264,7 +9767,7 @@ var LOCK_FILE = `/tmp/${upgradeHostname}-upgrade.lock`;
 var LOG_FILE = `/tmp/${upgradeHostname}-upgrade.log`;
 var LOCK_MAX_AGE_MS = 3 * 60 * 1e3;
 function isLockFresh() {
-  if (!existsSync15(LOCK_FILE)) return false;
+  if (!existsSync16(LOCK_FILE)) return false;
   try {
     const stat = statSync4(LOCK_FILE);
     return Date.now() - stat.mtimeMs < LOCK_MAX_AGE_MS;
@@ -9420,10 +9923,10 @@ async function POST15() {
 var PLATFORM_ROOT8 = process.env.MAXY_PLATFORM_ROOT || "";
 var BRAND_JSON_PATH = PLATFORM_ROOT8 ? join5(PLATFORM_ROOT8, "config", "brand.json") : "";
 var BRAND = { productName: "Maxy", hostname: "maxy", configDir: ".maxy", domain: "getmaxy.com" };
-if (BRAND_JSON_PATH && !existsSync16(BRAND_JSON_PATH)) {
+if (BRAND_JSON_PATH && !existsSync17(BRAND_JSON_PATH)) {
   console.error(`[brand] WARNING: brand.json not found at ${BRAND_JSON_PATH} \u2014 using Maxy defaults`);
 }
-if (BRAND_JSON_PATH && existsSync16(BRAND_JSON_PATH)) {
+if (BRAND_JSON_PATH && existsSync17(BRAND_JSON_PATH)) {
   try {
     const parsed = JSON.parse(readFileSync17(BRAND_JSON_PATH, "utf-8"));
     BRAND = { ...BRAND, ...parsed };
@@ -9435,7 +9938,7 @@ if (BRAND_JSON_PATH && existsSync16(BRAND_JSON_PATH)) {
 var ALIAS_DOMAINS_PATH = join5(homedir2(), BRAND.configDir, "alias-domains.json");
 function loadAliasDomains() {
   try {
-    if (!existsSync16(ALIAS_DOMAINS_PATH)) return null;
+    if (!existsSync17(ALIAS_DOMAINS_PATH)) return null;
     const parsed = JSON.parse(readFileSync17(ALIAS_DOMAINS_PATH, "utf-8"));
     if (!Array.isArray(parsed)) {
       console.error("[alias-domains] malformed alias-domains.json \u2014 expected array");
@@ -9764,7 +10267,7 @@ app.get(
 );
 var htmlCache = /* @__PURE__ */ new Map();
 var brandLogoPath = "/brand/maxy-monochrome.png";
-if (BRAND_JSON_PATH && existsSync16(BRAND_JSON_PATH)) {
+if (BRAND_JSON_PATH && existsSync17(BRAND_JSON_PATH)) {
   try {
     const fullBrand = JSON.parse(readFileSync17(BRAND_JSON_PATH, "utf-8"));
     if (fullBrand.assets?.logo) brandLogoPath = `/brand/${fullBrand.assets.logo}`;
@@ -9792,12 +10295,12 @@ function loadBrandingCache(agentSlug) {
   const configDir = join5(homedir2(), BRAND.configDir);
   try {
     const accountJsonPath = join5(configDir, "account.json");
-    if (!existsSync16(accountJsonPath)) return null;
+    if (!existsSync17(accountJsonPath)) return null;
     const account = JSON.parse(readFileSync17(accountJsonPath, "utf-8"));
     const accountId = account.accountId;
     if (!accountId) return null;
     const cachePath = join5(configDir, "branding-cache", accountId, `${agentSlug}.json`);
-    if (!existsSync16(cachePath)) return null;
+    if (!existsSync17(cachePath)) return null;
     return JSON.parse(readFileSync17(cachePath, "utf-8"));
   } catch {
     return null;
@@ -9807,7 +10310,7 @@ function resolveDefaultSlug() {
   try {
     const configDir = join5(homedir2(), BRAND.configDir);
     const accountJsonPath = join5(configDir, "account.json");
-    if (!existsSync16(accountJsonPath)) return null;
+    if (!existsSync17(accountJsonPath)) return null;
     const account = JSON.parse(readFileSync17(accountJsonPath, "utf-8"));
     return account.defaultAgent || null;
   } catch {