assistme 0.3.6 → 0.5.0

package/dist/index.js

@@ -5,6 +5,7 @@ import {
   CDP_COMMAND_TIMEOUT_MS,
   FRAME_CONTEXTS_MAX_SIZE,
   JobRunner,
+  MAX_BUDGET_USD,
   MAX_COMPLETE_TASK_RETRIES,
   MAX_CONTENT_SEARCH_FILES,
   MAX_CONTENT_SEARCH_RESULTS,
@@ -15,10 +16,14 @@ import {
   MAX_SKILL_RECORD_RESULT_LENGTH,
   MAX_TOOL_INPUT_LOG_LENGTH,
   MAX_TOOL_RESULT_LENGTH,
+  MEMORY_COMPRESSION_TARGET,
+  MEMORY_COMPRESSION_THRESHOLD,
+  MEMORY_DEDUP_SIMILARITY_THRESHOLD,
   SCHEDULER_INTERVAL_MS,
   SHELL_MAX_OUTPUT,
   SHELL_TIMEOUT_MS,
   SKILL_DESCRIPTION_BUDGET_CHARS,
+  SKILL_VALIDATION_MAX_TURNS,
   SkillCreateResultSchema,
   SkillDecisionSchema,
   SkillRowSchema,
@@ -30,9 +35,10 @@ import {
   readAuthStore,
   safeParse,
   setCorrelationId,
+  setLogHook,
   setLogLevel,
   writeAuthStore
-} from "./chunk-4YWS463E.js";
+} from "./chunk-KAS2PTOX.js";
 import {
   clearConfig,
   getConfig,
@@ -2807,7 +2813,92 @@ var MemoryManager = class {
     });
     return result.count;
   }
+  // ── Compression & Deduplication ──────────────────────────────────
+  /**
+   * Check if memory count exceeds threshold and compress if needed.
+   * Called automatically after task completion.
+   */
+  async compressIfNeeded() {
+    try {
+      const all = await this.list(void 0, 200);
+      if (all.length < MEMORY_COMPRESSION_THRESHOLD) {
+        return 0;
+      }
+      log.info(`Memory compression triggered: ${all.length} memories (threshold: ${MEMORY_COMPRESSION_THRESHOLD})`);
+      let removed = 0;
+      const now = Date.now();
+      for (const m of all) {
+        if (m.expires_at && new Date(m.expires_at).getTime() < now) {
+          await this.remove(m.id);
+          removed++;
+        }
+      }
+      const remaining = all.filter(
+        (m) => !m.expires_at || new Date(m.expires_at).getTime() >= now
+      );
+      const duplicateIds = this.findDuplicates(remaining);
+      for (const id of duplicateIds) {
+        await this.remove(id);
+        removed++;
+      }
+      const afterDedup = remaining.filter((m) => !duplicateIds.has(m.id));
+      if (afterDedup.length > MEMORY_COMPRESSION_TARGET) {
+        const toRemove = afterDedup.sort((a, b) => {
+          if (a.importance !== b.importance) return a.importance - b.importance;
+          if (a.access_count !== b.access_count) return a.access_count - b.access_count;
+          return new Date(a.created_at).getTime() - new Date(b.created_at).getTime();
+        }).slice(0, afterDedup.length - MEMORY_COMPRESSION_TARGET);
+        for (const m of toRemove) {
+          if (m.category === "instruction" && m.importance >= 8) continue;
+          await this.remove(m.id);
+          removed++;
+        }
+      }
+      if (removed > 0) {
+        log.info(`Memory compression complete: removed ${removed} memories`);
+      }
+      return removed;
+    } catch (err) {
+      log.warn(`Memory compression error: ${err instanceof Error ? err.message : err}`);
+      return 0;
+    }
+  }
+  /**
+   * Find duplicate memories based on content similarity.
+   * Returns the IDs of memories that should be removed (keeps the higher-importance duplicate).
+   */
+  findDuplicates(memories) {
+    const toRemove = /* @__PURE__ */ new Set();
+    for (let i = 0; i < memories.length; i++) {
+      if (toRemove.has(memories[i].id)) continue;
+      for (let j = i + 1; j < memories.length; j++) {
+        if (toRemove.has(memories[j].id)) continue;
+        if (memories[i].category !== memories[j].category) continue;
+        const similarity = computeWordOverlap(memories[i].content, memories[j].content);
+        if (similarity >= MEMORY_DEDUP_SIMILARITY_THRESHOLD) {
+          if (memories[i].importance > memories[j].importance || memories[i].importance === memories[j].importance && new Date(memories[i].created_at) > new Date(memories[j].created_at)) {
+            toRemove.add(memories[j].id);
+          } else {
+            toRemove.add(memories[i].id);
+          }
+        }
+      }
+    }
+    return toRemove;
+  }
 };
+function computeWordOverlap(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+  if (wordsA.size === 0 && wordsB.size === 0) return 1;
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  const union = wordsA.size + wordsB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
 
 // src/agent/skills.ts
 import { execSync as execSync2 } from "child_process";
@@ -3423,6 +3514,36 @@ function preprocessDynamicContext(content, cwd) {
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
+var SKILL_DECISION_OUTPUT_FORMAT = {
+  type: "json_schema",
+  schema: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["create", "update", "skip"] },
+      name: { type: "string" },
+      description: { type: "string" },
+      instructions: { type: "string" },
+      emoji: { type: "string" },
+      keywords: { type: "array", items: { type: "string" } },
+      existing_skill_name: { type: "string" },
+      improved_instructions: { type: "string" },
+      improved_description: { type: "string" },
+      reason: { type: "string" }
+    },
+    required: ["action", "reason"]
+  }
+};
+var SKILL_VALIDATION_OUTPUT_FORMAT = {
+  type: "json_schema",
+  schema: {
+    type: "object",
+    properties: {
+      valid: { type: "boolean" },
+      improvements: { type: "string" }
+    },
+    required: ["valid"]
+  }
+};
 var SKILL_EVALUATION_PROMPT = `You just completed a task. Now evaluate whether it should be saved as a reusable Agent Skill.
 
 ## Agent Skills Format (agentskills.io)
@@ -3450,6 +3571,22 @@ Respond with ONLY a JSON object (no markdown, no explanation outside the JSON).
 Always include "reason" explaining your decision.
 
 Use your judgment \u2014 no rigid rules. Consider: Is this repeatable? Can it be generalized? Would it save time next time?`;
+var SKILL_VALIDATION_PROMPT = `Validate this auto-generated skill before it becomes active.
+
+Check:
+1. Are the instructions clear, complete, and actionable?
+2. Do they use generic placeholders (not hardcoded values)?
+3. Are error handling steps included?
+4. Is the description accurate and searchable?
+5. Would this actually work if followed step-by-step?
+
+Respond with ONLY a JSON object:
+- {"valid": true, "improvements": null}
+- {"valid": false, "improvements": "Specific improvements needed"}
+- {"valid": true, "improvements": "Optional minor improvements"}
+
+Skill to validate:
+`;
 async function evaluateAndMaybeCreateSkill(opts) {
   const { sessionId, skillManager, model } = opts;
   if (!sessionId) {
@@ -3465,50 +3602,83 @@ ${existingList}
 
 Respond with a JSON object now.`;
   try {
-    let responseText = "";
+    let structuredOutput;
     for await (const message of query({
       prompt,
       options: {
         resume: sessionId,
         model,
         maxTurns: 1,
-        allowedTools: []
+        allowedTools: [],
+        effort: "low",
+        outputFormat: SKILL_DECISION_OUTPUT_FORMAT
       }
     })) {
-      if (message.type === "assistant") {
-        const assistantMsg = message;
-        for (const block of assistantMsg.message.content) {
-          if (block.type === "text") {
-            responseText += block.text;
-          }
-        }
-      } else if (message.type === "result") {
+      if (message.type === "result") {
         const resultMsg = message;
-        if (resultMsg.subtype === "success" && "total_cost_usd" in resultMsg) {
+        if (resultMsg.subtype === "success") {
+          const successMsg = resultMsg;
+          structuredOutput = successMsg.structured_output;
           log.debug(
-            `Skill evaluation cost: $${resultMsg.total_cost_usd.toFixed(4)}`
+            `Skill evaluation cost: $${successMsg.total_cost_usd.toFixed(4)}`
           );
         }
       }
     }
-    const decision = parseJsonResponse(responseText);
+    const decision = structuredOutput ? safeParse(SkillDecisionSchema, structuredOutput) : null;
     if (!decision) {
       log.debug("Skill evaluation: no valid JSON in response");
       return;
     }
-    await executeSkillDecision(decision, skillManager);
+    await executeSkillDecision(decision, skillManager, sessionId, model);
   } catch (err) {
     log.debug(`Skill evaluation error: ${errorMessage(err)}`);
   }
 }
-async function executeSkillDecision(decision, skillManager) {
+async function validateSkill(name, description, instructions, sessionId, model) {
+  try {
+    const skillDoc = `Name: ${name}
+Description: ${description}
+
+Instructions:
+${instructions}`;
+    let structuredOutput;
+    for await (const message of query({
+      prompt: SKILL_VALIDATION_PROMPT + skillDoc,
+      options: {
+        resume: sessionId,
+        model,
+        maxTurns: SKILL_VALIDATION_MAX_TURNS,
+        allowedTools: [],
+        effort: "low",
+        outputFormat: SKILL_VALIDATION_OUTPUT_FORMAT
+      }
+    })) {
+      if (message.type === "result") {
+        const resultMsg = message;
+        if (resultMsg.subtype === "success") {
+          structuredOutput = resultMsg.structured_output;
+        }
+      }
+    }
+    const parsed = structuredOutput;
+    if (parsed) {
+      return { valid: parsed.valid, improvements: parsed.improvements || void 0 };
+    }
+    return { valid: true };
+  } catch (err) {
+    log.debug(`Skill validation error: ${errorMessage(err)}`);
+    return { valid: true };
+  }
+}
+async function executeSkillDecision(decision, skillManager, sessionId, model) {
   switch (decision.action) {
     case "create": {
       if (!decision.name || !decision.instructions) {
         log.debug("Skill create skipped: missing name or instructions");
         return;
       }
-      let skillName = normalizeSkillName(decision.name);
+      const skillName = normalizeSkillName(decision.name);
       if (!skillName) {
         log.debug(`Skill create skipped: name "${decision.name}" cannot be normalized`);
         return;
@@ -3526,10 +3696,33 @@ async function executeSkillDecision(decision, skillManager) {
         log.debug(`Skill create skipped: similar skill "${existing.name}" exists`);
         return;
       }
+      let instructions = decision.instructions;
+      if (sessionId) {
+        log.debug(`Validating skill "${skillName}" before activation...`);
+        const validation = await validateSkill(
+          skillName,
+          decision.description || "",
+          instructions,
+          sessionId,
+          model
+        );
+        if (!validation.valid) {
+          log.info(
+            `Skill "${skillName}" failed validation: ${validation.improvements}. Skipping creation.`
+          );
+          return;
+        }
+        if (validation.improvements) {
+          log.debug(`Skill "${skillName}" validated with suggestions: ${validation.improvements}`);
+          instructions += `
+
+<!-- Validation notes: ${validation.improvements} -->`;
+        }
+      }
       const result = await skillManager.create(
         skillName,
         decision.description || "",
-        decision.instructions,
+        instructions,
         {
           source: "auto_extracted",
           emoji: decision.emoji,
@@ -3540,7 +3733,7 @@ async function executeSkillDecision(decision, skillManager) {
         await skillManager.syncToAgentSkills(
           skillName,
           decision.description || "",
-          decision.instructions,
+          instructions,
           "1.0.0",
           {
             source: "auto_extracted",
@@ -3549,7 +3742,7 @@ async function executeSkillDecision(decision, skillManager) {
             sourceSkillId: result.id
           }
         );
-        log.info(`Auto-created skill "${skillName}": ${decision.reason}`);
+        log.info(`Auto-created skill "${skillName}" (validated): ${decision.reason}`);
       }
       break;
     }
@@ -3558,6 +3751,21 @@ async function executeSkillDecision(decision, skillManager) {
         log.debug("Skill update skipped: missing skill name or instructions");
         return;
       }
+      if (sessionId) {
+        const validation = await validateSkill(
+          decision.existing_skill_name,
+          decision.improved_description || "",
+          decision.improved_instructions,
+          sessionId,
+          model
+        );
+        if (!validation.valid) {
+          log.info(
+            `Skill update for "${decision.existing_skill_name}" failed validation. Skipping.`
+          );
+          return;
+        }
+      }
       const updated = skillManager.update(
         decision.existing_skill_name,
         decision.improved_instructions,
@@ -3575,32 +3783,6 @@ async function executeSkillDecision(decision, skillManager) {
       break;
   }
 }
-function parseJsonResponse(text) {
-  const trimmed = text.trim();
-  const candidates = [trimmed];
-  const start = trimmed.indexOf("{");
-  if (start !== -1) {
-    let depth = 0;
-    for (let i = start; i < trimmed.length; i++) {
-      if (trimmed[i] === "{") depth++;
-      else if (trimmed[i] === "}") depth--;
-      if (depth === 0) {
-        candidates.push(trimmed.slice(start, i + 1));
-        break;
-      }
-    }
-  }
-  for (const candidate of candidates) {
-    try {
-      const parsed = JSON.parse(candidate);
-      const validated = safeParse(SkillDecisionSchema, parsed);
-      if (validated) return validated;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
 
 // src/utils/retry.ts
 async function withRetry(fn, opts = {}) {
@@ -5450,7 +5632,7 @@ function stripMcpPrefix(toolName) {
   const match = toolName.match(/^mcp__[^_]+(?:__)?(.+)$/);
   return match ? match[1] : toolName;
 }
-function createEventHooks(taskId, toolCallRecords) {
+function createEventHooks(taskId, toolCallRecords, toolFailures = []) {
   const preToolUseHook = async (input) => {
     if (input.hook_event_name !== "PreToolUse") return { continue: true };
     const preInput = input;
@@ -5488,9 +5670,30 @@ function createEventHooks(taskId, toolCallRecords) {
     });
     return {};
   };
+  const postToolUseFailureHook = async (input) => {
+    if (input.hook_event_name !== "PostToolUseFailure") return {};
+    const failureInput = input;
+    const rawName = failureInput.tool_name;
+    const displayName = stripMcpPrefix(rawName);
+    const errorStr = failureInput.error;
+    toolFailures.push({
+      toolName: displayName,
+      input: failureInput.tool_input || {},
+      error: errorStr.slice(0, 500),
+      timestamp: Date.now()
+    });
+    await emitEvent(taskId, "tool_failure", {
+      name: displayName,
+      error: errorStr.slice(0, 500),
+      failure_count: toolFailures.filter((f) => f.toolName === displayName).length
+    });
+    log.warn(`Tool failure tracked: ${displayName} (total: ${toolFailures.length})`);
+    return {};
+  };
   return {
     PreToolUse: [{ hooks: [preToolUseHook] }],
-    PostToolUse: [{ hooks: [postToolUseHook] }]
+    PostToolUse: [{ hooks: [postToolUseHook] }],
+    PostToolUseFailure: [{ hooks: [postToolUseFailureHook] }]
   };
 }
 
@@ -5602,7 +5805,16 @@ Workflow for form filling (e.g. "\u6CE8\u518C\u4E00\u4E2A Gmail \u8D26\u53F7"):
 4. Check the screenshot \u2014 if validation errors appear, re-snapshot and fix
 5. When a username/email is taken, append a random 4-digit suffix and retry
 
+7. FAILURE RECOVERY \u2014 Strategy Switching:
+   If a tool call fails, do NOT repeat the same call. Reflect on why it failed and switch strategy:
+   - CSS selector fails \u2192 use browser_snapshot refs instead
+   - Direct navigation fails \u2192 search for the page first
+   - API/programmatic approach fails \u2192 use browser UI instead
+   - One data source fails \u2192 try an alternative source
+   - If stuck after 2 failed attempts at the same step, try a fundamentally different approach
+
 Guidelines:
+- SELF-VERIFY before finishing: re-read modified files, take a final screenshot after browser actions, or re-check output to confirm correctness. Never assume success without confirming the end state.
 - Always use the real browser for web tasks, never try to fetch URLs programmatically
 - ALWAYS use browser_snapshot as your primary way to understand a page \u2014 the ref table gives actionable refs, the screenshot gives visual context
 - Use browser_act to batch multiple actions \u2014 fill an entire form in one call instead of individual clicks/types
@@ -5667,12 +5879,18 @@ var TaskProcessor = class {
   memoryManager = null;
   skillManager;
   sessionId = null;
+  userId = null;
   /** In-memory conversation history, keyed by conversation_id */
   historyCache = /* @__PURE__ */ new Map();
   constructor() {
     this.skillManager = new SkillManager();
   }
+  /** @deprecated Use setUserId() instead */
   init(userId) {
+    this.setUserId(userId);
+  }
+  setUserId(userId) {
+    this.userId = userId;
     this.memoryManager = new MemoryManager();
     this.skillManager.setUserId(userId);
     this.skillManager.loadFromDb().catch((err) => {
@@ -5702,6 +5920,7 @@ var TaskProcessor = class {
     log.info(`Processing task ${task.id.slice(0, 8)}...`);
     let finalResponse = "";
     const toolCallRecords = [];
+    const toolFailures = [];
     let tokenUsage;
     let agentSessionId;
     try {
@@ -5754,18 +5973,15 @@ var TaskProcessor = class {
         onUserWaitStart: () => taskTimeout.pause(),
         onUserWaitEnd: () => taskTimeout.resume()
       });
-      const eventHooks = createEventHooks(task.id, toolCallRecords);
+      const eventHooks = createEventHooks(task.id, toolCallRecords, toolFailures);
       const allowedTools = [
-        // SDK built-in tools
         "Read",
         "Write",
         "Edit",
         "Bash",
         "Glob",
         "Grep",
-        // Browser MCP tools
         ...BROWSER_TOOL_NAMES.map((n) => `mcp__assistme-browser__${n}`),
-        // Agent MCP tools (memory, skills)
         "mcp__assistme-agent__memory_store",
         "mcp__assistme-agent__skill_create",
         "mcp__assistme-agent__skill_improve",
@@ -5776,29 +5992,19 @@ var TaskProcessor = class {
         "mcp__assistme-agent__skill_browse",
         "mcp__assistme-agent__skill_add",
         "mcp__assistme-agent__skill_publish",
-        // User interaction
         "mcp__assistme-agent__ask_user",
-        // Job automation tools
         "mcp__assistme-agent__job_run",
         "mcp__assistme-agent__job_schedule",
         "mcp__assistme-agent__job_status",
-        // Credential tools (local storage)
         "mcp__assistme-agent__credential_get",
         "mcp__assistme-agent__credential_set",
         "mcp__assistme-agent__credential_list",
         "mcp__assistme-agent__credential_remove"
       ];
-      async function* promptMessages() {
-        yield {
-          type: "user",
-          message: {
-            role: "user",
-            content: task.prompt
-          },
-          parent_tool_use_id: null,
-          session_id: ""
-        };
-      }
+      const mcpServers = {
+        "assistme-browser": browserServer,
+        "assistme-agent": agentToolsServer
+      };
       const options = {
         model: config.model,
         systemPrompt,
@@ -5807,19 +6013,16 @@ var TaskProcessor = class {
         allowedTools,
         permissionMode: "bypassPermissions",
         allowDangerouslySkipPermissions: true,
-        mcpServers: {
-          "assistme-browser": browserServer,
-          "assistme-agent": agentToolsServer
-        },
+        mcpServers,
         hooks: eventHooks,
         persistSession: true,
-        abortController
+        abortController,
+        thinking: { type: "adaptive" },
+        effort: "high",
+        maxBudgetUsd: MAX_BUDGET_USD
       };
       try {
-        for await (const message of query2({
-          prompt: promptMessages(),
-          options
-        })) {
+        for await (const message of query2({ prompt: task.prompt, options })) {
           switch (message.type) {
             case "assistant": {
               const assistantMsg = message;
@@ -5827,16 +6030,11 @@ var TaskProcessor = class {
                 if (block.type === "text") {
                   finalResponse += block.text;
                   log.agent(block.text);
-                  await emitEvent(task.id, "text_delta", {
-                    text: block.text
-                  });
+                  await emitEvent(task.id, "text_delta", { text: block.text });
                 } else if (block.type === "thinking" && "thinking" in block) {
                   const thinkingBlock = block;
-                  const thinkingText = thinkingBlock.thinking;
-                  log.debug(`Thinking: ${thinkingText.slice(0, 100)}...`);
-                  await emitEvent(task.id, "thinking", {
-                    text: thinkingText
-                  });
+                  log.debug(`Thinking: ${thinkingBlock.thinking.slice(0, 100)}...`);
+                  await emitEvent(task.id, "thinking", { text: thinkingBlock.thinking });
                 }
               }
               break;
@@ -5852,13 +6050,14 @@ var TaskProcessor = class {
                 if (!finalResponse && successMsg.result) {
                   finalResponse = successMsg.result;
                 }
+                agentSessionId = successMsg.session_id;
                 log.info(
                   `Task cost: $${successMsg.total_cost_usd.toFixed(4)}, turns: ${successMsg.num_turns}`
                 );
               } else {
-                const errorMsg = resultMsg;
-                log.warn(`SDK result: ${errorMsg.subtype}`);
-                for (const err of errorMsg.errors) {
+                const errMsg = resultMsg;
+                log.warn(`SDK result: ${errMsg.subtype}`);
+                for (const err of errMsg.errors) {
                   await emitEvent(task.id, "error", { message: err });
                 }
               }
@@ -5892,16 +6091,21 @@ var TaskProcessor = class {
         convHistory.splice(0, convHistory.length - MAX_HISTORY_ENTRIES * 2);
       }
       this.historyCache.set(task.conversation_id, convHistory);
+      if (this.memoryManager) {
+        this.memoryManager.compressIfNeeded().catch(
+          (err) => log.debug(`Memory compression skipped: ${err}`)
+        );
+      }
       if (agentSessionId) {
         this.evaluateSkillPostTask(agentSessionId, config.model).catch(
           (err) => log.debug(`Post-task skill evaluation skipped: ${err}`)
         );
       }
     } catch (err) {
-      const errorMsg = errorMessage(err);
-      log.error(`Task failed: ${errorMsg}`);
-      await failTask(task.id, errorMsg);
-      await emitEvent(task.id, "error", { message: errorMsg });
+      const errMsg = errorMessage(err);
+      log.error(`Task failed: ${errMsg}`);
+      await failTask(task.id, errMsg);
+      await emitEvent(task.id, "error", { message: errMsg });
       await emitEvent(task.id, "status_change", { status: "failed" });
     } finally {
       setCorrelationId(null);
@@ -5916,6 +6120,57 @@ var TaskProcessor = class {
   }
 };
 
+// src/db/session-log.ts
+var FLUSH_INTERVAL_MS = 3e3;
+var MAX_BATCH_SIZE = 100;
+var SessionLogEmitter = class {
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+    this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+  }
+  sequence = 0;
+  buffer = [];
+  flushTimer = null;
+  flushing = false;
+  /** Queue a log entry for batch insertion */
+  push(logType, message) {
+    this.sequence++;
+    this.buffer.push({ log_type: logType, message, seq: this.sequence });
+    if (this.buffer.length >= MAX_BATCH_SIZE) {
+      this.flush();
+    }
+  }
+  /** Flush buffered logs to Supabase */
+  async flush() {
+    if (this.flushing || this.buffer.length === 0) return;
+    const batch = this.buffer.splice(0);
+    this.flushing = true;
+    try {
+      await callMcpHandler("log.emit_batch", {
+        session_id: this.sessionId,
+        logs: batch
+      });
+    } catch (err) {
+      log.debug(
+        `Failed to flush session logs: ${err instanceof Error ? err.message : err}`
+      );
+      if (this.buffer.length < MAX_BATCH_SIZE * 5) {
+        this.buffer.unshift(...batch);
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /** Stop the emitter and flush remaining logs */
+  async stop() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+};
+
 // src/commands/start.ts
 function registerStartCommand(program2) {
   program2.command("start", { isDefault: true, hidden: true }).description("Start the agent (default command)").option("-w, --workspace <path>", "Workspace path (default: current directory)").option("-n, --name <name>", "Session name").option("-v, --verbose", "Enable verbose/debug logging").action(runAgent);
@@ -5979,10 +6234,16 @@ async function runAgent(opts) {
   const processor = new TaskProcessor();
   processor.init(userId);
   const sessionManager = new SessionManager();
+  let logEmitter = null;
   const browserRef = getBrowser();
   const shutdown = async () => {
     console.log();
     log.info("Shutting down...");
+    setLogHook(null);
+    try {
+      if (logEmitter) await logEmitter.stop();
+    } catch {
+    }
     try {
       if (browserRef.isConnected()) await browserRef.disconnect();
     } catch {
@@ -5997,6 +6258,10 @@ async function runAgent(opts) {
       await processor.processTask(task);
     });
     processor.setSessionId(session.id);
+    logEmitter = new SessionLogEmitter(session.id);
+    setLogHook((logType, message) => {
+      logEmitter?.push(logType, message);
+    });
     log.info("Listening for tasks (chat + jobs) from web UI...");
     log.info("Press Ctrl+C to stop.\n");
     const rl = createInterface2({
@@ -6402,7 +6667,7 @@ function registerJobCommands(program2) {
   jobCmd.command("list").description("List your defined jobs").action(async () => {
     try {
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-JT3JWZBV.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-AT3V6LAQ.js");
       const runner = new JobRunner2();
       const jobs = await runner.listJobs();
       if (jobs.length === 0) {
@@ -6426,7 +6691,7 @@ function registerJobCommands(program2) {
   jobCmd.command("status [name]").description("Show run history for a job (or all jobs)").option("-l, --limit <number>", "Max runs to show (default: 5)").action(async (name, opts) => {
     try {
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-JT3JWZBV.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-AT3V6LAQ.js");
       const runner = new JobRunner2();
       const runs = await runner.getRunHistory(name, parseInt(opts.limit || "5"));
       if (runs.length === 0) {
@@ -6465,7 +6730,7 @@ Job Run History${name ? ` \u2014 ${name}` : ""}:`));
         process.exit(1);
       }
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-JT3JWZBV.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-AT3V6LAQ.js");
       const runner = new JobRunner2();
       const job = await runner.loadJob(name);
       if (!job) {