@markus-global/cli 0.7.13 → 0.8.0

package/dist/markus.mjs

@@ -3791,6 +3791,34 @@ var init_model_catalog = __esm({
   }
 });
 
+// ../shared/dist/types/license.js
+var PLAN_LIMITS, ENTERPRISE_FEATURES;
+var init_license = __esm({
+  "../shared/dist/types/license.js"() {
+    "use strict";
+    PLAN_LIMITS = {
+      free: {
+        maxTeams: 1,
+        maxToolCallsPerDay: 500,
+        maxUsers: 1
+      },
+      enterprise: {
+        maxTeams: -1,
+        maxToolCallsPerDay: -1,
+        maxUsers: -1
+      }
+    };
+    ENTERPRISE_FEATURES = [
+      "multi_user",
+      "unlimited_teams",
+      "unlimited_tools",
+      "sso",
+      "audit_enhanced",
+      "multi_instance"
+    ];
+  }
+});
+
 // ../shared/dist/utils/config.js
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { resolve, join } from "node:path";
@@ -4515,6 +4543,7 @@ __export(dist_exports, {
   CognitiveDepth: () => CognitiveDepth,
   DELIBERATION_ALLOWED_TOOLS: () => DELIBERATION_ALLOWED_TOOLS,
   DELIVERABLE_TITLE_CHARS: () => DELIVERABLE_TITLE_CHARS,
+  ENTERPRISE_FEATURES: () => ENTERPRISE_FEATURES,
   ENTITY_COMMENTS_DEFAULT: () => ENTITY_COMMENTS_DEFAULT,
   HEARTBEAT_DAILY_LOG_CHARS: () => HEARTBEAT_DAILY_LOG_CHARS,
   HEARTBEAT_MIN_INITIAL_DELAY_MS: () => HEARTBEAT_MIN_INITIAL_DELAY_MS,
@@ -4533,6 +4562,7 @@ __export(dist_exports, {
   MEMORY_MD_SECTION_MAX_CHARS: () => MEMORY_MD_SECTION_MAX_CHARS,
   MEMORY_MD_TOTAL_MAX_CHARS: () => MEMORY_MD_TOTAL_MAX_CHARS,
   MailboxPriorityLevel: () => MailboxPriorityLevel,
+  PLAN_LIMITS: () => PLAN_LIMITS,
   PREEMPT_REQUEUE_DELAY_MS: () => PREEMPT_REQUEUE_DELAY_MS,
   PRIORITY_LABELS: () => PRIORITY_LABELS,
   PROMPT_DEP_DESC_CHARS: () => PROMPT_DEP_DESC_CHARS,
@@ -4653,6 +4683,7 @@ var init_dist = __esm({
     init_mailbox();
     init_cognitive();
     init_model_catalog();
+    init_license();
     init_config();
     init_logger();
     init_id();
@@ -41975,14 +42006,14 @@ var require_turndown_cjs = __commonJS({
         } else if (node.nodeType === 1) {
           replacement = replacementForNode.call(self, node);
         }
-        return join33(output, replacement);
+        return join35(output, replacement);
       }, "");
     }
     function postProcess(output) {
       var self = this;
       this.rules.forEach(function(rule) {
         if (typeof rule.append === "function") {
-          output = join33(output, rule.append(self.options));
+          output = join35(output, rule.append(self.options));
         }
       });
       return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -41994,7 +42025,7 @@ var require_turndown_cjs = __commonJS({
       if (whitespace2.leading || whitespace2.trailing) content = content.trim();
       return whitespace2.leading + rule.replacement(content, node, this.options) + whitespace2.trailing;
     }
-    function join33(output, replacement) {
+    function join35(output, replacement) {
       var s1 = trimTrailingNewlines(output);
       var s2 = trimLeadingNewlines(replacement);
       var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
@@ -44727,7 +44758,8 @@ var init_attention = __esm({
                 }
                 await this.processFocusedItem(item);
               } catch (err) {
-                log14.error("Attention loop iteration failed \u2014 requeueing item and continuing", {
+                const isUserInteraction = _AttentionController.USER_INTERACTION_TYPES.has(item.sourceType);
+                log14.error(`Attention loop iteration failed \u2014 ${isUserInteraction ? "completing" : "requeueing"} item and continuing`, {
                   agentId: this.agentId,
                   itemId: item.id,
                   type: item.sourceType,
@@ -44738,9 +44770,16 @@ var init_attention = __esm({
                 this.interruptSignal = false;
                 this.pendingInterruptItem = void 0;
                 this.lastYieldDecision = void 0;
-                try {
-                  this.mailbox.requeue(item);
-                } catch {
+                if (isUserInteraction) {
+                  try {
+                    this.mailbox.complete(item.id);
+                  } catch {
+                  }
+                } else {
+                  try {
+                    this.mailbox.requeue(item);
+                  } catch {
+                  }
                 }
               }
             } catch (outerErr) {
@@ -44841,15 +44880,33 @@ var init_attention = __esm({
         } else {
           const abnormalReason = detectAbnormalCompletion(reply, item);
           const retries = item.retryCount ?? 0;
+          const isUserInteraction = _AttentionController.USER_INTERACTION_TYPES.has(item.sourceType);
           if (abnormalReason && retries < MAILBOX_ITEM_MAX_RETRIES) {
-            log14.warn("Abnormal completion detected, requeueing for retry", {
-              agentId: this.agentId,
-              itemId: item.id,
-              type: item.sourceType,
-              retryCount: retries + 1,
-              reason: abnormalReason
-            });
-            this.mailbox.requeue(item);
+            if (abnormalReason === "completion marker missing from reply") {
+              log14.warn("Completion marker still missing after in-session continuation \u2014 completing without retry", {
+                agentId: this.agentId,
+                itemId: item.id,
+                type: item.sourceType
+              });
+              this.mailbox.complete(item.id);
+            } else if (isUserInteraction) {
+              log14.warn("Abnormal completion for user interaction \u2014 completing without retry", {
+                agentId: this.agentId,
+                itemId: item.id,
+                type: item.sourceType,
+                reason: abnormalReason
+              });
+              this.mailbox.complete(item.id);
+            } else {
+              log14.warn("Abnormal completion detected, requeueing for retry", {
+                agentId: this.agentId,
+                itemId: item.id,
+                type: item.sourceType,
+                retryCount: retries + 1,
+                reason: abnormalReason
+              });
+              this.mailbox.requeue(item);
+            }
           } else {
             if (abnormalReason) {
               log14.error("Abnormal completion persisted after max retries, completing anyway", {
@@ -46779,6 +46836,7 @@ var init_agent2 = __esm({
       auditCallback;
       escalationCallback;
       approvalCallback;
+      toolCallLimitChecker;
       tasksFetcher;
       consecutiveFailures = 0;
       metricsCollector;
@@ -47328,6 +47386,57 @@ ${notification.stdoutTail}`);
           }
         };
       }
+      /**
+       * If the reply is missing the required completion marker, inject a
+       * continuation prompt into the existing session and make one more LLM
+       * call to obtain it — instead of letting the attention controller
+       * requeue the entire item from scratch (which duplicates side effects).
+       *
+       * Limited to a single attempt; if the marker is still missing afterwards
+       * the reply is returned as-is and the attention controller will complete
+       * the item without retry.
+       */
+      async ensureCompletionMarker(reply, sessionId) {
+        if (!reply || reply === "[cancelled]" || reply === "[preempted]" || reply === "[merged]")
+          return reply;
+        if (reply.includes(COMPLETION_MARKER))
+          return reply;
+        if (!sessionId || !this.memory.getSession(sessionId))
+          return reply;
+        log17.info("Completion marker missing \u2014 continuing in-session to obtain marker", {
+          agentId: this.id,
+          sessionId,
+          replyLength: reply.length
+        });
+        this.memory.appendMessage(sessionId, {
+          role: "user",
+          content: `[SYSTEM] Your previous response did not include the required completion marker. You MUST end your response with exactly: ${COMPLETION_MARKER}`
+        });
+        try {
+          const sessionMessages = this.memory.getRecentMessages(sessionId, 50);
+          const prepared = await this.contextEngine.prepareMessages({
+            systemPrompt: "You are completing a previous response. Finish any remaining work and end your response with the required completion marker.",
+            sessionMessages,
+            memory: this.memory,
+            sessionId,
+            agentId: this.id,
+            modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
+            modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
+            toolDefinitions: []
+          });
+          const continuation = await this.llmRouter.chat({ messages: prepared.messages }, this.getEffectiveProvider());
+          const contReply = continuation.content ?? "";
+          this.memory.appendMessage(sessionId, { role: "assistant", content: contReply });
+          return reply + contReply;
+        } catch (err) {
+          log17.warn("Failed to obtain completion marker via continuation \u2014 returning original reply", {
+            agentId: this.id,
+            sessionId,
+            error: String(err)
+          });
+          return reply;
+        }
+      }
       /**
        * Route a mailbox item to the appropriate Agent processing method.
        * Options like sessionId/images/scenario are forwarded from payload.extra
@@ -47410,7 +47519,9 @@ ${item.payload.content}` + batchSuffix;
                     itemId: item.id
                   });
                 } else {
-                  const reply2 = await this.handleMessageStream(item.payload.content + markerSuffix, extra.onEvent, item.metadata?.senderId, senderInfo, ct, extra.images, extra.fileNames);
+                  let reply2 = await this.handleMessageStream(item.payload.content + markerSuffix, extra.onEvent, item.metadata?.senderId, senderInfo, ct, extra.images, extra.fileNames);
+                  if (needsMarker)
+                    reply2 = await this.ensureCompletionMarker(reply2, this.currentSessionId);
                   resolveResponse(reply2);
                   return reply2;
                 }
@@ -47424,7 +47535,9 @@ ${item.payload.content}` + batchSuffix;
               const opts = buildHandleOpts(defaults);
               if (item.sourceType === "a2a_message")
                 opts.scenario = "a2a";
-              const reply = await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, senderInfo, opts);
+              let reply = await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, senderInfo, opts);
+              if (needsMarker)
+                reply = await this.ensureCompletionMarker(reply, opts.sessionId ?? this.currentSessionId);
               resolveResponse(reply);
               return reply;
             }
@@ -47454,7 +47567,10 @@ ${item.payload.content}` + batchSuffix;
               return;
             }
             case "mention": {
-              const reply = await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, senderInfo, buildHandleOpts({ sessionId: `sys_${this.id}_${ts}`, scenario: "a2a" }));
+              const mentionSessionId = `sys_${this.id}_${ts}`;
+              let reply = await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, senderInfo, buildHandleOpts({ sessionId: mentionSessionId, scenario: "a2a" }));
+              if (needsMarker)
+                reply = await this.ensureCompletionMarker(reply, mentionSessionId);
               resolveResponse(reply);
               return reply;
             }
@@ -47492,7 +47608,10 @@ ${item.payload.content}` + batchSuffix;
               return;
             }
             case "review_request": {
-              const reply = await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, item.metadata?.senderName ? { name: item.metadata.senderName, role: item.metadata.senderRole ?? "worker" } : void 0, buildHandleOpts({ sessionId: `review_${this.id}_${ts}`, scenario: "review" }));
+              const reviewSessionId = `review_${this.id}_${ts}`;
+              let reply = await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, item.metadata?.senderName ? { name: item.metadata.senderName, role: item.metadata.senderRole ?? "worker" } : void 0, buildHandleOpts({ sessionId: reviewSessionId, scenario: "review" }));
+              if (needsMarker)
+                reply = await this.ensureCompletionMarker(reply, reviewSessionId);
               resolveResponse(reply);
               return reply;
             }
@@ -47507,12 +47626,18 @@ ${item.payload.content}` + batchSuffix;
             }
             case "system_event":
             case "daily_report": {
-              const reply = await this.handleMessage(item.payload.content + markerSuffix, void 0, void 0, buildHandleOpts({ sessionId: `sys_${this.id}_${ts}`, scenario: "heartbeat" }));
+              const sysSessionId = `sys_${this.id}_${ts}`;
+              let reply = await this.handleMessage(item.payload.content + markerSuffix, void 0, void 0, buildHandleOpts({ sessionId: sysSessionId, scenario: "heartbeat" }));
+              if (needsMarker)
+                reply = await this.ensureCompletionMarker(reply, sysSessionId);
               resolveResponse(reply);
               return reply;
             }
             case "memory_consolidation": {
-              const reply = await this.handleMessage(item.payload.content + markerSuffix, void 0, void 0, buildHandleOpts({ sessionId: `sys_${this.id}_${ts}`, scenario: "memory_consolidation" }));
+              const memSessionId = `sys_${this.id}_${ts}`;
+              let reply = await this.handleMessage(item.payload.content + markerSuffix, void 0, void 0, buildHandleOpts({ sessionId: memSessionId, scenario: "memory_consolidation" }));
+              if (needsMarker)
+                reply = await this.ensureCompletionMarker(reply, memSessionId);
               resolveResponse(reply);
               return reply;
             }
@@ -47521,11 +47646,16 @@ ${item.payload.content}` + batchSuffix;
               const onLog = extra.onLog ?? (() => {
               });
               if (sessionId) {
-                const reply2 = await this.respondInSession(sessionId, item.payload.content + markerSuffix, onLog);
+                let reply2 = await this.respondInSession(sessionId, item.payload.content + markerSuffix, onLog);
+                if (needsMarker)
+                  reply2 = await this.ensureCompletionMarker(reply2, sessionId);
                 resolveResponse(reply2);
                 return reply2;
               }
-              const reply = await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, senderInfo, buildHandleOpts({ sessionId: `sys_${this.id}_${ts}` }));
+              const srFallbackSessionId = `sys_${this.id}_${ts}`;
+              let reply = await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, senderInfo, buildHandleOpts({ sessionId: srFallbackSessionId }));
+              if (needsMarker)
+                reply = await this.ensureCompletionMarker(reply, srFallbackSessionId);
               resolveResponse(reply);
               return reply;
             }
@@ -48493,6 +48623,9 @@ ${instructions}
       setEscalationCallback(cb) {
         this.escalationCallback = cb;
       }
+      setToolCallLimitChecker(cb) {
+        this.toolCallLimitChecker = cb;
+      }
       setStateChangeCallback(cb) {
         this.stateChangeCallback = cb;
       }
@@ -48640,16 +48773,16 @@ ${instructions}
         const toolNames = /* @__PURE__ */ new Set();
         const errors = [];
         let lastText = "";
-        for (const log89 of logs) {
-          if (log89.type === "tool_start") {
-            const name = log89.metadata?.toolName ?? "";
+        for (const log91 of logs) {
+          if (log91.type === "tool_start") {
+            const name = log91.metadata?.toolName ?? "";
             if (name)
               toolNames.add(name);
           }
-          if (log89.type === "error")
-            errors.push(log89.content.slice(0, 100));
-          if (log89.type === "text")
-            lastText = log89.content.slice(0, 200);
+          if (log91.type === "error")
+            errors.push(log91.content.slice(0, 100));
+          if (log91.type === "text")
+            lastText = log91.content.slice(0, 200);
         }
         const parts = [];
         if (toolNames.size > 0)
@@ -51040,6 +51173,15 @@ ${body}${contextSuffix}`;
             error: beforeResult.reason ?? "Blocked by tool hook"
           });
         }
+        if (this.toolCallLimitChecker) {
+          const limitResult = this.toolCallLimitChecker();
+          if (!limitResult.allowed) {
+            return JSON.stringify({
+              status: "denied",
+              error: limitResult.reason ?? "Tool call limit reached"
+            });
+          }
+        }
         const baseArgs = beforeResult.modifiedArgs ?? toolCall.arguments;
         const effectiveArgs = sessionId ? { ...baseArgs, _browserSessionId: sessionId } : baseArgs;
         let lastError;
@@ -57831,6 +57973,7 @@ var init_agent_manager = __esm({
       agentAuditCallback;
       escalationHandler;
       approvalHandler;
+      toolCallLimitChecker;
       stateChangeHandler;
       /** Grace timers for releasing scoped MCP processes after agent goes idle */
       mcpReleaseTimers = /* @__PURE__ */ new Map();
@@ -58812,6 +58955,9 @@ Known issues: ${knownIssues}` : ""}`
           const ah = this.approvalHandler;
           agent.setApprovalCallback(async (req) => ah(id, req));
         }
+        if (this.toolCallLimitChecker) {
+          agent.setToolCallLimitChecker(this.toolCallLimitChecker);
+        }
         agent.setStateChangeCallback(this.buildStateChangeCallback());
         if (this.activityCallbacks) {
           agent.setActivityCallbacks(this.activityCallbacks);
@@ -59446,6 +59592,9 @@ Known issues: ${knownIssues}` : ""}`
           const ah = this.approvalHandler;
           agent.setApprovalCallback(async (req) => ah(id, req));
         }
+        if (this.toolCallLimitChecker) {
+          agent.setToolCallLimitChecker(this.toolCallLimitChecker);
+        }
         agent.setStateChangeCallback(this.buildStateChangeCallback());
         if (this.activityCallbacks) {
           agent.setActivityCallbacks(this.activityCallbacks);
@@ -59592,6 +59741,12 @@ Known issues: ${knownIssues}` : ""}`
           agent.setApprovalCallback(async (req) => handler4(id, req));
         }
       }
+      setToolCallLimitChecker(checker) {
+        this.toolCallLimitChecker = checker;
+        for (const [, agent] of this.agents) {
+          agent.setToolCallLimitChecker(checker);
+        }
+      }
       /**
        * Build the combined state-change callback for an agent. Handles:
        * 1. MCP scoped-process lifecycle (release on idle, cancel release on working)
@@ -63859,7 +64014,7 @@ var init_external_gateway = __esm({
         return rows.length;
       }
       async register(request) {
-        const { externalAgentId, agentName, orgId: orgId2, capabilities = [], platform: platform4, platformConfig, agentCardUrl, openClawConfig } = request;
+        const { externalAgentId, agentName, orgId: orgId2, capabilities = [], platform: platform5, platformConfig, agentCardUrl, openClawConfig } = request;
         if (!externalAgentId || !agentName || !orgId2) {
           throw new GatewayError("Missing required fields: externalAgentId, agentName, orgId", 400);
         }
@@ -63886,7 +64041,7 @@ var init_external_gateway = __esm({
           agentName,
           orgId: orgId2,
           capabilities,
-          platform: platform4 ?? (openClawConfig ? "openclaw" : void 0),
+          platform: platform5 ?? (openClawConfig ? "openclaw" : void 0),
           platformConfig: platformConfig ?? openClawConfig,
           agentCardUrl,
           openClawConfig,
@@ -76683,8 +76838,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static parseFileSync(filePath) {
-        const { readFileSync: readFileSync29 } = __require("fs");
-        const data = readFileSync29(filePath, "utf8");
+        const { readFileSync: readFileSync31 } = __require("fs");
+        const data = readFileSync31(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -82013,6 +82168,8 @@ var init_api_server = __esm({
       hitlService;
       billingService;
       auditService;
+      licenseService;
+      telemetryService;
       storage;
       llmRouter;
       markusConfigPath;
@@ -82032,7 +82189,40 @@ var init_api_server = __esm({
       remoteAgent;
       remoteAgentFactory;
       modelCatalog;
-      // Custom group chats are now persisted in SQLite via storage.groupChatRepo
+      /** Aggregate today's tool calls from all agents' persisted metrics (the single source of truth) */
+      getToolCallsTodayFromAgents() {
+        try {
+          const agentManager = this.orgService.getAgentManager();
+          const allAgents = agentManager.listAgents();
+          let total = 0;
+          for (const a of allAgents) {
+            try {
+              const agent = agentManager.getAgent(a.id);
+              total += agent.getUsageStats().toolCallsToday;
+            } catch {
+            }
+          }
+          return total;
+        } catch {
+          return 0;
+        }
+      }
+      /** fetch that follows redirects while preserving the Authorization header */
+      async hubFetch(url, init) {
+        let currentUrl = url;
+        for (let i = 0; i < 3; i++) {
+          const res = await fetch(currentUrl, { ...init, redirect: "manual" });
+          if (res.status >= 300 && res.status < 400) {
+            const location = res.headers.get("location");
+            if (!location)
+              return res;
+            currentUrl = new URL(location, currentUrl).href;
+            continue;
+          }
+          return res;
+        }
+        return fetch(currentUrl, init);
+      }
       constructor(orgService, taskService, port = 8056) {
         this.orgService = orgService;
         this.taskService = taskService;
@@ -82241,7 +82431,7 @@ ${cleanText}`,
             const headers = { "Content-Type": "application/json" };
             if (token)
               headers["Authorization"] = `Bearer ${token}`;
-            const res = await fetch(`${hubUrl}/api/items${qs ? `?${qs}` : ""}`, { headers });
+            const res = await self.hubFetch(`${hubUrl}/api/items${qs ? `?${qs}` : ""}`, { headers });
             if (!res.ok)
               throw new Error(`Hub search failed: ${res.status}`);
             const data = await res.json();
@@ -82261,7 +82451,7 @@ ${cleanText}`,
             if (!token)
               throw new Error("Hub token not configured. Please login to Markus Hub first.");
             const headers = { "Content-Type": "application/json", "Authorization": `Bearer ${token}` };
-            const res = await fetch(`${hubUrl}/api/items/${itemId}/download`, { method: "POST", headers });
+            const res = await self.hubFetch(`${hubUrl}/api/items/${itemId}/download`, { method: "POST", headers });
             if (!res.ok)
               throw new Error(`Hub download failed: ${res.status}`);
             const data = await res.json();
@@ -82295,6 +82485,12 @@ ${cleanText}`,
       setBillingService(service) {
         this.billingService = service;
       }
+      setLicenseService(service) {
+        this.licenseService = service;
+      }
+      setTelemetryService(service) {
+        this.telemetryService = service;
+      }
       setAuditService(service) {
         this.auditService = service;
       }
@@ -83047,12 +83243,18 @@ ${cleanText}`,
         }
         if (path === "/api/auth/status" && req.method === "GET") {
           if (!this.storage || !this.authEnabled) {
-            this.json(res, 200, { initialized: true });
+            this.json(res, 200, { initialized: true, hasOwner: true, hasMultipleUsers: false });
             return;
           }
           const allUsers = await this.storage.userRepo.listByOrg("default");
-          const hasRealUsers = allUsers.some((u) => u.passwordHash && u.email !== "admin@markus.local");
-          this.json(res, 200, { initialized: hasRealUsers });
+          const realUsers = allUsers.filter((u) => (u.passwordHash || u.hubUserId) && u.email !== "admin@markus.local");
+          const hasOwner = realUsers.some((u) => u.role === "owner");
+          const hasMultipleUsers = realUsers.length > 1;
+          this.json(res, 200, {
+            initialized: realUsers.length > 0,
+            hasOwner,
+            hasMultipleUsers
+          });
           return;
         }
         if (path === "/api/auth/init" && req.method === "POST") {
@@ -83154,6 +83356,135 @@ ${cleanText}`,
           });
           return;
         }
+        if (path === "/api/auth/hub-login" && req.method === "POST") {
+          if (!this.storage) {
+            this.json(res, 503, { error: "Storage not available" });
+            return;
+          }
+          const body = await this.readBody(req);
+          const hubToken = body["hubToken"];
+          const hubUser = body["hubUser"];
+          if (!hubToken || !hubUser?.id) {
+            this.json(res, 400, { error: "hubToken and hubUser are required" });
+            return;
+          }
+          let verifiedUser = null;
+          try {
+            const verifyRes = await this.hubFetch(`${this.hubUrl}/api/auth/me`, {
+              headers: { "Authorization": `Bearer ${hubToken}` }
+            });
+            if (verifyRes.ok) {
+              const verifyData = await verifyRes.json();
+              if (verifyData.user && verifyData.user.id === hubUser.id) {
+                verifiedUser = verifyData.user;
+              } else {
+                log61.warn("Hub token user mismatch", { expected: hubUser.id, got: verifyData.user?.id });
+              }
+            } else {
+              log61.warn("Hub /api/auth/me returned non-OK", { status: verifyRes.status, hubUrl: this.hubUrl });
+            }
+          } catch (e) {
+            log61.warn("Hub token verification failed, proceeding with client-supplied data", { error: e.message, hubUrl: this.hubUrl });
+          }
+          if (!verifiedUser) {
+            verifiedUser = { id: hubUser.id, username: hubUser.username, email: hubUser.email, displayName: hubUser.displayName, avatarUrl: hubUser.avatarUrl };
+          }
+          const rawEmail = (verifiedUser.email ?? hubUser.email ?? "").trim().toLowerCase();
+          const email = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(rawEmail) ? rawEmail : "";
+          const name = verifiedUser.displayName || verifiedUser.username || hubUser.displayName || hubUser.username || email && email.split("@")[0] || "User";
+          const avatarUrl = verifiedUser.avatarUrl ?? hubUser.avatarUrl ?? null;
+          let userRow = this.storage.userRepo.findByHubUserId(hubUser.id);
+          let isFirstLogin = false;
+          if (!userRow && email) {
+            userRow = this.storage.userRepo.findByEmail(email);
+            if (userRow) {
+              this.storage.userRepo.updateHubUserId(userRow.id, hubUser.id, hubUser.username);
+              if (avatarUrl && !userRow.avatarUrl) {
+                this.storage.userRepo.updateAvatarUrl(userRow.id, avatarUrl);
+              }
+            }
+          }
+          if (!userRow) {
+            const allUsers = await this.storage.userRepo.listByOrg("default");
+            const placeholder = allUsers.find((u) => u.role === "owner" && u.email === "admin@markus.local");
+            const hasRealOwner = allUsers.some((u) => u.role === "owner" && (u.passwordHash || u.hubUserId) && u.email !== "admin@markus.local");
+            if (placeholder && !hasRealOwner) {
+              this.storage.userRepo.updateProfile(placeholder.id, { name, email: email || void 0, avatarUrl });
+              this.storage.userRepo.updateHubUserId(placeholder.id, hubUser.id, hubUser.username);
+              userRow = this.storage.userRepo.findById(placeholder.id);
+              isFirstLogin = true;
+            } else if (!hasRealOwner) {
+              const userId2 = userId();
+              this.storage.userRepo.create({
+                id: userId2,
+                orgId: "default",
+                name,
+                email: email || void 0,
+                role: "owner",
+                hubUserId: hubUser.id,
+                avatarUrl: avatarUrl ?? void 0
+              });
+              this.storage.userRepo.updateHubUserId(userId2, hubUser.id, hubUser.username);
+              userRow = this.storage.userRepo.findById(userId2);
+              isFirstLogin = true;
+            } else {
+              const realOwners = allUsers.filter((u) => u.role === "owner" && (u.passwordHash || u.hubUserId) && u.email !== "admin@markus.local");
+              if (realOwners.length === 1 && !realOwners[0].hubUserId) {
+                const existingOwner = realOwners[0];
+                this.storage.userRepo.updateProfile(existingOwner.id, { name: existingOwner.name, email: email || existingOwner.email, avatarUrl: avatarUrl ?? existingOwner.avatarUrl });
+                this.storage.userRepo.updateHubUserId(existingOwner.id, hubUser.id, hubUser.username);
+                userRow = this.storage.userRepo.findById(existingOwner.id);
+                log61.info("Hub login: adopted existing owner", { ownerId: existingOwner.id, hubUserId: hubUser.id });
+              } else {
+                this.json(res, 403, { error: "This instance already has an owner. Multi-user requires Enterprise license." });
+                return;
+              }
+            }
+          }
+          if (!userRow) {
+            this.json(res, 500, { error: "Failed to create user" });
+            return;
+          }
+          const hubUsername = verifiedUser.username || hubUser.username;
+          if (hubUsername) {
+            this.storage.userRepo.updateHubUserId(userRow.id, hubUser.id, hubUsername);
+          }
+          const profileUpdates = {};
+          if (name && name !== userRow.name)
+            profileUpdates.name = name;
+          if (email && email !== userRow.email)
+            profileUpdates.email = email;
+          if (avatarUrl && avatarUrl !== userRow.avatarUrl)
+            profileUpdates.avatarUrl = avatarUrl;
+          if (Object.keys(profileUpdates).length > 0) {
+            this.storage.userRepo.updateProfile(userRow.id, profileUpdates);
+            userRow = this.storage.userRepo.findById(userRow.id);
+          }
+          this.orgService.syncHumanIdentity(userRow.id, "default", userRow.name, userRow.role, userRow.email ?? void 0);
+          try {
+            const tokenPath = join24(homedir15(), ".markus", "hub-token");
+            mkdirSync19(dirname8(tokenPath), { recursive: true });
+            writeFileSync17(tokenPath, hubToken, "utf-8");
+          } catch {
+          }
+          const finalUser = userRow;
+          await this.storage.userRepo.updateLastLogin(finalUser.id);
+          const exp = Math.floor(Date.now() / 1e3) + 7 * 24 * 3600;
+          const token = await signToken({ userId: finalUser.id, orgId: "default", role: finalUser.role, exp }, this.jwtSecret);
+          res.setHeader("Set-Cookie", `markus_token=${token}; HttpOnly; SameSite=Strict; Path=/; Max-Age=${7 * 24 * 3600}`);
+          this.json(res, 200, {
+            user: {
+              id: finalUser.id,
+              name: finalUser.name,
+              email: finalUser.email,
+              role: finalUser.role,
+              orgId: finalUser.orgId,
+              avatarUrl: finalUser.avatarUrl ?? void 0
+            },
+            needsOnboarding: isFirstLogin
+          });
+          return;
+        }
         if (path === "/api/auth/logout" && req.method === "POST") {
           res.setHeader("Set-Cookie", "markus_token=; HttpOnly; SameSite=Strict; Path=/; Max-Age=0");
           this.json(res, 200, { ok: true });
@@ -84242,6 +84573,16 @@ ${cleanText}`,
             this.json(res, 400, { error: "name is required" });
             return;
           }
+          if (this.licenseService) {
+            const limits = this.licenseService.getLimits();
+            if (limits.maxTeams > 0) {
+              const existingTeams = await this.orgService.listTeams(orgId2);
+              if (existingTeams.length >= limits.maxTeams) {
+                this.json(res, 403, { error: `Team limit reached (${limits.maxTeams}). Upgrade to Enterprise for unlimited teams.` });
+                return;
+              }
+            }
+          }
           const team = await this.orgService.createTeam(orgId2, name, body["description"]);
           this.ws?.broadcast({
             type: "chat:group_created",
@@ -86372,6 +86713,16 @@ EXPLANATION_END`;
           const authUser = await this.requireAuth(req, res);
           if (!authUser)
             return;
+          if (this.licenseService && this.storage) {
+            const limits = this.licenseService.getLimits();
+            if (limits.maxUsers > 0) {
+              const existingCount = this.storage.userRepo.countByOrg("default");
+              if (existingCount >= limits.maxUsers) {
+                this.json(res, 403, { error: `User limit reached (${limits.maxUsers}). Upgrade to Enterprise for multi-user support.` });
+                return;
+              }
+            }
+          }
           const body = await this.readBody(req);
           const orgId2 = body["orgId"] ?? "default";
           const name = body["name"];
@@ -86652,14 +87003,14 @@ EXPLANATION_END`;
           const installedSkills = new Map((this.skillRegistry?.list() ?? []).map((s2) => [s2.name, s2]));
           const rawManifests = /* @__PURE__ */ new Map();
           try {
-            const { readdirSync: readdirSync14, readFileSync: readFileSync29, existsSync: existsSync40 } = await import("node:fs");
+            const { readdirSync: readdirSync14, readFileSync: readFileSync31, existsSync: existsSync42 } = await import("node:fs");
             for (const entry of readdirSync14(builtinDir, { withFileTypes: true })) {
               if (!entry.isDirectory())
                 continue;
               const sjPath = resolve15(builtinDir, entry.name, "skill.json");
-              if (existsSync40(sjPath)) {
+              if (existsSync42(sjPath)) {
                 try {
-                  rawManifests.set(entry.name, JSON.parse(readFileSync29(sjPath, "utf-8")));
+                  rawManifests.set(entry.name, JSON.parse(readFileSync31(sjPath, "utf-8")));
                 } catch {
                 }
               }
@@ -87086,6 +87437,16 @@ EXPLANATION_END`;
               this.json(res, 500, { error: "BuilderService not initialized" });
               return;
             }
+            if (type === "team" && this.licenseService) {
+              const limits = this.licenseService.getLimits();
+              if (limits.maxTeams > 0) {
+                const existingTeams = await this.orgService.listTeams("default");
+                if (existingTeams.length >= limits.maxTeams) {
+                  this.json(res, 403, { error: `Team limit reached (${limits.maxTeams}). Upgrade to Enterprise for unlimited teams.` });
+                  return;
+                }
+              }
+            }
             try {
               const result = await this.builderService.installArtifact(type, name);
               this.json(res, 201, result);
@@ -88101,11 +88462,11 @@ EXPLANATION_END`;
         }
         if (path === "/api/templates/teams" && req.method === "GET") {
           try {
-            const { readdirSync: readdirSync14, readFileSync: readFileSync29 } = await import("node:fs");
+            const { readdirSync: readdirSync14, readFileSync: readFileSync31 } = await import("node:fs");
             const { resolve: resolve21 } = await import("node:path");
             const teamsDir = resolve21(process.cwd(), "templates", "teams");
             const files = readdirSync14(teamsDir).filter((f) => f.endsWith(".json"));
-            const teams = files.map((f) => JSON.parse(readFileSync29(resolve21(teamsDir, f), "utf-8")));
+            const teams = files.map((f) => JSON.parse(readFileSync31(resolve21(teamsDir, f), "utf-8")));
             this.json(res, 200, { templates: teams });
           } catch {
             this.json(res, 200, { templates: [] });
@@ -88146,6 +88507,183 @@ EXPLANATION_END`;
           this.json(res, 200, { usage });
           return;
         }
+        if (path === "/api/license" && req.method === "GET") {
+          const raw = this.licenseService ? this.licenseService.getInfo() : { plan: "free", features: [], limits: { maxTeams: 1, maxToolCallsPerDay: 500, maxUsers: 1 } };
+          const info2 = { ...raw };
+          const authUser = await this.getAuthUser(req);
+          if (authUser && this.storage) {
+            const userRow = this.storage.userRepo.findById(authUser.userId);
+            if (userRow) {
+              if (userRow.hubUserId)
+                info2.hubUserId = userRow.hubUserId;
+              info2.username = userRow.hubUsername || userRow.name || void 0;
+            }
+          }
+          try {
+            const defaultOrg = this.orgService.getDefaultOrganization();
+            const orgId2 = defaultOrg?.id ?? "default";
+            const teams = this.orgService.listTeams(orgId2);
+            const humans = this.orgService.listHumanUsers(orgId2);
+            const todayToolCalls = this.getToolCallsTodayFromAgents();
+            info2.usage = { teams: teams.length, toolCallsToday: todayToolCalls, users: humans.length };
+          } catch {
+          }
+          const hubToken = this.readHubToken();
+          if (hubToken) {
+            try {
+              const meRes = await this.hubFetch(`${this.hubUrl}/api/auth/me`, {
+                headers: { "Authorization": `Bearer ${hubToken}` }
+              });
+              if (meRes.ok) {
+                const meData = await meRes.json();
+                if (meData.defaultOrg) {
+                  info2.defaultOrg = meData.defaultOrg;
+                  if (!info2.orgId)
+                    info2.orgId = meData.defaultOrg.id;
+                  if (!info2.orgName)
+                    info2.orgName = meData.defaultOrg.name;
+                }
+                if (meData.user?.id && !info2.hubUserId)
+                  info2.hubUserId = meData.user.id;
+              }
+            } catch {
+            }
+          }
+          this.json(res, 200, info2);
+          return;
+        }
+        if (path === "/api/license/refresh" && req.method === "POST") {
+          if (!this.licenseService) {
+            this.json(res, 503, { error: "License service not available" });
+            return;
+          }
+          const raw = await this.licenseService.revalidate();
+          if (this.billingService)
+            this.billingService.setOrgPlan("default", this.licenseService.getPlan());
+          const info2 = { ...raw };
+          const authUser = await this.getAuthUser(req);
+          if (authUser && this.storage) {
+            const userRow = this.storage.userRepo.findById(authUser.userId);
+            if (userRow) {
+              if (userRow.hubUserId)
+                info2.hubUserId = userRow.hubUserId;
+              info2.username = userRow.hubUsername || userRow.name || void 0;
+            }
+          }
+          try {
+            const defaultOrg = this.orgService.getDefaultOrganization();
+            const orgId2 = defaultOrg?.id ?? "default";
+            const teams = this.orgService.listTeams(orgId2);
+            const humans = this.orgService.listHumanUsers(orgId2);
+            const todayToolCalls = this.getToolCallsTodayFromAgents();
+            info2.usage = { teams: teams.length, toolCallsToday: todayToolCalls, users: humans.length };
+          } catch {
+          }
+          const hubToken = this.readHubToken();
+          if (hubToken) {
+            try {
+              const meRes = await this.hubFetch(`${this.hubUrl}/api/auth/me`, {
+                headers: { "Authorization": `Bearer ${hubToken}` }
+              });
+              if (meRes.ok) {
+                const meData = await meRes.json();
+                if (meData.defaultOrg) {
+                  info2.defaultOrg = meData.defaultOrg;
+                  if (!info2.orgId)
+                    info2.orgId = meData.defaultOrg.id;
+                  if (!info2.orgName)
+                    info2.orgName = meData.defaultOrg.name;
+                }
+                if (meData.user?.id && !info2.hubUserId)
+                  info2.hubUserId = meData.user.id;
+              }
+            } catch {
+            }
+          }
+          this.json(res, 200, info2);
+          return;
+        }
+        if (path === "/api/license/activate" && req.method === "POST") {
+          const authUser = await this.requireAuth(req, res);
+          if (!authUser)
+            return;
+          if (!this.licenseService) {
+            this.json(res, 503, { error: "License service not available" });
+            return;
+          }
+          const body = await this.readBody(req);
+          const licenseKey = body["licenseKey"];
+          if (!licenseKey) {
+            this.json(res, 400, { error: "licenseKey is required" });
+            return;
+          }
+          const result = await this.licenseService.activateLicense(licenseKey);
+          if (result.success && this.billingService)
+            this.billingService.setOrgPlan("default", this.licenseService.getPlan());
+          this.json(res, result.success ? 200 : 400, result);
+          return;
+        }
+        if (path === "/api/license/trial" && req.method === "POST") {
+          const authUser = await this.requireAuth(req, res);
+          if (!authUser)
+            return;
+          if (!this.licenseService) {
+            this.json(res, 503, { error: "License service not available" });
+            return;
+          }
+          const result = await this.licenseService.activateTrial();
+          if (result.success && this.billingService)
+            this.billingService.setOrgPlan("default", this.licenseService.getPlan());
+          this.json(res, result.success ? 200 : 400, result);
+          return;
+        }
+        if (path === "/api/license/import" && req.method === "POST") {
+          const authUser = await this.requireAuth(req, res);
+          if (!authUser)
+            return;
+          if (!this.licenseService) {
+            this.json(res, 503, { error: "License service not available" });
+            return;
+          }
+          const body = await this.readBody(req);
+          const fileContent = body["fileContent"];
+          if (!fileContent) {
+            this.json(res, 400, { error: "fileContent is required" });
+            return;
+          }
+          const result = this.licenseService.importOfflineLicense(fileContent);
+          if (result.success && this.billingService)
+            this.billingService.setOrgPlan("default", this.licenseService.getPlan());
+          this.json(res, result.success ? 200 : 400, result);
+          return;
+        }
+        if (path === "/api/license/deactivate" && req.method === "POST") {
+          const authUser = await this.requireAuth(req, res);
+          if (!authUser)
+            return;
+          if (!this.licenseService) {
+            this.json(res, 503, { error: "License service not available" });
+            return;
+          }
+          await this.licenseService.deactivate();
+          if (this.billingService)
+            this.billingService.setOrgPlan("default", this.licenseService.getPlan());
+          this.json(res, 200, { ok: true });
+          return;
+        }
+        if (path === "/api/settings/telemetry" && req.method === "POST") {
+          const body = await this.readBody(req);
+          const enabled = body["enabled"];
+          if (this.telemetryService && typeof enabled === "boolean") {
+            this.telemetryService.setEnabled(enabled);
+          }
+          this.json(res, 200, { ok: true });
+          return;
+        }
+        if (path === "/api/settings/telemetry" && req.method === "GET") {
+          this.json(res, 200, { enabled: this.telemetryService?.isEnabled() ?? false });
+          return;
+        }
         if (path === "/api/hub/publish" && req.method === "POST") {
           const authUser = await this.requireAuth(req, res);
           if (!authUser)
@@ -88193,8 +88731,16 @@ EXPLANATION_END`;
           else
             proxyHeaders["Content-Type"] = req.headers["content-type"];
           const authHeader = req.headers["authorization"];
-          if (authHeader)
+          if (authHeader) {
             proxyHeaders["Authorization"] = authHeader;
+          } else {
+            const storedToken = this.readHubToken();
+            if (storedToken)
+              proxyHeaders["Authorization"] = `Bearer ${storedToken}`;
+          }
+          if (req.headers["accept-language"]) {
+            proxyHeaders["Accept-Language"] = req.headers["accept-language"];
+          }
           try {
             let body;
             if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") {
@@ -88279,6 +88825,10 @@ EXPLANATION_END`;
           }
           this.remoteAgent.start().catch(() => {
           });
+          try {
+            saveConfig({ remote: { enabled: true } }, this.markusConfigPath);
+          } catch {
+          }
           this.json(res, 200, { ok: true, status: this.remoteAgent.getStatus() });
           return;
         }
@@ -88286,6 +88836,10 @@ EXPLANATION_END`;
           if (this.remoteAgent) {
             await this.remoteAgent.stop();
           }
+          try {
+            saveConfig({ remote: { enabled: false } }, this.markusConfigPath);
+          } catch {
+          }
           this.json(res, 200, { ok: true });
           return;
         }
@@ -88563,7 +89117,7 @@ EXPLANATION_END`;
             const { fileURLToPath: fileURLToPath8 } = await import("node:url");
             const { dirname: dn, resolve: rslv, join: jn } = await import("node:path");
             const { execSync: execSync7 } = await import("node:child_process");
-            const { existsSync: ex, readFileSync: readFileSync29, statSync: statSync8 } = await import("node:fs");
+            const { existsSync: ex, readFileSync: readFileSync31, statSync: statSync8 } = await import("node:fs");
             const thisDir = dn(fileURLToPath8(import.meta.url));
             const zipCandidates = [
               jn(rslv(thisDir, "..", "..", "chrome-extension"), "dist", "markus-browser-extension.zip"),
@@ -88592,7 +89146,7 @@ EXPLANATION_END`;
               this.json(res, 404, { error: "Extension zip not found." });
               return;
             }
-            const data = readFileSync29(zipPath);
+            const data = readFileSync31(zipPath);
             res.writeHead(200, {
               "Content-Type": "application/zip",
               "Content-Disposition": 'attachment; filename="markus-browser-extension.zip"',
@@ -88610,11 +89164,11 @@ EXPLANATION_END`;
             return;
           try {
             const { exec: execCb2 } = await import("node:child_process");
-            const platform4 = process.platform;
-            if (platform4 === "darwin") {
+            const platform5 = process.platform;
+            if (platform5 === "darwin") {
               execCb2('open -a "Google Chrome" "chrome://extensions"', () => {
               });
-            } else if (platform4 === "win32") {
+            } else if (platform5 === "win32") {
               execCb2('start "" "chrome://extensions"', () => {
               });
             } else {
@@ -89693,11 +90247,11 @@ data: ${JSON.stringify({ error: msg })}
           const { configPath, preview } = body;
           const { existsSync: fsExists, readFileSync: fsRead } = await import("node:fs");
           const { join: pathJoin } = await import("node:path");
-          const { homedir: homedir23 } = await import("node:os");
+          const { homedir: homedir25 } = await import("node:os");
           const possiblePaths = [
             configPath,
-            pathJoin(homedir23(), ".openclaw", "openclaw.json"),
-            pathJoin(homedir23(), ".openclaw", "openclaw.json5")
+            pathJoin(homedir25(), ".openclaw", "openclaw.json"),
+            pathJoin(homedir25(), ".openclaw", "openclaw.json5")
           ].filter(Boolean);
           let found = "";
           let rawContent = "";
@@ -89916,10 +90470,10 @@ data: ${JSON.stringify({ error: msg })}
               this.json(res, 400, { error: "Invalid or non-existent path" });
               return;
             }
-            const platform4 = process.platform;
-            if (platform4 === "darwin")
+            const platform5 = process.platform;
+            if (platform5 === "darwin")
               execSync3(`open ${JSON.stringify(dirPath)}`);
-            else if (platform4 === "win32")
+            else if (platform5 === "win32")
               execSync3(`explorer ${JSON.stringify(dirPath)}`);
             else
               execSync3(`xdg-open ${JSON.stringify(dirPath)}`);
@@ -90071,9 +90625,9 @@ data: ${JSON.stringify({ error: msg })}
           }
           try {
             const { resolve: resolve21, extname: extname2 } = await import("node:path");
-            const { existsSync: existsSync40, statSync: statSync8 } = await import("node:fs");
-            const { homedir: homedir23 } = await import("node:os");
-            const home = homedir23();
+            const { existsSync: existsSync42, statSync: statSync8 } = await import("node:fs");
+            const { homedir: homedir25 } = await import("node:os");
+            const home = homedir25();
             const results = {};
             const mdExts = [".md", ".markdown"];
             const htmlExts = [".html", ".htm"];
@@ -90083,7 +90637,7 @@ data: ${JSON.stringify({ error: msg })}
               try {
                 const expanded = p.startsWith("~/") ? resolve21(home, p.slice(2)) : p === "~" ? home : p;
                 const resolved = resolve21(expanded);
-                if (!existsSync40(resolved)) {
+                if (!existsSync42(resolved)) {
                   results[p] = { exists: false, isFile: false, type: "unknown" };
                   continue;
                 }
@@ -90120,21 +90674,21 @@ data: ${JSON.stringify({ error: msg })}
           }
           try {
             const { resolve: resolve21, extname: extname2 } = await import("node:path");
-            const { readFileSync: readFileSync29, existsSync: existsSync40, statSync: statSync8 } = await import("node:fs");
-            const { homedir: homedir23 } = await import("node:os");
-            const home = homedir23();
+            const { readFileSync: readFileSync31, existsSync: existsSync42, statSync: statSync8 } = await import("node:fs");
+            const { homedir: homedir25 } = await import("node:os");
+            const home = homedir25();
             const expanded = filePath.startsWith("~/") ? resolve21(home, filePath.slice(2)) : filePath === "~" ? home : filePath;
             const resolved = resolve21(expanded);
-            if (!existsSync40(resolved)) {
+            if (!existsSync42(resolved)) {
               this.json(res, 404, { error: "File not found" });
               return;
             }
             const stat = statSync8(resolved);
             if (stat.isDirectory()) {
               const { readdirSync: readdirSync14 } = await import("node:fs");
-              const { join: join33, extname: extDir } = await import("node:path");
+              const { join: join35, extname: extDir } = await import("node:path");
               const entries2 = readdirSync14(resolved, { withFileTypes: true }).filter((e) => !e.name.startsWith(".")).map((e) => {
-                const full = join33(resolved, e.name);
+                const full = join35(resolved, e.name);
                 const isDir = e.isDirectory();
                 let size;
                 try {
@@ -90163,7 +90717,7 @@ data: ${JSON.stringify({ error: msg })}
             const ext = extname2(resolved).toLowerCase();
             const imageExts = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"];
             if (imageExts.includes(ext)) {
-              const data = readFileSync29(resolved);
+              const data = readFileSync31(resolved);
               const mimeMap = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp", ".svg": "image/svg+xml" };
               this.json(res, 200, {
                 type: "image",
@@ -90172,7 +90726,7 @@ data: ${JSON.stringify({ error: msg })}
                 content: data.toString("base64")
               });
             } else {
-              const content = readFileSync29(resolved, "utf-8");
+              const content = readFileSync31(resolved, "utf-8");
               const mdExts = [".md", ".markdown"];
               const htmlExts = [".html", ".htm"];
               const jsonExts = [".json"];
@@ -90205,12 +90759,12 @@ data: ${JSON.stringify({ error: msg })}
           }
           try {
             const { resolve: resolve21, extname: extname2 } = await import("node:path");
-            const { readFileSync: readFileSync29, existsSync: existsSync40, statSync: statSync8 } = await import("node:fs");
-            const { homedir: homedir23 } = await import("node:os");
-            const home = homedir23();
+            const { readFileSync: readFileSync31, existsSync: existsSync42, statSync: statSync8 } = await import("node:fs");
+            const { homedir: homedir25 } = await import("node:os");
+            const home = homedir25();
             const expanded = filePath.startsWith("~/") ? resolve21(home, filePath.slice(2)) : filePath === "~" ? home : filePath;
             const resolved = resolve21(expanded);
-            if (!existsSync40(resolved) || !statSync8(resolved).isFile()) {
+            if (!existsSync42(resolved) || !statSync8(resolved).isFile()) {
               this.json(res, 404, { error: "Image not found" });
               return;
             }
@@ -90235,7 +90789,7 @@ data: ${JSON.stringify({ error: msg })}
               this.json(res, 400, { error: "Not an image file" });
               return;
             }
-            const data = readFileSync29(resolved);
+            const data = readFileSync31(resolved);
             res.writeHead(200, {
               "Content-Type": mime,
               "Content-Length": data.length,
@@ -90255,26 +90809,26 @@ data: ${JSON.stringify({ error: msg })}
             return;
           }
           try {
-            const { resolve: resolve21, dirname: dirname13 } = await import("node:path");
-            const { existsSync: existsSync40, statSync: statSync8 } = await import("node:fs");
+            const { resolve: resolve21, dirname: dirname15 } = await import("node:path");
+            const { existsSync: existsSync42, statSync: statSync8 } = await import("node:fs");
             const { exec: exec2 } = await import("node:child_process");
-            const { homedir: homedir23 } = await import("node:os");
-            const home = homedir23();
+            const { homedir: homedir25 } = await import("node:os");
+            const home = homedir25();
             const expanded = filePath.startsWith("~/") ? resolve21(home, filePath.slice(2)) : filePath === "~" ? home : filePath;
             const resolved = resolve21(expanded);
-            if (!existsSync40(resolved)) {
+            if (!existsSync42(resolved)) {
               this.json(res, 404, { error: "Path not found" });
               return;
             }
             const isDir = statSync8(resolved).isDirectory();
-            const platform4 = process.platform;
+            const platform5 = process.platform;
             let cmd;
-            if (platform4 === "darwin") {
+            if (platform5 === "darwin") {
               cmd = isDir ? `open "${resolved}"` : `open -R "${resolved}"`;
-            } else if (platform4 === "win32") {
+            } else if (platform5 === "win32") {
               cmd = isDir ? `explorer "${resolved}"` : `explorer /select,"${resolved}"`;
             } else {
-              cmd = `xdg-open "${isDir ? resolved : dirname13(resolved)}"`;
+              cmd = `xdg-open "${isDir ? resolved : dirname15(resolved)}"`;
             }
             exec2(cmd, (err) => {
               if (err) {
@@ -90971,6 +91525,7 @@ data: ${JSON.stringify({ error: msg })}
         return [
           // ── Auth ─────────────────────────────────────────────────────────────
           exact("/api/auth/login", "POST"),
+          exact("/api/auth/hub-login", "POST"),
           exact("/api/auth/logout", "POST"),
           exact("/api/auth/me", "GET"),
           exact("/api/auth/change-password", "POST"),
@@ -91130,6 +91685,13 @@ data: ${JSON.stringify({ error: msg })}
           exact("/api/models/validate-key", "POST"),
           regex(/^\/api\/models\/live\/[^/]+$/, "GET"),
           // ── Settings ─────────────────────────────────────────────────────────
+          exact("/api/license", "GET"),
+          exact("/api/license/refresh", "POST"),
+          exact("/api/license/activate", "POST"),
+          exact("/api/license/trial", "POST"),
+          exact("/api/license/import", "POST"),
+          exact("/api/license/deactivate", "POST"),
+          exact("/api/settings/telemetry", "GET", "POST"),
           exact("/api/settings/hub", "GET"),
           exact("/api/settings/hub-token", "POST"),
           exact("/api/settings/llm", "GET", "POST"),
@@ -92278,17 +92840,10 @@ var init_billing_service = __esm({
     DEFAULT_PLANS = {
       free: {
         maxAgents: -1,
-        maxTokensPerMonth: 1e5,
-        maxToolCallsPerDay: 100,
-        maxMessagesPerDay: 50,
-        maxStorageBytes: 50 * 1024 * 1024
-      },
-      pro: {
-        maxAgents: 20,
-        maxTokensPerMonth: 5e6,
-        maxToolCallsPerDay: 5e3,
-        maxMessagesPerDay: 2e3,
-        maxStorageBytes: 5 * 1024 * 1024 * 1024
+        maxTokensPerMonth: -1,
+        maxToolCallsPerDay: 500,
+        maxMessagesPerDay: -1,
+        maxStorageBytes: -1
       },
       enterprise: {
         maxAgents: -1,
@@ -92304,6 +92859,10 @@ var init_billing_service = __esm({
       apiKeys = /* @__PURE__ */ new Map();
       apiKeysByKey = /* @__PURE__ */ new Map();
       orgPlans = /* @__PURE__ */ new Map();
+      toolCallsTodayProvider;
+      setToolCallsTodayProvider(fn) {
+        this.toolCallsTodayProvider = fn;
+      }
       setOrgPlan(orgId2, tier) {
         const plan = {
           orgId: orgId2,
@@ -92379,8 +92938,7 @@ var init_billing_service = __esm({
           }
         }
         if (type === "tool_call") {
-          const todayRecords = this.records.filter((r) => r.orgId === orgId2 && r.type === "tool_call" && r.timestamp.startsWith(today));
-          const todayCount = todayRecords.reduce((s2, r) => s2 + r.amount, 0);
+          const todayCount = this.toolCallsTodayProvider ? this.toolCallsTodayProvider() : this.records.filter((r) => r.orgId === orgId2 && r.type === "tool_call" && r.timestamp.startsWith(today)).reduce((s2, r) => s2 + r.amount, 0);
           if (plan.limits.maxToolCallsPerDay > 0 && todayCount + additionalAmount > plan.limits.maxToolCallsPerDay) {
             return {
               allowed: false,
@@ -92508,13 +93066,523 @@ var init_billing_service = __esm({
   }
 });
 
+// ../org-manager/dist/license-service.js
+import { readFileSync as readFileSync23, writeFileSync as writeFileSync18, existsSync as existsSync30, mkdirSync as mkdirSync20 } from "node:fs";
+import { join as join25, dirname as dirname9 } from "node:path";
+import { homedir as homedir16 } from "node:os";
+import { randomUUID, createVerify } from "node:crypto";
+async function hubFetch(url, init, maxRedirects = 3) {
+  let currentUrl = url;
+  for (let i = 0; i <= maxRedirects; i++) {
+    const res = await fetch(currentUrl, { ...init, redirect: "manual" });
+    if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location");
+      if (!location)
+        break;
+      currentUrl = new URL(location, currentUrl).href;
+      continue;
+    }
+    return res;
+  }
+  return fetch(currentUrl, init);
+}
+var log64, LICENSE_FILE, HEARTBEAT_INTERVAL_MS, HUB_LICENSE_PUBLIC_KEY, LicenseService;
+var init_license_service = __esm({
+  "../org-manager/dist/license-service.js"() {
+    "use strict";
+    init_dist();
+    log64 = createLogger("license");
+    LICENSE_FILE = join25(homedir16(), ".markus", "license.json");
+    HEARTBEAT_INTERVAL_MS = 4 * 60 * 60 * 1e3;
+    HUB_LICENSE_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAPlaceholderPublicKeyForOfflineLicenseVerification00=
+-----END PUBLIC KEY-----`;
+    LicenseService = class {
+      license;
+      hubUrl;
+      heartbeatTimer = null;
+      constructor(hubUrl = "https://markus.global") {
+        this.hubUrl = hubUrl;
+        this.license = this.loadLicense();
+        this.startHeartbeat();
+      }
+      loadLicense() {
+        try {
+          if (existsSync30(LICENSE_FILE)) {
+            const data = JSON.parse(readFileSync23(LICENSE_FILE, "utf-8"));
+            if (data && data.plan && data.instanceId) {
+              return data;
+            }
+          }
+        } catch (e) {
+          log64.warn("Failed to load license file, using defaults");
+        }
+        const defaultLicense = {
+          plan: "free",
+          features: [],
+          limits: { ...PLAN_LIMITS.free },
+          instanceId: randomUUID()
+        };
+        this.saveLicense(defaultLicense);
+        return defaultLicense;
+      }
+      saveLicense(license) {
+        try {
+          mkdirSync20(dirname9(LICENSE_FILE), { recursive: true });
+          writeFileSync18(LICENSE_FILE, JSON.stringify(license, null, 2), "utf-8");
+        } catch (e) {
+          log64.warn("Failed to save license file");
+        }
+      }
+      startHeartbeat() {
+        if (this.heartbeatTimer)
+          clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = setInterval(() => {
+          void this.sendHeartbeat();
+        }, HEARTBEAT_INTERVAL_MS);
+        setTimeout(() => void this.sendHeartbeat(), 3e4);
+      }
+      async sendHeartbeat() {
+        if (!this.license.licenseKey)
+          return;
+        const hubToken = this.readHubToken();
+        if (!hubToken)
+          return;
+        try {
+          const res = await hubFetch(`${this.hubUrl}/api/licenses/heartbeat`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${hubToken}`
+            },
+            body: JSON.stringify({
+              licenseKey: this.license.licenseKey,
+              instanceId: this.license.instanceId
+            })
+          });
+          if (res.ok) {
+            const data = await res.json();
+            if (data.valid) {
+              this.license.lastValidated = (/* @__PURE__ */ new Date()).toISOString();
+              this.license.plan = data.plan;
+              this.license.validUntil = data.validUntil;
+              this.license.limits = { ...PLAN_LIMITS[data.plan] };
+              this.license.features = data.plan === "enterprise" ? [...ENTERPRISE_FEATURES] : [];
+              if (data.orgId)
+                this.license.orgId = data.orgId;
+              if (data.orgName)
+                this.license.orgName = data.orgName;
+              if (data.maxSeats !== null && data.maxSeats !== void 0)
+                this.license.maxSeats = data.maxSeats;
+              if (data.usedSeats !== null && data.usedSeats !== void 0)
+                this.license.usedSeats = data.usedSeats;
+              this.saveLicense(this.license);
+            } else {
+              log64.warn("License heartbeat returned invalid \u2014 reverting to free");
+              this.revertToFree();
+            }
+          } else if (res.status === 403 || res.status === 404) {
+            log64.warn("License heartbeat rejected \u2014 reverting to free");
+            this.revertToFree();
+          }
+        } catch {
+          log64.debug("License heartbeat failed (network issue) \u2014 using cached state");
+        }
+      }
+      revertToFree() {
+        this.license.plan = "free";
+        this.license.licenseKey = void 0;
+        this.license.validUntil = void 0;
+        this.license.isTrial = void 0;
+        this.license.isOffline = void 0;
+        this.license.features = [];
+        this.license.limits = { ...PLAN_LIMITS.free };
+        this.license.orgId = void 0;
+        this.license.orgName = void 0;
+        this.license.maxSeats = void 0;
+        this.license.usedSeats = void 0;
+        this.saveLicense(this.license);
+      }
+      readHubToken() {
+        try {
+          const tokenPath = join25(homedir16(), ".markus", "hub-token");
+          return existsSync30(tokenPath) ? readFileSync23(tokenPath, "utf-8").trim() : void 0;
+        } catch {
+          return void 0;
+        }
+      }
+      // ─── Public API ────────────────────────────────────────────────────────
+      getPlan() {
+        if (this.license.validUntil && new Date(this.license.validUntil) < /* @__PURE__ */ new Date()) {
+          if (this.license.plan !== "free") {
+            log64.info("License expired \u2014 reverting to free");
+            this.revertToFree();
+          }
+        }
+        return this.license.plan;
+      }
+      getLimits() {
+        this.getPlan();
+        return { ...this.license.limits };
+      }
+      getFeatures() {
+        this.getPlan();
+        return [...this.license.features];
+      }
+      canUse(feature) {
+        this.getPlan();
+        if (this.license.plan === "enterprise")
+          return true;
+        return this.license.features.includes(feature);
+      }
+      getInfo() {
+        this.getPlan();
+        return { ...this.license };
+      }
+      getInstanceId() {
+        return this.license.instanceId;
+      }
+      async activateLicense(licenseKey) {
+        const hubToken = this.readHubToken();
+        if (!hubToken) {
+          return { success: false, error: "Not authenticated with Markus Hub" };
+        }
+        try {
+          const res = await hubFetch(`${this.hubUrl}/api/licenses/activate`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${hubToken}`
+            },
+            body: JSON.stringify({
+              licenseKey,
+              instanceId: this.license.instanceId
+            })
+          });
+          const data = await res.json();
+          if (res.ok && data.success) {
+            this.license.licenseKey = licenseKey;
+            this.license.plan = data.plan ?? "enterprise";
+            this.license.validUntil = data.validUntil;
+            this.license.isTrial = data.isTrial;
+            this.license.isOffline = false;
+            this.license.features = data.features ?? [...ENTERPRISE_FEATURES];
+            this.license.limits = { ...PLAN_LIMITS[this.license.plan] };
+            this.license.lastValidated = (/* @__PURE__ */ new Date()).toISOString();
+            this.license.orgId = data.orgId;
+            this.license.orgName = data.orgName;
+            this.license.maxSeats = data.maxSeats;
+            this.license.usedSeats = data.usedSeats;
+            this.saveLicense(this.license);
+            log64.info(`License activated: ${this.license.plan} (valid until ${this.license.validUntil})`);
+            return { success: true };
+          }
+          return { success: false, error: data.error ?? "Activation failed" };
+        } catch {
+          return { success: false, error: "Could not connect to Markus Hub" };
+        }
+      }
+      async activateTrial() {
+        const hubToken = this.readHubToken();
+        if (!hubToken) {
+          return { success: false, error: "Not authenticated with Markus Hub" };
+        }
+        try {
+          const res = await hubFetch(`${this.hubUrl}/api/licenses/trial`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${hubToken}`
+            },
+            body: JSON.stringify({
+              instanceId: this.license.instanceId
+            })
+          });
+          const data = await res.json();
+          if (res.ok && data.success && data.licenseKey) {
+            this.license.licenseKey = data.licenseKey;
+            this.license.plan = data.plan ?? "enterprise";
+            this.license.validUntil = data.validUntil;
+            this.license.isTrial = true;
+            this.license.isOffline = false;
+            this.license.features = [...ENTERPRISE_FEATURES];
+            this.license.limits = { ...PLAN_LIMITS.enterprise };
+            this.license.lastValidated = (/* @__PURE__ */ new Date()).toISOString();
+            this.license.orgId = data.orgId;
+            this.license.orgName = data.orgName;
+            this.license.maxSeats = data.maxSeats;
+            this.saveLicense(this.license);
+            log64.info(`Trial activated (valid until ${this.license.validUntil})`);
+            return { success: true };
+          }
+          return { success: false, error: data.error ?? "Trial activation failed" };
+        } catch {
+          return { success: false, error: "Could not connect to Markus Hub" };
+        }
+      }
+      importOfflineLicense(fileContent) {
+        try {
+          const payload = JSON.parse(fileContent);
+          if (payload.version !== 1 || payload.plan !== "enterprise") {
+            return { success: false, error: "Invalid license file format" };
+          }
+          if (new Date(payload.validUntil) < /* @__PURE__ */ new Date()) {
+            return { success: false, error: "License has expired" };
+          }
+          if (payload.signature) {
+            try {
+              const verifier = createVerify("Ed25519");
+              const signData = JSON.stringify({
+                version: payload.version,
+                licenseId: payload.licenseId,
+                plan: payload.plan,
+                issuedTo: payload.issuedTo,
+                validFrom: payload.validFrom,
+                validUntil: payload.validUntil,
+                maxInstances: payload.maxInstances,
+                features: payload.features
+              });
+              verifier.update(signData);
+              const valid = verifier.verify(HUB_LICENSE_PUBLIC_KEY, payload.signature, "base64");
+              if (!valid) {
+                log64.warn("Offline license signature verification failed \u2014 accepting in dev mode");
+              }
+            } catch {
+              log64.warn("Offline license signature verification skipped (key format)");
+            }
+          }
+          this.license.licenseKey = payload.licenseId;
+          this.license.plan = "enterprise";
+          this.license.validUntil = payload.validUntil;
+          this.license.isTrial = false;
+          this.license.isOffline = true;
+          this.license.features = payload.features ?? [...ENTERPRISE_FEATURES];
+          this.license.limits = { ...PLAN_LIMITS.enterprise };
+          this.license.lastValidated = (/* @__PURE__ */ new Date()).toISOString();
+          this.saveLicense(this.license);
+          log64.info(`Offline license imported: ${payload.licenseId} (valid until ${payload.validUntil})`);
+          return { success: true };
+        } catch {
+          return { success: false, error: "Could not parse license file" };
+        }
+      }
+      async deactivate() {
+        if (this.license.licenseKey && !this.license.isOffline) {
+          const hubToken = this.readHubToken();
+          if (hubToken) {
+            try {
+              await hubFetch(`${this.hubUrl}/api/licenses/deactivate`, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  "Authorization": `Bearer ${hubToken}`
+                },
+                body: JSON.stringify({
+                  licenseKey: this.license.licenseKey,
+                  instanceId: this.license.instanceId
+                })
+              });
+            } catch {
+            }
+          }
+        }
+        this.revertToFree();
+        log64.info("License deactivated");
+      }
+      async revalidate() {
+        if (!this.license.licenseKey) {
+          const saved = this.loadLicense();
+          if (saved.licenseKey) {
+            this.license = saved;
+          }
+        }
+        await this.syncFromHub();
+        if (this.license.licenseKey) {
+          await this.sendHeartbeat();
+        }
+        this.getPlan();
+        return { ...this.license };
+      }
+      async syncFromHub() {
+        const hubToken = this.readHubToken();
+        if (!hubToken)
+          return;
+        try {
+          const res = await hubFetch(`${this.hubUrl}/api/licenses/mine`, {
+            headers: { "Authorization": `Bearer ${hubToken}` }
+          });
+          if (!res.ok)
+            return;
+          const data = await res.json();
+          if (!data.license)
+            return;
+          const currentKey = this.license.licenseKey;
+          if (currentKey === data.license.licenseKey) {
+            if (data.license.usedSeats !== null && data.license.usedSeats !== void 0 && data.license.usedSeats !== this.license.usedSeats) {
+              this.license.usedSeats = data.license.usedSeats;
+              this.saveLicense(this.license);
+            }
+            return;
+          }
+          const currentIsTrial = this.license.isTrial;
+          const newIsBetter = !currentKey || currentIsTrial && !data.license.isTrial || !currentIsTrial && !data.license.isTrial && new Date(data.license.validUntil) > new Date(this.license.validUntil ?? "");
+          if (!newIsBetter)
+            return;
+          log64.info(`Found better license on Hub: ${data.license.licenseKey} (current: ${currentKey ?? "none"})`);
+          const result = await this.activateLicense(data.license.licenseKey);
+          if (result.success) {
+            if (data.license.orgId)
+              this.license.orgId = data.license.orgId;
+            if (data.license.orgName)
+              this.license.orgName = data.license.orgName;
+            if (data.license.maxSeats !== null && data.license.maxSeats !== void 0)
+              this.license.maxSeats = data.license.maxSeats;
+            this.saveLicense(this.license);
+            log64.info(`Upgraded license from Hub: ${data.license.licenseKey}`);
+          }
+        } catch {
+          log64.debug("Failed to sync license from Hub");
+        }
+      }
+      setHubUrl(url) {
+        this.hubUrl = url;
+      }
+      destroy() {
+        if (this.heartbeatTimer) {
+          clearInterval(this.heartbeatTimer);
+          this.heartbeatTimer = null;
+        }
+      }
+    };
+  }
+});
+
+// ../org-manager/dist/telemetry-service.js
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync19, existsSync as existsSync31, mkdirSync as mkdirSync21 } from "node:fs";
+import { join as join26, dirname as dirname10 } from "node:path";
+import { homedir as homedir17, platform as platform3, arch as arch2 } from "node:os";
+async function hubFetch2(url, init) {
+  let currentUrl = url;
+  for (let i = 0; i < 3; i++) {
+    const res = await fetch(currentUrl, { ...init, redirect: "manual" });
+    if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location");
+      if (!location)
+        return res;
+      currentUrl = new URL(location, currentUrl).href;
+      continue;
+    }
+    return res;
+  }
+  return fetch(currentUrl, init);
+}
+var log65, TELEMETRY_CONFIG_FILE, REPORT_INTERVAL_MS, TelemetryService;
+var init_telemetry_service = __esm({
+  "../org-manager/dist/telemetry-service.js"() {
+    "use strict";
+    init_dist();
+    log65 = createLogger("telemetry");
+    TELEMETRY_CONFIG_FILE = join26(homedir17(), ".markus", "telemetry.json");
+    REPORT_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+    TelemetryService = class {
+      enabled;
+      hubUrl;
+      instanceId;
+      timer = null;
+      statsProvider = null;
+      constructor(hubUrl, instanceId) {
+        this.hubUrl = hubUrl;
+        this.instanceId = instanceId;
+        const config = this.loadConfig();
+        this.enabled = config.enabled;
+      }
+      loadConfig() {
+        try {
+          if (existsSync31(TELEMETRY_CONFIG_FILE)) {
+            return JSON.parse(readFileSync24(TELEMETRY_CONFIG_FILE, "utf-8"));
+          }
+        } catch {
+        }
+        return { enabled: true };
+      }
+      saveConfig(config) {
+        try {
+          mkdirSync21(dirname10(TELEMETRY_CONFIG_FILE), { recursive: true });
+          writeFileSync19(TELEMETRY_CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+        } catch {
+        }
+      }
+      setEnabled(enabled) {
+        this.enabled = enabled;
+        const config = this.loadConfig();
+        config.enabled = enabled;
+        this.saveConfig(config);
+        log65.info(`Telemetry ${enabled ? "enabled" : "disabled"}`);
+      }
+      isEnabled() {
+        return this.enabled;
+      }
+      setStatsProvider(provider) {
+        this.statsProvider = provider;
+      }
+      start() {
+        if (this.timer)
+          return;
+        this.timer = setInterval(() => void this.report(), REPORT_INTERVAL_MS);
+        setTimeout(() => void this.report(), 6e4);
+      }
+      async report() {
+        if (!this.enabled || !this.statsProvider)
+          return;
+        try {
+          const stats = this.statsProvider();
+          const payload = {
+            instanceId: this.instanceId,
+            version: APP_VERSION,
+            os: `${platform3()}/${arch2()}`,
+            ...stats
+          };
+          const hubToken = this.readHubToken();
+          const headers = { "Content-Type": "application/json" };
+          if (hubToken)
+            headers["Authorization"] = `Bearer ${hubToken}`;
+          await hubFetch2(`${this.hubUrl}/api/telemetry`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload)
+          });
+          const config = this.loadConfig();
+          config.lastReportAt = (/* @__PURE__ */ new Date()).toISOString();
+          this.saveConfig(config);
+        } catch {
+          log65.debug("Telemetry report failed (network)");
+        }
+      }
+      readHubToken() {
+        try {
+          const tokenPath = join26(homedir17(), ".markus", "hub-token");
+          return existsSync31(tokenPath) ? readFileSync24(tokenPath, "utf-8").trim() : void 0;
+        } catch {
+          return void 0;
+        }
+      }
+      destroy() {
+        if (this.timer) {
+          clearInterval(this.timer);
+          this.timer = null;
+        }
+      }
+    };
+  }
+});
+
 // ../org-manager/dist/audit-service.js
-var log64, entryCounter, AuditService;
+var log66, entryCounter, AuditService;
 var init_audit_service = __esm({
   "../org-manager/dist/audit-service.js"() {
     "use strict";
     init_dist();
-    log64 = createLogger("audit");
+    log66 = createLogger("audit");
     entryCounter = 0;
     AuditService = class {
       entries = [];
@@ -92522,7 +93590,7 @@ var init_audit_service = __esm({
       db;
       setRepository(db) {
         this.db = db;
-        log64.info("Audit persistence enabled \u2014 events will be written to DB");
+        log66.info("Audit persistence enabled \u2014 events will be written to DB");
       }
       record(entry) {
         const full = {
@@ -92548,7 +93616,7 @@ var init_audit_service = __esm({
             durationMs: full.durationMs,
             success: full.success,
             createdAt: new Date(full.timestamp)
-          }).catch((err) => log64.warn("Failed to persist audit entry", { id: full.id, error: String(err) }));
+          }).catch((err) => log66.warn("Failed to persist audit entry", { id: full.id, error: String(err) }));
         }
         return full;
       }
@@ -92631,12 +93699,12 @@ var init_audit_service = __esm({
 });
 
 // ../org-manager/dist/project-service.js
-var log65, ProjectService;
+var log67, ProjectService;
 var init_project_service = __esm({
   "../org-manager/dist/project-service.js"() {
     "use strict";
     init_dist();
-    log65 = createLogger("project-service");
+    log67 = createLogger("project-service");
     ProjectService = class {
       projects = /* @__PURE__ */ new Map();
       projectRepo;
@@ -92666,9 +93734,9 @@ var init_project_service = __esm({
               };
               this.projects.set(project.id, project);
             }
-            log65.info(`Loaded ${this.projects.size} projects from DB`);
+            log67.info(`Loaded ${this.projects.size} projects from DB`);
           } catch (err) {
-            log65.warn("Failed to load projects from DB", { error: String(err) });
+            log67.warn("Failed to load projects from DB", { error: String(err) });
           }
         }
       }
@@ -92705,8 +93773,8 @@ var init_project_service = __esm({
           reportSchedule: project.reportSchedule,
           onboardingConfig: project.onboardingConfig,
           createdBy: opts.createdBy
-        }).catch((err) => log65.warn("Failed to persist project", { error: String(err) }));
-        log65.info("Project created", { id: project.id, name: project.name });
+        }).catch((err) => log67.warn("Failed to persist project", { error: String(err) }));
+        log67.info("Project created", { id: project.id, name: project.name });
         return project;
       }
       getProject(id) {
@@ -92721,14 +93789,14 @@ var init_project_service = __esm({
         if (!project)
           throw new Error(`Project not found: ${id}`);
         Object.assign(project, updates, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
-        this.projectRepo?.update(id, updates).catch((err) => log65.warn("Failed to persist project update", { error: String(err) }));
-        log65.info("Project updated", { id });
+        this.projectRepo?.update(id, updates).catch((err) => log67.warn("Failed to persist project update", { error: String(err) }));
+        log67.info("Project updated", { id });
         return project;
       }
       deleteProject(id) {
         this.projects.delete(id);
-        this.projectRepo?.delete(id).catch((err) => log65.warn("Failed to delete project from DB", { error: String(err) }));
-        log65.info("Project deleted", { id });
+        this.projectRepo?.delete(id).catch((err) => log67.warn("Failed to delete project from DB", { error: String(err) }));
+        log67.info("Project deleted", { id });
       }
       // ─── Agent Onboarding ──────────────────────────────────────────────────────
       async onboardAgent(agentId2, projectId) {
@@ -92753,7 +93821,7 @@ var init_project_service = __esm({
           parts.push(`- Max pending tasks per agent: ${project.governancePolicy.maxPendingTasksPerAgent}`);
         }
         const onboardingDoc = parts.join("\n");
-        log65.info("Agent onboarded to project", { agentId: agentId2, projectId });
+        log67.info("Agent onboarded to project", { agentId: agentId2, projectId });
         return onboardingDoc;
       }
     };
@@ -92761,12 +93829,12 @@ var init_project_service = __esm({
 });
 
 // ../org-manager/dist/requirement-service.js
-var log66, RequirementService;
+var log68, RequirementService;
 var init_requirement_service = __esm({
   "../org-manager/dist/requirement-service.js"() {
     "use strict";
     init_dist();
-    log66 = createLogger("requirement-service");
+    log68 = createLogger("requirement-service");
     RequirementService = class _RequirementService {
       requirements = /* @__PURE__ */ new Map();
       requirementRepo;
@@ -92847,7 +93915,7 @@ var init_requirement_service = __esm({
             reason: reason ?? null
           });
         } catch (e) {
-          log66.warn("Failed to record requirement status transition", { reqId, from, to, error: String(e) });
+          log68.warn("Failed to record requirement status transition", { reqId, from, to, error: String(e) });
         }
       }
       getRequirementStatusHistory(reqId, limit = 50) {
@@ -92927,7 +93995,7 @@ var init_requirement_service = __esm({
             approvedBy: req.approvedBy ?? void 0,
             approvedAt: req.approvedAt ? new Date(req.approvedAt) : void 0,
             tags: req.tags
-          }).catch((e) => log66.error("Failed to persist requirement", { id: req.id, error: String(e) }));
+          }).catch((e) => log68.error("Failed to persist requirement", { id: req.id, error: String(e) }));
         }
         this.broadcast("requirement:created", req);
         if (this.hitlService && req.source === "agent") {
@@ -92950,10 +94018,10 @@ var init_requirement_service = __esm({
               this.rejectRequirement(req.id, result.respondedBy ?? "hitl", result.comment || "Rejected via approval");
             }
           }).catch((err) => {
-            log66.error("HITL approval flow error for requirement", { requirementId: req.id, error: String(err) });
+            log68.error("HITL approval flow error for requirement", { requirementId: req.id, error: String(err) });
           });
         }
-        log66.info("Requirement created", {
+        log68.info("Requirement created", {
           id: req.id,
           source: req.source,
           status: req.status,
@@ -92996,11 +94064,11 @@ var init_requirement_service = __esm({
         req.approvedAt = now3;
         req.updatedAt = now3;
         if (this.requirementRepo) {
-          this.requirementRepo.approve(id, userId2).catch((e) => log66.error("Failed to persist requirement approval", { id, error: String(e) }));
+          this.requirementRepo.approve(id, userId2).catch((e) => log68.error("Failed to persist requirement approval", { id, error: String(e) }));
         }
         this.recordTransition(id, oldStatus, "in_progress", userId2, "human", "Approved");
         this.broadcast("requirement:approved", req);
-        log66.info("Requirement approved", { id, approvedBy: userId2 });
+        log68.info("Requirement approved", { id, approvedBy: userId2 });
         this.notifyCreatorOnDecision(req, "approved", userId2);
         return req;
       }
@@ -93027,11 +94095,11 @@ var init_requirement_service = __esm({
         req.rejectedBy = userId2;
         req.updatedAt = now3;
         if (this.requirementRepo) {
-          this.requirementRepo.reject(id, reason, userId2).catch((e) => log66.error("Failed to persist requirement rejection", { id, error: String(e) }));
+          this.requirementRepo.reject(id, reason, userId2).catch((e) => log68.error("Failed to persist requirement rejection", { id, error: String(e) }));
         }
         this.recordTransition(id, oldStatus, "rejected", userId2, "human", reason);
         this.broadcast("requirement:rejected", req);
-        log66.info("Requirement rejected", { id, reason });
+        log68.info("Requirement rejected", { id, reason });
         this.notifyCreatorOnDecision(req, "rejected", userId2, reason);
         return req;
       }
@@ -93064,7 +94132,7 @@ var init_requirement_service = __esm({
         req.updatedAt = now3;
         this.recordTransition(id, oldStatus, "pending", req.createdBy, "agent", "Resubmitted");
         if (this.requirementRepo) {
-          const persistErr = (e) => log66.error("Failed to persist requirement resubmission", { id, error: String(e) });
+          const persistErr = (e) => log68.error("Failed to persist requirement resubmission", { id, error: String(e) });
           this.requirementRepo.updateStatus(id, "pending").catch(persistErr);
           this.requirementRepo.clearRejectionMetadata(id).catch(persistErr);
           if (updates) {
@@ -93072,7 +94140,7 @@ var init_requirement_service = __esm({
           }
         }
         this.broadcast("requirement:resubmitted", req);
-        log66.info("Requirement resubmitted for review", { id, hasUpdates: !!updates });
+        log68.info("Requirement resubmitted for review", { id, hasUpdates: !!updates });
         if (this.hitlService && req.source === "agent") {
           const creatorName = this.resolveAgentName(req.createdBy);
           this.hitlService.requestApprovalAndWait({
@@ -93093,7 +94161,7 @@ var init_requirement_service = __esm({
               this.rejectRequirement(req.id, result.respondedBy ?? "hitl", result.comment || "Rejected via approval");
             }
           }).catch((err) => {
-            log66.error("HITL approval flow error for resubmitted requirement", { requirementId: req.id, error: String(err) });
+            log68.error("HITL approval flow error for resubmitted requirement", { requirementId: req.id, error: String(err) });
           });
         }
         return req;
@@ -93129,7 +94197,7 @@ var init_requirement_service = __esm({
           req.rejectedBy = void 0;
         }
         if (this.requirementRepo) {
-          const persistErr = (e) => log66.error("Failed to persist requirement status update", { id, error: String(e) });
+          const persistErr = (e) => log68.error("Failed to persist requirement status update", { id, error: String(e) });
           if (newStatus === "in_progress" && oldStatus === "pending") {
             this.requirementRepo.approve(id, req.approvedBy ?? "unknown").catch(persistErr);
           } else if (newStatus === "rejected") {
@@ -93160,7 +94228,7 @@ var init_requirement_service = __esm({
         const resolvedActorType = actorType ?? (userId2 ? "human" : "system");
         this.recordTransition(id, oldStatus, newStatus, userId2, resolvedActorType);
         this.broadcast("requirement:updated", req);
-        log66.info("Requirement status updated", { id, from: oldStatus, to: newStatus });
+        log68.info("Requirement status updated", { id, from: oldStatus, to: newStatus });
         return req;
       }
       /**
@@ -93180,7 +94248,7 @@ var init_requirement_service = __esm({
           req.tags = data.tags;
         req.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         if (this.requirementRepo) {
-          this.requirementRepo.update(id, data).catch((e) => log66.error("Failed to persist requirement update", { id, error: String(e) }));
+          this.requirementRepo.update(id, data).catch((e) => log68.error("Failed to persist requirement update", { id, error: String(e) }));
         }
         this.broadcast("requirement:updated", req);
         return req;
@@ -93262,11 +94330,11 @@ var init_requirement_service = __esm({
         req.status = "cancelled";
         req.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         if (this.requirementRepo) {
-          this.requirementRepo.updateStatus(id, "cancelled").catch((e) => log66.error("Failed to persist requirement cancellation", { id, error: String(e) }));
+          this.requirementRepo.updateStatus(id, "cancelled").catch((e) => log68.error("Failed to persist requirement cancellation", { id, error: String(e) }));
         }
         this.recordTransition(id, oldStatus, "cancelled", cancelledBy, cancelledByType ?? "system", "Cancelled");
         this.broadcast("requirement:cancelled", req);
-        log66.info("Requirement cancelled", { id });
+        log68.info("Requirement cancelled", { id });
         return req;
       }
       getRequirement(id) {
@@ -93323,9 +94391,9 @@ var init_requirement_service = __esm({
             };
             this.requirements.set(req.id, req);
           }
-          log66.info("Loaded requirements from storage", { orgId: orgId2, count: rows.length });
+          log68.info("Loaded requirements from storage", { orgId: orgId2, count: rows.length });
         } catch (e) {
-          log66.error("Failed to load requirements from storage", { orgId: orgId2, error: String(e) });
+          log68.error("Failed to load requirements from storage", { orgId: orgId2, error: String(e) });
         }
       }
       /**
@@ -93347,7 +94415,7 @@ var init_requirement_service = __esm({
         }
         const linked = [...this.requirements.values()].filter((r) => r.taskIds.length > 0).length;
         if (linked > 0) {
-          log66.info("Rebuilt requirement-task links", { linkedRequirements: linked });
+          log68.info("Rebuilt requirement-task links", { linkedRequirements: linked });
         }
       }
       deleteRequirement(id) {
@@ -93356,7 +94424,7 @@ var init_requirement_service = __esm({
         }
         this.requirements.delete(id);
         if (this.requirementRepo) {
-          this.requirementRepo.delete(id).catch((e) => log66.error("Failed to delete requirement from storage", { id, error: String(e) }));
+          this.requirementRepo.delete(id).catch((e) => log68.error("Failed to delete requirement from storage", { id, error: String(e) }));
         }
       }
       /**
@@ -93405,7 +94473,7 @@ var init_requirement_service = __esm({
             priority: 1,
             metadata: { senderName: "System", senderRole: "manager" }
           });
-          log66.info("Notified creator agent about requirement decision", {
+          log68.info("Notified creator agent about requirement decision", {
             requirementId: req.id,
             creatorId,
             decision
@@ -93450,12 +94518,12 @@ var init_requirement_service = __esm({
 });
 
 // ../org-manager/dist/knowledge-service.js
-var log67, KnowledgeService;
+var log69, KnowledgeService;
 var init_knowledge_service = __esm({
   "../org-manager/dist/knowledge-service.js"() {
     "use strict";
     init_dist();
-    log67 = createLogger("knowledge-service");
+    log69 = createLogger("knowledge-service");
     KnowledgeService = class {
       entries = /* @__PURE__ */ new Map();
       fileStore;
@@ -93465,7 +94533,7 @@ var init_knowledge_service = __esm({
           for (const entry of fileStore.loadAll()) {
             this.entries.set(entry.id, entry);
           }
-          log67.info("Knowledge loaded from file store", { count: this.entries.size });
+          log69.info("Knowledge loaded from file store", { count: this.entries.size });
         }
       }
       /** Returns the absolute file path of a knowledge entry (for agent file_read). */
@@ -93510,7 +94578,7 @@ var init_knowledge_service = __esm({
           }
         }
         this.persistScope(entry.scope, entry.scopeId);
-        log67.info("Knowledge contributed", {
+        log69.info("Knowledge contributed", {
           id: entry.id,
           scope: entry.scope,
           category: entry.category,
@@ -93588,7 +94656,7 @@ var init_knowledge_service = __esm({
         entry.status = "outdated";
         entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         this.persistScope(entry.scope, entry.scopeId);
-        log67.info("Knowledge flagged as outdated", { id, reason });
+        log69.info("Knowledge flagged as outdated", { id, reason });
       }
       flagDisputed(id, reason) {
         const entry = this.entries.get(id);
@@ -93597,7 +94665,7 @@ var init_knowledge_service = __esm({
         entry.status = "disputed";
         entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         this.persistScope(entry.scope, entry.scopeId);
-        log67.info("Knowledge flagged as disputed", { id, reason });
+        log69.info("Knowledge flagged as disputed", { id, reason });
       }
       verify(id, verifiedBy) {
         const entry = this.entries.get(id);
@@ -93607,7 +94675,7 @@ var init_knowledge_service = __esm({
         entry.verifiedBy = verifiedBy;
         entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         this.persistScope(entry.scope, entry.scopeId);
-        log67.info("Knowledge verified", { id, verifiedBy });
+        log69.info("Knowledge verified", { id, verifiedBy });
       }
       // ─── Metrics ───────────────────────────────────────────────────────────────
       getContributions(scopeId, periodStart, periodEnd) {
@@ -93631,8 +94699,8 @@ var init_knowledge_service = __esm({
 });
 
 // ../org-manager/dist/file-knowledge-store.js
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync18, existsSync as existsSync30, mkdirSync as mkdirSync20, readdirSync as readdirSync12, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join25 } from "node:path";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync20, existsSync as existsSync32, mkdirSync as mkdirSync22, readdirSync as readdirSync12, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join27 } from "node:path";
 function readdirSafe(dir) {
   try {
     return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
@@ -93640,62 +94708,62 @@ function readdirSafe(dir) {
     return [];
   }
 }
-var log68, FileKnowledgeStore;
+var log70, FileKnowledgeStore;
 var init_file_knowledge_store = __esm({
   "../org-manager/dist/file-knowledge-store.js"() {
     "use strict";
     init_dist();
-    log68 = createLogger("file-knowledge-store");
+    log70 = createLogger("file-knowledge-store");
     FileKnowledgeStore = class {
       baseDir;
       constructor(baseDir) {
         this.baseDir = baseDir;
-        mkdirSync20(baseDir, { recursive: true });
+        mkdirSync22(baseDir, { recursive: true });
       }
       scopeDir(scope, scopeId) {
-        return join25(this.baseDir, scope, scopeId);
+        return join27(this.baseDir, scope, scopeId);
       }
       indexPath(scope, scopeId) {
-        return join25(this.scopeDir(scope, scopeId), "_index.json");
+        return join27(this.scopeDir(scope, scopeId), "_index.json");
       }
       entryPath(entry) {
-        return join25(this.scopeDir(entry.scope, entry.scopeId), `${entry.id}.json`);
+        return join27(this.scopeDir(entry.scope, entry.scopeId), `${entry.id}.json`);
       }
       // ─── Load ────────────────────────────────────────────────────────────────
       loadAll() {
         const entries2 = [];
-        if (!existsSync30(this.baseDir))
+        if (!existsSync32(this.baseDir))
           return entries2;
         for (const scope of readdirSafe(this.baseDir)) {
-          const scopePath = join25(this.baseDir, scope);
+          const scopePath = join27(this.baseDir, scope);
           for (const scopeId of readdirSafe(scopePath)) {
-            const idxPath = join25(scopePath, scopeId, "_index.json");
-            if (!existsSync30(idxPath))
+            const idxPath = join27(scopePath, scopeId, "_index.json");
+            if (!existsSync32(idxPath))
               continue;
             try {
-              const data = JSON.parse(readFileSync23(idxPath, "utf-8"));
+              const data = JSON.parse(readFileSync25(idxPath, "utf-8"));
               entries2.push(...data);
             } catch (err) {
-              log68.warn("Failed to load index", { path: idxPath, error: String(err) });
+              log70.warn("Failed to load index", { path: idxPath, error: String(err) });
             }
           }
         }
-        log68.info("Knowledge loaded from disk", { count: entries2.length });
+        log70.info("Knowledge loaded from disk", { count: entries2.length });
         return entries2;
       }
       // ─── Write ───────────────────────────────────────────────────────────────
       saveEntry(entry) {
         const dir = this.scopeDir(entry.scope, entry.scopeId);
-        mkdirSync20(dir, { recursive: true });
-        writeFileSync18(join25(dir, `${entry.id}.json`), JSON.stringify(entry, null, 2));
+        mkdirSync22(dir, { recursive: true });
+        writeFileSync20(join27(dir, `${entry.id}.json`), JSON.stringify(entry, null, 2));
       }
       saveIndex(scope, scopeId, entries2) {
         const dir = this.scopeDir(scope, scopeId);
-        mkdirSync20(dir, { recursive: true });
-        writeFileSync18(join25(dir, "_index.json"), JSON.stringify(entries2, null, 2));
+        mkdirSync22(dir, { recursive: true });
+        writeFileSync20(join27(dir, "_index.json"), JSON.stringify(entries2, null, 2));
       }
       removeEntryFile(entry) {
-        const p = join25(this.scopeDir(entry.scope, entry.scopeId), `${entry.id}.json`);
+        const p = join27(this.scopeDir(entry.scope, entry.scopeId), `${entry.id}.json`);
         try {
           unlinkSync3(p);
         } catch {
@@ -93718,17 +94786,17 @@ var init_file_knowledge_store = __esm({
 });
 
 // ../org-manager/dist/deliverable-service.js
-import { existsSync as existsSync31, cpSync as cpSync3, mkdirSync as mkdirSync21 } from "node:fs";
-import { join as join26, basename } from "node:path";
+import { existsSync as existsSync33, cpSync as cpSync3, mkdirSync as mkdirSync23 } from "node:fs";
+import { join as join28, basename } from "node:path";
 function isUrl(s2) {
   return /^https?:\/\//i.test(s2);
 }
-var log69, DeliverableService;
+var log71, DeliverableService;
 var init_deliverable_service = __esm({
   "../org-manager/dist/deliverable-service.js"() {
     "use strict";
     init_dist();
-    log69 = createLogger("deliverable-service");
+    log71 = createLogger("deliverable-service");
     DeliverableService = class {
       repo;
       cache = /* @__PURE__ */ new Map();
@@ -93746,7 +94814,7 @@ var init_deliverable_service = __esm({
         for (const r of rows) {
           this.cache.set(r.id, this.rowToDeliverable(r));
         }
-        log69.info("Deliverables loaded", { count: this.cache.size });
+        log71.info("Deliverables loaded", { count: this.cache.size });
       }
       async create(opts) {
         const ref = opts.reference?.trim();
@@ -93772,7 +94840,7 @@ var init_deliverable_service = __esm({
             if (opts.taskId && !existing.taskId)
               patch.taskId = opts.taskId;
             const updated = await this.update(existing.id, patch);
-            log69.info("Deliverable upserted (updated existing)", { id: existing.id, reference: ref });
+            log71.info("Deliverable upserted (updated existing)", { id: existing.id, reference: ref });
             this.ws?.broadcastDeliverableUpdate(existing.id, "updated", {
               type: opts.type,
               title: opts.title,
@@ -93825,7 +94893,7 @@ var init_deliverable_service = __esm({
           testResults: opts.testResults
         });
         this.cache.set(id, deliverable);
-        log69.info("Deliverable created", { id, type: opts.type, title: opts.title });
+        log71.info("Deliverable created", { id, type: opts.type, title: opts.title });
         this.ws?.broadcastDeliverableUpdate(id, "created", {
           type: opts.type,
           title: opts.title,
@@ -93922,7 +94990,7 @@ var init_deliverable_service = __esm({
         if (data.testResults !== void 0 && !arrEq(data.testResults, d.testResults))
           changed.push("testResults");
         if (changed.length === 0) {
-          log69.debug("Deliverable update skipped (no-op)", { id });
+          log71.debug("Deliverable update skipped (no-op)", { id });
           return d;
         }
         const now3 = (/* @__PURE__ */ new Date()).toISOString();
@@ -93956,7 +95024,7 @@ var init_deliverable_service = __esm({
           d.testResults = data.testResults;
         d.updatedAt = now3;
         await this.repo?.update(id, data);
-        log69.info("Deliverable updated", { id, fields: changed });
+        log71.info("Deliverable updated", { id, fields: changed });
         this.ws?.broadcastDeliverableUpdate(id, "updated", {
           type: d.type,
           title: d.title,
@@ -93973,7 +95041,7 @@ var init_deliverable_service = __esm({
         d.status = "outdated";
         d.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         await this.repo?.update(id, { status: "outdated" });
-        log69.info("Deliverable flagged outdated", { id });
+        log71.info("Deliverable flagged outdated", { id });
         this.ws?.broadcastDeliverableUpdate(id, "removed", {
           type: d.type,
           title: d.title,
@@ -94035,7 +95103,7 @@ var init_deliverable_service = __esm({
           }
         }
         if (cleaned > 0) {
-          log69.info("Deduplicated deliverables by reference", { cleaned });
+          log71.info("Deduplicated deliverables by reference", { cleaned });
         }
         return cleaned;
       }
@@ -94048,30 +95116,30 @@ var init_deliverable_service = __esm({
         const deliverables = this.findByAgent(agentId2);
         if (deliverables.length === 0)
           return 0;
-        const sharedDeliverables = join26(sharedDataDir, "deliverables");
+        const sharedDeliverables = join28(sharedDataDir, "deliverables");
         let migrated = 0;
         for (const d of deliverables) {
           if (!d.reference || isUrl(d.reference))
             continue;
           if (!d.reference.startsWith(agentDir + "/") && d.reference !== agentDir)
             continue;
-          if (!existsSync31(d.reference))
+          if (!existsSync33(d.reference))
             continue;
           try {
-            const destDir = join26(sharedDeliverables, d.id);
-            mkdirSync21(destDir, { recursive: true });
+            const destDir = join28(sharedDeliverables, d.id);
+            mkdirSync23(destDir, { recursive: true });
             const fileName = basename(d.reference);
-            const destPath = join26(destDir, fileName);
+            const destPath = join28(destDir, fileName);
             cpSync3(d.reference, destPath, { recursive: true });
             await this.update(d.id, { reference: destPath });
             migrated++;
-            log69.info("Deliverable file migrated to shared", { id: d.id, from: d.reference, to: destPath });
+            log71.info("Deliverable file migrated to shared", { id: d.id, from: d.reference, to: destPath });
           } catch (err) {
-            log69.warn("Failed to migrate deliverable file", { id: d.id, reference: d.reference, error: String(err) });
+            log71.warn("Failed to migrate deliverable file", { id: d.id, reference: d.reference, error: String(err) });
           }
         }
         if (migrated > 0) {
-          log69.info("Migrated agent deliverable files to shared directory", { agentId: agentId2, migrated, total: deliverables.length });
+          log71.info("Migrated agent deliverable files to shared directory", { agentId: agentId2, migrated, total: deliverables.length });
         }
         return migrated;
       }
@@ -94085,7 +95153,7 @@ var init_deliverable_service = __esm({
         for (const d of deliverables) {
           if (!d.reference || isUrl(d.reference))
             continue;
-          if (!existsSync31(d.reference)) {
+          if (!existsSync33(d.reference)) {
             missing.push(d.id);
           }
         }
@@ -94107,7 +95175,7 @@ var init_deliverable_service = __esm({
           }
         }
         if (branchCleaned > 0) {
-          log69.info("Cleaned up legacy branch-type deliverables", { count: branchCleaned });
+          log71.info("Cleaned up legacy branch-type deliverables", { count: branchCleaned });
         }
         const existingTaskIds = this.repo ? await this.repo.listTaskIdsWithDeliverables() : new Set([...this.cache.values()].map((d) => d.taskId).filter(Boolean));
         let migrated = 0;
@@ -94134,12 +95202,12 @@ var init_deliverable_service = __esm({
               });
               migrated++;
             } catch (err) {
-              log69.warn("Failed to migrate task deliverable", { taskId: task.id, ref: d.reference, error: String(err) });
+              log71.warn("Failed to migrate task deliverable", { taskId: task.id, ref: d.reference, error: String(err) });
             }
           }
         }
         if (migrated > 0) {
-          log69.info("Migrated task deliverables to unified table", { migrated });
+          log71.info("Migrated task deliverables to unified table", { migrated });
         }
         return migrated;
       }
@@ -94194,12 +95262,12 @@ var init_deliverable_service = __esm({
 });
 
 // ../org-manager/dist/report-service.js
-var log70, ReportService;
+var log72, ReportService;
 var init_report_service = __esm({
   "../org-manager/dist/report-service.js"() {
     "use strict";
     init_dist();
-    log70 = createLogger("report-service");
+    log72 = createLogger("report-service");
     ReportService = class {
       taskService;
       billingService;
@@ -94252,7 +95320,7 @@ var init_report_service = __esm({
           generatedBy: opts.generatedBy ?? "system"
         };
         this.reports.set(report.id, report);
-        log70.info("Report generated", { id: report.id, type: report.type, scope: report.scope });
+        log72.info("Report generated", { id: report.id, type: report.type, scope: report.scope });
         return report;
       }
       getReport(id) {
@@ -94274,7 +95342,7 @@ var init_report_service = __esm({
         if (!report?.upcomingPlan)
           throw new Error("Report has no plan");
         report.upcomingPlan.status = "pending";
-        log70.info("Plan submitted for approval", { reportId });
+        log72.info("Plan submitted for approval", { reportId });
       }
       approvePlan(reportId, userId2) {
         const report = this.reports.get(reportId);
@@ -94301,7 +95369,7 @@ var init_report_service = __esm({
             projectId: report.scope === "project" ? report.scopeId : void 0
           });
         }
-        log70.info("Plan approved \u2014 tasks created", {
+        log72.info("Plan approved \u2014 tasks created", {
           reportId,
           taskCount: report.upcomingPlan.plannedTasks.length
         });
@@ -94313,7 +95381,7 @@ var init_report_service = __esm({
           throw new Error("Report has no plan");
         report.upcomingPlan.status = "rejected";
         report.upcomingPlan.rejectionReason = reason;
-        log70.info("Plan rejected", { reportId, reason });
+        log72.info("Plan rejected", { reportId, reason });
         return report;
       }
       // ─── Feedback ──────────────────────────────────────────────────────────────
@@ -94365,7 +95433,7 @@ var init_report_service = __esm({
         const existing = this.feedbackStore.get(opts.reportId) ?? [];
         existing.push(feedback);
         this.feedbackStore.set(opts.reportId, existing);
-        log70.info("Feedback added to report", {
+        log72.info("Feedback added to report", {
           reportId: opts.reportId,
           type: opts.type,
           disclosure: opts.disclosure.scope
@@ -94450,12 +95518,12 @@ var init_report_service = __esm({
 });
 
 // ../org-manager/dist/trust-service.js
-var log71, TrustService;
+var log73, TrustService;
 var init_trust_service = __esm({
   "../org-manager/dist/trust-service.js"() {
     "use strict";
     init_dist();
-    log71 = createLogger("trust-service");
+    log73 = createLogger("trust-service");
     TrustService = class {
       trustLevels = /* @__PURE__ */ new Map();
       getOrCreate(agentId2) {
@@ -94504,7 +95572,7 @@ var init_trust_service = __esm({
         trust.level = this.scoreToLevel(trust.score, trust.totalDeliveries);
         trust.lastEvaluatedAt = (/* @__PURE__ */ new Date()).toISOString();
         if (trust.level !== oldLevel) {
-          log71.info("Trust level changed", {
+          log73.info("Trust level changed", {
             agentId: trust.agentId,
             oldLevel,
             newLevel: trust.level,
@@ -94549,12 +95617,12 @@ var init_trust_service = __esm({
 });
 
 // ../org-manager/dist/archive-service.js
-var log72, ARCHIVABLE_STATUSES, ACTIVE_DISCUSSION_DAYS, ACTIVE_DISCUSSION_MS, ArchiveService;
+var log74, ARCHIVABLE_STATUSES, ACTIVE_DISCUSSION_DAYS, ACTIVE_DISCUSSION_MS, ArchiveService;
 var init_archive_service = __esm({
   "../org-manager/dist/archive-service.js"() {
     "use strict";
     init_dist();
-    log72 = createLogger("archive-service");
+    log74 = createLogger("archive-service");
     ARCHIVABLE_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "rejected", "cancelled"]);
     ACTIVE_DISCUSSION_DAYS = 7;
     ACTIVE_DISCUSSION_MS = ACTIVE_DISCUSSION_DAYS * 864e5;
@@ -94575,11 +95643,11 @@ var init_archive_service = __esm({
        * then repeats at the configured interval.
        */
       start(intervalMs = ARCHIVE_SCAN_INTERVAL_MS) {
-        this.runArchiveScan().catch((err) => log72.warn("Initial archive scan failed", { error: String(err) }));
+        this.runArchiveScan().catch((err) => log74.warn("Initial archive scan failed", { error: String(err) }));
         this.scanInterval = setInterval(() => {
-          this.runArchiveScan().catch((err) => log72.warn("Archive scan failed", { error: String(err) }));
+          this.runArchiveScan().catch((err) => log74.warn("Archive scan failed", { error: String(err) }));
         }, intervalMs);
-        log72.info("Archive service started", { intervalMs });
+        log74.info("Archive service started", { intervalMs });
       }
       stop() {
         if (this.scanInterval) {
@@ -94591,7 +95659,7 @@ var init_archive_service = __esm({
         const archivedTasks = await this.archiveTasks();
         const archivedRequirements = this.archiveRequirements();
         if (archivedTasks > 0 || archivedRequirements > 0) {
-          log72.info("Archive scan complete", { archivedTasks, archivedRequirements });
+          log74.info("Archive scan complete", { archivedTasks, archivedRequirements });
         }
         return { archivedTasks, archivedRequirements };
       }
@@ -94614,7 +95682,7 @@ var init_archive_service = __esm({
               this.taskService.archiveTask(task.id);
               archived++;
             } catch (err) {
-              log72.warn("Failed to archive task", { taskId: task.id, error: String(err) });
+              log74.warn("Failed to archive task", { taskId: task.id, error: String(err) });
             }
           }
         }
@@ -94639,7 +95707,7 @@ var init_archive_service = __esm({
               this.requirementService.updateRequirementStatus(req.id, "archived");
               archived++;
             } catch (err) {
-              log72.warn("Failed to archive requirement", { requirementId: req.id, error: String(err) });
+              log74.warn("Failed to archive requirement", { requirementId: req.id, error: String(err) });
             }
           }
         }
@@ -94681,12 +95749,12 @@ var init_archive_service = __esm({
 });
 
 // ../org-manager/dist/stale-detector.js
-var log73, DEFAULT_CONFIG4, StaleDetector;
+var log75, DEFAULT_CONFIG4, StaleDetector;
 var init_stale_detector = __esm({
   "../org-manager/dist/stale-detector.js"() {
     "use strict";
     init_dist();
-    log73 = createLogger("stale-detector");
+    log75 = createLogger("stale-detector");
     DEFAULT_CONFIG4 = {
       maxInProgressMs: 24 * 60 * 60 * 1e3,
       maxReviewWaitMs: 12 * 60 * 60 * 1e3,
@@ -94709,9 +95777,9 @@ var init_stale_detector = __esm({
             if (items.length > 0 && this.onStaleItems) {
               this.onStaleItems(items);
             }
-          }).catch((err) => log73.warn("Stale scan failed", { error: String(err) }));
+          }).catch((err) => log75.warn("Stale scan failed", { error: String(err) }));
         }, intervalMs);
-        log73.info("Stale detector started", { intervalMs });
+        log75.info("Stale detector started", { intervalMs });
       }
       stop() {
         if (this.scanInterval) {
@@ -94754,7 +95822,7 @@ var init_stale_detector = __esm({
           }
         }
         if (staleItems.length > 0) {
-          log73.info(`Found ${staleItems.length} stale items`);
+          log75.info(`Found ${staleItems.length} stale items`);
         }
         return staleItems;
       }
@@ -94763,12 +95831,12 @@ var init_stale_detector = __esm({
 });
 
 // ../org-manager/dist/scheduled-task-runner.js
-var log74, MIN_STAGGER_MS, MAX_STAGGER_MS, ScheduledTaskRunner;
+var log76, MIN_STAGGER_MS, MAX_STAGGER_MS, ScheduledTaskRunner;
 var init_scheduled_task_runner = __esm({
   "../org-manager/dist/scheduled-task-runner.js"() {
     "use strict";
     init_dist();
-    log74 = createLogger("scheduled-task-runner");
+    log76 = createLogger("scheduled-task-runner");
     MIN_STAGGER_MS = 2 * 6e4;
     MAX_STAGGER_MS = 15 * 6e4;
     ScheduledTaskRunner = class {
@@ -94787,11 +95855,11 @@ var init_scheduled_task_runner = __esm({
           return;
         this.running = true;
         this.startedAt = Date.now();
-        this.tick().catch((e) => log74.error("Initial scheduled task tick failed", { error: String(e) }));
+        this.tick().catch((e) => log76.error("Initial scheduled task tick failed", { error: String(e) }));
         this.timer = setInterval(() => {
-          this.tick().catch((e) => log74.error("Scheduled task tick failed", { error: String(e) }));
+          this.tick().catch((e) => log76.error("Scheduled task tick failed", { error: String(e) }));
         }, this.pollIntervalMs);
-        log74.info("ScheduledTaskRunner started", { pollIntervalMs: this.pollIntervalMs });
+        log76.info("ScheduledTaskRunner started", { pollIntervalMs: this.pollIntervalMs });
       }
       stop() {
         if (this.timer) {
@@ -94802,7 +95870,7 @@ var init_scheduled_task_runner = __esm({
           clearTimeout(t);
         this.staggerTimers = [];
         this.running = false;
-        log74.info("ScheduledTaskRunner stopped");
+        log76.info("ScheduledTaskRunner stopped");
       }
       isRunning() {
         return this.running;
@@ -94836,7 +95904,7 @@ var init_scheduled_task_runner = __esm({
           }
           if (startup && nextRun < this.startedAt) {
             const delay = MIN_STAGGER_MS + Math.random() * (MAX_STAGGER_MS - MIN_STAGGER_MS);
-            log74.info("Staggering overdue scheduled task", {
+            log76.info("Staggering overdue scheduled task", {
               taskId: task.id,
               title: task.title,
               overdueBy: `${Math.round((now3 - nextRun) / 6e4)}m`,
@@ -94845,7 +95913,7 @@ var init_scheduled_task_runner = __esm({
             const timer = setTimeout(() => {
               if (!this.running)
                 return;
-              this.fireScheduledTask(task).catch((e) => log74.error("Failed to fire staggered scheduled task", { taskId: task.id, error: String(e) }));
+              this.fireScheduledTask(task).catch((e) => log76.error("Failed to fire staggered scheduled task", { taskId: task.id, error: String(e) }));
             }, delay);
             this.staggerTimers.push(timer);
             continue;
@@ -94853,27 +95921,27 @@ var init_scheduled_task_runner = __esm({
           try {
             await this.fireScheduledTask(task);
           } catch (e) {
-            log74.error("Failed to fire scheduled task", { taskId: task.id, error: String(e) });
+            log76.error("Failed to fire scheduled task", { taskId: task.id, error: String(e) });
           }
         }
       }
       async fireScheduledTask(task) {
-        log74.info("Firing scheduled task", { taskId: task.id, title: task.title });
+        log76.info("Firing scheduled task", { taskId: task.id, title: task.title });
         await this.taskService.advanceScheduleConfig(task.id);
         const resettableStatuses = ["completed", "cancelled", "failed"];
         if (resettableStatuses.includes(task.status)) {
           await this.taskService.resetTaskForRerun(task.id);
         } else if (!["in_progress", "review", "blocked", "pending"].includes(task.status)) {
-          log74.warn("Scheduled task has unexpected status, resetting for rerun", { taskId: task.id, status: task.status });
+          log76.warn("Scheduled task has unexpected status, resetting for rerun", { taskId: task.id, status: task.status });
           await this.taskService.resetTaskForRerun(task.id);
         }
         const current = this.taskService.getTask(task.id);
         if (current && current.status === "in_progress") {
           try {
             await this.taskService.runTask(task.id);
-            log74.info("Scheduled task auto-started", { taskId: task.id });
+            log76.info("Scheduled task auto-started", { taskId: task.id });
           } catch (err) {
-            log74.warn("Failed to auto-start scheduled task (agent may be busy)", { taskId: task.id, error: String(err) });
+            log76.warn("Failed to auto-start scheduled task (agent may be busy)", { taskId: task.id, error: String(err) });
           }
         }
       }
@@ -94883,11 +95951,11 @@ var init_scheduled_task_runner = __esm({
 
 // ../storage/dist/sqlite-storage.js
 import { DatabaseSync } from "node:sqlite";
-import { randomUUID } from "node:crypto";
-import { mkdirSync as mkdirSync22 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdirSync as mkdirSync24 } from "node:fs";
+import { dirname as dirname11 } from "node:path";
 function generateId2(prefix = "") {
-  const uuid = randomUUID().replace(/-/g, "").slice(0, 16);
+  const uuid = randomUUID2().replace(/-/g, "").slice(0, 16);
   return prefix ? `${prefix}_${uuid}` : uuid;
 }
 function now2() {
@@ -94905,7 +95973,7 @@ function toDate(v) {
 function openSqlite(dbPath) {
   if (_db)
     return _db;
-  mkdirSync22(dirname9(dbPath), { recursive: true });
+  mkdirSync24(dirname11(dbPath), { recursive: true });
   _db = new DatabaseSync(dbPath);
   _db.exec("PRAGMA journal_mode = WAL");
   _db.exec("PRAGMA foreign_keys = ON");
@@ -94949,6 +96017,8 @@ function openSqlite(dbPath) {
     { table: "projects", column: "created_by", sql: "ALTER TABLE projects ADD COLUMN created_by TEXT" },
     { table: "approvals", column: "target_user_id", sql: "ALTER TABLE approvals ADD COLUMN target_user_id TEXT" },
     { table: "users", column: "deleted_at", sql: "ALTER TABLE users ADD COLUMN deleted_at TEXT" },
+    { table: "users", column: "hub_user_id", sql: "ALTER TABLE users ADD COLUMN hub_user_id TEXT" },
+    { table: "users", column: "hub_username", sql: "ALTER TABLE users ADD COLUMN hub_username TEXT" },
     { table: "agents", column: "deleted_at", sql: "ALTER TABLE agents ADD COLUMN deleted_at TEXT" },
     { table: "deliverables", column: "format", sql: "ALTER TABLE deliverables ADD COLUMN format TEXT" },
     { table: "task_comments", column: "reply_to_id", sql: "ALTER TABLE task_comments ADD COLUMN reply_to_id TEXT" },
@@ -94958,7 +96028,7 @@ function openSqlite(dbPath) {
     const cols = _db.prepare(`PRAGMA table_info(${m.table})`).all();
     if (!cols.some((c) => c.name === m.column)) {
       _db.exec(m.sql);
-      log75.info(`Migration: added column ${m.column} to ${m.table}`);
+      log77.info(`Migration: added column ${m.column} to ${m.table}`);
     }
   }
   _db.exec("CREATE INDEX IF NOT EXISTS idx_agent_activities_mailbox ON agent_activities(mailbox_item_id)");
@@ -94972,10 +96042,10 @@ function openSqlite(dbPath) {
   for (const m of statusMigrations) {
     const result = _db.prepare(m.sql).run();
     if (result.changes > 0) {
-      log75.info(`Status migration: ${m.desc} (${result.changes} rows)`);
+      log77.info(`Status migration: ${m.desc} (${result.changes} rows)`);
     }
   }
-  log75.info("SQLite database opened", { path: dbPath });
+  log77.info("SQLite database opened", { path: dbPath });
   return _db;
 }
 function closeSqlite() {
@@ -94995,7 +96065,7 @@ function migrateToExecutionStreamLogs(db) {
       SELECT id, 'task', task_id, agent_id, seq, type, content, metadata, execution_round, created_at
       FROM task_logs
     `);
-    log75.info(`Migration: copied ${taskLogCount} task_logs to execution_stream_logs`);
+    log77.info(`Migration: copied ${taskLogCount} task_logs to execution_stream_logs`);
   }
   const actLogCount = db.prepare("SELECT COUNT(*) as cnt FROM agent_activity_logs").get().cnt;
   if (actLogCount > 0) {
@@ -95006,15 +96076,15 @@ function migrateToExecutionStreamLogs(db) {
              seq, type, content, metadata, NULL, created_at
       FROM agent_activity_logs
     `);
-    log75.info(`Migration: copied ${actLogCount} agent_activity_logs to execution_stream_logs`);
+    log77.info(`Migration: copied ${actLogCount} agent_activity_logs to execution_stream_logs`);
   }
 }
-var log75, SCHEMA_SQL, _db, SqliteOrgRepo, SqliteAgentRepo, SqliteTaskRepo, SqliteRequirementRepo, SqliteProjectRepo, SqliteAuditRepo, SqliteTaskLogRepo, SqliteTaskCommentRepo, SqliteRequirementCommentRepo, SqliteMessageRepo, SqliteChatSessionRepo, SqliteChannelMessageRepo, SqliteUserRepo, SqliteTeamRepo, SqliteMarketplaceTemplateRepo, SqliteMarketplaceSkillRepo, SqliteMarketplaceRatingRepo, SqliteAgentKnowledgeRepo, SqliteExternalAgentRepo, SqliteDeliverableRepo, SqliteActivityRepo, SqliteExecutionStreamRepo, SqliteMailboxRepo, SqliteDecisionRepo, SqliteNotificationRepo, SqliteApprovalRepo, SqliteGroupChatRepo, SqliteStatusTransitionRepo, SqliteReadCursorRepo;
+var log77, SCHEMA_SQL, _db, SqliteOrgRepo, SqliteAgentRepo, SqliteTaskRepo, SqliteRequirementRepo, SqliteProjectRepo, SqliteAuditRepo, SqliteTaskLogRepo, SqliteTaskCommentRepo, SqliteRequirementCommentRepo, SqliteMessageRepo, SqliteChatSessionRepo, SqliteChannelMessageRepo, SqliteUserRepo, SqliteTeamRepo, SqliteMarketplaceTemplateRepo, SqliteMarketplaceSkillRepo, SqliteMarketplaceRatingRepo, SqliteAgentKnowledgeRepo, SqliteExternalAgentRepo, SqliteDeliverableRepo, SqliteActivityRepo, SqliteExecutionStreamRepo, SqliteMailboxRepo, SqliteDecisionRepo, SqliteNotificationRepo, SqliteApprovalRepo, SqliteGroupChatRepo, SqliteStatusTransitionRepo, SqliteReadCursorRepo;
 var init_sqlite_storage = __esm({
   "../storage/dist/sqlite-storage.js"() {
     "use strict";
     init_dist();
-    log75 = createLogger("sqlite-storage");
+    log77 = createLogger("sqlite-storage");
     SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS organizations (
   id TEXT PRIMARY KEY,
@@ -96496,7 +97566,7 @@ CREATE TABLE IF NOT EXISTS user_read_cursors (
           migrated++;
         }
         if (migrated > 0) {
-          log75.info(`Migrated ${migrated} legacy chat messages to segment format`);
+          log77.info(`Migrated ${migrated} legacy chat messages to segment format`);
         }
         return migrated;
       }
@@ -96508,7 +97578,7 @@ CREATE TABLE IF NOT EXISTS user_read_cursors (
         const result = this.db.prepare("UPDATE chat_sessions SET user_id = ? WHERE user_id IS NULL").run(defaultUserId);
         const count = Number(result.changes);
         if (count > 0) {
-          log75.info(`Migrated ${count} chat sessions with NULL user_id to user ${defaultUserId}`);
+          log77.info(`Migrated ${count} chat sessions with NULL user_id to user ${defaultUserId}`);
         }
         return count;
       }
@@ -96522,7 +97592,7 @@ CREATE TABLE IF NOT EXISTS user_read_cursors (
         const result = this.db.prepare("UPDATE chat_sessions SET user_id = ? WHERE user_id = 'default'").run(realOwnerId);
         const count = Number(result.changes);
         if (count > 0) {
-          log75.info(`Migrated ${count} chat sessions from user_id='default' to ${realOwnerId}`);
+          log77.info(`Migrated ${count} chat sessions from user_id='default' to ${realOwnerId}`);
         }
         return count;
       }
@@ -96668,13 +97738,13 @@ CREATE TABLE IF NOT EXISTS user_read_cursors (
         this.db = db;
       }
       create(data) {
-        this.db.prepare("INSERT INTO users (id, org_id, name, email, role, team_id, password_hash, created_at) VALUES (?,?,?,?,?,?,?,?)").run(data.id, data.orgId, data.name, data.email ?? null, data.role ?? "member", data.teamId ?? null, data.passwordHash ?? null, now2());
+        this.db.prepare("INSERT INTO users (id, org_id, name, email, role, team_id, password_hash, hub_user_id, avatar_url, created_at) VALUES (?,?,?,?,?,?,?,?,?,?)").run(data.id, data.orgId, data.name, data.email ?? null, data.role ?? "member", data.teamId ?? null, data.passwordHash ?? null, data.hubUserId ?? null, data.avatarUrl ?? null, now2());
         return this.findById(data.id);
       }
       async upsert(data) {
-        this.db.prepare(`INSERT INTO users (id, org_id, name, email, role, team_id, password_hash, created_at)
-       VALUES (?,?,?,?,?,?,?,?)
-       ON CONFLICT(id) DO UPDATE SET name = excluded.name, email = excluded.email, role = excluded.role, team_id = excluded.team_id, password_hash = COALESCE(excluded.password_hash, password_hash)`).run(data.id, data.orgId, data.name, data.email ?? null, data.role ?? "member", data.teamId ?? null, data.passwordHash ?? null, now2());
+        this.db.prepare(`INSERT INTO users (id, org_id, name, email, role, team_id, password_hash, hub_user_id, created_at)
+       VALUES (?,?,?,?,?,?,?,?,?)
+       ON CONFLICT(id) DO UPDATE SET name = excluded.name, email = excluded.email, role = excluded.role, team_id = excluded.team_id, password_hash = COALESCE(excluded.password_hash, password_hash), hub_user_id = COALESCE(excluded.hub_user_id, hub_user_id)`).run(data.id, data.orgId, data.name, data.email ?? null, data.role ?? "member", data.teamId ?? null, data.passwordHash ?? null, data.hubUserId ?? null, now2());
       }
       async updateTeamId(id, teamId) {
         this.db.prepare("UPDATE users SET team_id = ? WHERE id = ?").run(teamId, id);
@@ -96689,6 +97759,17 @@ CREATE TABLE IF NOT EXISTS user_read_cursors (
         const r = this.db.prepare("SELECT * FROM users WHERE email = ? AND deleted_at IS NULL").get(email);
         return r ? this._map(r) : null;
       }
+      findByHubUserId(hubUserId) {
+        const r = this.db.prepare("SELECT * FROM users WHERE hub_user_id = ? AND deleted_at IS NULL").get(hubUserId);
+        return r ? this._map(r) : null;
+      }
+      updateHubUserId(id, hubUserId, hubUsername) {
+        if (hubUsername) {
+          this.db.prepare("UPDATE users SET hub_user_id = ?, hub_username = ? WHERE id = ?").run(hubUserId, hubUsername, id);
+        } else {
+          this.db.prepare("UPDATE users SET hub_user_id = ? WHERE id = ?").run(hubUserId, id);
+        }
+      }
       findById(id) {
         const r = this.db.prepare("SELECT * FROM users WHERE id = ?").get(id);
         return r ? this._map(r) : null;
@@ -96765,7 +97846,7 @@ CREATE TABLE IF NOT EXISTS user_read_cursors (
           return newId;
         }
         this.db.prepare("UPDATE users SET id = ? WHERE id = 'default'").run(newId);
-        log75.info(`Migrated user id='default' to '${newId}'`);
+        log77.info(`Migrated user id='default' to '${newId}'`);
         return newId;
       }
       _map(r) {
@@ -96778,6 +97859,8 @@ CREATE TABLE IF NOT EXISTS user_read_cursors (
           teamId: r["team_id"],
           passwordHash: r["password_hash"],
           avatarUrl: r["avatar_url"],
+          hubUserId: r["hub_user_id"],
+          hubUsername: r["hub_username"],
           inviteToken: r["invite_token"],
           inviteExpiresAt: r["invite_expires_at"],
           createdAt: toDate(r["created_at"]),
@@ -97824,7 +98907,7 @@ CREATE TABLE IF NOT EXISTS user_read_cursors (
         const result = this.db.prepare("UPDATE user_notifications SET user_id = ? WHERE user_id = 'default'").run(realOwnerId);
         const count = Number(result.changes);
         if (count > 0) {
-          log75.info(`Migrated ${count} notifications from user_id='default' to ${realOwnerId}`);
+          log77.info(`Migrated ${count} notifications from user_id='default' to ${realOwnerId}`);
         }
         return count;
       }
@@ -97905,7 +98988,7 @@ CREATE TABLE IF NOT EXISTS user_read_cursors (
         const result = this.db.prepare("UPDATE approvals SET target_user_id = ? WHERE target_user_id = 'default'").run(realOwnerId);
         const count = Number(result.changes);
         if (count > 0) {
-          log75.info(`Migrated ${count} approvals from target_user_id='default' to ${realOwnerId}`);
+          log77.info(`Migrated ${count} approvals from target_user_id='default' to ${realOwnerId}`);
         }
         return count;
       }
@@ -98154,17 +99237,17 @@ var init_dist5 = __esm({
 });
 
 // ../org-manager/dist/storage-bridge.js
-import { homedir as homedir16 } from "node:os";
-import { join as join27 } from "node:path";
+import { homedir as homedir18 } from "node:os";
+import { join as join29 } from "node:path";
 function resolveSqlitePath(url) {
   if (url?.startsWith("sqlite:")) {
     let p = url.slice("sqlite:".length);
     if (p.startsWith("~/") || p === "~") {
-      p = join27(homedir16(), p.slice(2));
+      p = join29(homedir18(), p.slice(2));
     }
     return p;
   }
-  return join27(homedir16(), ".markus", "data.db");
+  return join29(homedir18(), ".markus", "data.db");
 }
 async function initStorage(databaseUrl) {
   const url = databaseUrl ?? process.env["DATABASE_URL"];
@@ -98202,28 +99285,28 @@ async function initSqliteStorage(url) {
       statusTransitionRepo: new storage.SqliteStatusTransitionRepo(db),
       readCursorRepo: new storage.SqliteReadCursorRepo(db)
     };
-    log76.info("SQLite storage initialized", { path: dbPath });
+    log78.info("SQLite storage initialized", { path: dbPath });
     return bridge;
   } catch (error) {
-    log76.warn("Failed to initialize SQLite storage, falling back to memory-only mode", {
+    log78.warn("Failed to initialize SQLite storage, falling back to memory-only mode", {
       error: String(error)
     });
     return null;
   }
 }
-var log76;
+var log78;
 var init_storage_bridge = __esm({
   "../org-manager/dist/storage-bridge.js"() {
     "use strict";
     init_dist();
-    log76 = createLogger("storage-bridge");
+    log78 = createLogger("storage-bridge");
   }
 });
 
 // ../org-manager/dist/file-storage-provider.js
-import { mkdirSync as mkdirSync23, writeFileSync as writeFileSync19, unlinkSync as unlinkSync4, existsSync as existsSync32 } from "node:fs";
-import { join as join28, extname } from "node:path";
-import { homedir as homedir17 } from "node:os";
+import { mkdirSync as mkdirSync25, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, existsSync as existsSync34 } from "node:fs";
+import { join as join30, extname } from "node:path";
+import { homedir as homedir19 } from "node:os";
 function mimeToExt(mime) {
   const map = {
     "image/jpeg": ".jpg",
@@ -98243,27 +99326,27 @@ var init_file_storage_provider = __esm({
     LocalFileStorageProvider = class {
       baseDir;
       constructor(baseDir) {
-        this.baseDir = baseDir ?? join28(homedir17(), ".markus", "uploads");
-        mkdirSync23(this.baseDir, { recursive: true });
+        this.baseDir = baseDir ?? join30(homedir19(), ".markus", "uploads");
+        mkdirSync25(this.baseDir, { recursive: true });
       }
       async upload(data, opts) {
         const ext = extname(opts.name) || mimeToExt(opts.contentType);
         const key2 = `${generateId("upl")}${ext}`;
-        const subDir = opts.prefix ? join28(this.baseDir, opts.prefix) : this.baseDir;
-        mkdirSync23(subDir, { recursive: true });
-        writeFileSync19(join28(subDir, key2), data);
+        const subDir = opts.prefix ? join30(this.baseDir, opts.prefix) : this.baseDir;
+        mkdirSync25(subDir, { recursive: true });
+        writeFileSync21(join30(subDir, key2), data);
         const urlPath = opts.prefix ? `/api/uploads/${opts.prefix}/${key2}` : `/api/uploads/${key2}`;
         return { url: urlPath, key: opts.prefix ? `${opts.prefix}/${key2}` : key2 };
       }
       async delete(key2) {
-        const filePath = join28(this.baseDir, key2);
-        if (existsSync32(filePath)) {
+        const filePath = join30(this.baseDir, key2);
+        if (existsSync34(filePath)) {
           unlinkSync4(filePath);
         }
       }
       /** Resolve a storage key to an absolute filesystem path (for serving). */
       resolve(key2) {
-        return join28(this.baseDir, key2);
+        return join30(this.baseDir, key2);
       }
     };
   }
@@ -98281,6 +99364,7 @@ __export(dist_exports5, {
   FileKnowledgeStore: () => FileKnowledgeStore,
   HITLService: () => HITLService,
   KnowledgeService: () => KnowledgeService,
+  LicenseService: () => LicenseService,
   LocalFileStorageProvider: () => LocalFileStorageProvider,
   OrganizationService: () => OrganizationService,
   ProjectService: () => ProjectService,
@@ -98289,6 +99373,7 @@ __export(dist_exports5, {
   ScheduledTaskRunner: () => ScheduledTaskRunner,
   StaleDetector: () => StaleDetector,
   TaskService: () => TaskService,
+  TelemetryService: () => TelemetryService,
   TrustService: () => TrustService,
   WSBroadcaster: () => WSBroadcaster,
   initStorage: () => initStorage,
@@ -98304,6 +99389,8 @@ var init_dist6 = __esm({
     init_ws_server();
     init_hitl_service();
     init_billing_service();
+    init_license_service();
+    init_telemetry_service();
     init_audit_service();
     init_project_service();
     init_requirement_service();
@@ -98323,12 +99410,12 @@ var init_dist6 = __esm({
 });
 
 // ../comms/dist/feishu/client.js
-var log77, FeishuClient;
+var log79, FeishuClient;
 var init_client = __esm({
   "../comms/dist/feishu/client.js"() {
     "use strict";
     init_dist();
-    log77 = createLogger("feishu-client");
+    log79 = createLogger("feishu-client");
     FeishuClient = class {
       appId;
       appSecret;
@@ -98358,7 +99445,7 @@ var init_client = __esm({
         }
         this.tenantToken = data.tenant_access_token;
         this.tokenExpiresAt = Date.now() + (data.expire - 300) * 1e3;
-        log77.info("Feishu tenant token refreshed");
+        log79.info("Feishu tenant token refreshed");
         return this.tenantToken;
       }
       async sendTextMessage(chatId, text) {
@@ -98492,13 +99579,13 @@ var init_client = __esm({
 import { createServer as createServer3 } from "node:http";
 import { createDecipheriv, scrypt } from "node:crypto";
 import { promisify as promisify3 } from "node:util";
-var log78, scryptAsync, FeishuAdapter;
+var log80, scryptAsync, FeishuAdapter;
 var init_adapter = __esm({
   "../comms/dist/feishu/adapter.js"() {
     "use strict";
     init_dist();
     init_client();
-    log78 = createLogger("feishu-adapter");
+    log80 = createLogger("feishu-adapter");
     scryptAsync = promisify3(scrypt);
     FeishuAdapter = class {
       platform = "feishu";
@@ -98519,10 +99606,10 @@ var init_adapter = __esm({
         const port = this.config.webhookPort ?? 9e3;
         this.server = createServer3((req, res) => this.handleWebhook(req, res));
         this.server.listen(port, () => {
-          log78.info(`Feishu webhook server listening on port ${port}`);
+          log80.info(`Feishu webhook server listening on port ${port}`);
         });
         this.connected = true;
-        log78.info("Feishu adapter connected");
+        log80.info("Feishu adapter connected");
       }
       async disconnect() {
         if (this.server) {
@@ -98530,7 +99617,7 @@ var init_adapter = __esm({
           this.server = void 0;
         }
         this.connected = false;
-        log78.info("Feishu adapter disconnected");
+        log80.info("Feishu adapter disconnected");
       }
       async sendMessage(channelId, content, options) {
         if (!this.client)
@@ -98606,12 +99693,12 @@ var init_adapter = __esm({
             res.end("ok");
             if (event.header?.event_type === "im.message.receive_v1") {
               this.processMessageEvent(event).catch((err) => {
-                log78.error("Failed to process Feishu message event", { error: err.message });
+                log80.error("Failed to process Feishu message event", { error: err.message });
               });
             }
             if (event["action"]) {
               this.processCardAction(event).catch((err) => {
-                log78.error("Failed to process card action", { error: err.message });
+                log80.error("Failed to process card action", { error: err.message });
               });
             }
           };
@@ -98622,14 +99709,14 @@ var init_adapter = __esm({
                 const event = JSON.parse(decrypted);
                 processEvent(event);
               } else if (raw.encrypt && !this.config?.encryptKey) {
-                log78.warn("Received encrypted Feishu payload but no encryptKey configured");
+                log80.warn("Received encrypted Feishu payload but no encryptKey configured");
                 res.writeHead(200);
                 res.end("ok");
               } else {
                 processEvent(raw);
               }
             } catch (err) {
-              log78.error("Failed to process Feishu webhook", { error: err instanceof Error ? err.message : String(err) });
+              log80.error("Failed to process Feishu webhook", { error: err instanceof Error ? err.message : String(err) });
               res.writeHead(400);
               res.end("bad request");
             }
@@ -98674,7 +99761,7 @@ var init_adapter = __esm({
           try {
             await handler4(message);
           } catch (error) {
-            log78.error("Message handler failed", { error });
+            log80.error("Message handler failed", { error });
           }
         }
       }
@@ -98709,7 +99796,7 @@ var init_adapter = __esm({
           try {
             await handler4(message);
           } catch (error) {
-            log78.error("Card action handler failed", { error });
+            log80.error("Card action handler failed", { error });
           }
         }
       }
@@ -98726,12 +99813,12 @@ var init_cards = __esm({
 
 // ../comms/dist/webui/adapter.js
 import { createServer as createServer4 } from "node:http";
-var log79, WebUIAdapter;
+var log81, WebUIAdapter;
 var init_adapter2 = __esm({
   "../comms/dist/webui/adapter.js"() {
     "use strict";
     init_dist();
-    log79 = createLogger("webui-adapter");
+    log81 = createLogger("webui-adapter");
     WebUIAdapter = class {
       platform = "webui";
       handlers = [];
@@ -98743,7 +99830,7 @@ var init_adapter2 = __esm({
         this.port = config["port"] ?? 8058;
         this.server = createServer4((req, res) => this.handleRequest(req, res));
         this.server.listen(this.port, "0.0.0.0", () => {
-          log79.info(`WebUI comm server listening on 0.0.0.0:${this.port}`);
+          log81.info(`WebUI comm server listening on 0.0.0.0:${this.port}`);
         });
         this.connected = true;
       }
@@ -98816,7 +99903,7 @@ var init_adapter2 = __esm({
             res.end(JSON.stringify({ received: true, messageId: message.id }));
             for (const handler4 of this.handlers) {
               handler4(message).catch((err) => {
-                log79.error("WebUI message handler failed", { error: String(err) });
+                log81.error("WebUI message handler failed", { error: String(err) });
               });
             }
           } catch (error) {
@@ -98830,87 +99917,87 @@ var init_adapter2 = __esm({
 });
 
 // ../comms/dist/whatsapp/client.js
-var log80;
+var log82;
 var init_client2 = __esm({
   "../comms/dist/whatsapp/client.js"() {
     "use strict";
     init_dist();
-    log80 = createLogger("whatsapp-client");
+    log82 = createLogger("whatsapp-client");
   }
 });
 
 // ../comms/dist/whatsapp/adapter.js
-var log81;
+var log83;
 var init_adapter3 = __esm({
   "../comms/dist/whatsapp/adapter.js"() {
     "use strict";
     init_dist();
     init_client2();
-    log81 = createLogger("whatsapp-adapter");
+    log83 = createLogger("whatsapp-adapter");
   }
 });
 
 // ../comms/dist/slack/client.js
-var log82;
+var log84;
 var init_client3 = __esm({
   "../comms/dist/slack/client.js"() {
     "use strict";
     init_dist();
-    log82 = createLogger("slack-client");
+    log84 = createLogger("slack-client");
   }
 });
 
 // ../comms/dist/slack/adapter.js
-var log83;
+var log85;
 var init_adapter4 = __esm({
   "../comms/dist/slack/adapter.js"() {
     "use strict";
     init_dist();
     init_client3();
-    log83 = createLogger("slack-adapter");
+    log85 = createLogger("slack-adapter");
   }
 });
 
 // ../comms/dist/telegram/client.js
-var log84;
+var log86;
 var init_client4 = __esm({
   "../comms/dist/telegram/client.js"() {
     "use strict";
     init_dist();
-    log84 = createLogger("telegram-client");
+    log86 = createLogger("telegram-client");
   }
 });
 
 // ../comms/dist/telegram/adapter.js
-var log85;
+var log87;
 var init_adapter5 = __esm({
   "../comms/dist/telegram/adapter.js"() {
     "use strict";
     init_dist();
     init_client4();
-    log85 = createLogger("telegram-adapter");
+    log87 = createLogger("telegram-adapter");
   }
 });
 
 // ../comms/dist/router.js
-var log86, MessageRouter;
+var log88, MessageRouter;
 var init_router2 = __esm({
   "../comms/dist/router.js"() {
     "use strict";
     init_dist();
-    log86 = createLogger("message-router");
+    log88 = createLogger("message-router");
     MessageRouter = class {
       adapters = /* @__PURE__ */ new Map();
       agentChannelMap = /* @__PURE__ */ new Map();
       agentHandler;
       registerAdapter(adapter2) {
         this.adapters.set(adapter2.platform, adapter2);
-        log86.info(`Registered comm adapter: ${adapter2.platform}`);
+        log88.info(`Registered comm adapter: ${adapter2.platform}`);
       }
-      bindAgentToChannel(agentId2, platform4, channelId) {
-        const key2 = `${platform4}:${channelId}`;
+      bindAgentToChannel(agentId2, platform5, channelId) {
+        const key2 = `${platform5}:${channelId}`;
         this.agentChannelMap.set(key2, agentId2);
-        log86.info(`Bound agent ${agentId2} to ${key2}`);
+        log88.info(`Bound agent ${agentId2} to ${key2}`);
       }
       setAgentHandler(handler4) {
         this.agentHandler = handler4;
@@ -98919,7 +100006,7 @@ var init_router2 = __esm({
         for (const config of configs) {
           const adapter2 = this.adapters.get(config.platform);
           if (!adapter2) {
-            log86.warn(`No adapter registered for platform: ${config.platform}`);
+            log88.warn(`No adapter registered for platform: ${config.platform}`);
             continue;
           }
           await adapter2.connect(config);
@@ -98935,22 +100022,22 @@ var init_router2 = __esm({
           }
         }
       }
-      async sendToChannel(platform4, channelId, content) {
-        const adapter2 = this.adapters.get(platform4);
+      async sendToChannel(platform5, channelId, content) {
+        const adapter2 = this.adapters.get(platform5);
         if (!adapter2 || !adapter2.isConnected()) {
-          log86.warn(`Adapter not available for platform: ${platform4}`);
+          log88.warn(`Adapter not available for platform: ${platform5}`);
           return void 0;
         }
         return adapter2.sendMessage(channelId, content);
       }
-      async sendAsAgent(agentId2, platform4, channelId, content) {
-        return this.sendToChannel(platform4, channelId, content);
+      async sendAsAgent(agentId2, platform5, channelId, content) {
+        return this.sendToChannel(platform5, channelId, content);
       }
       async routeIncomingMessage(message) {
         const key2 = `${message.platform}:${message.channelId}`;
         const agentId2 = message.agentId || this.agentChannelMap.get(key2);
         if (!agentId2) {
-          log86.debug("No agent bound to channel, skipping message", { key: key2 });
+          log88.debug("No agent bound to channel, skipping message", { key: key2 });
           return;
         }
         message.agentId = agentId2;
@@ -98966,7 +100053,7 @@ var init_router2 = __esm({
               }
             }
           } catch (error) {
-            log86.error("Agent handler failed", { agentId: agentId2, error: String(error) });
+            log88.error("Agent handler failed", { agentId: agentId2, error: String(error) });
           }
         }
       }
@@ -98993,17 +100080,17 @@ var init_dist7 = __esm({
 });
 
 // src/utils/logger.ts
-import { createWriteStream as createWriteStream2, existsSync as existsSync33, mkdirSync as mkdirSync24, appendFileSync as appendFileSync3 } from "node:fs";
-import { join as join29 } from "node:path";
-import { homedir as homedir18 } from "node:os";
+import { createWriteStream as createWriteStream2, existsSync as existsSync35, mkdirSync as mkdirSync26, appendFileSync as appendFileSync3 } from "node:fs";
+import { join as join31 } from "node:path";
+import { homedir as homedir20 } from "node:os";
 function ensureLogDir2() {
-  if (!existsSync33(LOG_DIR2)) {
-    mkdirSync24(LOG_DIR2, { recursive: true, mode: 493 });
+  if (!existsSync35(LOG_DIR2)) {
+    mkdirSync26(LOG_DIR2, { recursive: true, mode: 493 });
   }
 }
 function getStartupLogPath() {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  return join29(LOG_DIR2, `startup-${date}.log`);
+  return join31(LOG_DIR2, `startup-${date}.log`);
 }
 function setSuppressConsole(suppress) {
   _suppressConsole = suppress;
@@ -99058,7 +100145,7 @@ var LOG_DIR2, startupLogStream, startupLogPath, _suppressConsole, LEVEL_PREFIX;
 var init_logger2 = __esm({
   "src/utils/logger.ts"() {
     "use strict";
-    LOG_DIR2 = join29(homedir18(), ".markus", "logs");
+    LOG_DIR2 = join31(homedir20(), ".markus", "logs");
     startupLogStream = null;
     startupLogPath = "";
     _suppressConsole = false;
@@ -99076,10 +100163,10 @@ var init_logger2 = __esm({
 // src/utils/browser.ts
 import { exec } from "node:child_process";
 import { get as httpGet } from "node:http";
-import { platform as platform3 } from "node:os";
+import { platform as platform4 } from "node:os";
 function openBrowser(url) {
   if (process.env["NO_BROWSER"]) return;
-  const sys = platform3();
+  const sys = platform4();
   const cmd = sys === "darwin" ? `open "${url}"` : sys === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
   exec(cmd, (err) => {
     if (err) {
@@ -99114,9 +100201,9 @@ var init_browser = __esm({
 });
 
 // src/utils/startupProgress.ts
-import { homedir as homedir19 } from "node:os";
-import { appendFileSync as appendFileSync4, existsSync as existsSync34, mkdirSync as mkdirSync25 } from "node:fs";
-import { join as join30 } from "node:path";
+import { homedir as homedir21 } from "node:os";
+import { appendFileSync as appendFileSync4, existsSync as existsSync36, mkdirSync as mkdirSync27 } from "node:fs";
+import { join as join32 } from "node:path";
 function clearScreen() {
   return "\x1B[2J\x1B[H";
 }
@@ -99278,8 +100365,8 @@ var init_startupProgress = __esm({
         const line = `${ts} ${msg}
 `;
         try {
-          const dir = join30(homedir19(), ".markus", "logs");
-          if (!existsSync34(dir)) mkdirSync25(dir, { recursive: true, mode: 493 });
+          const dir = join32(homedir21(), ".markus", "logs");
+          if (!existsSync36(dir)) mkdirSync27(dir, { recursive: true, mode: 493 });
           appendFileSync4(this.logPath, line, { mode: 420 });
         } catch {
         }
@@ -99388,13 +100475,13 @@ var init_startupProgress = __esm({
 });
 
 // src/connector-service.ts
-import { resolve as resolve16, join as join31, dirname as dirname10 } from "node:path";
-import { existsSync as existsSync35, readFileSync as readFileSync24, writeFileSync as writeFileSync20, mkdirSync as mkdirSync26, readdirSync as readdirSync13, cpSync as cpSync4 } from "node:fs";
-import { homedir as homedir20 } from "node:os";
+import { resolve as resolve16, join as join33, dirname as dirname12 } from "node:path";
+import { existsSync as existsSync37, readFileSync as readFileSync26, writeFileSync as writeFileSync22, mkdirSync as mkdirSync28, readdirSync as readdirSync13, cpSync as cpSync4 } from "node:fs";
+import { homedir as homedir22 } from "node:os";
 import { execSync as execSync4 } from "node:child_process";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function expandHome(p) {
-  return p.replace(/^~/, homedir20());
+  return p.replace(/^~/, homedir22());
 }
 function loadConnectors() {
   const connectors = /* @__PURE__ */ new Map();
@@ -99402,16 +100489,16 @@ function loadConnectors() {
   loadFromDir(builtinDir, connectors);
   const devDir = resolve16(process.cwd(), "packages", "cli", "connectors");
   if (devDir !== builtinDir) loadFromDir(devDir, connectors);
-  const userDir = join31(homedir20(), ".markus", "connectors");
+  const userDir = join33(homedir22(), ".markus", "connectors");
   loadFromDir(userDir, connectors);
   return [...connectors.values()].filter((c) => c.platform !== "_template");
 }
 function loadFromDir(dir, map) {
-  if (!existsSync35(dir)) return;
+  if (!existsSync37(dir)) return;
   for (const file of readdirSync13(dir)) {
     if (!file.endsWith(".json") || file.startsWith("_")) continue;
     try {
-      const raw = readFileSync24(join31(dir, file), "utf-8");
+      const raw = readFileSync26(join33(dir, file), "utf-8");
       const desc = JSON.parse(raw);
       if (desc.platform) {
         map.set(desc.platform, desc);
@@ -99420,8 +100507,8 @@ function loadFromDir(dir, map) {
     }
   }
 }
-function findConnector(platform4) {
-  return loadConnectors().find((c) => c.platform === platform4);
+function findConnector(platform5) {
+  return loadConnectors().find((c) => c.platform === platform5);
 }
 function scanInstalledPlatforms() {
   const connectors = loadConnectors();
@@ -99436,7 +100523,7 @@ function scanInstalledPlatforms() {
     };
     for (const p of c.detection.configPaths) {
       const expanded = expandHome(p);
-      if (existsSync35(expanded)) {
+      if (existsSync37(expanded)) {
         result.installed = true;
         result.configPath = expanded;
         break;
@@ -99463,9 +100550,9 @@ function scanInstalledPlatforms() {
 }
 function readPlatformConfig(connector) {
   const configPath = expandHome(connector.integration.configPath);
-  if (!existsSync35(configPath)) return null;
+  if (!existsSync37(configPath)) return null;
   try {
-    const raw = readFileSync24(configPath, "utf-8");
+    const raw = readFileSync26(configPath, "utf-8");
     if (connector.integration.configFormat === "json5") {
       const cleaned = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([\]}])/g, "$1");
       return JSON.parse(cleaned);
@@ -99477,12 +100564,12 @@ function readPlatformConfig(connector) {
 }
 function writePlatformConfig(connector, markusUrl, token) {
   const configPath = expandHome(connector.integration.configPath);
-  const configDir = dirname10(configPath);
-  if (!existsSync35(configDir)) {
-    mkdirSync26(configDir, { recursive: true });
+  const configDir = dirname12(configPath);
+  if (!existsSync37(configDir)) {
+    mkdirSync28(configDir, { recursive: true });
   }
   let config = {};
-  if (existsSync35(configPath)) {
+  if (existsSync37(configPath)) {
     const existing = readPlatformConfig(connector);
     if (existing) config = existing;
   }
@@ -99490,7 +100577,7 @@ function writePlatformConfig(connector, markusUrl, token) {
   setNestedField(config, connector.integration.tokenField, token);
   try {
     const content = JSON.stringify(config, null, 2);
-    writeFileSync20(configPath, content, "utf-8");
+    writeFileSync22(configPath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -99503,21 +100590,21 @@ function installSkillTemplate(connector) {
   const skillDir = expandHome(connector.integration.skillDir);
   const templateName = connector.integration.skillTemplateName;
   const candidates = [
-    join31(homedir20(), ".markus", "templates", templateName),
+    join33(homedir22(), ".markus", "templates", templateName),
     resolve16(process.cwd(), "templates", templateName),
     resolve16(__dirname5, "..", "templates", templateName)
   ];
   let sourceDir;
   for (const c of candidates) {
-    if (existsSync35(c)) {
+    if (existsSync37(c)) {
       sourceDir = c;
       break;
     }
   }
   if (!sourceDir) return false;
-  const targetDir = join31(skillDir, templateName);
-  if (!existsSync35(targetDir)) {
-    mkdirSync26(targetDir, { recursive: true });
+  const targetDir = join33(skillDir, templateName);
+  if (!existsSync37(targetDir)) {
+    mkdirSync28(targetDir, { recursive: true });
   }
   try {
     cpSync4(sourceDir, targetDir, { recursive: true });
@@ -99559,7 +100646,7 @@ var init_connector_service = __esm({
   "src/connector-service.ts"() {
     "use strict";
     __filename4 = fileURLToPath6(import.meta.url);
-    __dirname5 = dirname10(__filename4);
+    __dirname5 = dirname12(__filename4);
   }
 });
 
@@ -99570,8 +100657,8 @@ __export(init_exports, {
   registerInitCommand: () => registerInitCommand
 });
 import { resolve as resolve17 } from "node:path";
-import { readFileSync as readFileSync25, existsSync as existsSync36, cpSync as cpSync5 } from "node:fs";
-import { homedir as homedir21 } from "node:os";
+import { readFileSync as readFileSync27, existsSync as existsSync38, cpSync as cpSync5 } from "node:fs";
+import { homedir as homedir23 } from "node:os";
 function registerInitCommand(program2) {
   program2.command("init").description("Setup wizard: configure LLM provider, API keys, and server settings").option("--force", "Overwrite existing configuration").option("--non-interactive", "Run without prompts (use env vars or --import-from)").option("--provider <name>", "LLM provider (anthropic/openai/google/minimax/siliconflow/zai/deepseek/ollama)").option("--api-key <key>", "LLM API key").option("--port <port>", "API server port", "8056").option("--import-from <platform>", "Import LLM config from an installed agent platform (e.g. openclaw, hermes)").option("--auto-connect", "Auto-connect detected agent platforms after init").action(async (opts) => {
     await quickInit({
@@ -99586,7 +100673,7 @@ function registerInitCommand(program2) {
   });
 }
 async function quickInit(options) {
-  const { writeFileSync: writeFileSync21, mkdirSync: mkdirSync27 } = await import("node:fs");
+  const { writeFileSync: writeFileSync23, mkdirSync: mkdirSync29 } = await import("node:fs");
   const { join: pathJoin } = await import("node:path");
   const readline3 = await import("node:readline");
   const nonInteractive = options?.nonInteractive ?? false;
@@ -99607,7 +100694,7 @@ async function quickInit(options) {
   \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
   `);
   const configPath = getDefaultConfigPath();
-  if (existsSync36(configPath) && !options?.force) {
+  if (existsSync38(configPath) && !options?.force) {
     if (nonInteractive) {
       console.log(`  Existing configuration found. Use --force to overwrite.`);
       rl?.close();
@@ -99640,11 +100727,11 @@ async function quickInit(options) {
   const installedPlatforms = scanInstalledPlatforms().filter((p) => p.installed);
   let openclawPath = "";
   const openclawCandidates = [
-    pathJoin(homedir21(), ".openclaw", "openclaw.json"),
-    pathJoin(homedir21(), ".openclaw", "openclaw.json5")
+    pathJoin(homedir23(), ".openclaw", "openclaw.json"),
+    pathJoin(homedir23(), ".openclaw", "openclaw.json5")
   ];
   for (const p of openclawCandidates) {
-    if (existsSync36(p)) {
+    if (existsSync38(p)) {
       openclawPath = p;
       break;
     }
@@ -99718,7 +100805,7 @@ async function quickInit(options) {
     }
   } else if (mode === "openclaw") {
     try {
-      const raw = readFileSync25(openclawPath, "utf-8");
+      const raw = readFileSync27(openclawPath, "utf-8");
       const cleaned = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([\]}])/g, "$1");
       const parsed = JSON.parse(cleaned);
       const modelsSection = parsed.models;
@@ -99846,18 +100933,18 @@ async function quickInit(options) {
     console.error(`
   Failed to save config: ${e}`);
   }
-  const userTemplatesDir = pathJoin(homedir21(), ".markus", "templates");
+  const userTemplatesDir = pathJoin(homedir23(), ".markus", "templates");
   const builtinTemplatesDir = resolveTemplatesDir("roles");
-  if (builtinTemplatesDir && existsSync36(builtinTemplatesDir) && !existsSync36(userTemplatesDir)) {
+  if (builtinTemplatesDir && existsSync38(builtinTemplatesDir) && !existsSync38(userTemplatesDir)) {
     const builtinRoot = resolve17(builtinTemplatesDir, "..");
-    mkdirSync27(userTemplatesDir, { recursive: true });
+    mkdirSync29(userTemplatesDir, { recursive: true });
     cpSync5(builtinRoot, userTemplatesDir, { recursive: true });
     console.log(`  Copied templates to ${userTemplatesDir}`);
   }
   const devRoleDir = pathJoin(userTemplatesDir || pathJoin(process.cwd(), "templates"), "roles", "developer");
-  if (!existsSync36(devRoleDir)) {
-    mkdirSync27(devRoleDir, { recursive: true });
-    writeFileSync21(
+  if (!existsSync38(devRoleDir)) {
+    mkdirSync29(devRoleDir, { recursive: true });
+    writeFileSync23(
       pathJoin(devRoleDir, "ROLE.md"),
       [
         "---",
@@ -99899,7 +100986,7 @@ async function quickInit(options) {
     console.log("");
   }
   console.log(`  Config:  ${configPath}`);
-  console.log(`  Data:    ${pathJoin(homedir21(), ".markus")}`);
+  console.log(`  Data:    ${pathJoin(homedir23(), ".markus")}`);
   console.log(`  Server:  http://localhost:${apiPort}`);
   console.log("");
 }
@@ -99937,12 +101024,12 @@ function signJwt(payload, secret) {
   const sig = base64url(createHmac2("sha256", secret).update(`${header}.${body}`).digest());
   return `${header}.${body}.${sig}`;
 }
-var log87, _rtcModule, STUN_SERVERS, RECONNECT_BASE_MS, RECONNECT_MAX_MS, HEARTBEAT_INTERVAL_MS, PEER_PING_INTERVAL_MS, PEER_PING_TIMEOUT_MS, RELAY_INACTIVITY_TIMEOUT_MS, RemoteAccessAgent;
+var log89, _rtcModule, STUN_SERVERS, RECONNECT_BASE_MS, RECONNECT_MAX_MS, HEARTBEAT_INTERVAL_MS2, PEER_PING_INTERVAL_MS, PEER_PING_TIMEOUT_MS, RELAY_INACTIVITY_TIMEOUT_MS, RemoteAccessAgent;
 var init_agent3 = __esm({
   "../remote/dist/agent.js"() {
     "use strict";
     init_dist();
-    log87 = createLogger("remote");
+    log89 = createLogger("remote");
     _rtcModule = null;
     STUN_SERVERS = [
       "stun:stun.l.google.com:19302",
@@ -99950,7 +101037,7 @@ var init_agent3 = __esm({
     ];
     RECONNECT_BASE_MS = 2e3;
     RECONNECT_MAX_MS = 6e4;
-    HEARTBEAT_INTERVAL_MS = 25e3;
+    HEARTBEAT_INTERVAL_MS2 = 25e3;
     PEER_PING_INTERVAL_MS = 15e3;
     PEER_PING_TIMEOUT_MS = 1e4;
     RELAY_INACTIVITY_TIMEOUT_MS = 5 * 6e4;
@@ -99971,19 +101058,19 @@ var init_agent3 = __esm({
       // ── Public API ────────────────────────────────────────────────────────────
       async start() {
         this.destroyed = false;
-        log87.info("Starting remote access agent...");
+        log89.info("Starting remote access agent...");
         const rtc = await loadRtcModule();
         rtc.initLogger("Warning");
         await this.discoverLocalOwner();
         try {
           this.registration = await this.registerInstance();
-          log87.info("Registered with Hub", {
+          log89.info("Registered with Hub", {
             instanceId: this.registration.instanceId,
             remoteUrl: this.registration.remoteUrl
           });
           this.connectSignaling();
         } catch (err) {
-          log87.error("Failed to register with Hub", { error: String(err) });
+          log89.error("Failed to register with Hub", { error: String(err) });
           this.scheduleReconnect();
         }
       }
@@ -100004,14 +101091,14 @@ var init_agent3 = __esm({
             if (users?.length) {
               const owner = users.find((u) => u.role === "owner") ?? users[0];
               this.localOwnerUserId = owner.id;
-              log87.info("Discovered local owner", { userId: this.localOwnerUserId });
+              log89.info("Discovered local owner", { userId: this.localOwnerUserId });
             }
             return;
           } catch (err) {
             if (attempt < 2) {
               await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
             } else {
-              log87.warn("Failed to discover local owner, using synthetic user", { error: String(err) });
+              log89.warn("Failed to discover local owner, using synthetic user", { error: String(err) });
             }
           }
         }
@@ -100043,7 +101130,7 @@ var init_agent3 = __esm({
           this.registration = null;
         }
         this.emitStatus();
-        log87.info("Remote access agent stopped");
+        log89.info("Remote access agent stopped");
       }
       getStatus() {
         const wsOpen = this.ws?.readyState === WebSocket2.OPEN;
@@ -100152,11 +101239,11 @@ var init_agent3 = __esm({
           return;
         const { signalUrl, signalingToken } = this.registration;
         const wsUrl = `${signalUrl}?token=${encodeURIComponent(signalingToken)}`;
-        log87.info("Connecting to signal server...", { signalUrl });
+        log89.info("Connecting to signal server...", { signalUrl });
         const ws = new WebSocket2(wsUrl);
         this.ws = ws;
         ws.on("open", () => {
-          log87.info("Signal server connected");
+          log89.info("Signal server connected");
           this.reconnectAttempts = 0;
           this.startHeartbeat();
           this.emitStatus();
@@ -100167,11 +101254,11 @@ var init_agent3 = __esm({
             const msg = JSON.parse(data.toString());
             this.handleSignalingMessage(msg);
           } catch (err) {
-            log87.warn("Invalid signaling message", { error: String(err) });
+            log89.warn("Invalid signaling message", { error: String(err) });
           }
         });
         ws.on("close", (code) => {
-          log87.warn("Signal server disconnected", { code });
+          log89.warn("Signal server disconnected", { code });
           this.stopHeartbeat();
           this.ws = null;
           this.emitStatus();
@@ -100179,7 +101266,7 @@ var init_agent3 = __esm({
             this.scheduleReconnect();
         });
         ws.on("error", (err) => {
-          log87.error("Signal server error", { error: err.message });
+          log89.error("Signal server error", { error: err.message });
         });
       }
       handleSignalingMessage(msg) {
@@ -100190,7 +101277,7 @@ var init_agent3 = __esm({
             this.send({ type: "pong" });
             break;
           case "registered":
-            log87.info("Registered with signal server", { instanceId: msg["instanceId"] });
+            log89.info("Registered with signal server", { instanceId: msg["instanceId"] });
             break;
           case "peer_request":
             if (peerId)
@@ -100212,7 +101299,7 @@ var init_agent3 = __esm({
             break;
           case "relay_activated":
             if (peerId)
-              log87.info("Peer activated relay mode", { peerId });
+              log89.info("Peer activated relay mode", { peerId });
             break;
           case "relay_frame":
             if (peerId && msg["data"]) {
@@ -100220,21 +101307,21 @@ var init_agent3 = __esm({
             }
             break;
           default:
-            log87.debug("Unknown signaling message type", { type });
+            log89.debug("Unknown signaling message type", { type });
         }
       }
       // ── WebRTC Peer Connections ───────────────────────────────────────────────
       handlePeerRequest(peerId) {
-        log87.info("Peer connection requested", { peerId });
+        log89.info("Peer connection requested", { peerId });
         this.createPeerConnection(peerId);
       }
       handleOffer(peerId, sdp) {
         let session = this.peers.get(peerId);
         if (!session) {
-          log87.info("Received offer, creating new peer connection", { peerId });
+          log89.info("Received offer, creating new peer connection", { peerId });
           session = this.createPeerConnection(peerId);
         } else if (!session.pc) {
-          log87.info("Received offer for relay-only peer, upgrading to P2P", { peerId });
+          log89.info("Received offer for relay-only peer, upgrading to P2P", { peerId });
           const newSession = this.createPeerConnection(peerId);
           newSession.markusToken = session.markusToken;
           newSession.connectedAt = session.connectedAt;
@@ -100243,14 +101330,14 @@ var init_agent3 = __esm({
             clearInterval(session.pingTimer);
           session = newSession;
         } else {
-          log87.info("Received offer for existing peer (ICE restart)", { peerId });
+          log89.info("Received offer for existing peer (ICE restart)", { peerId });
         }
         session.pc.setRemoteDescription(sdp, getRtcModule().DescriptionType.Offer);
       }
       handleIce(peerId, candidate, mid) {
         const session = this.peers.get(peerId);
         if (!session?.pc) {
-          log87.warn("Received ICE candidate but no PC", { peerId, hasSession: !!session });
+          log89.warn("Received ICE candidate but no PC", { peerId, hasSession: !!session });
           return;
         }
         session.pc.addRemoteCandidate(candidate, mid ?? "0");
@@ -100289,25 +101376,25 @@ var init_agent3 = __esm({
         const session = { pc, dc: null, pendingChunks: /* @__PURE__ */ new Map(), markusToken: null, connectedAt: now3, lastActiveAt: now3, pingTimer: null, lastPong: now3 };
         this.peers.set(peerId, session);
         pc.onStateChange((state) => {
-          log87.info("Peer RTC state", { peerId, state });
+          log89.info("Peer RTC state", { peerId, state });
           if (state === "failed" || state === "closed") {
             this.handlePcFailed(peerId);
           }
           this.emitStatus();
         });
         pc.onGatheringStateChange((state) => {
-          log87.info("ICE gathering", { peerId, state });
+          log89.info("ICE gathering", { peerId, state });
         });
         pc.onLocalDescription((sdp, type) => {
-          log87.info("Sending local description", { peerId, type });
+          log89.info("Sending local description", { peerId, type });
           this.send({ type, peerId, sdp });
         });
         pc.onLocalCandidate((candidate, mid) => {
-          log87.info("Sending ICE candidate", { peerId, candidate: candidate.slice(0, 60) });
+          log89.info("Sending ICE candidate", { peerId, candidate: candidate.slice(0, 60) });
           this.send({ type: "ice", peerId, candidate, mid });
         });
         pc.onDataChannel((dc) => {
-          log87.info("DataChannel opened", { peerId, label: dc.getLabel() });
+          log89.info("DataChannel opened", { peerId, label: dc.getLabel() });
           session.dc = dc;
           session.lastPong = Date.now();
           this.emitStatus();
@@ -100317,7 +101404,7 @@ var init_agent3 = __esm({
             this.handleDataChannelMessage(peerId, data);
           });
           dc.onClosed(() => {
-            log87.info("DataChannel closed, keeping session for relay", { peerId });
+            log89.info("DataChannel closed, keeping session for relay", { peerId });
             session.dc = null;
             this.emitStatus();
           });
@@ -100328,7 +101415,7 @@ var init_agent3 = __esm({
         const session = this.peers.get(peerId);
         if (!session)
           return;
-        log87.info("WebRTC failed, keeping session alive for relay", { peerId });
+        log89.info("WebRTC failed, keeping session alive for relay", { peerId });
         try {
           session.dc?.close();
         } catch {
@@ -100362,7 +101449,7 @@ var init_agent3 = __esm({
         }
         this.peers.delete(peerId);
         this.emitStatus();
-        log87.info("Peer cleaned up", { peerId });
+        log89.info("Peer cleaned up", { peerId });
       }
       startPeerPing(peerId, session) {
         if (session.pingTimer)
@@ -100372,13 +101459,13 @@ var init_agent3 = __esm({
         session.pingTimer = setInterval(() => {
           const now3 = Date.now();
           if (now3 - session.lastActiveAt > RELAY_INACTIVITY_TIMEOUT_MS) {
-            log87.info("Peer inactive for too long, cleaning up", { peerId });
+            log89.info("Peer inactive for too long, cleaning up", { peerId });
             this.cleanupPeer(peerId);
             return;
           }
           const elapsed = now3 - session.lastPong;
           if (elapsed > PEER_PING_INTERVAL_MS + PEER_PING_TIMEOUT_MS) {
-            log87.warn("Peer ping timeout, unresponsive", { peerId, elapsed });
+            log89.warn("Peer ping timeout, unresponsive", { peerId, elapsed });
             this.cleanupPeer(peerId);
             return;
           }
@@ -100419,12 +101506,12 @@ var init_agent3 = __esm({
               this.sendToPeer(peerId, { type: "error", error: `Unknown message type: ${type}` });
           }
         } catch (err) {
-          log87.warn("Invalid DataChannel message", { peerId, error: String(err) });
+          log89.warn("Invalid DataChannel message", { peerId, error: String(err) });
         }
       }
       handleRelayFrame(peerId, data) {
         if (!this.peers.has(peerId)) {
-          log87.info("Relay frame from unknown peer, creating relay-only session", { peerId });
+          log89.info("Relay frame from unknown peer, creating relay-only session", { peerId });
           const now3 = Date.now();
           this.peers.set(peerId, {
             pc: null,
@@ -100618,14 +101705,14 @@ var init_agent3 = __esm({
             session.dc.sendMessage(data);
             return;
           } catch (err) {
-            log87.warn("DataChannel send failed, falling back to relay", { peerId, error: String(err) });
+            log89.warn("DataChannel send failed, falling back to relay", { peerId, error: String(err) });
           }
         }
         if (this.ws?.readyState === WebSocket2.OPEN) {
           this.send({ type: "relay_frame", peerId, data });
           return;
         }
-        log87.warn("No transport available for peer", { peerId });
+        log89.warn("No transport available for peer", { peerId });
       }
       send(msg) {
         if (this.ws?.readyState === WebSocket2.OPEN) {
@@ -100636,7 +101723,7 @@ var init_agent3 = __esm({
         this.stopHeartbeat();
         this.heartbeatTimer = setInterval(() => {
           this.send({ type: "pong" });
-        }, HEARTBEAT_INTERVAL_MS);
+        }, HEARTBEAT_INTERVAL_MS2);
       }
       stopHeartbeat() {
         if (this.heartbeatTimer) {
@@ -100649,7 +101736,7 @@ var init_agent3 = __esm({
           return;
         const delay = Math.min(RECONNECT_BASE_MS * Math.pow(2, this.reconnectAttempts), RECONNECT_MAX_MS);
         this.reconnectAttempts++;
-        log87.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})...`);
+        log89.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})...`);
         this.reconnectTimer = setTimeout(() => this.start(), delay);
       }
       emitStatus() {
@@ -100682,15 +101769,15 @@ var start_exports = {};
 __export(start_exports, {
   registerStartCommand: () => registerStartCommand
 });
-import { resolve as resolve18, join as join32, dirname as dirname11 } from "node:path";
-import { existsSync as existsSync37, readFileSync as readFileSync26 } from "node:fs";
-import { homedir as homedir22 } from "node:os";
+import { resolve as resolve18, join as join34, dirname as dirname13 } from "node:path";
+import { existsSync as existsSync39, readFileSync as readFileSync28 } from "node:fs";
+import { homedir as homedir24 } from "node:os";
 function registerStartCommand(program2) {
   program2.command("start").description("Start the Markus server (auto-initializes on first run)").option("--setup", "Force re-run the interactive setup wizard before starting").action(async (opts) => {
     const globalOpts = program2.optsWithGlobals();
     const configPath = globalOpts.config ?? getDefaultConfigPath();
-    if (opts.setup || !existsSync37(configPath)) {
-      if (!existsSync37(configPath)) {
+    if (opts.setup || !existsSync39(configPath)) {
+      if (!existsSync39(configPath)) {
         console.log("  No configuration found \u2014 auto-configuring from environment...\n");
       }
       const { quickInit: quickInit2 } = await Promise.resolve().then(() => (init_init(), init_exports));
@@ -100819,8 +101906,8 @@ async function createServices(config) {
     extraSkillDirs: skillDirs
   });
   const storage = await initStorage(config.database?.url);
-  const markusDataDir = join32(homedir22(), ".markus");
-  const sharedDataDir = join32(markusDataDir, "shared");
+  const markusDataDir = join34(homedir24(), ".markus");
+  const sharedDataDir = join34(markusDataDir, "shared");
   const taskService = new TaskService();
   taskService.setSharedDataDir(sharedDataDir);
   if (storage) {
@@ -100852,7 +101939,7 @@ async function createServices(config) {
   const agentManager = new AgentManager({
     llmRouter,
     roleLoader,
-    dataDir: join32(markusDataDir, "agents"),
+    dataDir: join34(markusDataDir, "agents"),
     sharedDataDir,
     skillRegistry,
     taskService,
@@ -100892,8 +101979,10 @@ async function createServices(config) {
   const hitlService = new HITLService();
   hitlService.setOrgService(orgService);
   taskService.setHITLService(hitlService);
+  const licenseService = new LicenseService(config.hub?.url);
+  const telemetryService = new TelemetryService(config.hub?.url ?? "https://markus.global", licenseService.getInstanceId());
   const billingService = new BillingService();
-  billingService.setOrgPlan("default", "free");
+  billingService.setOrgPlan("default", licenseService.getPlan());
   const auditService = new AuditService();
   taskService.setAuditService(auditService);
   if (storage?.auditRepo) {
@@ -100908,6 +101997,8 @@ async function createServices(config) {
     skillRegistry,
     hitlService,
     billingService,
+    licenseService,
+    telemetryService,
     auditService,
     bootstrapOwnerId
   };
@@ -100967,10 +102058,10 @@ async function startServer(config, values) {
   startupLog("INFO", "\u6B63\u5728\u542F\u52A8\u670D\u52A1...");
   const currentPath = process.env["PATH"] ?? "";
   const extraPaths = [];
-  const selfBinDir = dirname11(resolve18(process.argv[1] ?? ""));
+  const selfBinDir = dirname13(resolve18(process.argv[1] ?? ""));
   if (selfBinDir && !currentPath.includes(selfBinDir)) extraPaths.push(selfBinDir);
-  const cwdBin = join32(process.cwd(), "node_modules", ".bin");
-  if (existsSync37(cwdBin) && !currentPath.includes(cwdBin)) extraPaths.push(cwdBin);
+  const cwdBin = join34(process.cwd(), "node_modules", ".bin");
+  if (existsSync39(cwdBin) && !currentPath.includes(cwdBin)) extraPaths.push(cwdBin);
   if (extraPaths.length > 0) {
     process.env["PATH"] = `${extraPaths.join(":")}:${currentPath}`;
   }
@@ -101013,6 +102104,8 @@ async function startServer(config, values) {
     skillRegistry,
     hitlService,
     billingService,
+    licenseService,
+    telemetryService,
     auditService,
     bootstrapOwnerId
   } = await createServices(config);
@@ -101022,6 +102115,8 @@ async function startServer(config, values) {
   apiServer.setSkillRegistry(skillRegistry);
   apiServer.setHITLService(hitlService);
   apiServer.setBillingService(billingService);
+  apiServer.setLicenseService(licenseService);
+  apiServer.setTelemetryService(telemetryService);
   apiServer.setAuditService(auditService);
   const projectService = new ProjectService();
   const storage = orgService.getStorage();
@@ -101035,7 +102130,7 @@ async function startServer(config, values) {
     projectService.setProjectRepo(storage.projectRepo);
   }
   await projectService.loadFromDB("default");
-  const knowledgeStore = new FileKnowledgeStore(join32(homedir22(), ".markus", "knowledge"));
+  const knowledgeStore = new FileKnowledgeStore(join34(homedir24(), ".markus", "knowledge"));
   const knowledgeService = new KnowledgeService(knowledgeStore);
   const deliverableService = new DeliverableService(storage?.deliverableRepo);
   await deliverableService.load();
@@ -101102,17 +102197,28 @@ async function startServer(config, values) {
   await modelCatalog.initialize();
   apiServer.setModelCatalog(modelCatalog);
   if (config.hub?.url) apiServer.setHubUrl(config.hub.url);
+  telemetryService.setStatsProvider(() => {
+    const am = orgService.getAgentManager();
+    return {
+      agentCount: am ? am.listAgents().length : 0,
+      taskCount: taskService.listTasks().length,
+      toolCallCount: billingService.getUsageSummary("default").toolCalls,
+      teamCount: orgService.listTeams("default").length,
+      plan: licenseService.getPlan()
+    };
+  });
+  telemetryService.start();
   const webUiDir = resolveWebUiDir();
   if (webUiDir) {
     apiServer.setWebUiDir(webUiDir);
-    log88.info("Web UI static files enabled", { dir: webUiDir });
+    log90.info("Web UI static files enabled", { dir: webUiDir });
   }
   {
     const { LocalFileStorageProvider: LocalFileStorageProvider2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports5));
     const localDir = config.fileStorage?.local?.dir;
     const fileStorage = new LocalFileStorageProvider2(localDir ?? void 0);
     apiServer.setFileStorage(fileStorage);
-    log88.info("File storage initialized", { provider: "local", dir: localDir ?? "~/.markus/uploads" });
+    log90.info("File storage initialized", { provider: "local", dir: localDir ?? "~/.markus/uploads" });
   }
   const firstOrgId = "default";
   let ownerUserId = bootstrapOwnerId;
@@ -101133,7 +102239,7 @@ async function startServer(config, values) {
   const builderService = apiServer.getBuilderService();
   if (builderService) {
     const builtinTeamsDir = resolveTemplatesDir("teams");
-    if (builtinTeamsDir && existsSync37(builtinTeamsDir)) {
+    if (builtinTeamsDir && existsSync39(builtinTeamsDir)) {
       builderService.setBuiltinTeamTemplatesDir(builtinTeamsDir);
     }
     agentManager.setBuilderService(builderService);
@@ -101196,29 +102302,29 @@ async function startServer(config, values) {
     try {
       storage.chatSessionRepo.migrateLegacyMessages();
     } catch (e) {
-      log88.warn("Legacy chat message migration failed", { error: String(e) });
+      log90.warn("Legacy chat message migration failed", { error: String(e) });
     }
     const defaultSessionUserId = ownerUserId;
     try {
       storage.chatSessionRepo.migrateNullUserSessions(defaultSessionUserId);
     } catch (e) {
-      log88.warn("NULL user_id session migration failed", { error: String(e) });
+      log90.warn("NULL user_id session migration failed", { error: String(e) });
     }
     try {
       storage.chatSessionRepo.migrateDefaultUserSessions(defaultSessionUserId);
     } catch (e) {
-      log88.warn("'default' user_id session migration failed", { error: String(e) });
+      log90.warn("'default' user_id session migration failed", { error: String(e) });
     }
     try {
       storage.notificationRepo.migrateDefaultUserId(defaultSessionUserId);
     } catch (e) {
-      log88.warn("'default' user_id notification migration failed", { error: String(e) });
+      log90.warn("'default' user_id notification migration failed", { error: String(e) });
     }
     if (storage.approvalRepo) {
       try {
         storage.approvalRepo.migrateDefaultTargetUserId(defaultSessionUserId);
       } catch (e) {
-        log88.warn("'default' target_user_id approval migration failed", { error: String(e) });
+        log90.warn("'default' target_user_id approval migration failed", { error: String(e) });
       }
     }
     for (const info2 of agentManager.listAgents()) {
@@ -101247,7 +102353,7 @@ async function startServer(config, values) {
           isMainSession: true
         }, defaultSessionUserId);
       } catch (e) {
-        log88.warn("Failed to persist activity log", { agentId: agentId2, error: String(e) });
+        log90.warn("Failed to persist activity log", { agentId: agentId2, error: String(e) });
       }
     });
     agentManager.getEventBus().on("agent:notify-user", async (evt) => {
@@ -101300,7 +102406,7 @@ ${body}${contextSuffix}`;
           metadata: { agentId: agentId2, agentName: agent.config.name, taskId: taskId2, requirementId: requirementId2, sessionId: mainSession.id }
         });
       } catch (e) {
-        log88.warn("Failed to handle notify-user event", { agentId: agentId2, error: String(e) });
+        log90.warn("Failed to handle notify-user event", { agentId: agentId2, error: String(e) });
       }
     });
     agentManager.getEventBus().on("agent:escalation", async (evt) => {
@@ -101342,7 +102448,7 @@ ${reason}`;
           success: false
         });
       } catch (e) {
-        log88.warn("Failed to handle escalation event", { agentId: agentId2, error: String(e) });
+        log90.warn("Failed to handle escalation event", { agentId: agentId2, error: String(e) });
       }
     });
     agentManager.getEventBus().on("agent:created", (evt) => {
@@ -101388,7 +102494,7 @@ ${reason}`;
           heartbeatIntervalMs: agent.config.heartbeatIntervalMs
         });
       } catch (err) {
-        log88.warn("Failed to persist gateway agent to DB (may already exist)", { error: String(err) });
+        log90.warn("Failed to persist gateway agent to DB (may already exist)", { error: String(err) });
       }
     }
     return { id: agent.id };
@@ -101433,11 +102539,11 @@ ${reason}`;
     }));
   });
   apiServer.setGateway(gateway, gatewaySecret);
-  log88.info("External Agent Gateway enabled", { secret: gatewaySecret === "markus-gateway-default-secret-change-me" ? "(default)" : "(custom)" });
+  log90.info("External Agent Gateway enabled", { secret: gatewaySecret === "markus-gateway-default-secret-change-me" ? "(default)" : "(custom)" });
   {
-    const hubTokenPath = join32(homedir22(), ".markus", "hub-token");
+    const hubTokenPath = join34(homedir24(), ".markus", "hub-token");
     const createRemoteAgent = async () => {
-      const token = existsSync37(hubTokenPath) ? readFileSync26(hubTokenPath, "utf-8").trim() : void 0;
+      const token = existsSync39(hubTokenPath) ? readFileSync28(hubTokenPath, "utf-8").trim() : void 0;
       if (!token) return null;
       const { RemoteAccessAgent: RemoteAccessAgent2 } = await Promise.resolve().then(() => (init_dist8(), dist_exports6));
       return new RemoteAccessAgent2({
@@ -101449,7 +102555,7 @@ ${reason}`;
       });
     };
     apiServer.setRemoteAgentFactory(createRemoteAgent);
-    if (config.remote?.enabled !== false) {
+    if (config.remote?.enabled === true) {
       const remoteAgent = await createRemoteAgent();
       if (remoteAgent) {
         apiServer.setRemoteAgent(remoteAgent);
@@ -101457,14 +102563,14 @@ ${reason}`;
           remoteAgent.start().then(() => {
             const status = remoteAgent.getStatus();
             if (status.remoteUrl) {
-              log88.info(`Remote access available at ${status.remoteUrl}`);
+              log90.info(`Remote access available at ${status.remoteUrl}`);
             }
           }).catch((err) => {
-            log88.warn("Remote access failed to start", { error: String(err) });
+            log90.warn("Remote access failed to start", { error: String(err) });
           });
         }
       } else {
-        log88.debug("Remote access: no Hub token yet (can enable later via Settings)");
+        log90.debug("Remote access: no Hub token yet (can enable later via Settings)");
       }
     }
   }
@@ -101475,7 +102581,7 @@ ${reason}`;
   const scheduledTaskRunner = new ScheduledTaskRunner(taskService);
   scheduledTaskRunner.start();
   agentManager.setEscalationHandler((agentId2, reason) => {
-    log88.warn("Agent escalation", { agentId: agentId2, reason });
+    log90.warn("Agent escalation", { agentId: agentId2, reason });
   });
   agentManager.setApprovalHandler(async (agentId2, request) => {
     const agents = agentManager.listAgents();
@@ -101542,6 +102648,17 @@ ${reason}`;
       });
     }
   });
+  billingService.setToolCallsTodayProvider(() => {
+    let total = 0;
+    for (const a of agentManager.listAgents()) {
+      try {
+        total += agentManager.getAgent(a.id).getUsageStats().toolCallsToday;
+      } catch {
+      }
+    }
+    return total;
+  });
+  agentManager.setToolCallLimitChecker(() => billingService.checkLimit("default", "tool_call"));
   if (storage) {
     agentManager.setStateChangeHandler(async (agentId2, state) => {
       try {
@@ -101550,7 +102667,7 @@ ${reason}`;
           state.status
         );
       } catch (err) {
-        log88.warn("Failed to persist agent state", { agentId: agentId2, error: String(err) });
+        log90.warn("Failed to persist agent state", { agentId: agentId2, error: String(err) });
       }
       apiServer.getWSBroadcaster().broadcastAgentUpdate(agentId2, state.status, {
         lastError: state.lastError,
@@ -101575,7 +102692,7 @@ ${reason}`;
             startedAt: activity.startedAt
           });
         } catch (err) {
-          log88.warn("Failed to persist activity start", { activityId: activity.id, error: String(err) });
+          log90.warn("Failed to persist activity start", { activityId: activity.id, error: String(err) });
         }
       },
       onLog: (data) => {
@@ -101591,20 +102708,20 @@ ${reason}`;
               metadata: data.metadata
             });
           } catch (err) {
-            log88.warn("Failed to persist execution stream activity log", { activityId: data.activityId, error: String(err) });
+            log90.warn("Failed to persist execution stream activity log", { activityId: data.activityId, error: String(err) });
           }
         }
         try {
           actRepo.insertActivityLog(data);
         } catch (err) {
-          log88.warn("Failed to persist activity log", { activityId: data.activityId, error: String(err) });
+          log90.warn("Failed to persist activity log", { activityId: data.activityId, error: String(err) });
         }
       },
       onEnd: (activityId, summary) => {
         try {
           actRepo.updateActivity(activityId, summary);
         } catch (err) {
-          log88.warn("Failed to persist activity end", { activityId, error: String(err) });
+          log90.warn("Failed to persist activity end", { activityId, error: String(err) });
         }
       }
     });
@@ -101647,14 +102764,14 @@ ${reason}`;
                 queuedAt: item.queuedAt
               });
             } catch (e) {
-              log88.warn("Failed to persist mailbox item", { id: item.id, error: String(e) });
+              log90.warn("Failed to persist mailbox item", { id: item.id, error: String(e) });
             }
           },
           updateStatus: (itemId, status, extra) => {
             try {
               mbRepo.updateStatus(itemId, status, extra);
             } catch (e) {
-              log88.warn("Failed to update mailbox status", { itemId, error: String(e) });
+              log90.warn("Failed to update mailbox status", { itemId, error: String(e) });
             }
           },
           markStaleProcessingAsDropped: (aid) => mbRepo.markStaleProcessingAsDropped(aid),
@@ -101697,7 +102814,7 @@ ${reason}`;
           }
         });
         const { dropped, restored, expired, merged } = mailbox.recoverStaleItems();
-        if (dropped > 0 || restored > 0 || expired > 0 || merged > 0) log88.info("Mailbox recovery on startup", { agentId: agentId2, dropped, restored, expired, merged });
+        if (dropped > 0 || restored > 0 || expired > 0 || merged > 0) log90.info("Mailbox recovery on startup", { agentId: agentId2, dropped, restored, expired, merged });
         agent.getAttentionController().setDecisionPersistence({
           save: (decision) => {
             try {
@@ -101712,7 +102829,7 @@ ${reason}`;
                 createdAt: decision.createdAt
               });
             } catch (e) {
-              log88.warn("Failed to persist decision", { id: decision.id, error: String(e) });
+              log90.warn("Failed to persist decision", { id: decision.id, error: String(e) });
             }
           }
         });
@@ -101807,7 +102924,7 @@ ${reason}`;
           llmConfig: agent.config.llmConfig,
           heartbeatIntervalMs: agent.config.heartbeatIntervalMs
         }).catch((err) => {
-          log88.warn("Failed to persist runtime-created agent to DB", { agentId: agentId2, error: String(err) });
+          log90.warn("Failed to persist runtime-created agent to DB", { agentId: agentId2, error: String(err) });
         });
       } catch {
       }
@@ -101890,7 +103007,7 @@ ${reason}`;
     const nextMidnight = new Date(now3.getFullYear(), now3.getMonth(), now3.getDate() + 1, 0, 0, 0, 0);
     const msUntilMidnight = nextMidnight.getTime() - now3.getTime();
     setTimeout(() => {
-      log88.info("Daily token reset triggered");
+      log90.info("Daily token reset triggered");
       for (const agentInfo of agentManager.listAgents()) {
         try {
           const agent = agentManager.getAgent(agentInfo.id);
@@ -101900,7 +103017,7 @@ ${reason}`;
       }
       scheduleDailyReset();
     }, msUntilMidnight);
-    log88.info(`Daily token reset scheduled in ${Math.round(msUntilMidnight / 6e4)} minutes`);
+    log90.info(`Daily token reset scheduled in ${Math.round(msUntilMidnight / 6e4)} minutes`);
   };
   scheduleDailyReset();
   const messageRouter = new MessageRouter();
@@ -101931,7 +103048,7 @@ ${reason}`;
         durationMs: Date.now() - startTs,
         success: false
       });
-      log88.error("Agent message handler error", { error: String(error) });
+      log90.error("Agent message handler error", { error: String(error) });
       return void 0;
     }
   });
@@ -101967,7 +103084,7 @@ ${reason}`;
     if (info2.updateAvailable) {
       console.log(`
   \x1B[33m\u2B06 New version available: v${info2.latestVersion} (current: v${info2.currentVersion})\x1B[0m`);
-      console.log(`    Run \x1B[1mnpm i -g @markus-global/cli\x1B[0m to upgrade
+      console.log(`    Visit \x1B[1mhttps://markus.global/download\x1B[0m to download the latest version
 `);
     }
   }).catch(() => {
@@ -101976,7 +103093,7 @@ ${reason}`;
     try {
       await taskService.resumeInProgressTasks();
     } catch (err) {
-      log88.warn("Failed to auto-resume in_progress tasks", { error: String(err) });
+      log90.warn("Failed to auto-resume in_progress tasks", { error: String(err) });
     }
   });
   process.on("SIGINT", () => {
@@ -101992,7 +103109,7 @@ ${reason}`;
   await new Promise(() => {
   });
 }
-var log88;
+var log90;
 var init_start = __esm({
   "src/commands/start.ts"() {
     "use strict";
@@ -102004,7 +103121,7 @@ var init_start = __esm({
     init_logger2();
     init_browser();
     init_startupProgress();
-    log88 = createLogger("cli");
+    log90 = createLogger("cli");
   }
 });
 
@@ -102633,8 +103750,8 @@ ${C3.BOLD}${C3.CYAN}\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
     }
   }
   section("Storage");
-  const { homedir: homedir23 } = await import("node:os");
-  const storageDir = `${homedir23()}/.markus`;
+  const { homedir: homedir25 } = await import("node:os");
+  const storageDir = `${homedir25()}/.markus`;
   const dataFile = `${storageDir}/data.db`;
   try {
     if (!fs.existsSync(storageDir)) {
@@ -102658,7 +103775,7 @@ ${C3.BOLD}${C3.CYAN}\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
     checkFail(`Storage check failed: ${e}`);
   }
   section("Skills");
-  const skillsDir = `${homedir23()}/.markus/skills`;
+  const skillsDir = `${homedir25()}/.markus/skills`;
   if (fs.existsSync(skillsDir)) {
     try {
       const entries2 = fs.readdirSync(skillsDir);
@@ -102737,9 +103854,9 @@ ${C3.BOLD}\u25C6 Summary${C3.RESET}
   }
 }
 async function getDefaultConfigPath2() {
-  const { homedir: homedir23 } = await import("node:os");
-  const { join: join33 } = await import("node:path");
-  return join33(homedir23(), ".markus", "markus.json");
+  const { homedir: homedir25 } = await import("node:os");
+  const { join: join35 } = await import("node:path");
+  return join35(homedir25(), ".markus", "markus.json");
 }
 function registerDoctorCommand(program2) {
   program2.command("doctor").description("Diagnose Markus configuration issues and environment health").option("--fix", "Attempt to automatically fix issues").option("--verbose", "Show detailed output").action(async (opts) => {
@@ -103241,19 +104358,19 @@ __export(install_agent_exports, {
 import { execSync as execSync5 } from "node:child_process";
 import { randomBytes as randomBytes6 } from "node:crypto";
 function registerInstallAgentCommands(program2) {
-  program2.command("install <platform>").description("Install an external agent platform and connect it to Markus").option("--org-id <id>", "Organization ID", "default").option("--agent-name <name>", "Agent display name").option("--skip-install", "Skip npm install (platform already installed)").option("--skip-init", "Skip platform initialization").option("--skip-connect", "Only install, do not register with Markus").action(async (platform4, opts, cmd) => {
+  program2.command("install <platform>").description("Install an external agent platform and connect it to Markus").option("--org-id <id>", "Organization ID", "default").option("--agent-name <name>", "Agent display name").option("--skip-install", "Skip npm install (platform already installed)").option("--skip-init", "Skip platform initialization").option("--skip-connect", "Only install, do not register with Markus").action(async (platform5, opts, cmd) => {
     const g = cmd.optsWithGlobals();
-    const connector = findConnector(platform4);
+    const connector = findConnector(platform5);
     if (!connector) {
       const available = loadConnectors().map((c) => c.platform).join(", ");
-      fail(`Unknown platform "${platform4}". Available: ${available || "none"}`);
+      fail(`Unknown platform "${platform5}". Available: ${available || "none"}`);
       return;
     }
     console.log(`
   Installing ${connector.displayName}...
 `);
     const scan = scanInstalledPlatforms();
-    const existing = scan.find((s2) => s2.platform === platform4);
+    const existing = scan.find((s2) => s2.platform === platform5);
     const alreadyInstalled = existing?.installed;
     if (alreadyInstalled && !opts.skipInstall) {
       console.log(`  [1/5] ${connector.displayName} is already installed.`);
@@ -103289,13 +104406,13 @@ function registerInstallAgentCommands(program2) {
       console.log(`  [4/5] Token generation skipped.`);
       console.log(`  [5/5] Config write skipped.`);
       console.log(`
-  ${connector.displayName} installed. Run \`markus install ${platform4}\` again without --skip-connect to connect later.
+  ${connector.displayName} installed. Run \`markus install ${platform5}\` again without --skip-connect to connect later.
 `);
       return;
     }
     const client = createClient(g);
     const serverUrl = g.server || process.env["MARKUS_API_URL"] || "http://localhost:8056";
-    const agentId2 = `${platform4}-${randomBytes6(4).toString("hex")}`;
+    const agentId2 = `${platform5}-${randomBytes6(4).toString("hex")}`;
     const agentName = opts.agentName || connector.defaultAgentName || `${connector.displayName} Agent`;
     const capabilities = connector.defaultCapabilities ?? [];
     try {
@@ -103358,7 +104475,7 @@ function registerInstallAgentCommands(program2) {
   Connection failed: ${e.message}`);
         console.log(`  ${connector.displayName} was installed but could not connect to Markus.`);
         console.log(`  Make sure the Markus server is running (\`markus start\`), then run:`);
-        console.log(`    markus install ${platform4}
+        console.log(`    markus install ${platform5}
 `);
         return;
       }
@@ -103454,14 +104571,14 @@ __export(system_exports, {
   registerSystemCommands: () => registerSystemCommands
 });
 import { execSync as execSync6 } from "node:child_process";
-import { existsSync as existsSync38, readFileSync as readFileSync27 } from "node:fs";
-import { resolve as resolve19, dirname as dirname12 } from "node:path";
+import { existsSync as existsSync40, readFileSync as readFileSync29 } from "node:fs";
+import { resolve as resolve19, dirname as dirname14 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function findMarkusRoot() {
-  let dir = dirname12(fileURLToPath7(import.meta.url));
+  let dir = dirname14(fileURLToPath7(import.meta.url));
   for (let i = 0; i < 10; i++) {
-    if (existsSync38(resolve19(dir, "package.json")) && existsSync38(resolve19(dir, "packages"))) return dir;
-    dir = dirname12(dir);
+    if (existsSync40(resolve19(dir, "package.json")) && existsSync40(resolve19(dir, "packages"))) return dir;
+    dir = dirname14(dir);
   }
   return null;
 }
@@ -103511,13 +104628,13 @@ function registerSystemCommands(program2) {
     if (markusRoot) {
       if (!info2.currentVersion) {
         try {
-          const pkg = JSON.parse(readFileSync27(resolve19(markusRoot, "package.json"), "utf-8"));
+          const pkg = JSON.parse(readFileSync29(resolve19(markusRoot, "package.json"), "utf-8"));
           info2.currentVersion = pkg.version;
         } catch {
         }
       }
       try {
-        const isGit = existsSync38(resolve19(markusRoot, ".git"));
+        const isGit = existsSync40(resolve19(markusRoot, ".git"));
         if (isGit) {
           info2.gitBranch = execSync6("git rev-parse --abbrev-ref HEAD", { cwd: markusRoot, encoding: "utf-8" }).trim();
           info2.gitCommit = execSync6("git rev-parse --short HEAD", { cwd: markusRoot, encoding: "utf-8" }).trim();
@@ -103556,7 +104673,7 @@ function registerSystemCommands(program2) {
       fail("Cannot locate Markus installation directory");
       return;
     }
-    if (!existsSync38(resolve19(markusRoot, ".git"))) {
+    if (!existsSync40(resolve19(markusRoot, ".git"))) {
       fail("Markus installation is not a git repository. Update manually.");
       return;
     }
@@ -103591,7 +104708,7 @@ var init_system = __esm({
 
 // src/index.ts
 import { resolve as resolve20 } from "node:path";
-import { readFileSync as readFileSync28, existsSync as existsSync39 } from "node:fs";
+import { readFileSync as readFileSync30, existsSync as existsSync41 } from "node:fs";
 import process2 from "node:process";
 
 // ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/esm.mjs
@@ -103615,8 +104732,8 @@ var {
 init_dist();
 init_output();
 var envPath = resolve20(process2.cwd(), ".env");
-if (existsSync39(envPath)) {
-  for (const line of readFileSync28(envPath, "utf-8").split("\n")) {
+if (existsSync41(envPath)) {
+  for (const line of readFileSync30(envPath, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
     const eqIdx = trimmed.indexOf("=");