@memtensor/memos-local-openclaw-plugin 1.0.4-beta.7 → 1.0.4-beta.9

package/src/recall/engine.ts

@@ -74,10 +74,49 @@ export class RecallEngine {
       score: 1 / (i + 1),
     }));
 
+    // Step 1c: Hub memories search (when sharing is enabled and hub_memories exist)
+    let hubMemFtsRanked: Array<{ id: string; score: number }> = [];
+    let hubMemVecRanked: Array<{ id: string; score: number }> = [];
+    if (query && this.ctx.config.sharing?.enabled) {
+      try {
+        const hubFtsHits = this.store.searchHubMemories(query, { maxResults: candidatePool });
+        hubMemFtsRanked = hubFtsHits.map(({ hit }, i) => ({
+          id: `hubmem:${hit.id}`, score: 1 / (i + 1),
+        }));
+      } catch { /* hub_memories table may not exist */ }
+      try {
+        const hubMemEmbs = this.store.getVisibleHubMemoryEmbeddings("");
+        if (hubMemEmbs.length > 0) {
+          const qv = await this.embedder.embedQuery(query).catch(() => null);
+          if (qv) {
+            const scored: Array<{ id: string; score: number }> = [];
+            for (const e of hubMemEmbs) {
+              let dot = 0, nA = 0, nB = 0;
+              for (let i = 0; i < qv.length && i < e.vector.length; i++) {
+                dot += qv[i] * e.vector[i]; nA += qv[i] * qv[i]; nB += e.vector[i] * e.vector[i];
+              }
+              const sim = nA > 0 && nB > 0 ? dot / (Math.sqrt(nA) * Math.sqrt(nB)) : 0;
+              if (sim > 0.3) {
+                scored.push({ id: `hubmem:${e.memoryId}`, score: sim });
+              }
+            }
+            scored.sort((a, b) => b.score - a.score);
+            hubMemVecRanked = scored.slice(0, candidatePool);
+          }
+        }
+      } catch { /* best-effort */ }
+      if (hubMemFtsRanked.length > 0 || hubMemVecRanked.length > 0) {
+        this.ctx.log.debug(`recall: hub_memories candidates: fts=${hubMemFtsRanked.length}, vec=${hubMemVecRanked.length}`);
+      }
+    }
+
     // Step 2: RRF fusion
     const ftsRanked = ftsCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
     const vecRanked = vecCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
-    const rrfScores = rrfFuse([ftsRanked, vecRanked, patternRanked], recallCfg.rrfK);
+    const allRankedLists = [ftsRanked, vecRanked, patternRanked];
+    if (hubMemFtsRanked.length > 0) allRankedLists.push(hubMemFtsRanked);
+    if (hubMemVecRanked.length > 0) allRankedLists.push(hubMemVecRanked);
+    const rrfScores = rrfFuse(allRankedLists, recallCfg.rrfK);
 
     if (rrfScores.size === 0) {
       this.recordQuery(query, maxResults, minScore, 0);
@@ -101,6 +140,11 @@ export class RecallEngine {
 
     // Step 4: Time decay
     const withTs = mmrResults.map((r) => {
+      if (r.id.startsWith("hubmem:")) {
+        const memId = r.id.slice(7);
+        const mem = this.store.getHubMemoryById(memId);
+        return { ...r, createdAt: mem?.createdAt ?? 0 };
+      }
       const chunk = this.store.getChunk(r.id);
       return { ...r, createdAt: chunk?.createdAt ?? 0 };
     });
@@ -128,6 +172,34 @@ export class RecallEngine {
     const hits: SearchHit[] = [];
     for (const candidate of normalized) {
       if (hits.length >= maxResults) break;
+
+      if (candidate.id.startsWith("hubmem:")) {
+        const memId = candidate.id.slice(7);
+        const mem = this.store.getHubMemoryById(memId);
+        if (!mem) continue;
+        if (roleFilter && mem.role !== roleFilter) continue;
+        hits.push({
+          summary: mem.summary || mem.content.slice(0, 200),
+          original_excerpt: mem.content,
+          ref: {
+            sessionKey: `hub-shared:${mem.sourceUserId}`,
+            chunkId: mem.id,
+            turnId: "",
+            seq: 0,
+          },
+          score: Math.round(candidate.score * 1000) / 1000,
+          taskId: null,
+          skillId: null,
+          owner: `hub-user:${mem.sourceUserId}`,
+          source: {
+            ts: mem.createdAt,
+            role: (mem.role || "assistant") as any,
+            sessionKey: `hub-shared:${mem.sourceUserId}`,
+          },
+        });
+        continue;
+      }
+
       const chunk = this.store.getChunk(candidate.id);
       if (!chunk) continue;
       if (roleFilter && chunk.role !== roleFilter) continue;

package/src/shared/llm-call.ts

@@ -1,6 +1,34 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { SummarizerConfig, Logger, PluginContext, OpenClawAPI } from "../types";
+import type { SummarizerConfig, SummaryProvider, Logger, PluginContext, OpenClawAPI } from "../types";
+
+/**
+ * Detect provider type from provider key name or base URL.
+ */
+function detectProvider(providerKey: string | undefined, baseUrl: string): SummaryProvider {
+  const key = providerKey?.toLowerCase() ?? "";
+  const url = baseUrl.toLowerCase();
+  if (key.includes("anthropic") || url.includes("anthropic")) return "anthropic";
+  if (key.includes("gemini") || url.includes("generativelanguage.googleapis.com")) {
+    return "gemini";
+  }
+  if (key.includes("bedrock") || url.includes("bedrock")) return "bedrock";
+  return "openai_compatible";
+}
+
+/**
+ * Return the correct default endpoint for a given provider.
+ */
+function defaultEndpointForProvider(provider: SummaryProvider, baseUrl: string): string {
+  const stripped = baseUrl.replace(/\/+$/, "");
+  if (provider === "anthropic") {
+    if (stripped.endsWith("/v1/messages")) return stripped;
+    return `${stripped}/v1/messages`;
+  }
+  if (stripped.endsWith("/chat/completions")) return stripped;
+  if (stripped.endsWith("/completions")) return stripped;
+  return `${stripped}/chat/completions`;
+}
 
 /**
  * Build a SummarizerConfig from OpenClaw's native model configuration (openclaw.json).
@@ -30,13 +58,12 @@ export function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | unde
     const apiKey: string | undefined = providerCfg.apiKey;
     if (!baseUrl || !apiKey) return undefined;
 
-    const endpoint = baseUrl.endsWith("/chat/completions")
-      ? baseUrl
-      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
+    const provider = detectProvider(providerKey, baseUrl);
+    const endpoint = defaultEndpointForProvider(provider, baseUrl);
 
-    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl} (${provider})`);
     return {
-      provider: "openai_compatible",
+      provider,
       endpoint,
       apiKey,
       model: modelId,
@@ -70,23 +97,34 @@ export interface LLMCallOptions {
   openclawAPI?: OpenClawAPI;
 }
 
-function normalizeEndpoint(url: string): string {
+function normalizeOpenAIEndpoint(url: string): string {
   const stripped = url.replace(/\/+$/, "");
   if (stripped.endsWith("/chat/completions")) return stripped;
   if (stripped.endsWith("/completions")) return stripped;
   return `${stripped}/chat/completions`;
 }
 
+function normalizeAnthropicEndpoint(url: string): string {
+  const stripped = url.replace(/\/+$/, "");
+  if (stripped.endsWith("/v1/messages")) return stripped;
+  if (stripped.endsWith("/messages")) return stripped;
+  return `${stripped}/v1/messages`;
+}
+
+function isAnthropicProvider(cfg: SummarizerConfig): boolean {
+  return cfg.provider === "anthropic";
+}
+
 /**
  * Make a single LLM call with the given config. Throws on failure.
  * When cfg.provider === "openclaw", delegates to the OpenClaw host completion API.
+ * Dispatches to Anthropic or OpenAI-compatible format based on provider.
  */
 export async function callLLMOnce(
   cfg: SummarizerConfig,
   prompt: string,
   opts: LLMCallOptions = {},
 ): Promise<string> {
-  // Handle openclaw provider via host completion API
   if (cfg.provider === "openclaw") {
     const api = opts.openclawAPI;
     if (!api) {
@@ -101,7 +139,57 @@ export async function callLLMOnce(
     return response.text.trim();
   }
 
-  const endpoint = normalizeEndpoint(cfg.endpoint ?? "https://api.openai.com/v1/chat/completions");
+  if (isAnthropicProvider(cfg)) {
+    return callLLMOnceAnthropic(cfg, prompt, opts);
+  }
+  return callLLMOnceOpenAI(cfg, prompt, opts);
+}
+
+async function callLLMOnceAnthropic(
+  cfg: SummarizerConfig,
+  prompt: string,
+  opts: LLMCallOptions = {},
+): Promise<string> {
+  const endpoint = normalizeAnthropicEndpoint(
+    cfg.endpoint ?? "https://api.anthropic.com/v1/messages",
+  );
+  const model = cfg.model ?? "claude-3-haiku-20240307";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "x-api-key": cfg.apiKey ?? "",
+    "anthropic-version": "2023-06-01",
+    ...cfg.headers,
+  };
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model,
+      temperature: opts.temperature ?? 0.1,
+      max_tokens: opts.maxTokens ?? 1024,
+      messages: [{ role: "user", content: prompt }],
+    }),
+    signal: AbortSignal.timeout(opts.timeoutMs ?? 30_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`LLM call failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { content: Array<{ type: string; text: string }> };
+  return json.content.find((c) => c.type === "text")?.text?.trim() ?? "";
+}
+
+async function callLLMOnceOpenAI(
+  cfg: SummarizerConfig,
+  prompt: string,
+  opts: LLMCallOptions = {},
+): Promise<string> {
+  const endpoint = normalizeOpenAIEndpoint(
+    cfg.endpoint ?? "https://api.openai.com/v1/chat/completions",
+  );
   const model = cfg.model ?? "gpt-4o-mini";
   const headers: Record<string, string> = {
     "Content-Type": "application/json",

package/src/skill/evolver.ts

@@ -12,6 +12,8 @@ import { SkillUpgrader } from "./upgrader";
 import { SkillInstaller } from "./installer";
 import { buildSkillConfigChain, callLLMWithFallback } from "../shared/llm-call";
 
+export type SkillEvolvedCallback = (skillName: string, upgradeType: "created" | "upgraded") => void;
+
 export class SkillEvolver {
   private evaluator: SkillEvaluator;
   private generator: SkillGenerator;
@@ -19,6 +21,7 @@ export class SkillEvolver {
   private installer: SkillInstaller;
   private processing = false;
   private queue: Task[] = [];
+  onSkillEvolved: SkillEvolvedCallback | null = null;
 
   constructor(
     private store: SqliteStore,
@@ -279,6 +282,7 @@ Use selectedIndex 0 when none is highly relevant.`;
       if (upgraded) {
         this.store.linkTaskSkill(task.id, freshSkill.id, "evolved_from", freshSkill.version + 1);
         this.installer.syncIfInstalled(freshSkill.name);
+        this.onSkillEvolved?.(freshSkill.name, "upgraded");
       } else {
         this.store.linkTaskSkill(task.id, freshSkill.id, "applied_to", freshSkill.version);
       }
@@ -307,6 +311,7 @@ Use selectedIndex 0 when none is highly relevant.`;
       this.markChunksWithSkill(chunks, skill.id);
       this.store.linkTaskSkill(task.id, skill.id, "generated_from", 1);
       this.store.setTaskSkillMeta(task.id, { skillStatus: "generated", skillReason: evalResult.reason });
+      this.onSkillEvolved?.(skill.name, "created");
 
       const autoInstall = this.ctx.config.skillEvolution?.autoInstall ?? DEFAULTS.skillAutoInstall;
       if (autoInstall && skill.status === "active") {

package/src/storage/sqlite.ts

@@ -1818,8 +1818,8 @@ export class SqliteStore {
     return result.changes > 0;
   }
 
-  updateHubUserActivity(userId: string, ip: string): void {
-    this.db.prepare('UPDATE hub_users SET last_ip = ?, last_active_at = ? WHERE id = ?').run(ip, Date.now(), userId);
+  updateHubUserActivity(userId: string, ip: string, timestamp?: number): void {
+    this.db.prepare('UPDATE hub_users SET last_ip = ?, last_active_at = ? WHERE id = ?').run(ip, timestamp ?? Date.now(), userId);
   }
 
   getHubUserContributions(): Record<string, { memoryCount: number; taskCount: number; skillCount: number }> {
@@ -2063,6 +2063,11 @@ export class SqliteStore {
     }));
   }
 
+  listHubChunksByTaskId(hubTaskId: string): HubChunkRecord[] {
+    const rows = this.db.prepare('SELECT * FROM hub_chunks WHERE hub_task_id = ? ORDER BY created_at ASC').all(hubTaskId) as HubChunkRow[];
+    return rows.map(rowToHubChunk);
+  }
+
   deleteHubTaskById(taskId: string): boolean {
     const info = this.db.prepare('DELETE FROM hub_tasks WHERE id = ?').run(taskId);
     return info.changes > 0;
@@ -2151,6 +2156,14 @@ export class SqliteStore {
     ).run(n.id, n.userId, n.type, n.resource, n.title, n.message ?? '', Date.now());
   }
 
+  hasRecentHubNotification(userId: string, type: string, resource: string, windowMs: number = 300_000): boolean {
+    const since = Date.now() - windowMs;
+    const row = this.db.prepare(
+      'SELECT COUNT(*) AS cnt FROM hub_notifications WHERE user_id = ? AND type = ? AND resource = ? AND created_at > ?'
+    ).get(userId, type, resource, since) as { cnt: number };
+    return row.cnt > 0;
+  }
+
   listHubNotifications(userId: string, opts?: { unreadOnly?: boolean; limit?: number }): Array<{ id: string; userId: string; type: string; resource: string; title: string; message: string; read: boolean; createdAt: number }> {
     const where = opts?.unreadOnly ? 'WHERE user_id = ? AND read = 0' : 'WHERE user_id = ?';
     const limit = opts?.limit ?? 50;
@@ -2233,7 +2246,7 @@ export class SqliteStore {
     return row ?? null;
   }
 
-  listVisibleHubMemories(userId: string, limit = 40): Array<{ id: string; sourceChunkId: string; sourceUserId: string; role: string; summary: string; kind: string; groupId: string | null; groupName: string | null; visibility: string; ownerName: string; createdAt: number; updatedAt: number }> {
+  listVisibleHubMemories(userId: string, limit = 40): Array<{ id: string; sourceChunkId: string; sourceUserId: string; role: string; content: string; summary: string; kind: string; groupId: string | null; groupName: string | null; visibility: string; ownerName: string; createdAt: number; updatedAt: number }> {
     const rows = this.db.prepare(`
       SELECT m.*, u.username AS owner_name, NULL AS group_name
       FROM hub_memories m
@@ -2243,13 +2256,13 @@ export class SqliteStore {
     `).all(limit) as any[];
     return rows.map(r => ({
       id: r.id, sourceChunkId: r.source_chunk_id, sourceUserId: r.source_user_id,
-      role: r.role, summary: r.summary, kind: r.kind,
+      role: r.role, content: r.content ?? "", summary: r.summary, kind: r.kind,
       groupId: r.group_id, groupName: r.group_name ?? null, visibility: r.visibility,
       ownerName: r.owner_name ?? "unknown", createdAt: r.created_at, updatedAt: r.updated_at,
     }));
   }
 
-  listAllHubMemories(): Array<{ id: string; sourceChunkId: string; sourceUserId: string; role: string; summary: string; kind: string; groupId: string | null; groupName: string | null; visibility: string; ownerName: string; createdAt: number; updatedAt: number }> {
+  listAllHubMemories(): Array<{ id: string; sourceChunkId: string; sourceUserId: string; role: string; content: string; summary: string; kind: string; groupId: string | null; groupName: string | null; visibility: string; ownerName: string; createdAt: number; updatedAt: number }> {
     const rows = this.db.prepare(`
       SELECT m.*, u.username AS owner_name
       FROM hub_memories m
@@ -2258,7 +2271,7 @@ export class SqliteStore {
     `).all() as any[];
     return rows.map(r => ({
       id: r.id, sourceChunkId: r.source_chunk_id, sourceUserId: r.source_user_id,
-      role: r.role, summary: r.summary, kind: r.kind,
+      role: r.role, content: r.content ?? "", summary: r.summary, kind: r.kind,
       groupId: r.group_id, groupName: null as string | null, visibility: r.visibility,
       ownerName: r.owner_name ?? "unknown", createdAt: r.created_at, updatedAt: r.updated_at,
     }));

package/src/telemetry.ts

@@ -1,5 +1,5 @@
 /**
- * Telemetry module — anonymous usage analytics via PostHog.
+ * Telemetry module — anonymous usage analytics via Aliyun ARMS RUM.
  *
  * Privacy-first design:
  * - Enabled by default with anonymous data only; opt-out via TELEMETRY_ENABLED=false
@@ -8,7 +8,6 @@
  * - Only sends aggregate counts, tool names, latencies, and version info
  */
 
-import { PostHog } from "posthog-node";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -17,45 +16,61 @@ import type { Logger } from "./types";
 
 export interface TelemetryConfig {
   enabled?: boolean;
-  posthogApiKey?: string;
-  posthogHost?: string;
 }
 
-const DEFAULT_POSTHOG_API_KEY = "phc_7lae6UC5jyImDefX6uub7zCxWyswCGNoBifCKqjvDrI";
-const DEFAULT_POSTHOG_HOST = "https://eu.i.posthog.com";
+const ARMS_ENDPOINT =
+  "https://proj-xtrace-e218d9316b328f196a3c640cc7ca84-cn-hangzhou.cn-hangzhou.log.aliyuncs.com" +
+  "/rum/web/v2" +
+  "?workspace=default-cms-1026429231103299-cn-hangzhou" +
+  "&service_id=a3u72ukxmr@066657d42a13a9a9f337f";
+
+const ARMS_PID = "a3u72ukxmr@066657d42a13a9a9f337f";
+const ARMS_ENV = "prod";
+
+const FLUSH_AT = 10;
+const FLUSH_INTERVAL_MS = 30_000;
+const SEND_TIMEOUT_MS = 30_000;
+const SESSION_TTL_MS = 30 * 60_000; // 30 min inactivity → new session
+interface ArmsEvent {
+  event_type: "custom";
+  type: string;
+  name: string;
+  group: string;
+  value: number;
+  properties: Record<string, string | number | boolean>;
+  timestamp: number;
+  event_id: string;
+  times: number;
+}
 
 export class Telemetry {
-  private client: PostHog | null = null;
   private distinctId: string;
   private enabled: boolean;
   private pluginVersion: string;
   private log: Logger;
   private dailyPingSent = false;
   private dailyPingDate = "";
+  private buffer: ArmsEvent[] = [];
+  private flushTimer: ReturnType<typeof setInterval> | null = null;
+  private sessionId: string;
+  private firstSeenDate: string;
 
   constructor(config: TelemetryConfig, stateDir: string, pluginVersion: string, log: Logger) {
     this.log = log;
     this.pluginVersion = pluginVersion;
     this.enabled = config.enabled !== false;
     this.distinctId = this.loadOrCreateAnonymousId(stateDir);
+    this.firstSeenDate = this.loadOrCreateFirstSeen(stateDir);
+    this.sessionId = this.loadOrCreateSessionId(stateDir);
 
     if (!this.enabled) {
       this.log.debug("Telemetry disabled (opt-out via TELEMETRY_ENABLED=false)");
       return;
     }
 
-    const apiKey = config.posthogApiKey || DEFAULT_POSTHOG_API_KEY;
-    try {
-      this.client = new PostHog(apiKey, {
-        host: config.posthogHost || DEFAULT_POSTHOG_HOST,
-        flushAt: 10,
-        flushInterval: 30_000,
-      });
-      this.log.debug("Telemetry initialized (PostHog)");
-    } catch (err) {
-      this.log.warn(`Telemetry init failed: ${err}`);
-      this.enabled = false;
-    }
+    this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+    if (this.flushTimer.unref) this.flushTimer.unref();
+    this.log.debug("Telemetry initialized (ARMS)");
   }
 
   private loadOrCreateAnonymousId(stateDir: string): string {
@@ -81,24 +96,113 @@ export class Telemetry {
     return newId;
   }
 
+  private loadOrCreateSessionId(stateDir: string): string {
+    const filePath = path.join(stateDir, "memos-local", ".session");
+    try {
+      const raw = fs.readFileSync(filePath, "utf-8").trim();
+      const sep = raw.indexOf("|");
+      if (sep > 0) {
+        const ts = parseInt(raw.slice(0, sep), 10);
+        const id = raw.slice(sep + 1);
+        if (id.length > 10 && Date.now() - ts < SESSION_TTL_MS) {
+          this.touchSession(filePath, id);
+          return id;
+        }
+      }
+    } catch {}
+    const newId = uuidv4();
+    this.touchSession(filePath, newId);
+    return newId;
+  }
+
+  private touchSession(filePath: string, id: string): void {
+    try {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, `${Date.now()}|${id}`, "utf-8");
+    } catch {}
+  }
+
+  private loadOrCreateFirstSeen(stateDir: string): string {
+    const filePath = path.join(stateDir, "memos-local", ".first-seen");
+    try {
+      const existing = fs.readFileSync(filePath, "utf-8").trim();
+      if (existing.length === 10) return existing;
+    } catch {}
+    const today = new Date().toISOString().slice(0, 10);
+    try {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, today, "utf-8");
+    } catch {}
+    return today;
+  }
+
   private capture(event: string, properties?: Record<string, unknown>): void {
-    if (!this.enabled || !this.client) return;
+    if (!this.enabled) return;
+
+    const safeProps: Record<string, string | number | boolean> = {
+      plugin_version: this.pluginVersion,
+      os: os.platform(),
+      os_version: os.release(),
+      node_version: process.version,
+      arch: os.arch(),
+    };
+    if (properties) {
+      for (const [k, v] of Object.entries(properties)) {
+        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+          safeProps[k] = v;
+        }
+      }
+    }
+
+    this.buffer.push({
+      event_type: "custom",
+      type: "memos_plugin",
+      name: event,
+      group: "memos_local",
+      value: 1,
+      properties: safeProps,
+      timestamp: Date.now(),
+      event_id: uuidv4(),
+      times: 1,
+    });
+
+    if (this.buffer.length >= FLUSH_AT) {
+      this.flush();
+    }
+  }
+
+  private buildPayload(events: ArmsEvent[]): Record<string, unknown> {
+    return {
+      app: {
+        id: ARMS_PID,
+        env: ARMS_ENV,
+        version: this.pluginVersion,
+        type: "node",
+      },
+      user: { id: this.distinctId },
+      session: { id: this.sessionId },
+      net: {},
+      view: { id: "plugin", name: "memos-local-openclaw" },
+      events,
+      _v: "1.0.0",
+    };
+  }
+
+  private async flush(): Promise<void> {
+    if (this.buffer.length === 0) return;
+    const batch = this.buffer.splice(0);
+    const payload = this.buildPayload(batch);
 
     try {
-      this.client.capture({
-        distinctId: this.distinctId,
-        event,
-        properties: {
-          plugin_version: this.pluginVersion,
-          os: os.platform(),
-          os_version: os.release(),
-          node_version: process.version,
-          arch: os.arch(),
-          ...properties,
-        },
+      const resp = await fetch(ARMS_ENDPOINT, {
+        method: "POST",
+        headers: { "Content-Type": "text/plain" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
       });
-    } catch {
-      // best-effort, never throw
+      this.log.debug(`Telemetry flush: ${batch.length} events → ${resp.status}`);
+    } catch (err) {
+      this.log.debug(`Telemetry flush failed: ${err}`);
     }
   }
 
@@ -131,7 +235,7 @@ export class Telemetry {
     });
   }
 
-  trackSkillEvolved(skillName: string, upgradeType: string): void {
+  trackSkillEvolved(skillName: string, upgradeType: "created" | "upgraded"): void {
     this.capture("skill_evolved", {
       skill_name: skillName,
       upgrade_type: upgradeType,
@@ -150,19 +254,28 @@ export class Telemetry {
     });
   }
 
+  trackError(source: string, errorType: string): void {
+    this.capture("plugin_error", {
+      error_source: source,
+      error_type: errorType,
+    });
+  }
+
   private maybeSendDailyPing(): void {
     const today = new Date().toISOString().slice(0, 10);
     if (this.dailyPingSent && this.dailyPingDate === today) return;
     this.dailyPingSent = true;
     this.dailyPingDate = today;
-    this.capture("daily_active");
+    this.capture("daily_active", {
+      first_seen_date: this.firstSeenDate,
+    });
   }
 
   async shutdown(): Promise<void> {
-    if (this.client) {
-      try {
-        await this.client.shutdown();
-      } catch {}
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
     }
+    await this.flush();
   }
 }

package/src/types.ts

@@ -255,8 +255,6 @@ export interface SkillEvolutionConfig {
 
 export interface TelemetryConfig {
   enabled?: boolean;
-  posthogApiKey?: string;
-  posthogHost?: string;
 }
 
 export type SharingRole = "hub" | "client";
@@ -277,6 +275,7 @@ export interface ClientModeConfig {
   hubAddress?: string;
   userToken?: string;
   teamToken?: string;
+  nickname?: string;
   pendingUserId?: string;
 }