assistme 0.4.0 → 0.6.0

package/dist/index.js

@@ -3,6 +3,7 @@ import {
   AppError,
   BrowseSkillRowSchema,
   CDP_COMMAND_TIMEOUT_MS,
+  EDSGER_PRODUCT_SLUG,
   FRAME_CONTEXTS_MAX_SIZE,
   JobRunner,
   MAX_BUDGET_USD,
@@ -20,10 +21,16 @@ import {
   MEMORY_COMPRESSION_THRESHOLD,
   MEMORY_DEDUP_SIMILARITY_THRESHOLD,
   SCHEDULER_INTERVAL_MS,
+  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,
   SHELL_MAX_OUTPUT,
   SHELL_TIMEOUT_MS,
   SKILL_DESCRIPTION_BUDGET_CHARS,
   SKILL_VALIDATION_MAX_TURNS,
+  SelfAnalysisResultSchema,
   SkillCreateResultSchema,
   SkillDecisionSchema,
   SkillRowSchema,
@@ -35,9 +42,10 @@ import {
   readAuthStore,
   safeParse,
   setCorrelationId,
+  setLogHook,
   setLogLevel,
   writeAuthStore
-} from "./chunk-4SBIN27G.js";
+} from "./chunk-ECEOBNDM.js";
 import {
   clearConfig,
   getConfig,
@@ -2711,7 +2719,7 @@ var SessionManager = class {
 
 // src/agent/processor.ts
 import {
-  query as query2
+  query as query3
 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/agent/memory.ts
@@ -2736,10 +2744,10 @@ var MemoryManager = class {
   /**
    * Search memories by query text. Uses ILIKE + tag containment.
    */
-  async search(query3, limit = 10) {
+  async search(query4, limit = 10) {
     try {
       return await callMcpHandler("memory.search", {
-        query: query3,
+        query: query4,
         limit
       });
     } catch (err) {
@@ -3384,11 +3392,11 @@ _(${skills.length - included} additional skills available \u2014 use skill_searc
       log.debug(`Invocation log error: ${err}`);
     }
   }
-  async searchDb(query3, limit = 10) {
+  async searchDb(query4, limit = 10) {
     if (this.userId) {
       try {
         const data = await callMcpHandler("skill.search", {
-          query: query3,
+          query: query4,
           limit
         });
         if (data) {
@@ -3403,7 +3411,7 @@ _(${skills.length - included} additional skills available \u2014 use skill_searc
       } catch {
       }
     }
-    const results = this.findRelevant(query3, limit);
+    const results = this.findRelevant(query4, limit);
     return results.map((s) => ({
       name: s.name,
       description: s.description,
@@ -3783,6 +3791,386 @@ async function executeSkillDecision(decision, skillManager, sessionId, model) {
   }
 }
 
+// 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) {
+  try {
+    const data = await callMcpHandler("log.list", {
+      session_id: sessionId,
+      limit
+    });
+    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: {
+      is_perfect: { type: "boolean" },
+      overall_score: { type: "number" },
+      task_completion_quality: {
+        type: "object",
+        properties: {
+          score: { type: "number" },
+          assessment: { type: "string" }
+        },
+        required: ["score", "assessment"]
+      },
+      improvements: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            area: { type: "string" },
+            severity: {
+              type: "string",
+              enum: ["critical", "major", "minor", "suggestion"]
+            },
+            description: { type: "string" },
+            suggestion: { type: "string" }
+          },
+          required: ["area", "severity", "description", "suggestion"]
+        }
+      },
+      data_quality: {
+        type: "object",
+        properties: {
+          session_logs_useful: { type: "boolean" },
+          session_logs_gaps: { type: "string" },
+          message_events_useful: { type: "boolean" },
+          message_events_gaps: { type: "string" },
+          conversation_context_useful: { type: "boolean" },
+          conversation_context_gaps: { type: "string" }
+        },
+        required: [
+          "session_logs_useful",
+          "message_events_useful",
+          "conversation_context_useful"
+        ]
+      },
+      summary: { type: "string" }
+    },
+    required: [
+      "is_perfect",
+      "overall_score",
+      "task_completion_quality",
+      "improvements",
+      "data_quality",
+      "summary"
+    ]
+  }
+};
+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. Consider:
+- Are the session logs capturing enough detail for debugging?
+- Do the message events provide sufficient visibility into the agent's decision-making?
+- Is the conversation context giving enough user intent signal?
+- Were tools used efficiently?
+- Could the overall execution flow be improved?
+
+Set is_perfect to true ONLY if there are genuinely zero improvements to suggest (this should be rare).
+The overall_score should be 1-10 where 10 means absolutely perfect.
+
+Respond with a JSON object now.`;
+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),
+    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(analysis) {
+  const title = `Self-Analysis: Score ${analysis.overall_score}/10 \u2014 ${analysis.improvements.length} improvement(s)`;
+  const improvementDetails = analysis.improvements.map((imp, i) => `${i + 1}. [${imp.severity}] **${imp.area}**: ${imp.description}
+   \u2192 ${imp.suggestion}`).join("\n");
+  const dataQualityNotes = [
+    analysis.data_quality.session_logs_gaps ? `Session logs: ${analysis.data_quality.session_logs_gaps}` : null,
+    analysis.data_quality.message_events_gaps ? `Message events: ${analysis.data_quality.message_events_gaps}` : null,
+    analysis.data_quality.conversation_context_gaps ? `Conversation context: ${analysis.data_quality.conversation_context_gaps}` : null
+  ].filter(Boolean).join("\n");
+  let description = `## Summary
+${analysis.summary}
+
+`;
+  description += `## Task Completion Quality (${analysis.task_completion_quality.score}/10)
+${analysis.task_completion_quality.assessment}
+
+`;
+  description += `## Improvements
+${improvementDetails}
+`;
+  if (dataQualityNotes) {
+    description += `
+## Data Quality Gaps
+${dataQualityNotes}
+`;
+  }
+  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 analyzeSelfPostTask(opts) {
+  const {
+    model,
+    taskId,
+    conversationId,
+    taskPrompt,
+    taskResponse,
+    toolCallRecords,
+    toolFailures,
+    tokenUsage,
+    sessionId
+  } = opts;
+  try {
+    const analysisContext = await buildAnalysisContext({
+      taskId,
+      conversationId,
+      sessionId,
+      taskPrompt,
+      taskResponse,
+      toolCallRecords,
+      toolFailures,
+      tokenUsage
+    });
+    const prompt = `${SELF_ANALYSIS_PROMPT}
+${analysisContext}
+
+Respond with a JSON object now.`;
+    let structuredOutput;
+    for await (const message of query2({
+      prompt,
+      options: {
+        model,
+        maxTurns: 1,
+        allowedTools: [],
+        effort: "low",
+        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)}`
+          );
+        }
+      }
+    }
+    const analysis = structuredOutput ? safeParse(SelfAnalysisResultSchema, structuredOutput) : null;
+    if (!analysis) {
+      log.debug("Self-analysis: no valid structured output");
+      return;
+    }
+    log.info(
+      `Self-analysis complete: score=${analysis.overall_score}/10, perfect=${analysis.is_perfect}, improvements=${analysis.improvements.length}`
+    );
+    if (!analysis.is_perfect && analysis.improvements.length > 0) {
+      await submitSelfAnalysisFeedback(analysis);
+    } else {
+      log.debug("Self-analysis: no improvements to report \u2014 skipping feedback");
+    }
+  } catch (err) {
+    log.debug(`Self-analysis error: ${errorMessage(err)}`);
+  }
+}
+
 // src/utils/retry.ts
 async function withRetry(fn, opts = {}) {
   const {
@@ -6021,7 +6409,7 @@ var TaskProcessor = class {
         maxBudgetUsd: MAX_BUDGET_USD
       };
       try {
-        for await (const message of query2({ prompt: task.prompt, options })) {
+        for await (const message of query3({ prompt: task.prompt, options })) {
           switch (message.type) {
             case "assistant": {
               const assistantMsg = message;
@@ -6096,9 +6484,29 @@ var TaskProcessor = class {
         );
       }
       if (agentSessionId) {
-        this.evaluateSkillPostTask(agentSessionId, config.model).catch(
-          (err) => log.debug(`Post-task skill evaluation skipped: ${err}`)
-        );
+        (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);
@@ -6119,6 +6527,57 @@ var TaskProcessor = class {
   }
 };
 
+// src/db/session-log.ts
+var FLUSH_INTERVAL_MS = 3e3;
+var MAX_BATCH_SIZE = 100;
+var SessionLogEmitter = class {
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+    this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+  }
+  sequence = 0;
+  buffer = [];
+  flushTimer = null;
+  flushing = false;
+  /** Queue a log entry for batch insertion */
+  push(logType, message) {
+    this.sequence++;
+    this.buffer.push({ log_type: logType, message, seq: this.sequence });
+    if (this.buffer.length >= MAX_BATCH_SIZE) {
+      this.flush();
+    }
+  }
+  /** Flush buffered logs to Supabase */
+  async flush() {
+    if (this.flushing || this.buffer.length === 0) return;
+    const batch = this.buffer.splice(0);
+    this.flushing = true;
+    try {
+      await callMcpHandler("log.emit_batch", {
+        session_id: this.sessionId,
+        logs: batch
+      });
+    } catch (err) {
+      log.debug(
+        `Failed to flush session logs: ${err instanceof Error ? err.message : err}`
+      );
+      if (this.buffer.length < MAX_BATCH_SIZE * 5) {
+        this.buffer.unshift(...batch);
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /** Stop the emitter and flush remaining logs */
+  async stop() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+};
+
 // src/commands/start.ts
 function registerStartCommand(program2) {
   program2.command("start", { isDefault: true, hidden: true }).description("Start the agent (default command)").option("-w, --workspace <path>", "Workspace path (default: current directory)").option("-n, --name <name>", "Session name").option("-v, --verbose", "Enable verbose/debug logging").action(runAgent);
@@ -6182,10 +6641,16 @@ async function runAgent(opts) {
   const processor = new TaskProcessor();
   processor.init(userId);
   const sessionManager = new SessionManager();
+  let logEmitter = null;
   const browserRef = getBrowser();
   const shutdown = async () => {
     console.log();
     log.info("Shutting down...");
+    setLogHook(null);
+    try {
+      if (logEmitter) await logEmitter.stop();
+    } catch {
+    }
     try {
       if (browserRef.isConnected()) await browserRef.disconnect();
     } catch {
@@ -6200,6 +6665,10 @@ async function runAgent(opts) {
       await processor.processTask(task);
     });
     processor.setSessionId(session.id);
+    logEmitter = new SessionLogEmitter(session.id);
+    setLogHook((logType, message) => {
+      logEmitter?.push(logType, message);
+    });
     log.info("Listening for tasks (chat + jobs) from web UI...");
     log.info("Press Ctrl+C to stop.\n");
     const rl = createInterface2({
@@ -6425,17 +6894,17 @@ Memories (${memories.length}):`));
       process.exit(1);
     }
   });
-  memoryCmd.command("search <query>").description("Search memories").action(async (query3) => {
+  memoryCmd.command("search <query>").description("Search memories").action(async (query4) => {
     try {
       await getCurrentUserId();
       const mm = new MemoryManager();
-      const results = await mm.search(query3);
+      const results = await mm.search(query4);
       if (results.length === 0) {
-        console.log(chalk7.yellow(`No memories matching "${query3}"`));
+        console.log(chalk7.yellow(`No memories matching "${query4}"`));
         return;
       }
       console.log(chalk7.bold(`
-Search results for "${query3}":`));
+Search results for "${query4}":`));
       for (const m of results) {
         console.log(`  [${m.category}] ${m.content}`);
       }
@@ -6501,18 +6970,18 @@ function registerSkillCommands(program2) {
     );
     console.log();
   });
-  skillCmd.command("search <query>").description("Search skills in your collection and marketplace").action(async (query3) => {
+  skillCmd.command("search <query>").description("Search skills in your collection and marketplace").action(async (query4) => {
     const spinner = ora4("Searching skills...").start();
     const sm = await getAuthenticatedSkillManager();
     try {
-      const results = await sm.searchDb(query3);
+      const results = await sm.searchDb(query4);
       spinner.stop();
       if (results.length === 0) {
-        console.log(chalk8.yellow(`No skills found for "${query3}"`));
+        console.log(chalk8.yellow(`No skills found for "${query4}"`));
         return;
       }
       console.log(chalk8.bold(`
-Skills matching "${query3}":`));
+Skills matching "${query4}":`));
       for (const r of results) {
         const emoji = r.emoji ? `${r.emoji} ` : "";
         console.log(`  ${emoji}${chalk8.cyan(r.name)} [${r.source}]`);
@@ -6605,7 +7074,7 @@ function registerJobCommands(program2) {
   jobCmd.command("list").description("List your defined jobs").action(async () => {
     try {
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-CJ7HM4GZ.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-RGP4CLYV.js");
       const runner = new JobRunner2();
       const jobs = await runner.listJobs();
       if (jobs.length === 0) {
@@ -6629,7 +7098,7 @@ function registerJobCommands(program2) {
   jobCmd.command("status [name]").description("Show run history for a job (or all jobs)").option("-l, --limit <number>", "Max runs to show (default: 5)").action(async (name, opts) => {
     try {
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-CJ7HM4GZ.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-RGP4CLYV.js");
       const runner = new JobRunner2();
       const runs = await runner.getRunHistory(name, parseInt(opts.limit || "5"));
       if (runs.length === 0) {
@@ -6668,7 +7137,7 @@ Job Run History${name ? ` \u2014 ${name}` : ""}:`));
         process.exit(1);
       }
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-CJ7HM4GZ.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-RGP4CLYV.js");
       const runner = new JobRunner2();
       const job = await runner.loadJob(name);
       if (!job) {

package/dist/{job-runner-CJ7HM4GZ.js → job-runner-RGP4CLYV.js}

@@ -1,6 +1,6 @@
 import {
   JobRunner
-} from "./chunk-4SBIN27G.js";
+} from "./chunk-ECEOBNDM.js";
 import "./chunk-JVA6DHXD.js";
 export {
   JobRunner

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "AssistMe CLI Agent - AI-powered assistant that controls your real browser",
   "type": "module",
   "main": "dist/index.js",
@@ -26,6 +26,7 @@
     "conf": "^13.0.1",
     "croner": "^10.0.1",
     "dotenv": "^16.5.0",
+    "edsger-feedback": "^0.1.0",
     "glob": "^11.0.1",
     "ora": "^8.2.0",
     "ws": "^8.18.0",