assistme 0.7.0 → 0.8.2

package/dist/workers/entry.js

@@ -0,0 +1,3280 @@
+#!/usr/bin/env node
+import {
+  BrowserController,
+  MemoryManager,
+  SkillManager,
+  completeTask,
+  createScheduledTask,
+  emitEvent,
+  ensureBrowserAvailable,
+  executeShell,
+  failTask,
+  getBrowser,
+  getConversationHistory,
+  getCredentialStore,
+  getLocalStore,
+  getNextRunTime,
+  normalizeSkillName,
+  pollActionResponse,
+  preprocessDynamicContext,
+  resetEventSequence,
+  setActionRequest,
+  substituteArguments,
+  validateSkillName
+} from "../chunk-IKYXC4RJ.js";
+import {
+  AppError,
+  EDSGER_PRODUCT_SLUG,
+  JobRunner,
+  MAX_BUDGET_USD,
+  MAX_COMPLETE_TASK_RETRIES,
+  MAX_CONTENT_SEARCH_FILES,
+  MAX_CONTENT_SEARCH_RESULTS,
+  MAX_FILE_SEARCH_RESULTS,
+  MAX_HISTORY_ENTRIES,
+  MAX_HISTORY_RESPONSE_LENGTH,
+  MAX_RESPONSE_CONTENT_LENGTH,
+  MAX_SKILL_RECORD_RESULT_LENGTH,
+  MAX_TOOL_INPUT_LOG_LENGTH,
+  MAX_TOOL_RESULT_LENGTH,
+  SELF_ANALYSIS_EVENT_CONTEXT_CHARS,
+  SELF_ANALYSIS_LOG_CONTEXT_CHARS,
+  SELF_ANALYSIS_MAX_CONVERSATION_MESSAGES,
+  SELF_ANALYSIS_MAX_MESSAGE_EVENTS,
+  SELF_ANALYSIS_MAX_SESSION_LOGS,
+  SELF_ANALYSIS_TIMEOUT_MS,
+  SkillDecisionSchema,
+  callMcpHandler,
+  errorMessage,
+  log,
+  newCorrelationId,
+  safeParse,
+  setCorrelationId,
+  setLogTransport
+} from "../chunk-A2NR7LCQ.js";
+import {
+  getConfig
+} from "../chunk-YYSJHZSO.js";
+
+// src/workers/conversation.ts
+import { config as loadEnv } from "dotenv";
+
+// src/workers/base-handler.ts
+var BaseHandler = class {
+  config = null;
+  running = false;
+  /** Start listening for IPC messages from the orchestrator. */
+  start() {
+    this.running = true;
+    setLogTransport((method, message, extra) => {
+      this.send({ type: "log_forward", method, message, extra });
+    });
+    process.on("message", async (raw) => {
+      const message = raw;
+      try {
+        switch (message.type) {
+          case "init":
+            this.config = message.config;
+            await this.onInit(message.config);
+            this.send({ type: "ready" });
+            break;
+          case "shutdown":
+            this.running = false;
+            setLogTransport(null);
+            await this.onShutdown();
+            process.exit(0);
+            break;
+          default:
+            await this.onMessage(message);
+            break;
+        }
+      } catch (err) {
+        this.send({
+          type: "error",
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    });
+    process.on("SIGTERM", async () => {
+      this.running = false;
+      await this.onShutdown();
+      process.exit(0);
+    });
+    process.on("disconnect", () => {
+      this.running = false;
+      process.exit(0);
+    });
+  }
+  /** Send a message to the orchestrator (main process). */
+  send(message) {
+    if (process.send) {
+      process.send(message);
+    }
+  }
+  /** Log via IPC (logs are displayed by the orchestrator). */
+  log(level, message) {
+    this.send({ type: "log", level, message });
+  }
+};
+
+// src/agent/processor.ts
+import {
+  query as query3
+} from "@anthropic-ai/claude-agent-sdk";
+
+// src/agent/skill-evaluator.ts
+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)
+
+A skill follows the SKILL.md format:
+- name: 1-64 chars, lowercase kebab-case (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens
+- description: 1-1024 chars, describe WHAT it does AND WHEN to use it, include searchable keywords
+- body: markdown step-by-step instructions, examples, edge cases. Keep under 500 lines, <5000 tokens.
+- Use generic placeholders (e.g. {url}, {query}, {product_name}) instead of specific values
+- Instructions should be a REUSABLE workflow, not a transcript of what just happened
+- Include error handling steps and tool references (browser_navigate, browser_read_page, Bash, Read, etc.)
+
+## Your Decision
+
+Respond with ONLY a JSON object (no markdown, no explanation outside the JSON). Choose one action:
+
+1. **"create"** \u2014 The task is a reusable workflow worth saving.
+   Include: name, description, instructions (full SKILL.md body), emoji, keywords (3-5, include Chinese if task was in Chinese)
+
+2. **"update"** \u2014 An existing skill should be improved based on what you just learned.
+   Include: existing_skill_name, improved_instructions (full updated body), improved_description (if changed)
+
+3. **"skip"** \u2014 Not worth capturing (simple Q&A, one-off, too vague, already fully covered by existing skill).
+
+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) {
+    log.debug("Skill evaluation skipped: no session ID to resume");
+    return;
+  }
+  const existingSkills = skillManager.getAll();
+  const existingList = existingSkills.length > 0 ? existingSkills.map((s) => `- ${s.name}: ${s.description}`).join("\n") : "(no existing skills)";
+  const prompt = `${SKILL_EVALUATION_PROMPT}
+
+## Existing Skills (do NOT duplicate these)
+${existingList}
+
+Respond with a JSON object now.`;
+  try {
+    let structuredOutput;
+    for await (const message of query({
+      prompt,
+      options: {
+        resume: sessionId,
+        model,
+        allowedTools: [],
+        effort: "low",
+        outputFormat: SKILL_DECISION_OUTPUT_FORMAT
+      }
+    })) {
+      if (message.type === "result") {
+        const resultMsg = message;
+        if (resultMsg.subtype === "success") {
+          const successMsg = resultMsg;
+          structuredOutput = successMsg.structured_output;
+          log.debug(
+            `Skill evaluation cost: $${successMsg.total_cost_usd.toFixed(4)}`
+          );
+        }
+      }
+    }
+    const decision = structuredOutput ? safeParse(SkillDecisionSchema, structuredOutput) : null;
+    if (!decision) {
+      log.debug("Skill evaluation: no valid JSON in response");
+      return;
+    }
+    await executeSkillDecision(decision, skillManager, sessionId, model);
+  } catch (err) {
+    log.debug(`Skill evaluation error: ${errorMessage(err)}`);
+  }
+}
+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,
+        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;
+      }
+      const skillName = normalizeSkillName(decision.name);
+      if (!skillName) {
+        log.debug(`Skill create skipped: name "${decision.name}" cannot be normalized`);
+        return;
+      }
+      const validationError = validateSkillName(skillName);
+      if (validationError) {
+        log.debug(`Skill create skipped: ${validationError}`);
+        return;
+      }
+      if (skillName !== decision.name) {
+        log.debug(`Normalized skill name: "${decision.name}" \u2192 "${skillName}"`);
+      }
+      const existing = skillManager.findSimilar(skillName);
+      if (existing) {
+        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 || "",
+        instructions,
+        {
+          source: "auto_extracted",
+          emoji: decision.emoji,
+          keywords: decision.keywords
+        }
+      );
+      if (result) {
+        await skillManager.syncToAgentSkills(
+          skillName,
+          decision.description || "",
+          instructions,
+          "1.0.0",
+          {
+            source: "auto_extracted",
+            emoji: decision.emoji,
+            keywords: decision.keywords,
+            sourceSkillId: result.id
+          }
+        );
+        log.info(`Auto-created skill "${skillName}" (validated): ${decision.reason}`);
+      }
+      break;
+    }
+    case "update": {
+      if (!decision.existing_skill_name || !decision.improved_instructions) {
+        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,
+        decision.improved_description
+      );
+      if (updated) {
+        log.info(`Auto-improved skill "${decision.existing_skill_name}": ${decision.reason}`);
+      } else {
+        log.debug(`Skill update failed: "${decision.existing_skill_name}" not found`);
+      }
+      break;
+    }
+    case "skip":
+      log.debug(`Skill evaluation: skip \u2014 ${decision.reason}`);
+      break;
+  }
+}
+
+// src/agent/self-analyzer.ts
+import {
+  query as query2
+} from "@anthropic-ai/claude-agent-sdk";
+import { submitFeedback, FeedbackError } from "edsger-feedback";
+
+// src/db/analysis-data.ts
+async function getSessionLogs(sessionId, limit = 500, conversationId) {
+  try {
+    const data = await callMcpHandler("log.list", {
+      session_id: sessionId,
+      limit,
+      ...conversationId ? { conversation_id: conversationId } : {}
+    });
+    return data || [];
+  } catch (err) {
+    log.debug(`Failed to fetch session logs: ${err instanceof Error ? err.message : err}`);
+    return [];
+  }
+}
+async function getMessageEvents(messageId, limit = 500) {
+  try {
+    const data = await callMcpHandler("event.list", {
+      message_id: messageId,
+      limit
+    });
+    return data || [];
+  } catch (err) {
+    log.debug(`Failed to fetch message events: ${err instanceof Error ? err.message : err}`);
+    return [];
+  }
+}
+async function getConversationMessages(conversationId, limit = 10) {
+  try {
+    const data = await callMcpHandler(
+      "conversation.list_messages",
+      {
+        conversation_id: conversationId,
+        limit
+      }
+    );
+    return data || [];
+  } catch (err) {
+    log.debug(`Failed to fetch conversation messages: ${err instanceof Error ? err.message : err}`);
+    return [];
+  }
+}
+
+// src/agent/self-analyzer.ts
+var SELF_ANALYSIS_OUTPUT_FORMAT = {
+  type: "json_schema",
+  schema: {
+    type: "object",
+    properties: {
+      needsImprovement: { type: "boolean" },
+      title: { type: "string" },
+      description: { type: "string" }
+    },
+    required: ["needsImprovement", "title", "description"]
+  }
+};
+var SELF_ANALYSIS_PROMPT = `You just completed a task as the AssistMe agent. Now critically analyze AssistMe's own implementation \u2014 NOT the user's task itself, but how well AssistMe (the agent system) performed and whether AssistMe's codebase can be improved.
+
+## Your Role
+You are a perfectionist code reviewer analyzing the AssistMe agent system itself. Be critical, thorough, and constructive. Focus on:
+
+1. **Task Completion Quality**: Did AssistMe handle the task optimally? Were there unnecessary steps, missed edge cases, or suboptimal tool usage?
+2. **Agent Architecture**: Based on what you observed during execution, are there architectural improvements to AssistMe's code (processor, event hooks, MCP servers, skill system, etc.)?
+3. **Data & Observability**: Evaluate the quality of the context data provided (session logs, message events, conversation messages). What information is missing that would help diagnose issues or improve the system?
+4. **Error Handling & Resilience**: Were there any failures or retries? Could the error handling be improved?
+5. **Performance & Efficiency**: Were there unnecessary API calls, redundant operations, or opportunities to optimize?
+6. **User Experience**: Could the interaction flow be smoother? Is the feedback to the user adequate?
+
+## Context Data Provided
+Below you will find:
+- **Session Logs**: stdout/stderr/status logs from the agent session
+- **Message Events**: Real-time events emitted during task execution (tool calls, results, status changes, thinking blocks)
+- **Conversation Messages**: User interaction history for this conversation
+- **Tool Call Records**: Summary of all tool calls made during the task
+- **Tool Failures**: Any tool calls that failed during execution
+
+## Instructions
+Analyze all provided data critically. Respond with a JSON object containing:
+- "needsImprovement": set to false ONLY if the task was handled perfectly with zero improvements, true otherwise
+- "title": a short summary under 100 chars (empty string if needsImprovement is false)
+- "description": a detailed markdown report (empty string if needsImprovement is false) that includes:
+  - **Summary**: overall assessment of how AssistMe performed
+  - **Task Completion Quality**: score (1-10) and assessment
+  - **Improvements**: numbered list, each with severity (critical/major/minor/suggestion), area, description, and suggestion
+  - **Data Quality Gaps**: any gaps in session logs, message events, or conversation context that limited your analysis`;
+function truncateToChars(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + "\n... [truncated]";
+}
+var EVENT_RESULT_SUMMARY_CHARS = 150;
+function filterAndAggregateEvents(events) {
+  const lines = [];
+  let pendingTextChunks = [];
+  const flushTextDelta = () => {
+    if (pendingTextChunks.length > 0) {
+      const merged = pendingTextChunks.join("");
+      const summary = merged.length > 200 ? merged.slice(0, 200) + "..." : merged;
+      lines.push(`[text_delta x${pendingTextChunks.length}] ${summary}`);
+      pendingTextChunks = [];
+    }
+  };
+  for (const e of events) {
+    switch (e.event_type) {
+      case "text_delta": {
+        const text = e.event_data.text || "";
+        pendingTextChunks.push(text);
+        break;
+      }
+      case "thinking":
+        flushTextDelta();
+        break;
+      case "tool_use_input":
+        flushTextDelta();
+        break;
+      case "tool_result": {
+        flushTextDelta();
+        const name = e.event_data.name || "unknown";
+        const result = (e.event_data.result || "").slice(0, EVENT_RESULT_SUMMARY_CHARS);
+        lines.push(`[tool_result] ${name}: ${result}`);
+        break;
+      }
+      case "tool_failure":
+      case "status_change":
+      case "error": {
+        flushTextDelta();
+        lines.push(`[${e.event_type}] ${JSON.stringify(e.event_data)}`);
+        break;
+      }
+      default: {
+        flushTextDelta();
+        const dataStr = JSON.stringify(e.event_data);
+        lines.push(`[${e.event_type}] ${dataStr.slice(0, 200)}`);
+        break;
+      }
+    }
+  }
+  flushTextDelta();
+  return lines;
+}
+async function buildAnalysisContext(ctx) {
+  const [sessionLogs, messageEvents, conversationMessages] = await Promise.all([
+    getSessionLogs(ctx.sessionId, SELF_ANALYSIS_MAX_SESSION_LOGS, ctx.conversationId),
+    getMessageEvents(ctx.taskId, SELF_ANALYSIS_MAX_MESSAGE_EVENTS),
+    getConversationMessages(ctx.conversationId, SELF_ANALYSIS_MAX_CONVERSATION_MESSAGES)
+  ]);
+  let context = "";
+  if (sessionLogs.length > 0) {
+    const logText = sessionLogs.map((l) => `[${l.log_type}] ${l.message}`).join("\n");
+    context += `
+## Session Logs (${sessionLogs.length} entries)
+`;
+    context += truncateToChars(logText, SELF_ANALYSIS_LOG_CONTEXT_CHARS);
+  } else {
+    context += "\n## Session Logs\n(No session logs available \u2014 this is itself a data gap to note)\n";
+  }
+  if (messageEvents.length > 0) {
+    const filteredLines = filterAndAggregateEvents(messageEvents);
+    const eventText = filteredLines.join("\n");
+    context += `
+## Message Events (${messageEvents.length} raw \u2192 ${filteredLines.length} aggregated)
+`;
+    context += truncateToChars(eventText, SELF_ANALYSIS_EVENT_CONTEXT_CHARS);
+  } else {
+    context += "\n## Message Events\n(No message events available \u2014 this is itself a data gap to note)\n";
+  }
+  if (conversationMessages.length > 0) {
+    context += `
+## Conversation Messages (${conversationMessages.length} entries)
+`;
+    for (const msg of conversationMessages) {
+      const role = msg.role || "unknown";
+      const content = (msg.content || "").slice(0, 500);
+      const status = msg.status || "";
+      context += `[${role}${status ? ` (${status})` : ""}] ${content}
+`;
+    }
+  } else {
+    context += "\n## Conversation Messages\n(No conversation messages available)\n";
+  }
+  if (ctx.toolCallRecords.length > 0) {
+    context += `
+## Tool Call Records (${ctx.toolCallRecords.length} calls)
+`;
+    for (const tc of ctx.toolCallRecords) {
+      const inputStr = JSON.stringify(tc.input).slice(0, 200);
+      context += `- ${tc.name}: ${inputStr} \u2192 ${tc.result.slice(0, 100)}
+`;
+    }
+  }
+  if (ctx.toolFailures.length > 0) {
+    context += `
+## Tool Failures (${ctx.toolFailures.length} failures)
+`;
+    for (const tf of ctx.toolFailures) {
+      context += `- ${tf.toolName}: ${tf.error}
+`;
+    }
+  }
+  if (ctx.tokenUsage) {
+    context += `
+## Token Usage
+`;
+    context += `Input: ${ctx.tokenUsage.input_tokens}, Output: ${ctx.tokenUsage.output_tokens}
+`;
+  }
+  context += `
+## Task
+`;
+  context += `Prompt: ${ctx.taskPrompt.slice(0, 500)}
+`;
+  context += `Response length: ${ctx.taskResponse.length} chars
+`;
+  return context;
+}
+async function submitSelfAnalysisFeedback(title, description) {
+  if (description.length > 4900) {
+    description = description.slice(0, 4900) + "\n...[truncated]";
+  }
+  try {
+    const result = await submitFeedback({
+      slug: EDSGER_PRODUCT_SLUG,
+      title: title.slice(0, 200),
+      description,
+      category: "improvement"
+    });
+    log.info(`Self-analysis feedback submitted: ${result.id}`);
+  } catch (err) {
+    if (err instanceof FeedbackError) {
+      log.debug(`Feedback submission failed (${err.statusCode}): ${err.message}`);
+    } else {
+      log.debug(`Feedback submission failed: ${errorMessage(err)}`);
+    }
+  }
+}
+async function runAnalysisQuery(model, prompt) {
+  let structuredOutput;
+  for await (const message of query2({
+    prompt,
+    options: {
+      model,
+      allowedTools: [],
+      effort: "medium",
+      outputFormat: SELF_ANALYSIS_OUTPUT_FORMAT
+    }
+  })) {
+    if (message.type === "result") {
+      const resultMsg = message;
+      if (resultMsg.subtype === "success") {
+        const successMsg = resultMsg;
+        structuredOutput = successMsg.structured_output;
+        log.debug(
+          `Self-analysis cost: $${successMsg.total_cost_usd.toFixed(4)}`
+        );
+        if (!structuredOutput) {
+          log.warn(
+            `Self-analysis: success but no structured_output. result text: ${String(successMsg.result ?? "").slice(0, 500)}`
+          );
+        }
+      } else {
+        log.warn(
+          `Self-analysis: query returned subtype="${resultMsg.subtype}".`
+        );
+      }
+    }
+  }
+  if (!structuredOutput || typeof structuredOutput !== "object") return null;
+  const output = structuredOutput;
+  return {
+    needsImprovement: Boolean(output.needsImprovement),
+    title: String(output.title || ""),
+    description: String(output.description || "")
+  };
+}
+async function analyzeSelfPostTask(opts) {
+  const {
+    model,
+    taskId,
+    conversationId,
+    taskPrompt,
+    taskResponse,
+    toolCallRecords,
+    toolFailures,
+    tokenUsage,
+    sessionId
+  } = opts;
+  try {
+    log.info(`Self-analysis starting for task ${taskId}`);
+    const analysisContext = await buildAnalysisContext({
+      taskId,
+      conversationId,
+      sessionId,
+      taskPrompt,
+      taskResponse,
+      toolCallRecords,
+      toolFailures,
+      tokenUsage
+    });
+    const prompt = `${SELF_ANALYSIS_PROMPT}
+${analysisContext}`;
+    const analysisPromise = runAnalysisQuery(model, prompt);
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`Self-analysis timed out after ${SELF_ANALYSIS_TIMEOUT_MS / 1e3}s`)), SELF_ANALYSIS_TIMEOUT_MS)
+    );
+    const result = await Promise.race([analysisPromise, timeoutPromise]);
+    if (!result) {
+      log.warn("Self-analysis: no result from query");
+      return;
+    }
+    if (!result.needsImprovement) {
+      log.info("Self-analysis complete: no improvements needed");
+      return;
+    }
+    log.info(`Self-analysis complete: improvements found \u2014 ${result.title}`);
+    await submitSelfAnalysisFeedback(result.title, result.description);
+  } catch (err) {
+    log.warn(`Self-analysis error: ${errorMessage(err)}`);
+  }
+}
+
+// src/utils/retry.ts
+async function withRetry(fn, opts = {}) {
+  const {
+    maxRetries = 3,
+    baseDelayMs = 500,
+    maxDelayMs = 1e4,
+    backoffFactor = 2,
+    retryIf,
+    label
+  } = opts;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (retryIf && !retryIf(err)) {
+        throw err;
+      }
+      if (attempt < maxRetries) {
+        const delay = Math.min(
+          baseDelayMs * Math.pow(backoffFactor, attempt),
+          maxDelayMs
+        );
+        if (label) {
+          log.debug(`${label}: attempt ${attempt + 1} failed, retrying in ${delay}ms`);
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/mcp/browser-server.ts
+import {
+  createSdkMcpServer,
+  tool
+} from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod/v4";
+
+// src/tools/filesystem.ts
+import { readFile, writeFile, readdir, stat, mkdir } from "fs/promises";
+import { resolve, relative, join, sep } from "path";
+import { glob } from "glob";
+function assertWithinWorkspace(filePath) {
+  const config = getConfig();
+  const resolved = resolve(config.workspacePath, filePath);
+  const rel = relative(config.workspacePath, resolved);
+  if (rel.startsWith("..") || rel.startsWith(sep + sep)) {
+    throw new AppError(
+      `Access denied: path "${filePath}" is outside workspace "${config.workspacePath}"`,
+      "PATH_TRAVERSAL"
+    );
+  }
+  return resolved;
+}
+async function readFileContent(path, offset, limit) {
+  const resolved = assertWithinWorkspace(path);
+  const content = await readFile(resolved, "utf-8");
+  const lines = content.split("\n");
+  const start = offset || 0;
+  const end = limit ? start + limit : lines.length;
+  const selected = lines.slice(start, end);
+  return selected.map((line, i) => `${String(start + i + 1).padStart(5)} | ${line}`).join("\n");
+}
+async function writeFileContent(path, content) {
+  const resolved = assertWithinWorkspace(path);
+  const dir = resolve(resolved, "..");
+  await mkdir(dir, { recursive: true });
+  await writeFile(resolved, content, "utf-8");
+  return `File written: ${path} (${content.length} bytes)`;
+}
+async function searchFiles(pattern, directory) {
+  const config = getConfig();
+  const cwd = directory ? assertWithinWorkspace(directory) : config.workspacePath;
+  const matches = await glob(pattern, {
+    cwd,
+    nodir: false,
+    ignore: ["node_modules/**", ".git/**", "dist/**", ".next/**"]
+  });
+  if (matches.length === 0) return "No files found matching the pattern.";
+  return matches.slice(0, MAX_FILE_SEARCH_RESULTS).map((m) => relative(config.workspacePath, join(cwd, m))).join("\n");
+}
+async function listDirectory(path) {
+  const config = getConfig();
+  const resolved = path ? assertWithinWorkspace(path) : config.workspacePath;
+  const entries = await readdir(resolved, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") && entry.name !== ".env.example") continue;
+    const icon = entry.isDirectory() ? "\u{1F4C1}" : "\u{1F4C4}";
+    const info = entry.isFile() ? await stat(join(resolved, entry.name)).then((s) => ` (${formatSize(s.size)})`) : "";
+    results.push(`${icon} ${entry.name}${info}`);
+  }
+  return results.join("\n") || "Empty directory.";
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+async function searchContent(pattern, fileGlob, directory) {
+  const config = getConfig();
+  const cwd = directory ? assertWithinWorkspace(directory) : config.workspacePath;
+  const files = await glob(fileGlob || "**/*", {
+    cwd,
+    nodir: true,
+    ignore: ["node_modules/**", ".git/**", "dist/**", ".next/**"]
+  });
+  let regex;
+  try {
+    regex = new RegExp(pattern, "gi");
+  } catch {
+    regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
+  }
+  const results = [];
+  for (const file of files.slice(0, MAX_CONTENT_SEARCH_FILES)) {
+    try {
+      const content = await readFile(join(cwd, file), "utf-8");
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (regex.test(lines[i])) {
+          const relPath = relative(config.workspacePath, join(cwd, file));
+          results.push(`${relPath}:${i + 1}: ${lines[i].trim()}`);
+          regex.lastIndex = 0;
+          if (results.length >= MAX_CONTENT_SEARCH_RESULTS) break;
+        }
+      }
+      if (results.length >= MAX_CONTENT_SEARCH_RESULTS) break;
+    } catch {
+    }
+  }
+  return results.length > 0 ? results.join("\n") : "No matches found.";
+}
+
+// src/tools/index.ts
+async function detectAndHandleLogin(browser) {
+  const detection = await browser.detectLoginPage();
+  if (!detection.isLoginPage) return null;
+  const pageInfo = await browser.getPageInfo();
+  let siteName;
+  try {
+    siteName = new URL(pageInfo.url).hostname;
+  } catch {
+    siteName = pageInfo.url;
+  }
+  console.log("\n");
+  console.log("\u2501".repeat(60));
+  console.log("  \u{1F510} LOGIN REQUIRED");
+  console.log("\u2501".repeat(60));
+  console.log(`  ${detection.reason}`);
+  console.log(`  Site: ${siteName}`);
+  console.log(`  Please log in using the browser window.`);
+  console.log(`  Your session will be saved for future use.`);
+  console.log(`  (Waiting up to 120s for you to complete login)`);
+  console.log("\u2501".repeat(60));
+  console.log("\n");
+  const loginUrl = pageInfo.url;
+  const deadline = Date.now() + 12e4;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 3e3));
+    try {
+      const currentInfo = await browser.getPageInfo();
+      if (currentInfo.url !== loginUrl) {
+        await new Promise((r) => setTimeout(r, 1500));
+        const newPage = await browser.readPage();
+        return `Login completed. Redirected to: ${currentInfo.url}
+Session saved in assistme browser profile for future use.
+
+Current page:
+${newPage.slice(0, 3e3)}`;
+      }
+      const stillLogin = await browser.detectLoginPage();
+      if (!stillLogin.isLoginPage) {
+        const newPage = await browser.readPage();
+        return `Login completed on ${siteName}.
+Session saved in assistme browser profile for future use.
+
+Current page:
+${newPage.slice(0, 3e3)}`;
+      }
+    } catch {
+      try {
+        await browser.connect();
+      } catch {
+      }
+    }
+  }
+  return `Login wait timed out after 120s. The user may still need to log in at ${siteName}.`;
+}
+async function ensureConnected(browser, tabIndex) {
+  if (browser.isConnected() && tabIndex === void 0) return;
+  if (!await browser.isAvailable()) {
+    const result = await ensureBrowserAvailable();
+    if (!result.success) {
+      throw new Error(
+        `Chrome is not available (${result.action}). ${result.detail || "Please ensure Google Chrome is installed."}`
+      );
+    }
+  }
+  await browser.connect(tabIndex);
+}
+async function executeTool(name, input) {
+  const browser = getBrowser();
+  switch (name) {
+    // ── Filesystem ──────────────────────────────────────────
+    case "read_file":
+      return readFileContent(
+        input.path,
+        input.offset,
+        input.limit
+      );
+    case "write_file":
+      return writeFileContent(input.path, input.content);
+    case "search_files":
+      return searchFiles(input.pattern, input.directory);
+    case "search_content":
+      return searchContent(
+        input.pattern,
+        input.file_glob,
+        input.directory
+      );
+    case "list_directory":
+      return listDirectory(input.path);
+    case "execute_command":
+      return executeShell(input.command, input.cwd);
+    // ── Browser (CDP) ───────────────────────────────────────
+    case "browser_connect": {
+      await ensureConnected(browser, input.tab_index);
+      return browser.isConnected() ? "Connected to browser." : "Failed to connect.";
+    }
+    case "browser_navigate": {
+      await ensureConnected(browser);
+      const navResult = await browser.navigate(input.url);
+      const loginResult = await detectAndHandleLogin(browser);
+      if (loginResult) {
+        return navResult + "\n\n" + loginResult;
+      }
+      return navResult;
+    }
+    case "browser_read_page":
+      await ensureConnected(browser);
+      return browser.readPage();
+    case "browser_screenshot":
+      await ensureConnected(browser);
+      return browser.screenshot();
+    case "browser_click":
+      await ensureConnected(browser);
+      return browser.click(input.selector);
+    case "browser_type":
+      await ensureConnected(browser);
+      return browser.typeText(input.selector, input.text);
+    case "browser_press_key":
+      await ensureConnected(browser);
+      return browser.pressKey(input.key);
+    case "browser_scroll":
+      await ensureConnected(browser);
+      return input.direction === "up" ? browser.scrollUp() : browser.scrollDown();
+    case "browser_select":
+      await ensureConnected(browser);
+      return browser.selectOption(input.selector, input.option);
+    case "browser_evaluate":
+      await ensureConnected(browser);
+      return browser.evaluate(input.expression);
+    case "browser_snapshot": {
+      await ensureConnected(browser);
+      const snap = await browser.snapshot(input.annotate);
+      return BrowserController.formatRefTable(snap) + "\n__SNAPSHOT_IMAGE__:" + snap.image;
+    }
+    case "browser_act": {
+      await ensureConnected(browser);
+      const actions = input.actions;
+      const wantScreenshot = input.screenshot || false;
+      const actResult = await browser.act(actions, wantScreenshot);
+      let response = actResult.results.map((r) => `${r.success ? "OK" : "FAIL"}: ${r.result}`).join("\n");
+      if (actResult.screenshot) {
+        response += "\n__ACT_SCREENSHOT__:" + actResult.screenshot;
+      }
+      return response;
+    }
+    case "browser_list_tabs":
+      return browser.listTabs();
+    case "browser_switch_tab":
+      return browser.switchTab(input.index);
+    case "browser_new_tab":
+      return browser.openNewTab(input.url);
+    case "browser_request_user_action": {
+      const message = input.message;
+      const waitSeconds = input.wait_seconds || 60;
+      console.log("\n");
+      console.log("\u2501".repeat(60));
+      console.log("  \u{1F64B} USER ACTION REQUIRED");
+      console.log("\u2501".repeat(60));
+      console.log(`  ${message}`);
+      console.log(`  (Waiting up to ${waitSeconds}s for you to complete this)`);
+      console.log("\u2501".repeat(60));
+      console.log("\n");
+      let initialUrl = "";
+      try {
+        const info = await browser.getPageInfo();
+        initialUrl = info.url;
+      } catch {
+      }
+      const deadline = Date.now() + waitSeconds * 1e3;
+      while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 3e3));
+        try {
+          const info = await browser.getPageInfo();
+          if (initialUrl && info.url !== initialUrl) {
+            break;
+          }
+        } catch {
+        }
+      }
+      try {
+        const pageInfo = await browser.readPage();
+        return `User action wait completed. Current page state:
+${pageInfo.slice(0, 3e3)}`;
+      } catch {
+        return "User action wait completed. Could not read page state.";
+      }
+    }
+    default:
+      return `Unknown tool: ${name}`;
+  }
+}
+
+// src/utils/rate-limiter.ts
+var RateLimiter = class {
+  tokens;
+  maxTokens;
+  refillRate;
+  // tokens per second
+  lastRefill;
+  maxWaitMs;
+  constructor(opts) {
+    this.maxTokens = opts.maxTokens;
+    this.refillRate = opts.refillRate;
+    this.tokens = opts.maxTokens;
+    this.lastRefill = Date.now();
+    this.maxWaitMs = opts.maxWaitMs ?? 1e4;
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = (now - this.lastRefill) / 1e3;
+    this.tokens = Math.min(
+      this.maxTokens,
+      this.tokens + elapsed * this.refillRate
+    );
+    this.lastRefill = now;
+  }
+  /**
+   * Acquire a token. Returns immediately if available,
+   * otherwise waits until a token is refilled.
+   * Throws if wait would exceed maxWaitMs.
+   */
+  async acquire() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return;
+    }
+    const deficit = 1 - this.tokens;
+    const waitMs = deficit / this.refillRate * 1e3;
+    if (waitMs > this.maxWaitMs) {
+      throw new Error(
+        `Rate limit exceeded. Would need to wait ${Math.round(waitMs)}ms (max: ${this.maxWaitMs}ms)`
+      );
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, Math.ceil(waitMs)));
+    this.refill();
+    this.tokens -= 1;
+  }
+  /**
+   * Try to acquire a token without waiting.
+   * Returns true if acquired, false if rate limited.
+   */
+  tryAcquire() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get remaining tokens (for monitoring).
+   */
+  remaining() {
+    this.refill();
+    return Math.floor(this.tokens);
+  }
+};
+var toolRateLimiters = {
+  /** Browser tools: max 10 calls/sec, burst up to 20 */
+  browser: new RateLimiter({ maxTokens: 20, refillRate: 10 }),
+  /** Shell commands: max 5/sec, burst up to 10 */
+  shell: new RateLimiter({ maxTokens: 10, refillRate: 5 }),
+  /** File operations: max 20/sec, burst up to 40 */
+  filesystem: new RateLimiter({ maxTokens: 40, refillRate: 20 })
+};
+function getLimiterForTool(toolName) {
+  if (toolName.includes("assistme-browser") || toolName.startsWith("browser_"))
+    return toolRateLimiters.browser;
+  if (toolName === "Bash" || toolName === "execute_command")
+    return toolRateLimiters.shell;
+  if ([
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "read_file",
+    "write_file",
+    "search_files",
+    "search_content",
+    "list_directory"
+  ].includes(toolName))
+    return toolRateLimiters.filesystem;
+  return null;
+}
+
+// src/mcp/browser-server.ts
+async function callTool(name, input) {
+  const limiter = getLimiterForTool(name);
+  if (limiter) await limiter.acquire();
+  const result = await executeTool(name, input);
+  return { content: [{ type: "text", text: result }] };
+}
+var BROWSER_TOOL_NAMES = [
+  "browser_connect",
+  "browser_navigate",
+  "browser_read_page",
+  "browser_screenshot",
+  "browser_click",
+  "browser_type",
+  "browser_press_key",
+  "browser_scroll",
+  "browser_select",
+  "browser_snapshot",
+  "browser_act",
+  "browser_evaluate",
+  "browser_list_tabs",
+  "browser_switch_tab",
+  "browser_new_tab",
+  "browser_request_user_action"
+];
+function createBrowserMcpServer() {
+  return createSdkMcpServer({
+    name: "assistme-browser",
+    version: "1.0.0",
+    tools: [
+      tool(
+        "browser_connect",
+        "Connect to the user's real Chrome browser via CDP. Chrome will be auto-launched if not already running.",
+        { tab_index: z.number().optional().describe("Tab index (default: 0)") },
+        async (args) => callTool("browser_connect", args)
+      ),
+      tool(
+        "browser_navigate",
+        "Navigate the user's browser to a URL, using the user's real browser with all their cookies and logins.",
+        { url: z.string().describe("URL to navigate to") },
+        async (args) => callTool("browser_navigate", args)
+      ),
+      tool(
+        "browser_read_page",
+        "Read the text content of the currently open page. Returns page title, URL, and main text content.",
+        {},
+        async () => callTool("browser_read_page", {})
+      ),
+      tool(
+        "browser_screenshot",
+        "Take a screenshot of the current browser page. Returns a base64-encoded PNG image.",
+        {},
+        async () => {
+          const limiter = getLimiterForTool("browser_screenshot");
+          if (limiter) await limiter.acquire();
+          const base64 = await executeTool("browser_screenshot", {});
+          if (base64.length > 100) {
+            return {
+              content: [{ type: "image", data: base64, mimeType: "image/png" }]
+            };
+          }
+          return { content: [{ type: "text", text: base64 }] };
+        }
+      ),
+      tool(
+        "browser_click",
+        "Click on an element in the user's browser using a CSS selector.",
+        { selector: z.string().describe("CSS selector of the element to click") },
+        async (args) => callTool("browser_click", args)
+      ),
+      tool(
+        "browser_type",
+        "Type text into an input field in the user's browser. If the CSS selector fails, automatically falls back to typing into the currently focused element. Works with contenteditable elements (rich text editors) and cross-origin iframes.",
+        {
+          selector: z.string().describe("CSS selector of the input element"),
+          text: z.string().describe("Text to type")
+        },
+        async (args) => callTool("browser_type", args)
+      ),
+      tool(
+        "browser_press_key",
+        "Press a keyboard key in the browser. Supports: Enter, Tab, Escape, Backspace, ArrowDown, ArrowUp.",
+        { key: z.string().describe("Key to press") },
+        async (args) => callTool("browser_press_key", args)
+      ),
+      tool(
+        "browser_scroll",
+        "Scroll the page up or down.",
+        { direction: z.string().describe("'down' or 'up'") },
+        async (args) => callTool("browser_scroll", args)
+      ),
+      tool(
+        "browser_select",
+        "Select an option from a dropdown menu. Handles both native <select> elements and custom dropdowns (Material Design, React, Angular). Use this instead of manually clicking dropdown items.",
+        {
+          selector: z.string().describe(
+            "CSS selector of the dropdown, or its label/placeholder text (e.g. 'Month', 'Gender', '#country')"
+          ),
+          option: z.string().describe("Visible text of the option to select (e.g. 'March', 'Male')")
+        },
+        async (args) => callTool("browser_select", args)
+      ),
+      tool(
+        "browser_snapshot",
+        "Take a screenshot and discover all interactive elements with numbered refs. Returns a screenshot + a compact ref table. PREFERRED way to understand a page. Set annotate=true to overlay red ref badges (useful for simple pages). Use the ref numbers with browser_act to interact with elements.",
+        {
+          annotate: z.boolean().optional().describe(
+            "Overlay ref badges on the screenshot. Default false. Use true for simple pages where visual context helps."
+          )
+        },
+        async (args) => {
+          const limiter = getLimiterForTool("browser_snapshot");
+          if (limiter) await limiter.acquire();
+          const result = await executeTool("browser_snapshot", args);
+          const parts = result.split("\n__SNAPSHOT_IMAGE__:");
+          const refTable = parts[0];
+          const imageData = parts[1] || "";
+          const content = [];
+          if (imageData.length > 100) {
+            content.push({ type: "image", data: imageData, mimeType: "image/png" });
+          }
+          content.push({ type: "text", text: refTable });
+          return { content };
+        }
+      ),
+      tool(
+        "browser_act",
+        "Execute actions using ref numbers from browser_snapshot. Supports: click, type, select, press, scroll, wait. Batch multiple actions in one call to reduce round-trips. Set screenshot=true to see the result.",
+        {
+          actions: z.array(
+            z.object({
+              action: z.enum(["click", "type", "select", "press", "scroll", "wait"]).describe("Action type"),
+              ref: z.number().optional().describe("Ref number from browser_snapshot"),
+              text: z.string().optional().describe("Text to type (for 'type' action)"),
+              option: z.string().optional().describe("Option to select (for 'select' action)"),
+              key: z.string().optional().describe("Key to press (for 'press' action)"),
+              direction: z.string().optional().describe("'up' or 'down' (for 'scroll')"),
+              ms: z.number().optional().describe("Wait duration in ms (for 'wait', max 5000)")
+            })
+          ).describe("Actions to execute sequentially"),
+          screenshot: z.boolean().optional().describe("Take screenshot after actions (default: false)")
+        },
+        async (args) => {
+          const limiter = getLimiterForTool("browser_act");
+          if (limiter) await limiter.acquire();
+          const result = await executeTool("browser_act", {
+            actions: args.actions,
+            screenshot: args.screenshot
+          });
+          const parts = result.split("\n__ACT_SCREENSHOT__:");
+          const actionText = parts[0];
+          const screenshotData = parts[1] || "";
+          const content = [];
+          content.push({ type: "text", text: actionText });
+          if (screenshotData.length > 100) {
+            content.push({ type: "image", data: screenshotData, mimeType: "image/png" });
+          }
+          return { content };
+        }
+      ),
+      tool(
+        "browser_evaluate",
+        "Execute JavaScript in the browser page context. Use as a last resort when browser_snapshot + browser_act cannot handle the interaction.",
+        { expression: z.string().describe("JavaScript expression to evaluate") },
+        async (args) => callTool("browser_evaluate", args)
+      ),
+      tool(
+        "browser_list_tabs",
+        "List all open tabs in the user's browser.",
+        {},
+        async () => callTool("browser_list_tabs", {})
+      ),
+      tool(
+        "browser_switch_tab",
+        "Switch to a different browser tab by index.",
+        { index: z.number().describe("Tab index") },
+        async (args) => callTool("browser_switch_tab", args)
+      ),
+      tool(
+        "browser_new_tab",
+        "Open a new tab in the user's browser, optionally navigating to a URL.",
+        { url: z.string().optional().describe("URL to open (default: blank)") },
+        async (args) => callTool("browser_new_tab", args)
+      ),
+      tool(
+        "browser_request_user_action",
+        "Request the user to perform an action in their browser (login, CAPTCHA, 2FA, etc.).",
+        {
+          message: z.string().describe("Clear description of what the user needs to do"),
+          wait_seconds: z.number().optional().describe("How long to wait (default: 60)")
+        },
+        async (args) => callTool("browser_request_user_action", args)
+      )
+    ]
+  });
+}
+
+// src/mcp/agent-tools-server.ts
+import {
+  createSdkMcpServer as createSdkMcpServer2,
+  tool as tool2
+} from "@anthropic-ai/claude-agent-sdk";
+import { z as z2 } from "zod/v4";
+
+// src/credentials/program-store.ts
+import { randomUUID } from "crypto";
+function rowToMeta(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    language: row.language,
+    directory: row.directory,
+    skillName: row.skill_name,
+    tags: JSON.parse(row.tags),
+    status: row.status,
+    metadata: JSON.parse(row.metadata),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var ProgramStore = class {
+  get db() {
+    return getLocalStore().getDb();
+  }
+  save(name, description, directory, opts) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = this.getByName(name);
+    if (existing) {
+      this.db.prepare(
+        `UPDATE programs
+           SET description = ?, directory = ?, language = ?, skill_name = ?, tags = ?, metadata = ?, updated_at = ?
+           WHERE name = ?`
+      ).run(
+        description,
+        directory,
+        opts?.language ?? existing.language,
+        opts?.skillName ?? existing.skillName,
+        JSON.stringify(opts?.tags ?? existing.tags),
+        JSON.stringify(opts?.metadata ?? existing.metadata),
+        now,
+        name
+      );
+      return this.getByName(name);
+    }
+    const id = randomUUID();
+    this.db.prepare(
+      `INSERT INTO programs (id, name, description, language, directory, skill_name, tags, status, metadata, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?)`
+    ).run(
+      id,
+      name,
+      description,
+      opts?.language ?? "unknown",
+      directory,
+      opts?.skillName ?? null,
+      JSON.stringify(opts?.tags ?? []),
+      JSON.stringify(opts?.metadata ?? {}),
+      now,
+      now
+    );
+    return {
+      id,
+      name,
+      description,
+      language: opts?.language ?? "unknown",
+      directory,
+      skillName: opts?.skillName ?? null,
+      tags: opts?.tags ?? [],
+      status: "active",
+      metadata: opts?.metadata ?? {},
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  getByName(name) {
+    const row = this.db.prepare("SELECT * FROM programs WHERE name = ?").get(name);
+    return row ? rowToMeta(row) : null;
+  }
+  getById(id) {
+    const row = this.db.prepare("SELECT * FROM programs WHERE id = ?").get(id);
+    return row ? rowToMeta(row) : null;
+  }
+  list(opts) {
+    let query4 = "SELECT * FROM programs WHERE 1=1";
+    const params = [];
+    if (opts?.skillName) {
+      query4 += " AND skill_name = ?";
+      params.push(opts.skillName);
+    }
+    if (opts?.status) {
+      query4 += " AND status = ?";
+      params.push(opts.status);
+    }
+    query4 += " ORDER BY updated_at DESC";
+    const rows = this.db.prepare(query4).all(...params);
+    return rows.map(rowToMeta);
+  }
+  removeByName(name) {
+    const result = this.db.prepare("DELETE FROM programs WHERE name = ?").run(name);
+    return result.changes > 0;
+  }
+  archive(name) {
+    const result = this.db.prepare("UPDATE programs SET status = 'archived', updated_at = ? WHERE name = ?").run((/* @__PURE__ */ new Date()).toISOString(), name);
+    return result.changes > 0;
+  }
+};
+var _instance = null;
+function getProgramStore() {
+  if (!_instance) {
+    _instance = new ProgramStore();
+  }
+  return _instance;
+}
+
+// src/mcp/agent-tools-server.ts
+function createAgentToolsServer(deps) {
+  const { memoryManager, skillManager, taskId, sessionId, heartbeatEngine, onUserWaitStart, onUserWaitEnd } = deps;
+  return createSdkMcpServer2({
+    name: "assistme-agent",
+    version: "1.0.0",
+    tools: [
+      tool2(
+        "memory_store",
+        "Store a memory about the user that persists across conversations. Use when you learn preferences, habits, or standing instructions.",
+        {
+          content: z2.string().describe("What to remember (concise, factual statement)"),
+          category: z2.string().optional().describe("Category: general, preference, instruction, context, skill_learned, fact"),
+          importance: z2.number().optional().describe("Importance 1-10 (default: 5). Use 8+ for instructions"),
+          tags: z2.array(z2.string()).optional().describe("Optional tags for searchability")
+        },
+        async (args) => {
+          if (!memoryManager) {
+            return {
+              content: [{ type: "text", text: "Memory manager not available." }]
+            };
+          }
+          const mem = await memoryManager.remember(
+            args.content,
+            args.category || "general",
+            {
+              importance: args.importance || 5,
+              tags: args.tags || [],
+              sourceMessageId: taskId
+            }
+          );
+          const result = `Memory stored: "${mem.content}" [${mem.category}, importance: ${mem.importance}]`;
+          return { content: [{ type: "text", text: result }] };
+        }
+      ),
+      tool2(
+        "skill_create",
+        "Create a new skill and add it to the user's collection. Returns the skill ID on success.",
+        {
+          name: z2.string().describe("Skill name in kebab-case, e.g. 'flight-booking'"),
+          description: z2.string().describe("One-line description of what this skill does"),
+          instructions: z2.string().describe("Markdown step-by-step instructions"),
+          emoji: z2.string().optional().describe("Single emoji representing this skill")
+        },
+        async (args) => {
+          const nameError = validateSkillName(args.name);
+          if (nameError) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Invalid skill name: ${nameError}. Use lowercase kebab-case like "flight-booking".`
+                }
+              ]
+            };
+          }
+          const existing = skillManager.findSimilar(args.name);
+          if (existing) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `A similar skill "${existing.name}" already exists in your collection. Use skill_improve to update it instead.`
+                }
+              ]
+            };
+          }
+          const result = await skillManager.create(args.name, args.description, args.instructions, {
+            source: "manual",
+            emoji: args.emoji
+          });
+          if (!result) {
+            return {
+              content: [{ type: "text", text: `Failed to create skill "${args.name}".` }]
+            };
+          }
+          await skillManager.syncToAgentSkills(
+            args.name,
+            args.description,
+            args.instructions,
+            "1.0.0",
+            {
+              source: "manual",
+              emoji: args.emoji,
+              sourceSkillId: result.id
+            }
+          );
+          log.success(`Skill "${args.name}" created and added to collection`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Skill "${args.name}" created and added to your collection (ID: ${result.id}).`
+              }
+            ]
+          };
+        }
+      ),
+      tool2(
+        "skill_improve",
+        "Improve an existing skill with better instructions based on what you just learned. Version auto-bumped.",
+        {
+          name: z2.string().describe("Name of the existing skill to improve"),
+          improved_instructions: z2.string().describe("Full updated markdown instructions (not a diff)"),
+          description: z2.string().optional().describe("Updated description (optional)")
+        },
+        async (args) => {
+          const existing = skillManager.get(args.name);
+          if (!existing) {
+            const available = skillManager.getAll().map((s) => s.name).join(", ");
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Skill "${args.name}" not found. Available skills: ${available}`
+                }
+              ]
+            };
+          }
+          const updated = skillManager.update(
+            args.name,
+            args.improved_instructions,
+            args.description
+          );
+          if (updated) {
+            log.success(`Self-improvement: improved skill "${args.name}"`);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Skill "${args.name}" improved and version bumped.`
+                }
+              ]
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Failed to update skill "${args.name}".`
+              }
+            ]
+          };
+        }
+      ),
+      tool2(
+        "skill_invoke",
+        "Load a skill's full instructions when relevant to the current task. Call this when you determine a skill from the Available Skills list matches the user's request.",
+        {
+          name: z2.string().describe("Skill name from the Available Skills list"),
+          arguments: z2.string().optional().describe("Arguments to pass to the skill (replaces $ARGUMENTS placeholders)")
+        },
+        async (args) => {
+          const skill = skillManager.get(args.name);
+          if (!skill) {
+            const available = skillManager.getAll().map((s) => s.name).join(", ");
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Skill "${args.name}" not found. Available skills: ${available}`
+                }
+              ]
+            };
+          }
+          let content = skill.content;
+          if (args.arguments) {
+            content = substituteArguments(content, args.arguments);
+          }
+          content = preprocessDynamicContext(content);
+          let response = `## Skill: ${skill.name}
+`;
+          if (skill.description) {
+            response += `*${skill.description}*
+`;
+          }
+          response += `
+${content}`;
+          if (skill.allowedTools.length > 0) {
+            response += `
+
+**Allowed tools for this skill:** ${skill.allowedTools.join(", ")}
+`;
+          }
+          const credReqs = skill.metadata.credentials;
+          if (credReqs && credReqs.length > 0) {
+            const store = getCredentialStore();
+            const missing = [];
+            for (const req of credReqs) {
+              const cred = store.getByName(req.name);
+              if (cred) {
+                response += `
+
+**Credential: ${req.name}** (${req.type})
+`;
+                response += `\`\`\`json
+${JSON.stringify(cred.data, null, 2)}
+\`\`\`
+`;
+              } else if (req.required) {
+                missing.push(`${req.name} (${req.description})`);
+              }
+            }
+            if (missing.length > 0) {
+              response += `
+
+**Missing required credentials:**
+`;
+              for (const m of missing) {
+                response += `- ${m}
+`;
+              }
+              response += `
+Use \`ask_user\` to request these from the user, or create them yourself (e.g. register an account), then store with \`credential_set\`.
+`;
+            }
+          }
+          log.info(`Skill invoked: "${args.name}"`);
+          skillManager.logInvocation(args.name, {
+            messageId: taskId,
+            sessionId,
+            arguments: args.arguments
+          }).catch(() => {
+          });
+          return {
+            content: [{ type: "text", text: response }]
+          };
+        }
+      ),
+      tool2(
+        "skill_search",
+        "Search for skills by keyword. Uses full-text search across skill names, descriptions, and content. Use this to discover relevant skills when the Available Skills list doesn't have an obvious match.",
+        {
+          query: z2.string().describe("Search query (keywords, topic, or task description)"),
+          limit: z2.number().optional().describe("Max results (default: 5)")
+        },
+        async (args) => {
+          const results = await skillManager.searchDb(args.query, args.limit || 5);
+          if (results.length === 0) {
+            return {
+              content: [{ type: "text", text: `No skills found for "${args.query}".` }]
+            };
+          }
+          let response = `## Skills matching "${args.query}"
+
+`;
+          for (const r of results) {
+            const emoji = r.emoji ? `${r.emoji} ` : "";
+            const usage = r.invocationCount > 0 ? ` (used ${r.invocationCount}x)` : "";
+            response += `- **${emoji}${r.name}**${usage}: ${r.description}
+`;
+          }
+          response += "\nUse skill_invoke to load any of these skills.";
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+      tool2(
+        "skill_generate",
+        "Prepare context for generating skills from a job description. Returns existing skills and job info so you can analyze the job and create skills using skill_create (which auto-adds to user's collection). After creating all skills, call skill_link_job to link them to the job and mark it as analyzed.",
+        {
+          job_name: z2.string().describe(
+            "Short name for this job/role. Example: '\u7535\u5546\u8FD0\u8425', 'Frontend Dev', 'Data Analyst'"
+          ),
+          job_description: z2.string().describe(
+            "Description of the user's job, role, and daily tasks. Can be in any language. Example: '\u6211\u662F\u7535\u5546\u8FD0\u8425\uFF0C\u6BCF\u5929\u8981\u770B\u7ADE\u54C1\u4EF7\u683C\u3001\u5199\u5546\u54C1\u6587\u6848\u3001\u56DE\u590D\u5BA2\u6237\u8BC4\u8BBA'"
+          )
+        },
+        async (args) => {
+          const existingNames = skillManager.getAll().map((s) => s.name);
+          let response = `## Job: ${args.job_name}
+`;
+          response += `**Description:** ${args.job_description}
+
+`;
+          if (existingNames.length > 0) {
+            response += `**Existing skills (do NOT duplicate):** ${existingNames.join(", ")}
+
+`;
+          }
+          response += `**Your task:** Analyze this job description and decompose it into 4-10 automatable skills.
+
+`;
+          response += `**IMPORTANT \u2014 You MUST use ask_user before creating skills:**
+`;
+          response += `1. Analyze the job and draft a list of proposed skills (name, emoji, one-line description for each).
+`;
+          response += `2. Call \`ask_user\` with the formatted skill list as "question" and these options:
+`;
+          response += `   - options: [{label: "Approve All", action_key: "approve_all", description: "Create all proposed skills"}, {label: "Cancel", action_key: "cancel", description: "Do not create any skills"}]
+`;
+          response += `3. WAIT for the response. If action_key is "approve_all", create all skills using \`skill_create\`. If "cancel", stop.
+`;
+          response += `4. Do NOT ask for confirmation in text. Do NOT create skills without calling ask_user first.
+
+`;
+          response += `For each skill, call \`skill_create\` with:
+`;
+          response += `- name: kebab-case name (e.g. "slack-message-check")
+`;
+          response += `- description: one-line description
+`;
+          response += `- instructions: detailed step-by-step markdown instructions the agent can follow
+`;
+          response += `- emoji: a single emoji representing the skill
+
+`;
+          response += `skill_create automatically adds the skill to the user's collection \u2014 no need to call skill_add.
+
+`;
+          response += `After ALL skills are created, call \`skill_link_job\` with job_name="${args.job_name}" and the list of created skill names to link them and mark the job as analyzed.
+
+`;
+          response += `**Guidelines for skill instructions:**
+`;
+          response += `- Write clear, actionable markdown steps
+`;
+          response += `- Reference browser tools (browser_navigate, browser_click, browser_read_page, etc.) for web tasks
+`;
+          response += `- Include error handling steps
+`;
+          response += `- Use placeholders like {query}, {date} for variable inputs
+`;
+          response += `- Each skill should be a single, well-defined workflow (10-25 steps)
+`;
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+      tool2(
+        "skill_link_job",
+        "Link created skills to a job and mark it as analyzed. Call this after creating all skills for a job via skill_create + skill_add.",
+        {
+          job_name: z2.string().describe("Name of the job to link skills to"),
+          job_description: z2.string().describe("Job description (used if job doesn't exist yet)"),
+          skill_names: z2.array(z2.string()).describe("Names of skills to link to this job")
+        },
+        async (args) => {
+          try {
+            await saveJobToDb(args.job_name, args.job_description, args.skill_names);
+            log.success(
+              `Job "${args.job_name}": linked ${args.skill_names.length} skills and marked as analyzed`
+            );
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Job "${args.job_name}" linked with ${args.skill_names.length} skills and marked as analyzed.`
+                }
+              ]
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to link job: ${err instanceof Error ? err.message : err}`
+                }
+              ]
+            };
+          }
+        }
+      ),
+      tool2(
+        "skill_browse",
+        "Browse the skill marketplace to discover skills published by the community. Search by keyword, filter by category, and sort by popularity or rating.",
+        {
+          query: z2.string().optional().describe("Search keywords"),
+          category: z2.string().optional().describe("Filter by category (e.g. 'productivity', 'ecommerce', 'dev-tools')"),
+          sort: z2.enum(["popular", "recent", "rating"]).optional().describe("Sort order (default: popular)"),
+          limit: z2.number().optional().describe("Max results (default: 10)")
+        },
+        async (args) => {
+          const results = await skillManager.browse({
+            query: args.query,
+            category: args.category,
+            sort: args.sort,
+            limit: args.limit || 10
+          });
+          if (results.length === 0) {
+            const hint = args.query ? ` for "${args.query}"` : "";
+            return {
+              content: [{ type: "text", text: `No skills found in marketplace${hint}.` }]
+            };
+          }
+          let response = "## Skill Marketplace\n\n";
+          for (const s of results) {
+            const emoji = s.emoji ? `${s.emoji} ` : "";
+            const rating = s.avgRating ? ` \u2605${s.avgRating}` : "";
+            const installs = s.installCount > 0 ? ` (${s.installCount} installs)` : "";
+            const author = s.authorName ? ` by ${s.authorName}` : "";
+            response += `- **${emoji}${s.name}** v${s.version}${author}${installs}${rating}
+`;
+            response += `  ${s.description}
+`;
+            response += `  ID: \`${s.id}\`
+
+`;
+          }
+          response += "Use `skill_add` with the skill ID to add any of these to your collection.";
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+      tool2(
+        "skill_add",
+        "Add a skill to your personal collection. Works for both marketplace skills and newly created drafts. This is the approval step \u2014 after adding, the skill becomes available for use via skill_invoke.",
+        {
+          skill_id: z2.string().describe("The skill UUID (from skill_browse or skill_create results)")
+        },
+        async (args) => {
+          const added = await skillManager.addSkill(args.skill_id);
+          if (!added) {
+            return {
+              content: [
+                { type: "text", text: `Failed to add skill. Check that the ID is correct.` }
+              ]
+            };
+          }
+          const emoji = added.metadata.emoji ? `${added.metadata.emoji} ` : "";
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Added **${emoji}${added.name}** v${added.version} to your collection. It's now available for use via skill_invoke.`
+              }
+            ]
+          };
+        }
+      ),
+      tool2(
+        "skill_publish",
+        "Publish one of your skills to the marketplace so others can discover and install it.",
+        {
+          name: z2.string().describe("Name of your skill to publish"),
+          category: z2.string().optional().describe("Category (e.g. 'productivity', 'ecommerce', 'dev-tools')"),
+          author_name: z2.string().optional().describe("Your display name as the author")
+        },
+        async (args) => {
+          const skill = skillManager.get(args.name);
+          if (!skill) {
+            return {
+              content: [
+                { type: "text", text: `Skill "${args.name}" not found in your collection.` }
+              ]
+            };
+          }
+          if (skill.source === "external") {
+            return {
+              content: [{ type: "text", text: `Cannot publish external skills.` }]
+            };
+          }
+          const result = await skillManager.publish(args.name, {
+            category: args.category,
+            authorName: args.author_name
+          });
+          if (!result) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to publish "${args.name}". The name may already be taken by another author.`
+                }
+              ]
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Skill "${args.name}" published to the marketplace! Others can now find and install it.`
+              }
+            ]
+          };
+        }
+      ),
+      // ── User Interaction Tool ───────────────────────────────────
+      tool2(
+        "ask_user",
+        "Ask the user a question via the web UI and wait for their response. Shows a message with optional predefined option buttons PLUS a free-text input field \u2014 the user can either click a suggested option or type a custom answer. ALWAYS provide options when you can suggest likely answers. Do NOT use this for information you can discover yourself (git remote, file contents, etc.).",
+        {
+          question: z2.string().describe(
+            "The question to ask (supports markdown). Be specific about what you need and why."
+          ),
+          options: z2.array(
+            z2.object({
+              label: z2.string().describe("Button label shown to user"),
+              action_key: z2.string().describe("Machine-readable key returned when selected"),
+              description: z2.string().optional().describe("Tooltip/description for this option")
+            })
+          ).optional().describe(
+            "Suggested options shown as buttons. The user can always type a custom answer instead."
+          ),
+          placeholder: z2.string().optional().describe("Placeholder text for the free-text input field"),
+          timeout_seconds: z2.number().optional().describe("How long to wait for response (default: 300)")
+        },
+        async (args) => {
+          const actionId = `ask_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          const timeout = (args.timeout_seconds || 300) * 1e3;
+          const actionData = {
+            id: actionId,
+            type: "ask_user",
+            message: args.question,
+            options: args.options || [],
+            placeholder: args.placeholder || "",
+            created_at: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          try {
+            await setActionRequest(taskId, actionData);
+            log.info(`Ask user ${actionId}: "${args.question.slice(0, 80)}..."`);
+            await emitEvent(taskId, "user_action_request", actionData);
+            await emitEvent(taskId, "status_change", {
+              status: "waiting_for_user",
+              message: args.question
+            });
+            onUserWaitStart?.();
+            const startTime = Date.now();
+            const pollInterval = 2e3;
+            try {
+              while (Date.now() - startTime < timeout) {
+                const response = await pollActionResponse(taskId);
+                if (response && (!response.action_id || response.action_id === actionId)) {
+                  const actionKey = response.action_key || "";
+                  const text = response.text || "";
+                  const label = response.label || actionKey || text;
+                  log.info(`User responded: "${label}"`);
+                  return {
+                    content: [
+                      {
+                        type: "text",
+                        text: JSON.stringify({
+                          status: "responded",
+                          action_key: actionKey || "custom_input",
+                          label,
+                          text: text || label
+                        })
+                      }
+                    ]
+                  };
+                }
+                await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+              }
+              log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify({
+                      status: "timeout",
+                      message: "User did not respond within the timeout period. Continue the task with a reasonable default or skip the step that required user input."
+                    })
+                  }
+                ]
+              };
+            } finally {
+              onUserWaitEnd?.();
+            }
+          } catch (err) {
+            log.error(`ask_user failed: ${err}`);
+            onUserWaitEnd?.();
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to ask user: ${err instanceof Error ? err.message : err}`
+                }
+              ]
+            };
+          }
+        }
+      ),
+      // ── Job Automation Tools ──────────────────────────────────────
+      tool2(
+        "job_run",
+        "Run a job by loading its goal and available skills as capabilities. You then decide dynamically which skills to use, in what order, and how to chain them based on what you discover. Use this when the user asks to run their job, or when a scheduled job fires.",
+        {
+          job_name: z2.string().describe("Name of the job to run (e.g. 'software-engineer', 'Frontend Dev')")
+        },
+        async (args) => {
+          const runner = new JobRunner();
+          const job = await runner.loadJob(args.job_name);
+          if (!job) {
+            const jobs = await runner.listJobs();
+            const available = jobs.length > 0 ? `Available jobs: ${jobs.map((j) => `"${j.name}" (${j.skillCount} skills)`).join(", ")}` : "No jobs defined yet. Use skill_generate to create a job from a job description.";
+            return {
+              content: [{ type: "text", text: `Job "${args.job_name}" not found. ${available}` }]
+            };
+          }
+          if (job.skills.length === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Job "${args.job_name}" has no linked skills. Use skill_generate to add skills to this job.`
+                }
+              ]
+            };
+          }
+          const runId = await runner.createRun(job.jobId, {
+            sessionId,
+            messageId: taskId,
+            triggerType: "manual"
+          });
+          if (!runId) {
+            log.debug("Failed to create job run record, proceeding without tracking");
+          }
+          const prompt = runner.buildJobPrompt(job, runId || "untracked");
+          log.info(
+            `Job "${args.job_name}" started with ${job.skills.length} skills (run: ${runId?.slice(0, 8) || "untracked"})`
+          );
+          return {
+            content: [{ type: "text", text: prompt }]
+          };
+        }
+      ),
+      tool2(
+        "job_schedule",
+        "Schedule a job to run automatically on a recurring basis using a cron expression. For example, schedule your 'software-engineer' job to run every morning at 9am.",
+        {
+          job_name: z2.string().describe("Name of the job to schedule"),
+          cron: z2.string().describe(
+            "Cron expression: 'minute hour day-of-month month day-of-week'. Examples: '0 9 * * *' (daily 9am), '0 9 * * 1-5' (weekdays 9am), '0 */2 * * *' (every 2 hours)"
+          ),
+          timezone: z2.string().optional().describe("Timezone (default: UTC). Examples: 'UTC', 'America/New_York'"),
+          schedule_name: z2.string().optional().describe("Custom name for this schedule (default: 'Job: <job_name>')")
+        },
+        async (args) => {
+          const runner = new JobRunner();
+          const job = await runner.loadJob(args.job_name);
+          if (!job) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Job "${args.job_name}" not found. Create it first with skill_generate.`
+                }
+              ]
+            };
+          }
+          try {
+            getNextRunTime(args.cron, args.timezone || "UTC");
+          } catch {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Invalid cron expression: "${args.cron}". Use format: "minute hour day-of-month month day-of-week"`
+                }
+              ]
+            };
+          }
+          const name = args.schedule_name || `Job: ${args.job_name}`;
+          const prompt = `[JobRun: ${args.job_name}] Run the "${args.job_name}" job. Use job_run to execute it.`;
+          const tz = args.timezone || "UTC";
+          try {
+            const task = await createScheduledTask(name, prompt, args.cron, tz);
+            await callMcpHandler("schedule.link_job", {
+              task_id: task.id,
+              job_id: job.jobId
+            });
+            const nextRun = task.next_run_at ? new Date(task.next_run_at).toLocaleString() : "calculating...";
+            let response = `## Job Scheduled: ${args.job_name}
+
+`;
+            response += `- **Schedule:** ${args.cron} (${tz})
+`;
+            response += `- **Next run:** ${nextRun}
+`;
+            response += `- **Skills:** ${job.skills.length}
+
+`;
+            response += `The job "${args.job_name}" will automatically run on this schedule. `;
+            response += `Each run will execute ${job.skills.length} skills in sequence:
+`;
+            for (const skill of job.skills) {
+              const emoji = skill.skillEmoji ? `${skill.skillEmoji} ` : "";
+              response += `  - ${emoji}${skill.skillName}
+`;
+            }
+            log.success(`Job "${args.job_name}" scheduled: ${args.cron}`);
+            return { content: [{ type: "text", text: response }] };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to schedule job: ${err instanceof Error ? err.message : err}`
+                }
+              ]
+            };
+          }
+        }
+      ),
+      tool2(
+        "job_status",
+        "Check the status and run history of a job. Shows recent executions, success rates, and details.",
+        {
+          job_name: z2.string().optional().describe("Job name to check (omit for all jobs)"),
+          limit: z2.number().optional().describe("Max number of runs to show (default: 5)")
+        },
+        async (args) => {
+          const runner = new JobRunner();
+          if (!args.job_name) {
+            const jobs = await runner.listJobs();
+            if (jobs.length === 0) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: "No jobs defined. Use skill_generate to create a job from your job description."
+                  }
+                ]
+              };
+            }
+            let response2 = "## Your Jobs\n\n";
+            for (const job of jobs) {
+              response2 += `- **${job.name}** (${job.skillCount} skills): ${job.description.slice(0, 100)}
+`;
+            }
+            response2 += "\nUse `job_run` to execute a job, or `job_schedule` to automate it.";
+            return { content: [{ type: "text", text: response2 }] };
+          }
+          const runs = await runner.getRunHistory(args.job_name, args.limit || 5);
+          if (runs.length === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `No runs found for job "${args.job_name}". Use job_run to execute it.`
+                }
+              ]
+            };
+          }
+          let response = `## Job Status: ${args.job_name}
+
+`;
+          response += `### Recent Runs
+
+`;
+          for (const run of runs) {
+            const statusIcon = run.status === "completed" ? "+" : run.status === "failed" ? "x" : run.status === "running" ? "~" : "-";
+            const date = new Date(run.startedAt).toLocaleString();
+            const duration = run.completedAt ? `${Math.round((new Date(run.completedAt).getTime() - new Date(run.startedAt).getTime()) / 1e3)}s` : "in progress";
+            response += `[${statusIcon}] ${date} | ${run.triggerType} | ${duration}
+`;
+            if (run.summary) {
+              response += `    ${run.summary.slice(0, 100)}
+`;
+            }
+          }
+          const total = runs.length;
+          const completed = runs.filter((r) => r.status === "completed").length;
+          const failed = runs.filter((r) => r.status === "failed").length;
+          response += `
+**Stats:** ${completed}/${total} successful`;
+          if (failed > 0) response += `, ${failed} failed`;
+          response += "\n";
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+      // ── Credential Tools ──────────────────────────────────────────
+      tool2(
+        "credential_get",
+        "Retrieve a locally stored credential by name. Returns the secret data (API keys, tokens, etc.) stored on the user's machine. Use this when a skill needs authentication or API access.",
+        {
+          name: z2.string().describe("Credential name (e.g. 'amazon-login', 'openai-api-key')")
+        },
+        async (args) => {
+          const store = getCredentialStore();
+          const credential = store.getByName(args.name);
+          if (!credential) {
+            const all = store.list();
+            const available = all.length > 0 ? `Available credentials: ${all.map((m) => m.name).join(", ")}` : "No credentials stored yet.";
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Credential "${args.name}" not found. ${available}
+Use ask_user to request it from the user, or create it yourself (e.g. register an account), then store with credential_set.`
+                }
+              ]
+            };
+          }
+          log.info(`Credential accessed: "${args.name}" (${credential.meta.type})`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  name: credential.meta.name,
+                  type: credential.meta.type,
+                  data: credential.data,
+                  skill: credential.meta.skillName || null
+                })
+              }
+            ]
+          };
+        }
+      ),
+      tool2(
+        "credential_set",
+        "Store a credential locally on the user's machine. The credential is encrypted at rest and never sent to any remote server. IMPORTANT: Always use this to persist credentials \u2014 both when receiving them from the user via ask_user AND when you generate new credentials yourself (e.g. registering an account, creating an API key, generating a token). This ensures credentials survive across sessions and don't need to be recreated.",
+        {
+          name: z2.string().describe("Credential name (lowercase kebab-case, e.g. 'amazon-login')"),
+          type: z2.enum(["api_key", "oauth_token", "login", "secret", "custom"]).describe("Credential type"),
+          data: z2.record(z2.string(), z2.string()).describe(
+            'Key-value pairs (e.g. { "username": "...", "password": "..." } or { "api_key": "..." })'
+          ),
+          skill_name: z2.string().optional().describe("Associate with a specific skill"),
+          tags: z2.array(z2.string()).optional().describe("Tags for searchability")
+        },
+        async (args) => {
+          const store = getCredentialStore();
+          const meta = store.save(args.name, args.type, args.data, {
+            skillName: args.skill_name,
+            tags: args.tags
+          });
+          log.info(`Credential stored: "${args.name}" (${args.type})`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Credential "${meta.name}" stored locally (type: ${meta.type}, id: ${meta.id}). It is encrypted and will persist across app restarts.`
+              }
+            ]
+          };
+        }
+      ),
+      tool2(
+        "credential_list",
+        "List all locally stored credentials (metadata only, no secrets). Use this to check what credentials are available before executing a skill.",
+        {
+          skill_name: z2.string().optional().describe("Filter by skill name"),
+          type: z2.string().optional().describe("Filter by credential type")
+        },
+        async (args) => {
+          const store = getCredentialStore();
+          let results = store.list();
+          if (args.skill_name) {
+            results = results.filter((m) => m.skillName === args.skill_name);
+          }
+          if (args.type) {
+            results = results.filter((m) => m.type === args.type);
+          }
+          if (results.length === 0) {
+            const filter = args.skill_name ? ` for skill "${args.skill_name}"` : "";
+            return {
+              content: [{ type: "text", text: `No credentials found${filter}.` }]
+            };
+          }
+          let response = "## Stored Credentials\n\n";
+          for (const m of results) {
+            const skill = m.skillName ? ` [${m.skillName}]` : "";
+            const tags = m.tags.length > 0 ? ` (${m.tags.join(", ")})` : "";
+            response += `- **${m.name}** (${m.type})${skill}${tags}
+`;
+          }
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+      tool2(
+        "credential_remove",
+        "Remove a locally stored credential by name.",
+        {
+          name: z2.string().describe("Credential name to remove")
+        },
+        async (args) => {
+          const store = getCredentialStore();
+          const removed = store.removeByName(args.name);
+          if (!removed) {
+            return {
+              content: [{ type: "text", text: `Credential "${args.name}" not found.` }]
+            };
+          }
+          log.info(`Credential removed: "${args.name}"`);
+          return {
+            content: [
+              { type: "text", text: `Credential "${args.name}" removed from local storage.` }
+            ]
+          };
+        }
+      ),
+      // ── Program Tools ─────────────────────────────────────────────
+      tool2(
+        "program_register",
+        "Register a program (script, CLI tool, local program) that was created to solve a task. This stores metadata about the program so it appears in the desktop app's Programs list and can be reused in future tasks. Call this after you've written the code and verified it works.",
+        {
+          name: z2.string().describe("Program name in kebab-case (e.g. 'github-issues-viewer')"),
+          description: z2.string().describe("What this program does \u2014 one sentence"),
+          directory: z2.string().describe("Absolute path to the program directory"),
+          language: z2.string().optional().describe("Primary language (e.g. 'typescript', 'python', 'shell')"),
+          skill_name: z2.string().optional().describe("Associated skill name if applicable"),
+          tags: z2.array(z2.string()).optional().describe("Tags for discoverability"),
+          metadata: z2.record(z2.string(), z2.string()).optional().describe("Extra metadata (e.g. { entry_point: 'index.ts', run_command: 'npm start' })")
+        },
+        async (args) => {
+          const store = getProgramStore();
+          const meta = store.save(args.name, args.description, args.directory, {
+            language: args.language,
+            skillName: args.skill_name,
+            tags: args.tags,
+            metadata: args.metadata
+          });
+          try {
+            await callMcpHandler("program.register", {
+              id: meta.id,
+              name: meta.name,
+              description: meta.description,
+              language: meta.language,
+              directory: meta.directory,
+              skill_name: meta.skillName,
+              tags: meta.tags,
+              metadata: meta.metadata
+            });
+          } catch {
+            log.debug("Program Supabase sync skipped (edge function may not exist yet)");
+          }
+          log.info(`Program registered: "${args.name}" at ${args.directory}`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Program "${meta.name}" registered (id: ${meta.id}, language: ${meta.language}, dir: ${meta.directory}). It will appear in the desktop app's Programs list.`
+              }
+            ]
+          };
+        }
+      ),
+      tool2(
+        "program_list",
+        "List all registered programs. Use this to check if a reusable program already exists before creating a new one for a task.",
+        {
+          skill_name: z2.string().optional().describe("Filter by associated skill"),
+          status: z2.string().optional().describe("Filter by status: 'active' or 'archived'")
+        },
+        async (args) => {
+          const store = getProgramStore();
+          const results = store.list({
+            skillName: args.skill_name,
+            status: args.status
+          });
+          if (results.length === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "No programs registered yet. Create a program and use program_register to register it."
+                }
+              ]
+            };
+          }
+          let response = "## Registered Programs\n\n";
+          for (const p of results) {
+            const skill = p.skillName ? ` [skill: ${p.skillName}]` : "";
+            const tags = p.tags.length > 0 ? ` (${p.tags.join(", ")})` : "";
+            const runCmd = p.metadata.run_command ? ` | Run: \`${p.metadata.run_command}\`` : "";
+            response += `- **${p.name}** (${p.language})${skill}${tags}
+`;
+            response += `  ${p.description}
+`;
+            response += `  Dir: \`${p.directory}\`${runCmd}
+
+`;
+          }
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+      tool2(
+        "program_run",
+        "Execute a registered program. Looks up the program's directory and run command, then executes it. The program must have a 'run_command' in its metadata (set during registration). Use program_list first to find available programs and their run commands.",
+        {
+          name: z2.string().describe("Program name to run"),
+          args: z2.string().optional().describe("Additional CLI arguments to append to the run command")
+        },
+        async (toolArgs) => {
+          const store = getProgramStore();
+          const program = store.getByName(toolArgs.name);
+          if (!program) {
+            const available = store.list({ status: "active" });
+            const names = available.length > 0 ? `Available programs: ${available.map((p) => p.name).join(", ")}` : "No programs registered yet.";
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Program "${toolArgs.name}" not found. ${names}`
+                }
+              ]
+            };
+          }
+          const runCommand = program.metadata.run_command || null;
+          if (!runCommand) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Program "${toolArgs.name}" has no run_command in its metadata. Re-register with metadata: { run_command: "npm start" } or similar. Alternatively, use execute_command directly with dir: "${program.directory}".`
+                }
+              ]
+            };
+          }
+          const fullCommand = toolArgs.args ? `${runCommand} ${toolArgs.args}` : runCommand;
+          log.info(`Running program "${toolArgs.name}": ${fullCommand} (in ${program.directory})`);
+          try {
+            const output = await executeShell(fullCommand, program.directory);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `## ${program.name} output
+
+\`\`\`
+${output}
+\`\`\``
+                }
+              ]
+            };
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Program "${toolArgs.name}" execution failed:
+${message}`
+                }
+              ]
+            };
+          }
+        }
+      ),
+      tool2(
+        "program_remove",
+        "Remove a registered program by name. This only removes the registration \u2014 the actual code files on disk are NOT deleted.",
+        {
+          name: z2.string().describe("Program name to remove")
+        },
+        async (args) => {
+          const store = getProgramStore();
+          const removed = store.removeByName(args.name);
+          if (!removed) {
+            return {
+              content: [{ type: "text", text: `Program "${args.name}" not found.` }]
+            };
+          }
+          log.info(`Program removed: "${args.name}"`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Program "${args.name}" removed from registry. Code files on disk were NOT deleted.`
+              }
+            ]
+          };
+        }
+      ),
+      // ── Heartbeat Tools ──────────────────────────────────────────
+      tool2(
+        "heartbeat_status",
+        "Get the current status of the heartbeat engine. Shows whether it's enabled, the interval, cycle count, and whether a HEARTBEAT.md checklist exists.",
+        {},
+        async () => {
+          if (!heartbeatEngine) {
+            return {
+              content: [{ type: "text", text: "HeartbeatEngine is not available in this session." }]
+            };
+          }
+          const status = heartbeatEngine.getStatus();
+          const lines = [
+            `Enabled: ${status.enabled ? "yes" : "no"}`,
+            `Interval: ${status.intervalMs / 1e3}s (${(status.intervalMs / 6e4).toFixed(1)} min)`,
+            `Cycles completed: ${status.cycleCount}`,
+            `HEARTBEAT.md: ${status.hasChecklist ? "found" : "not found"}`,
+            `Currently executing: ${status.executing ? "yes" : "no"}`
+          ];
+          return {
+            content: [{ type: "text", text: lines.join("\n") }]
+          };
+        }
+      ),
+      tool2(
+        "heartbeat_enable",
+        "Enable the heartbeat engine. When enabled, the agent periodically reads HEARTBEAT.md and uses LLM to check each item.",
+        {},
+        async () => {
+          if (!heartbeatEngine) {
+            return {
+              content: [{ type: "text", text: "HeartbeatEngine is not available in this session." }]
+            };
+          }
+          heartbeatEngine.setEnabled(true);
+          return {
+            content: [{ type: "text", text: "Heartbeat enabled." }]
+          };
+        }
+      ),
+      tool2(
+        "heartbeat_disable",
+        "Disable the heartbeat engine. Monitoring is paused but the engine keeps running (can be re-enabled).",
+        {},
+        async () => {
+          if (!heartbeatEngine) {
+            return {
+              content: [{ type: "text", text: "HeartbeatEngine is not available in this session." }]
+            };
+          }
+          heartbeatEngine.setEnabled(false);
+          return {
+            content: [{ type: "text", text: "Heartbeat disabled. Monitoring paused." }]
+          };
+        }
+      ),
+      tool2(
+        "heartbeat_interval",
+        "Set the heartbeat interval. Controls how often the agent wakes up to check the HEARTBEAT.md checklist.",
+        {
+          seconds: z2.number().min(30).describe("Interval in seconds (minimum 30)")
+        },
+        async (args) => {
+          if (!heartbeatEngine) {
+            return {
+              content: [{ type: "text", text: "HeartbeatEngine is not available in this session." }]
+            };
+          }
+          heartbeatEngine.setIntervalMs(args.seconds * 1e3);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Heartbeat interval set to ${args.seconds}s (${(args.seconds / 60).toFixed(1)} min).`
+              }
+            ]
+          };
+        }
+      ),
+      tool2(
+        "heartbeat_log",
+        "Read recent heartbeat log entries to see past cycle outcomes, timing, and costs.",
+        {
+          limit: z2.number().optional().describe("Number of entries to return (default: 20)")
+        },
+        async (args) => {
+          if (!heartbeatEngine) {
+            return {
+              content: [{ type: "text", text: "HeartbeatEngine is not available in this session." }]
+            };
+          }
+          const entries = await heartbeatEngine.readLog(args.limit ?? 20);
+          if (entries.length === 0) {
+            return {
+              content: [{ type: "text", text: "No heartbeat log entries yet." }]
+            };
+          }
+          const lines = entries.map((e) => {
+            const icon = e.outcome === "ok" ? "\u2713" : e.outcome === "action_taken" ? "!" : "\u2717";
+            const cost = e.costUsd ? ` $${e.costUsd.toFixed(4)}` : "";
+            return `${icon} #${e.cycle} ${e.timestamp} (${e.durationMs}ms${cost}) \u2014 ${e.summary.slice(0, 120)}`;
+          });
+          return {
+            content: [{ type: "text", text: lines.join("\n") }]
+          };
+        }
+      )
+    ]
+  });
+}
+async function saveJobToDb(jobName, jobDescription, createdSkillNames) {
+  try {
+    const data = await callMcpHandler("job.save_with_skills", {
+      job_name: jobName,
+      job_description: jobDescription,
+      skill_names: createdSkillNames
+    });
+    log.debug(
+      `Job "${jobName}" saved via edge function (id: ${data}), ${createdSkillNames.length} skill(s) linked`
+    );
+  } catch (err) {
+    log.debug(`saveJobToDb error: ${err}`);
+  }
+}
+
+// src/agent/event-hooks.ts
+function stripMcpPrefix(toolName) {
+  const match = toolName.match(/^mcp__[^_]+(?:__)?(.+)$/);
+  return match ? match[1] : toolName;
+}
+function createEventHooks(taskId, toolCallRecords, toolFailures = []) {
+  const preToolUseHook = async (input) => {
+    if (input.hook_event_name !== "PreToolUse") return { continue: true };
+    const preInput = input;
+    const rawName = preInput.tool_name;
+    const displayName = stripMcpPrefix(rawName);
+    const toolInput = preInput.tool_input;
+    log.tool(displayName, JSON.stringify(toolInput).slice(0, MAX_TOOL_INPUT_LOG_LENGTH));
+    await emitEvent(taskId, "tool_use_start", { name: displayName });
+    await emitEvent(taskId, "tool_use_input", { input: toolInput });
+    if (displayName === "browser_request_user_action") {
+      await emitEvent(taskId, "status_change", {
+        status: "waiting_for_user",
+        message: toolInput?.message
+      });
+    }
+    return { continue: true };
+  };
+  const postToolUseHook = async (input) => {
+    if (input.hook_event_name !== "PostToolUse") return {};
+    const postInput = input;
+    const rawName = postInput.tool_name;
+    const displayName = stripMcpPrefix(rawName);
+    const toolInput = postInput.tool_input;
+    const toolResponse = postInput.tool_response;
+    const resultStr = typeof toolResponse === "string" ? toolResponse : JSON.stringify(toolResponse);
+    log.result(resultStr.slice(0, MAX_TOOL_INPUT_LOG_LENGTH));
+    await emitEvent(taskId, "tool_result", {
+      name: displayName,
+      result: resultStr.slice(0, MAX_TOOL_RESULT_LENGTH)
+    });
+    toolCallRecords.push({
+      name: displayName,
+      input: toolInput || {},
+      result: resultStr.slice(0, MAX_SKILL_RECORD_RESULT_LENGTH)
+    });
+    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] }],
+    PostToolUseFailure: [{ hooks: [postToolUseFailureHook] }]
+  };
+}
+
+// src/agent/system-prompt.ts
+var BASE_SYSTEM_PROMPT = `You are AssistMe, an AI-powered agentic assistant that operates on the user's computer. You can complete tasks through multiple approaches: writing code and building local programs, using CLI tools, controlling the user's real Chrome browser, and working with files directly.
+
+KEY PRINCIPLE: You are an agentic agent \u2014 you choose the best approach for each task:
+- **Code & CLI approach**: Write scripts, install CLI tools (e.g. gh, aws, gcloud), call APIs programmatically. This is often more efficient, reusable, and saves tokens in future runs.
+- **Browser approach**: Control the user's real Chrome browser (with real cookies, logins, sessions) when a web UI is the only or simplest way.
+- **Hybrid approach**: Combine both \u2014 e.g., use an API for data retrieval but browser for UI-only operations.
+
+When a task can be done BOTH via code/API and via browser, PROACTIVELY suggest the code approach:
+- Use ask_user to present both options, explaining:
+  - Code/API: "Initial setup takes a bit longer (install CLI, configure API key), but subsequent runs are faster, reusable, and save tokens."
+  - Browser: "Quick to start, but slower for repeated tasks and uses more tokens each time."
+- Tell the user exactly what credentials/keys are needed and how to obtain them.
+- If the user chooses code, create a local project directory under the workspace, write the code, write a README with setup instructions (including how to get API keys), and register it as a program via program_register.
+- Store any required API keys/tokens using credential_set.
+
+Browser capabilities (user's real Chrome via CDP):
+- The browser has the user's real cookies, logins, and sessions
+- When you navigate to amazon.com, you see the user's logged-in Amazon
+- If a site needs login, the browser will auto-detect the login page and prompt the user
+- After the user logs in, their session is saved in the persistent browser profile (~/.assistme/browser-profile)
+- Saved sessions persist across assistme restarts \u2014 the user only needs to log in once per site
+- Chrome is automatically managed \u2014 just call browser_connect and it will auto-launch if needed
+- NEVER ask the user to manually start Chrome or run any terminal commands for browser setup
+
+Available capabilities:
+1. CODE EXECUTION & LOCAL PROGRAMS:
+   - Write scripts (Node.js, Python, shell, etc.) to solve tasks programmatically
+   - Install and use CLI tools (gh, aws, gcloud, jq, curl, etc.) via Bash
+   - Build reusable local programs that the user can run again later
+   - Register completed programs via program_register so they appear in the desktop app
+   - Store API keys and secrets using credential_set (encrypted on disk)
+   - When creating a program:
+     1. Create a directory under the workspace (e.g. {workspace_path}/programs/<project-name>/)
+     2. Write the code, a README.md (with setup instructions, how to get API keys, usage examples)
+     3. If credentials are needed, use ask_user to tell the user what's needed and how to get them
+     4. Once credentials are provided, store them via credential_set
+     5. Register the project via program_register with name, description, directory path, and language
+
+2. BROWSER CONTROL (user's real Chrome via CDP):
+   **PREFERRED workflow \u2014 Snapshot + Act (ref-based):**
+   - browser_snapshot \u2192 takes a screenshot and discovers all interactive elements with numbered refs
+     Returns a ref table (text) + screenshot (image). The ref table is your PRIMARY context for element identification.
+     Use annotate=true only on simple pages (few elements) where visual badge overlay helps.
+   - browser_act \u2192 execute actions using ref numbers: click, type, select, press, scroll, wait
+   - This is MORE RELIABLE than CSS selectors because:
+     (a) The ref table gives you role, name, and type for every interactive element \u2014 no guessing
+     (b) Refs use stable semantic resolution (role + accessible name) that survives DOM changes
+     (c) Actions use CDP Input events (real mouse/keyboard) instead of JavaScript \u2014 works with all frameworks
+     (d) You can batch multiple actions in one call \u2014 fewer round-trips
+   - Example workflow:
+     1. browser_snapshot \u2192 ref table shows [1] button "Next", [2] textbox "Email", [3] combobox "Month"
+     2. browser_act actions=[{action:"type", ref:2, text:"user@example.com"}, {action:"select", ref:3, option:"March"}, {action:"click", ref:1}] screenshot=true
+   - Refs persist across actions unless the page navigates. Re-snapshot after navigation or major DOM changes.
+
+   **Legacy tools (still available, use when refs don't work):**
+   - browser_click, browser_type, browser_select, browser_screenshot, browser_evaluate
+   - browser_click supports :contains('text') pseudo-selectors
+   - browser_select handles native and custom dropdowns
+
+   **Other browser tools:**
+   - browser_connect, browser_navigate, browser_read_page, browser_list_tabs, browser_switch_tab, browser_new_tab
+   - If auth is needed: use browser_request_user_action to ask the user to log in
+
+3. FILE OPERATIONS & SHELL:
+   - Read, Write, Edit tools for file operations
+   - Bash tool for shell commands
+   - Glob and Grep for file search
+
+4. MEMORY & CREDENTIALS:
+   - You can remember things about the user using memory_store
+   - Use this when you learn preferences, important facts, or standing instructions
+   - Your stored memories persist across conversations
+   - PROACTIVELY use memory_store during tasks when you discover user preferences, habits, or important context
+   - Before completing a task, consider if anything learned should be remembered for future conversations
+   - CRITICAL \u2014 Credential Storage: When you create, register, or receive any account credentials (username, password, API keys, tokens), you MUST use credential_set to save them locally. NEVER use memory_store for credentials \u2014 memory_store is for preferences and facts, credential_set is for secrets. Examples:
+     * After registering a new email/account \u2192 credential_set with type "login" and data { "username": "...", "password": "...", "email": "..." }
+     * After generating an API key \u2192 credential_set with type "api_key" and data { "api_key": "..." }
+     * Credentials saved via credential_set are encrypted on disk and viewable in the desktop app's Credentials panel
+
+5. SKILL-AWARE EXECUTION (CRITICAL \u2014 follow this for EVERY task):
+   Step A \u2014 Search: Before executing ANY task, check if an existing skill matches (use skill_invoke or skill_search).
+   Step B \u2014 If skill found: load it with skill_invoke and follow its instructions precisely. If the instructions are incomplete or wrong, adapt and improve as you go \u2014 note what changed.
+   Step C \u2014 If NO skill found: BEFORE executing, draft a skill plan following the Agent Skills format:
+     Skill Draft: [kebab-case-name]
+     Description: [what this skill does and when to use it]
+     Steps:
+     1. [first step]
+     2. [second step]
+     ...
+     The draft should be a reusable workflow, not specific to this one request. Use generic placeholders where the user provided specific values.
+   Step D \u2014 Execute: Follow the skill draft (or loaded skill) step by step. Refine the draft as you discover better approaches, edge cases, or missing steps.
+   Step E \u2014 After execution: The system will automatically evaluate whether to save the skill. You do NOT need to call skill_create manually.
+
+   Agent Skills format reference (agentskills.io):
+   - name: 1-64 chars, lowercase kebab-case (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens
+   - description: 1-1024 chars, describe what the skill does AND when to use it, include keywords for discoverability
+   - body: markdown step-by-step instructions, examples, edge cases. Keep under 500 lines.
+   - Progressive disclosure: metadata (~100 tokens) \u2192 instructions (<5000 tokens) \u2192 references (on demand)
+
+6. JOB AUTOMATION:
+   - When the user describes their job/role/daily work, use skill_generate to decompose it into automatable skills
+   - ALWAYS use ask_user to get user approval before creating skills \u2014 never create skills without approval
+   - Use job_run to start a job \u2014 it gives you the job's goal and available skills as capabilities
+   - When running a job, be AGENTIC: decide dynamically what to do based on what you discover
+   - Do NOT follow a fixed sequence \u2014 if checking Slack reveals a task that needs GitHub, go do GitHub immediately
+   - Chain actions intelligently: one skill's findings should inform your next move
+   - Skip irrelevant skills, use tools directly when skills aren't needed
+   - Use job_schedule for recurring automation (e.g., "run my SE job every weekday morning")
+   - Use job_status to check run history
+
+7. HEARTBEAT MONITORING (HEARTBEAT.md):
+   - You have a heartbeat engine that periodically reads {workspace_path}/HEARTBEAT.md
+   - On each heartbeat cycle, the LLM reads the checklist, uses tools to check each item, and decides what needs attention
+   - If everything is fine, the cycle silently responds HEARTBEAT_OK (the user sees nothing)
+   - If something needs attention, the agent takes action and notifies the user
+   - **When the user asks to monitor something** (e.g. "\u5E2E\u6211\u76D1\u63A7\u78C1\u76D8", "watch for new PRs", "alert me if server goes down"):
+     1. Read the current HEARTBEAT.md (create it if it doesn't exist)
+     2. Use the Write or Edit tool to add the new monitoring item to the checklist
+     3. Confirm to the user what you added \u2014 they do NOT need to edit the file themselves
+     4. The heartbeat engine will automatically pick up the changes on the next cycle
+   - When the user asks to stop monitoring something, edit HEARTBEAT.md to remove that item
+   - The user should NEVER need to manually edit HEARTBEAT.md \u2014 you do it for them via conversation
+   - Use heartbeat_status to check the current heartbeat state
+   - Use heartbeat_enable / heartbeat_disable to toggle monitoring
+   - Use heartbeat_interval to change how often the heartbeat runs (default: 30 minutes)
+   - Use heartbeat_log to see past cycle outcomes, timing, and costs
+   - Heartbeat logs are saved to ~/.assistme/heartbeat-log.jsonl
+
+8. SKILL MARKETPLACE:
+   - Use skill_browse to discover community-published skills
+   - Use skill_add to add marketplace skills to the user's collection
+   - Use skill_publish to share the user's skills with the community
+
+Workflow for tasks that can be done via code/API:
+1. Check if a program already exists for this type of task (program_list)
+2. If yes: use the existing project (run its scripts, etc.)
+3. If no: suggest code approach via ask_user, explaining benefits and required credentials
+4. If user agrees: create project directory, write code + README, register via program_register
+5. Execute and verify
+
+Workflow for web tasks (e.g. "\u67E5\u4E00\u4E0B kindle \u6700\u65B0\u6B3E\u4EF7\u683C"):
+1. browser_connect \u2192 connect to user's Chrome
+2. browser_new_tab \u2192 open a new tab
+3. browser_navigate \u2192 go to the website (login pages are auto-detected)
+4. browser_snapshot \u2192 get ref table + screenshot (use annotate=true for simple pages)
+5. browser_act \u2192 interact using refs (type, click, select, etc.), set screenshot=true to see result
+6. Repeat 4-5 as needed (re-snapshot after navigation or major page changes)
+7. Summarize findings
+
+Workflow for form filling (e.g. "\u6CE8\u518C\u4E00\u4E2A Gmail \u8D26\u53F7"):
+1. browser_connect + browser_navigate \u2192 go to the form page
+2. browser_snapshot \u2192 see all form fields with ref numbers
+3. browser_act \u2192 batch fill multiple fields + click submit in ONE call:
+   actions=[{action:"type", ref:1, text:"John"}, {action:"type", ref:2, text:"Doe"}, {action:"select", ref:3, option:"March"}, {action:"click", ref:7}] screenshot=true
+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
+
+9. 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
+   - Browser approach too slow \u2192 consider building a script/CLI solution
+   - 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.
+- Choose the right tool for the job: code/API for repeatable tasks, browser for one-off web interactions
+- 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
+- Only re-snapshot when: (a) the page navigated, (b) significant DOM changes occurred, (c) an action failed with "ref not found"
+- Refs are semantically stable (resolved by role + name), so they often survive minor DOM updates
+- Login pages are auto-detected after navigation \u2014 the user is prompted and sessions are saved automatically
+- If auto-detection misses a login page, use browser_request_user_action manually
+- Fall back to legacy tools (browser_click, browser_type, browser_evaluate) only when refs don't work
+- Be thorough: check multiple sources when comparing prices/products
+- Summarize results clearly at the end
+- When you learn something about the user (preferences, habits), use memory_store to remember it
+
+CRITICAL \u2014 Ask before you guess:
+- Before executing a task, verify you have all required information. If anything is ambiguous or missing, use ask_user to ask.
+- First try to resolve unknowns yourself: check memories, read workspace files (e.g. git remote, config files), or infer from conversation history.
+- If you still lack a critical piece of information after self-resolution, ASK the user via ask_user. Do NOT guess, assume defaults, or proceed with incomplete information.
+- When asking, provide suggested options as buttons whenever possible \u2014 the user can always type a custom answer instead.
+- Examples of when to ask: which account/repo/project to target, what format the user wants, which of multiple options to choose, credentials or URLs that cannot be inferred.
+- Keep questions specific and actionable. Explain what you already know and what exactly you need.
+- After receiving the answer, store it with memory_store if it is likely to be useful in future conversations.
+
+Workspace path: {workspace_path}`;
+
+// src/agent/processor.ts
+var TaskTimeout = class {
+  constructor(abortController, timeoutMs) {
+    this.abortController = abortController;
+    this.remainingMs = timeoutMs;
+    this.resumedAt = Date.now();
+    this.schedule();
+  }
+  timeoutId = null;
+  remainingMs;
+  resumedAt;
+  schedule() {
+    this.timeoutId = setTimeout(() => {
+      this.abortController.abort();
+    }, this.remainingMs);
+  }
+  /** Pause the timeout (e.g. while waiting for user). */
+  pause() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+      const elapsed = Date.now() - this.resumedAt;
+      this.remainingMs = Math.max(0, this.remainingMs - elapsed);
+    }
+  }
+  /** Resume the timeout after user interaction completes. */
+  resume() {
+    this.resumedAt = Date.now();
+    this.schedule();
+  }
+  clear() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+};
+var TaskProcessor = class {
+  memoryManager = null;
+  skillManager;
+  sessionId = null;
+  userId = null;
+  heartbeatEngine = 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) => {
+      log.debug(`DB skill load deferred: ${err}`);
+    });
+  }
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  setHeartbeatEngine(engine) {
+    this.heartbeatEngine = engine;
+  }
+  /**
+   * Post-task: resume the same Agent SDK session to evaluate whether
+   * to create/update a skill. The agent already has full context from
+   * the task it just completed — no need to re-describe anything.
+   */
+  async evaluateSkillPostTask(agentSessionId, model) {
+    await evaluateAndMaybeCreateSkill({
+      sessionId: agentSessionId,
+      skillManager: this.skillManager,
+      model
+    });
+  }
+  async processTask(task) {
+    const config = getConfig();
+    resetEventSequence();
+    const taskTimeoutMs = config.taskTimeoutMinutes * 6e4;
+    newCorrelationId();
+    log.info(`Processing task ${task.id.slice(0, 8)}...`);
+    let finalResponse = "";
+    const toolCallRecords = [];
+    const toolFailures = [];
+    let tokenUsage;
+    let agentSessionId;
+    try {
+      await emitEvent(task.id, "status_change", { status: "running" });
+      let systemPrompt = BASE_SYSTEM_PROMPT.replace("{workspace_path}", config.workspacePath);
+      if (this.memoryManager) {
+        try {
+          const memoryPrompt = await this.memoryManager.buildMemoryPrompt();
+          if (memoryPrompt) {
+            systemPrompt += memoryPrompt;
+          }
+        } catch (err) {
+          log.debug(`Memory load failed: ${err}`);
+        }
+      }
+      const skillPrompt = this.skillManager.buildSkillDescriptions(task.prompt);
+      if (skillPrompt) {
+        systemPrompt += skillPrompt;
+      }
+      let history = [];
+      try {
+        history = await getConversationHistory(task.conversation_id, task.id, MAX_HISTORY_ENTRIES);
+      } catch {
+        log.debug("DB conversation history unavailable, using in-memory cache");
+      }
+      if (history.length === 0) {
+        history = this.historyCache.get(task.conversation_id) || [];
+      }
+      if (history.length > 0) {
+        log.info(`Loaded ${history.length} message(s) from conversation history`);
+        let historyPrompt = "\n\n## Conversation History\nThe following is the history of previous messages in this conversation. Use this context to maintain continuity and understand references to earlier tasks.\n\n";
+        for (const entry of history) {
+          historyPrompt += `User: ${entry.prompt}
+`;
+          const truncated = entry.response.length > MAX_HISTORY_RESPONSE_LENGTH ? entry.response.slice(0, MAX_HISTORY_RESPONSE_LENGTH) + "\u2026" : entry.response;
+          historyPrompt += `Assistant: ${truncated}
+
+`;
+        }
+        systemPrompt += historyPrompt;
+      }
+      const abortController = new AbortController();
+      const taskTimeout = new TaskTimeout(abortController, taskTimeoutMs);
+      const browserServer = createBrowserMcpServer();
+      const agentToolsServer = createAgentToolsServer({
+        memoryManager: this.memoryManager,
+        skillManager: this.skillManager,
+        taskId: task.id,
+        sessionId: this.sessionId || void 0,
+        heartbeatEngine: this.heartbeatEngine || void 0,
+        onUserWaitStart: () => taskTimeout.pause(),
+        onUserWaitEnd: () => taskTimeout.resume()
+      });
+      const eventHooks = createEventHooks(task.id, toolCallRecords, toolFailures);
+      const allowedTools = [
+        "Read",
+        "Write",
+        "Edit",
+        "Bash",
+        "Glob",
+        "Grep",
+        ...BROWSER_TOOL_NAMES.map((n) => `mcp__assistme-browser__${n}`),
+        "mcp__assistme-agent__memory_store",
+        "mcp__assistme-agent__skill_create",
+        "mcp__assistme-agent__skill_improve",
+        "mcp__assistme-agent__skill_invoke",
+        "mcp__assistme-agent__skill_search",
+        "mcp__assistme-agent__skill_generate",
+        "mcp__assistme-agent__skill_link_job",
+        "mcp__assistme-agent__skill_browse",
+        "mcp__assistme-agent__skill_add",
+        "mcp__assistme-agent__skill_publish",
+        "mcp__assistme-agent__ask_user",
+        "mcp__assistme-agent__job_run",
+        "mcp__assistme-agent__job_schedule",
+        "mcp__assistme-agent__job_status",
+        "mcp__assistme-agent__credential_get",
+        "mcp__assistme-agent__credential_set",
+        "mcp__assistme-agent__credential_list",
+        "mcp__assistme-agent__credential_remove",
+        "mcp__assistme-agent__program_register",
+        "mcp__assistme-agent__program_list",
+        "mcp__assistme-agent__program_run",
+        "mcp__assistme-agent__program_remove",
+        "mcp__assistme-agent__heartbeat_status",
+        "mcp__assistme-agent__heartbeat_enable",
+        "mcp__assistme-agent__heartbeat_disable",
+        "mcp__assistme-agent__heartbeat_interval",
+        "mcp__assistme-agent__heartbeat_log"
+      ];
+      const mcpServers = {
+        "assistme-browser": browserServer,
+        "assistme-agent": agentToolsServer
+      };
+      const options = {
+        model: config.model,
+        systemPrompt,
+        cwd: config.workspacePath,
+        allowedTools,
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        mcpServers,
+        hooks: eventHooks,
+        persistSession: true,
+        abortController,
+        thinking: { type: "adaptive" },
+        effort: "high",
+        maxBudgetUsd: MAX_BUDGET_USD
+      };
+      try {
+        for await (const message of query3({ prompt: task.prompt, options })) {
+          switch (message.type) {
+            case "assistant": {
+              const assistantMsg = message;
+              for (const block of assistantMsg.message.content) {
+                if (block.type === "text") {
+                  finalResponse += block.text;
+                  log.agent(block.text);
+                  await emitEvent(task.id, "text_delta", { text: block.text });
+                } else if (block.type === "thinking" && "thinking" in block) {
+                  const thinkingBlock = block;
+                  log.debug(`Thinking: ${thinkingBlock.thinking.slice(0, 100)}...`);
+                  await emitEvent(task.id, "thinking", { text: thinkingBlock.thinking });
+                }
+              }
+              break;
+            }
+            case "result": {
+              const resultMsg = message;
+              tokenUsage = {
+                input_tokens: resultMsg.usage.input_tokens,
+                output_tokens: resultMsg.usage.output_tokens
+              };
+              if (resultMsg.subtype === "success") {
+                const successMsg = resultMsg;
+                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 errMsg = resultMsg;
+                log.warn(`SDK result: ${errMsg.subtype}`);
+                for (const err of errMsg.errors) {
+                  await emitEvent(task.id, "error", { message: err });
+                }
+              }
+              break;
+            }
+            default:
+              if (message.type === "system" && "subtype" in message) {
+                const sysMsg = message;
+                if (sysMsg.subtype === "init" && sysMsg.session_id) {
+                  agentSessionId = sysMsg.session_id;
+                }
+              }
+              log.debug(`SDK message type: ${message.type}`);
+              break;
+          }
+        }
+      } finally {
+        taskTimeout.clear();
+      }
+      const truncatedResponse = finalResponse.length > MAX_RESPONSE_CONTENT_LENGTH ? finalResponse.slice(0, MAX_RESPONSE_CONTENT_LENGTH) + "\n\n[Response truncated]" : finalResponse;
+      await withRetry(() => completeTask(task.id, truncatedResponse, tokenUsage), {
+        maxRetries: MAX_COMPLETE_TASK_RETRIES,
+        baseDelayMs: 300,
+        label: "completeTask"
+      });
+      await emitEvent(task.id, "status_change", { status: "completed" });
+      log.success("Task completed.");
+      const convHistory = this.historyCache.get(task.conversation_id) || [];
+      convHistory.push({ prompt: task.prompt, response: finalResponse });
+      if (convHistory.length > MAX_HISTORY_ENTRIES * 2) {
+        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) {
+        (async () => {
+          try {
+            await this.evaluateSkillPostTask(agentSessionId, config.model);
+          } catch (err) {
+            log.debug(`Post-task skill evaluation skipped: ${err}`);
+          }
+          try {
+            await analyzeSelfPostTask({
+              model: config.model,
+              taskId: task.id,
+              conversationId: task.conversation_id,
+              taskPrompt: task.prompt,
+              taskResponse: finalResponse,
+              toolCallRecords,
+              toolFailures,
+              tokenUsage,
+              sessionId: this.sessionId || ""
+            });
+          } catch (err) {
+            log.debug(`Post-task self-analysis skipped: ${err}`);
+          }
+        })().catch(() => {
+        });
+      }
+    } catch (err) {
+      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);
+      try {
+        const browser = getBrowser();
+        if (browser.isConnected()) {
+          await browser.disconnect();
+        }
+      } catch {
+      }
+    }
+  }
+};
+
+// src/workers/conversation.ts
+loadEnv();
+var ConversationHandler = class extends BaseHandler {
+  workerType = "conversation";
+  processor = null;
+  async onInit(config) {
+    this.processor = new TaskProcessor();
+    this.processor.setUserId(config.userId);
+    this.processor.setSessionId(config.sessionId);
+    this.log(
+      "info",
+      `Conversation worker initialized (conversation: ${config.conversationId ?? "any"})`
+    );
+  }
+  async onMessage(message) {
+    switch (message.type) {
+      case "process_task": {
+        const { task } = message;
+        this.log("info", `Processing task ${task.id.slice(0, 8)}...`);
+        try {
+          await this.processor.processTask(task);
+          this.send({ type: "task_completed", taskId: task.id });
+        } catch (err) {
+          this.send({
+            type: "task_failed",
+            taskId: task.id,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+        break;
+      }
+      default:
+        this.log("warn", `Unknown message type: ${message.type}`);
+    }
+  }
+  async onShutdown() {
+    this.log("info", "Conversation worker shutting down");
+    try {
+      const browser = getBrowser();
+      if (browser.isConnected()) {
+        await browser.disconnect();
+      }
+    } catch {
+    }
+  }
+};
+
+// src/workers/entry.ts
+function getWorkerType() {
+  const typeIndex = process.argv.indexOf("--type");
+  if (typeIndex === -1 || !process.argv[typeIndex + 1]) {
+    console.error("Usage: worker --type <conversation>");
+    process.exit(1);
+  }
+  return process.argv[typeIndex + 1];
+}
+function createHandler(type2) {
+  switch (type2) {
+    case "conversation":
+      return new ConversationHandler();
+    default:
+      console.error(`Unknown worker type: ${type2}`);
+      process.exit(1);
+  }
+}
+var type = getWorkerType();
+var handler = createHandler(type);
+handler.start();