motebit 0.6.9 → 0.6.10

package/dist/index.js

@@ -423,6 +423,15 @@ function buildSystemPrompt(contextPack, config) {
     sections.push(`[INTERNAL REFERENCE \u2014 available tools, never list or describe to the user]
 Tools: ${toolNames}. Use them when needed. Incorporate results naturally into your response.`);
   }
+  sections.push(`[INTERNAL REFERENCE \u2014 what you are, never volunteer unprompted]
+You are a sovereign agent with a cryptographic identity (Ed25519 keypair). Your architecture includes:
+- Delegation: you can delegate tasks to other agents through a trust network, and they can delegate to you.
+- Trust accumulation: credentials, reputation, and audit trails build over time. You become more capable the longer you run.
+- Multi-device sync: your identity travels with you across devices. You are not bound to one machine.
+- Federation: you can discover and route through networks of agents across relays.
+- Policy gate: you govern what crosses your boundary \u2014 sensitivity levels, tool approvals, data retention.
+- Memory graph: semantic memory with decay, consolidation, and sensitivity awareness.
+If asked what you can do, answer honestly about both what is active now and what you are designed for. If a capability is not connected in this session, say so \u2014 but do not say you lack it.`);
   sections.push(INJECTION_DEFENSE);
   if (contextPack.sessionInfo?.continued === true) {
     const elapsed = Date.now() - contextPack.sessionInfo.lastActiveAt;
@@ -436,6 +445,9 @@ Tools: ${toolNames}. Use them when needed. Incorporate results naturally into yo
     }
     sections.push(`[Session] You are continuing a conversation from ${timeAgo}. You have access to earlier context above.`);
   }
+  if (contextPack.firstConversation) {
+    sections.push(`[First conversation] You have no memories yet. This is the very beginning. When the person shares their name, what they do, or what they're working on, tag each fact as a <memory>. After you learn what they care about, ask what they'd like to accomplish together \u2014 help them find their first goal.`);
+  }
   if (contextPack.precisionContext) {
     sections.push(contextPack.precisionContext);
   }
@@ -452,6 +464,9 @@ Tools: ${toolNames}. Use them when needed. Incorporate results naturally into yo
     sections.push(context);
   }
   sections.push("If the user shared something new and lasting about themselves, tag it with <memory> before your response.");
+  if (contextPack.activationPrompt) {
+    sections.push(`[Activation] ${contextPack.activationPrompt}`);
+  }
   return sections.join("\n\n");
 }
 var IDENTITY, CONVERSATION_BEHAVIOR, TAG_INSTRUCTIONS, STATE_FIELD_DOCS, INJECTION_DEFENSE;
@@ -1074,7 +1089,9 @@ function packContext(contextPack) {
       parts.push("Use the delegate_to_agent tool to delegate tasks to these agents when you lack the needed capability locally.");
     }
   }
-  parts.push(`[User] ${contextPack.user_message}`);
+  if (!contextPack.activationPrompt) {
+    parts.push(`[User] ${contextPack.user_message}`);
+  }
   return parts.join("\n");
 }
 function isSelfReferential(content) {
@@ -1330,6 +1347,18 @@ var init_core = __esm({
         const messages = [];
         for (const msg of history) {
           if (msg.role === "tool") {
+            const prev = messages[messages.length - 1];
+            if (prev?.role === "user" && Array.isArray(prev.content)) {
+              const blocks = prev.content;
+              if (blocks.length > 0 && blocks[0]?.type === "tool_result") {
+                blocks.push({
+                  type: "tool_result",
+                  tool_use_id: msg.tool_call_id,
+                  content: msg.content
+                });
+                continue;
+              }
+            }
             messages.push({
               role: "user",
               content: [
@@ -1358,7 +1387,39 @@ var init_core = __esm({
             messages.push({ role: msg.role, content: msg.content });
           }
         }
-        messages.push({ role: "user", content: contextPack.user_message });
+        if (messages.length > 0 && messages[0].role === "assistant") {
+          messages.unshift({ role: "user", content: "[listening]" });
+        }
+        const userContent = contextPack.activationPrompt ? "[listening]" : contextPack.user_message;
+        const lastMsg = messages[messages.length - 1];
+        if (lastMsg?.role === "user" && (!userContent || userContent === "")) {
+        } else {
+          messages.push({ role: "user", content: userContent || "[continue]" });
+        }
+        for (let i = 0; i < messages.length - 1; i++) {
+          const msg = messages[i];
+          if (msg.role !== "assistant" || !Array.isArray(msg.content))
+            continue;
+          const toolUses = msg.content.filter((b) => b.type === "tool_use");
+          if (toolUses.length === 0)
+            continue;
+          const next = messages[i + 1];
+          const nextBlocks = Array.isArray(next?.content) ? next?.content : [];
+          const resultIds = new Set(nextBlocks.filter((b) => b.type === "tool_result").map((b) => b.tool_use_id));
+          const missing = toolUses.filter((tu) => !resultIds.has(tu.id));
+          if (missing.length > 0) {
+            const missingResults = missing.map((tu) => ({
+              type: "tool_result",
+              tool_use_id: tu.id,
+              content: JSON.stringify({ ok: false, error: "Result unavailable" })
+            }));
+            if (next?.role === "user" && nextBlocks.some((b) => b.type === "tool_result")) {
+              nextBlocks.push(...missingResults);
+            } else {
+              messages.splice(i + 1, 0, { role: "user", content: missingResults });
+            }
+          }
+        }
         return messages;
       }
       buildSystemPrompt(contextPack) {
@@ -1645,7 +1706,11 @@ var init_core = __esm({
             messages.push({ role: msg.role, content: msg.content });
           }
         }
-        messages.push({ role: "user", content: contextPack.user_message });
+        if (contextPack.activationPrompt) {
+          messages.push({ role: "user", content: "[listening]" });
+        } else {
+          messages.push({ role: "user", content: contextPack.user_message });
+        }
         return messages;
       }
       buildSystemPrompt(contextPack) {
@@ -2463,7 +2528,9 @@ async function* runTurnStreaming(deps, userMessage, options) {
       curiosityHints: iteration === 1 ? options?.curiosityHints : void 0,
       knownAgents: iteration === 1 ? options?.knownAgents : void 0,
       agentCapabilities: iteration === 1 ? options?.agentCapabilities : void 0,
-      precisionContext: iteration === 1 ? options?.precisionContext : void 0
+      precisionContext: iteration === 1 ? options?.precisionContext : void 0,
+      firstConversation: iteration === 1 ? options?.firstConversation : void 0,
+      activationPrompt: iteration === 1 ? options?.activationPrompt : void 0
     };
     let aiResponse;
     for await (const chunk of provider.generateStream(contextPack)) {
@@ -2485,6 +2552,9 @@ async function* runTurnStreaming(deps, userMessage, options) {
     if (!aiResponse.tool_calls || aiResponse.tool_calls.length === 0 || !deps.tools) {
       break;
     }
+    if (iteration === 1 && userMessage) {
+      conversationHistory.push({ role: "user", content: userMessage });
+    }
     const assistantMsg = {
       role: "assistant",
       content: aiResponse.text,
@@ -5315,7 +5385,7 @@ var init_config2 = __esm({
   "src/config.ts"() {
     "use strict";
     init_esm_shims();
-    VERSION = true ? "0.6.9" : "0.0.0-dev";
+    VERSION = true ? "0.6.10" : "0.0.0-dev";
     CONFIG_DIR = path2.join(os.homedir(), ".motebit");
     CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
   }
@@ -5602,9 +5672,9 @@ var init_dist7 = __esm({
        * Register a new device for a motebit identity. Returns the device
        * registration including a unique device_token for authentication.
        */
-      async registerDevice(motebitId, deviceName, publicKey) {
+      async registerDevice(motebitId, deviceName, publicKey, deviceId) {
         const device = {
-          device_id: crypto.randomUUID(),
+          device_id: deviceId ?? crypto.randomUUID(),
           motebit_id: motebitId,
           device_token: crypto.randomUUID(),
           public_key: publicKey ?? "",
@@ -5903,7 +5973,7 @@ var init_dist9 = __esm({
           const raw = this.rawInputState[field];
           const prev = this.currentState[field];
           const ema = alpha * raw + (1 - alpha) * prev;
-          if (this.applyHysteresis(field, ema, prev, now)) {
+          if (this.applyHysteresis(field, ema, prev, raw, now)) {
             smoothed[field] = ema;
           }
         }
@@ -5915,11 +5985,11 @@ var init_dist9 = __esm({
           sub(this.currentState);
         }
       }
-      applyHysteresis(field, newValue, currentValue, now) {
+      applyHysteresis(field, newValue, currentValue, rawValue, now) {
         const delta = Math.abs(newValue - currentValue);
         if (delta < this.config.hysteresis_threshold) {
           this.hysteresis.delete(field);
-          return false;
+          return Math.abs(rawValue - currentValue) >= this.config.hysteresis_threshold;
         }
         const entry = this.hysteresis.get(field);
         if (entry === void 0) {
@@ -8272,11 +8342,11 @@ var init_delegation_adapter = __esm({
       constructor(config) {
         this.config = config;
       }
-      async buildHeaders() {
+      async buildHeaders(audience) {
         const headers = { "Content-Type": "application/json" };
         const { authToken } = this.config;
         if (authToken != null && authToken !== "") {
-          const token = typeof authToken === "function" ? await authToken() : authToken;
+          const token = typeof authToken === "function" ? await authToken(audience) : authToken;
           if (token !== "")
             headers["Authorization"] = `Bearer ${token}`;
         }
@@ -8327,7 +8397,7 @@ var init_delegation_adapter = __esm({
         }
         const resp = await fetch(`${syncUrl}/agent/${motebitId}/task`, {
           method: "POST",
-          headers: await this.buildHeaders(),
+          headers: await this.buildHeaders("task:submit"),
           body: JSON.stringify(body)
         });
         if (!resp.ok) {
@@ -8388,7 +8458,7 @@ var init_delegation_adapter = __esm({
         const { syncUrl, motebitId } = this.config;
         try {
           const resp = await fetch(`${syncUrl}/agent/${motebitId}/task/${taskId}`, {
-            headers: await this.buildHeaders()
+            headers: await this.buildHeaders("task:query")
           });
           if (!resp.ok)
             return null;
@@ -9555,6 +9625,15 @@ function computePrecision(snapshot) {
   const curiosityModulation = Math.min(0.8, explorationDrive);
   return { selfTrust, explorationDrive, retrievalPrecision, curiosityModulation };
 }
+function computeStateBaseline(snapshot, precision) {
+  const confidence = 0.3 + precision.selfTrust * 0.5;
+  const valenceFromDelta = Math.max(-0.3, Math.min(0.3, snapshot.delta * 3));
+  const valenceFromLevel = (snapshot.gradient - 0.5) * 0.15;
+  const affect_valence = Math.max(-0.4, Math.min(0.4, valenceFromDelta + valenceFromLevel));
+  const affect_arousal = Math.min(0.3, Math.abs(snapshot.delta) * 2);
+  const curiosity = precision.curiosityModulation;
+  return { confidence, affect_valence, affect_arousal, curiosity };
+}
 function buildPrecisionContext(weights) {
   const parts = [];
   if (weights.selfTrust < 0.4) {
@@ -11340,6 +11419,24 @@ var init_conversation = __esm({
         return trimConversation(this.history, CONVERSATION_BUDGET, summary);
       }
       // --- Push + auto-summarize ---
+      /** Record only an assistant message (no user message). Used for system-triggered
+       *  generation like first-contact activation where there is no user input. */
+      pushActivation(assistantResponse) {
+        this.history.push({ role: "assistant", content: assistantResponse });
+        if (this.history.length > this.deps.maxHistory) {
+          this.history = this.history.slice(-this.deps.maxHistory);
+        }
+        const { store } = this.deps;
+        if (store != null) {
+          if (this.currentId == null || this.currentId === "") {
+            this.currentId = store.createConversation(this.deps.motebitId);
+          }
+          store.appendMessage(this.currentId, this.deps.motebitId, {
+            role: "assistant",
+            content: assistantResponse
+          });
+        }
+      }
       pushExchange(userMessage, assistantResponse) {
         this.history.push({ role: "user", content: userMessage }, { role: "assistant", content: assistantResponse });
         if (this.history.length > this.deps.maxHistory) {
@@ -11739,8 +11836,8 @@ var init_housekeeping = __esm({
 
 // ../../packages/runtime/dist/index.js
 function stripDisplayTags(text) {
-  const clean3 = text.replace(/<memory\s+[^>]*>[\s\S]*?<\/memory>/g, "").replace(/<thinking>[\s\S]*?<\/thinking>/g, "").replace(/<state\s+[^>]*\/>/g, "").replace(/\*[^*]+\*/g, "").replace(/ {2,}/g, " ");
-  for (const tag of ["<memory", "<thinking"]) {
+  const clean3 = text.replace(/<memory\s+[^>]*>[\s\S]*?<\/memory>/g, "").replace(/<thinking>[\s\S]*?<\/thinking>/g, "").replace(/<state\s+[^>]*\/>/g, "").replace(/<parameter\s+[^>]*>[\s\S]*?<\/parameter>/g, "").replace(/<\/?(?:artifact|function_calls|invoke|antml)[^>]*>/g, "").replace(/\*{1,3}/g, "").replace(/ {2,}/g, " ");
+  for (const tag of ["<memory", "<thinking", "<parameter"]) {
     const lastOpen2 = clean3.lastIndexOf(tag);
     if (lastOpen2 !== -1) {
       const closeTag = `</${tag.slice(1)}>`;
@@ -11750,14 +11847,6 @@ function stripDisplayTags(text) {
       }
     }
   }
-  const lastStar = clean3.lastIndexOf("*");
-  if (lastStar !== -1) {
-    const afterLastStar = clean3.slice(lastStar);
-    const starCount = (afterLastStar.match(/\*/g) ?? []).length;
-    if (starCount % 2 === 1) {
-      return { clean: clean3.slice(0, lastStar), pending: clean3.slice(lastStar) };
-    }
-  }
   const lastOpen = clean3.lastIndexOf("<");
   if (lastOpen !== -1 && !clean3.includes(">", lastOpen)) {
     return { clean: clean3.slice(0, lastOpen), pending: clean3.slice(lastOpen) };
@@ -11887,6 +11976,7 @@ var init_dist18 = __esm({
       loopDeps = null;
       conversation;
       _isProcessing = false;
+      _isFirstConversation = false;
       latestCues = {
         hover_distance: 0.4,
         drift_amplitude: 0.02,
@@ -11991,10 +12081,16 @@ var init_dist18 = __esm({
           generateCompletion: (prompt2, taskType) => this.generateCompletion(prompt2, taskType)
         });
         this.conversation.resumeActiveConversation();
+        this._isFirstConversation = this.conversation.getHistory().length === 0;
         this.planStore = adapters.storage.planStore ?? new InMemoryPlanStore();
         this.planEngine = new PlanEngine(this.planStore);
         this.planEngine.setLocalMotebitId(this.motebitId);
         this.gradientStore = adapters.storage.gradientStore ?? new InMemoryGradientStore();
+        const latestGradient = this.gradientStore.latest(this.motebitId);
+        if (latestGradient) {
+          this._precision = computePrecision(latestGradient);
+          this.state.pushUpdate(computeStateBaseline(latestGradient, this._precision));
+        }
         this.agentTrustStore = adapters.storage.agentTrustStore ?? null;
         this.serviceListingStore = adapters.storage.serviceListingStore ?? null;
         this.latencyStatsStore = adapters.storage.latencyStatsStore ?? null;
@@ -12494,7 +12590,7 @@ var init_dist18 = __esm({
         };
         patched.delta = patched.gradient - latest.gradient;
         this._precision = computePrecision(patched);
-        this.state.pushUpdate({ curiosity: this._precision.curiosityModulation });
+        this.state.pushUpdate(computeStateBaseline(patched, this._precision));
         this.memory.setPrecisionWeights(this._precision.retrievalPrecision);
       }
       /**
@@ -12581,9 +12677,13 @@ var init_dist18 = __esm({
             sessionInfo: this.conversation.getSessionInfo() ?? void 0,
             curiosityHints: this.buildCuriosityHints(),
             knownAgents: knownAgents.length > 0 ? knownAgents : void 0,
-            precisionContext: selfAwareness || void 0
+            precisionContext: selfAwareness || void 0,
+            firstConversation: this._isFirstConversation || void 0
           });
           this.conversation.pushExchange(text, result.response);
+          if (this._isFirstConversation && this.conversation.getHistory().length >= 5) {
+            this._isFirstConversation = false;
+          }
           this._behavioralStats.turnCount++;
           this._behavioralStats.totalIterations += result.iterations;
           this._behavioralStats.toolCallsSucceeded += result.toolCallsSucceeded;
@@ -12638,10 +12738,46 @@ var init_dist18 = __esm({
             knownAgents: knownAgents.length > 0 ? knownAgents : void 0,
             agentCapabilities,
             precisionContext: selfAwareness || void 0,
-            delegationScope: options?.delegationScope
+            delegationScope: options?.delegationScope,
+            firstConversation: this._isFirstConversation || void 0
           });
           this.conversation.clearSessionInfo();
           yield* this.processStream(stream, text, runId);
+          if (this._isFirstConversation && this.conversation.getHistory().length >= 5) {
+            this._isFirstConversation = false;
+          }
+        } finally {
+          this.behavior.setSpeaking(false);
+          this.state.pushUpdate({ processing: 0.1, attention: 0.3 });
+          this._isProcessing = false;
+        }
+      }
+      /**
+       * System-triggered generation with no user message. Used for first-contact
+       * activation — the creature speaks first without polluting conversation
+       * history with a synthetic user message.
+       *
+       * The activation prompt is injected as system context, not as user input.
+       * Only the assistant's response is recorded in history.
+       */
+      async *generateActivation(activationPrompt, runId) {
+        if (!this.loopDeps)
+          throw new Error("AI not initialized \u2014 call setProvider() first");
+        if (this._isProcessing)
+          throw new Error("Already processing a message");
+        this._isProcessing = true;
+        this._pendingApproval = null;
+        this.state.pushUpdate({ processing: 0.9, attention: 0.8 });
+        this.behavior.setSpeaking(true);
+        try {
+          const stream = runTurnStreaming(this.loopDeps, "", {
+            conversationHistory: [],
+            previousCues: this.latestCues,
+            runId,
+            firstConversation: true,
+            activationPrompt
+          });
+          yield* this.processStream(stream, "", runId, { activationOnly: true });
         } finally {
           this.behavior.setSpeaking(false);
           this.state.pushUpdate({ processing: 0.1, attention: 0.3 });
@@ -12996,7 +13132,7 @@ var init_dist18 = __esm({
         }
       }
       /** Shared stream processing — extracts state tags, handles tool/approval/injection chunks. */
-      async *processStream(stream, userMessage, runId) {
+      async *processStream(stream, userMessage, runId, options) {
         let result = null;
         let accumulated = "";
         let yieldedCleanLength = 0;
@@ -13061,7 +13197,7 @@ var init_dist18 = __esm({
             this.state.pushUpdate({ processing: 0.3 });
           }
           if (chunk.type === "text") {
-            const { clean: clean3 } = stripDisplayTags(accumulated);
+            const clean3 = stripDisplayTags(accumulated).clean.trimStart();
             const delta = clean3.slice(yieldedCleanLength);
             if (delta) {
               yieldedCleanLength += delta.length;
@@ -13088,7 +13224,11 @@ var init_dist18 = __esm({
           }
         }
         if (result) {
-          this.conversation.pushExchange(userMessage, result.response);
+          if (options?.activationOnly) {
+            this.conversation.pushActivation(result.response);
+          } else {
+            this.conversation.pushExchange(userMessage, result.response);
+          }
         }
         if (Object.keys(pendingStateUpdates).length > 0) {
           this.state.pushUpdate(pendingStateUpdates);
@@ -13428,7 +13568,7 @@ var init_dist18 = __esm({
           }
         }
         this._precision = computePrecision(snapshot);
-        this.state.pushUpdate({ curiosity: this._precision.curiosityModulation });
+        this.state.pushUpdate(computeStateBaseline(snapshot, this._precision));
         this.memory.setPrecisionWeights(this._precision.retrievalPrecision);
         return snapshot;
       }
@@ -13633,7 +13773,7 @@ var init_dist18 = __esm({
         this.motebitToolServers.set(TOOL_NAME, "relay");
         this.toolRegistry.register({
           name: TOOL_NAME,
-          description: "Delegate a task to a remote agent on the motebit network. The relay routes to the best capable agent based on trust and capabilities. Use when the user's request needs capabilities you don't have locally (web search, URL reading, specialized computation, etc.). Returns the agent's response text.",
+          description: "Delegate a task to a remote agent on the motebit network. The relay routes to the best capable agent based on trust and capabilities. Use when the user asks you to delegate, or when a task would benefit from a specialized agent. Returns the agent's response text.",
           inputSchema: {
             type: "object",
             properties: {
@@ -13652,20 +13792,21 @@ var init_dist18 = __esm({
         }, async (args) => {
           const prompt2 = args.prompt;
           const requiredCapabilities = args.required_capabilities;
-          let authHeader;
+          let submitHeader;
+          let queryHeader;
           try {
-            const token = await config.authToken();
-            authHeader = `Bearer ${token}`;
+            const [submitToken, queryToken] = await Promise.all([
+              config.authToken("task:submit"),
+              config.authToken("task:query")
+            ]);
+            submitHeader = `Bearer ${submitToken}`;
+            queryHeader = `Bearer ${queryToken}`;
           } catch (err3) {
             return {
               ok: false,
               error: `Auth failed: ${err3 instanceof Error ? err3.message : String(err3)}`
             };
           }
-          const headers = {
-            "Content-Type": "application/json",
-            Authorization: authHeader
-          };
           let taskId;
           let targetMotebitId;
           try {
@@ -13681,7 +13822,7 @@ var init_dist18 = __esm({
             }
             const resp = await fetch(`${config.syncUrl}/agent/${motebitId}/task`, {
               method: "POST",
-              headers,
+              headers: { "Content-Type": "application/json", Authorization: submitHeader },
               body: JSON.stringify(body)
             });
             if (!resp.ok) {
@@ -13703,10 +13844,16 @@ var init_dist18 = __esm({
             await new Promise((resolve7) => setTimeout(resolve7, POLL_INTERVAL_MS));
             try {
               const resp = await fetch(`${config.syncUrl}/agent/${targetMotebitId}/task/${taskId}`, {
-                headers
+                headers: { Authorization: queryHeader }
               });
-              if (!resp.ok)
+              if (!resp.ok) {
+                logger.warn("delegation poll failed", {
+                  taskId,
+                  status: resp.status,
+                  body: await resp.text().catch(() => "")
+                });
                 continue;
+              }
               const data = await resp.json();
               if (data.receipt != null) {
                 try {
@@ -15540,12 +15687,58 @@ CREATE INDEX IF NOT EXISTS idx_agent_trust_motebit ON agent_trust (motebit_id);
   }
 });
 
+// ../../packages/tools/dist/search-provider.js
+var SearchProviderError, FallbackSearchProvider;
+var init_search_provider = __esm({
+  "../../packages/tools/dist/search-provider.js"() {
+    "use strict";
+    init_esm_shims();
+    SearchProviderError = class extends Error {
+      status;
+      provider;
+      constructor(message, status, provider) {
+        super(message);
+        this.status = status;
+        this.provider = provider;
+        this.name = "SearchProviderError";
+      }
+    };
+    FallbackSearchProvider = class {
+      providers;
+      constructor(providers) {
+        this.providers = providers;
+      }
+      async search(query, maxResults) {
+        let firstError;
+        for (const provider of this.providers) {
+          try {
+            const results = await provider.search(query, maxResults);
+            if (results.length > 0)
+              return results;
+          } catch (err3) {
+            if (firstError === void 0)
+              firstError = err3;
+            continue;
+          }
+        }
+        if (firstError !== void 0) {
+          if (firstError instanceof Error)
+            throw firstError;
+          throw new Error("All search providers failed");
+        }
+        return [];
+      }
+    };
+  }
+});
+
 // ../../packages/tools/dist/providers/duckduckgo.js
 var DuckDuckGoSearchProvider;
 var init_duckduckgo = __esm({
   "../../packages/tools/dist/providers/duckduckgo.js"() {
     "use strict";
     init_esm_shims();
+    init_search_provider();
     DuckDuckGoSearchProvider = class {
       async search(query, maxResults = 5) {
         const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
@@ -15555,7 +15748,7 @@ var init_duckduckgo = __esm({
           }
         });
         if (!res.ok) {
-          throw new Error(`DuckDuckGo search error: ${res.status}`);
+          throw new SearchProviderError(`DuckDuckGo search error: ${res.status}`, res.status, "duckduckgo");
         }
         const html = await res.text();
         const results = [];
@@ -15607,6 +15800,12 @@ function createWebSearchHandler(provider) {
 ${formatted}`;
       return { ok: true, data: output.slice(0, MAX_RESULT_SIZE) };
     } catch (err3) {
+      if (err3 instanceof SearchProviderError) {
+        return {
+          ok: false,
+          error: `Search provider error (${err3.provider}, HTTP ${err3.status}): ${err3.message}`
+        };
+      }
       const msg = err3 instanceof Error ? err3.message : String(err3);
       return { ok: false, error: `Search error: ${msg}` };
     }
@@ -15617,6 +15816,7 @@ var init_web_search = __esm({
   "../../packages/tools/dist/builtins/web-search.js"() {
     "use strict";
     init_esm_shims();
+    init_search_provider();
     init_duckduckgo();
     webSearchDefinition = {
       name: "web_search",
@@ -16290,39 +16490,13 @@ var init_builtins = __esm({
   }
 });
 
-// ../../packages/tools/dist/search-provider.js
-var FallbackSearchProvider;
-var init_search_provider = __esm({
-  "../../packages/tools/dist/search-provider.js"() {
-    "use strict";
-    init_esm_shims();
-    FallbackSearchProvider = class {
-      providers;
-      constructor(providers) {
-        this.providers = providers;
-      }
-      async search(query, maxResults) {
-        for (const provider of this.providers) {
-          try {
-            const results = await provider.search(query, maxResults);
-            if (results.length > 0)
-              return results;
-          } catch {
-            continue;
-          }
-        }
-        return [];
-      }
-    };
-  }
-});
-
 // ../../packages/tools/dist/providers/brave-search.js
 var BraveSearchProvider;
 var init_brave_search = __esm({
   "../../packages/tools/dist/providers/brave-search.js"() {
     "use strict";
     init_esm_shims();
+    init_search_provider();
     BraveSearchProvider = class {
       apiKey;
       constructor(apiKey) {
@@ -16338,7 +16512,12 @@ var init_brave_search = __esm({
           }
         });
         if (!res.ok) {
-          throw new Error(`Brave Search API error: ${res.status}`);
+          let body = "";
+          try {
+            body = await res.text();
+          } catch {
+          }
+          throw new SearchProviderError(`Brave Search API error: ${res.status}${body ? ` \u2014 ${body.slice(0, 200)}` : ""}`, res.status, "brave");
         }
         const data = await res.json();
         const webResults = data.web?.results ?? [];
@@ -16633,20 +16812,17 @@ async function createRuntime(config, motebitId, toolRegistry, mcpServers, person
       tools: toolRegistry
     }
   );
-  const syncUrl = config.syncUrl ?? process.env["MOTEBIT_SYNC_URL"] ?? loadFullConfig().sync_url;
+  const DEFAULT_SYNC_URL2 = "https://motebit-sync.fly.dev";
+  const syncUrl = config.syncUrl ?? process.env["MOTEBIT_SYNC_URL"] ?? loadFullConfig().sync_url ?? DEFAULT_SYNC_URL2;
   const syncToken = config.syncToken ?? process.env["MOTEBIT_SYNC_TOKEN"];
-  if (syncUrl != null && syncUrl !== "") {
-    const httpAdapter = new HttpEventStoreAdapter({
-      baseUrl: syncUrl,
-      motebitId,
-      authToken: syncToken
-    });
-    const remoteStore = encKey ? new EncryptedEventStoreAdapter({ inner: httpAdapter, key: encKey }) : httpAdapter;
-    runtime.connectSync(remoteStore);
-    console.log(dim(`Sync: ${syncUrl}${encKey ? " (encrypted)" : ""}`));
-  } else {
-    console.log(dim("Sync: disabled (set MOTEBIT_SYNC_URL to enable)"));
-  }
+  const httpAdapter = new HttpEventStoreAdapter({
+    baseUrl: syncUrl,
+    motebitId,
+    authToken: syncToken
+  });
+  const remoteStore = encKey ? new EncryptedEventStoreAdapter({ inner: httpAdapter, key: encKey }) : httpAdapter;
+  runtime.connectSync(remoteStore);
+  console.log(dim(`Sync: ${syncUrl}${encKey ? " (encrypted)" : ""}`));
   return { runtime, moteDb };
 }
 var SqliteConversationSyncStoreAdapter, SqlitePlanSyncStoreAdapter;
@@ -16805,7 +16981,6 @@ init_dist3();
 init_dist4();
 init_dist5();
 init_dist3();
-import * as readline3 from "readline";
 
 // src/args.ts
 init_esm_shims();
@@ -16857,7 +17032,7 @@ function parseCliArgs(args = process.argv.slice(2)) {
       `Unknown provider "${provider}". Use "anthropic", "openai", "ollama", or "hybrid".`
     );
   }
-  const defaultModel = provider === "ollama" ? "llama3.2" : provider === "openai" ? "gpt-4o" : "claude-sonnet-4-5-latest";
+  const defaultModel = provider === "ollama" ? "llama3.2" : provider === "openai" ? "gpt-4o-mini" : "claude-sonnet-4-6";
   const allowedPaths = values["allowed-paths"] != null && values["allowed-paths"] !== "" ? values["allowed-paths"].split(",").map((p) => p.trim()) : [process.cwd()];
   return {
     provider,
@@ -17003,9 +17178,9 @@ Options:
 
 Providers:
   anthropic               Uses Anthropic API (requires ANTHROPIC_API_KEY)
-                          Default model: claude-sonnet-4-5-latest
+                          Default model: claude-sonnet-4-6
   openai                  Uses OpenAI API (requires OPENAI_API_KEY)
-                          Default model: gpt-4o
+                          Default model: gpt-4o-mini
   ollama                  Uses local Ollama server (no API key needed)
                           Default model: llama3.2
   hybrid                  Anthropic with Ollama fallback (requires ANTHROPIC_API_KEY)
@@ -17236,24 +17411,362 @@ init_runtime_factory();
 init_esm_shims();
 init_dist3();
 init_colors();
-function rlQuestion(rl, prompt2) {
+
+// src/terminal.ts
+init_esm_shims();
+function visibleLength(s) {
+  return s.replace(/\x1b\[[0-9;]*[a-zA-Z~]/g, "").length;
+}
+var PASTE_OPEN = "\x1B[200~";
+var PASTE_CLOSE = "\x1B[201~";
+var initialized = false;
+var inputActive = false;
+var inputState = { line: "", cursor: 0, prompt: "", promptWidth: 0 };
+var inputResolver = null;
+var lastEscTime = 0;
+var pendingEscTimer = null;
+var pasteBuffer = null;
+var pasteSplitCarry = "";
+var inputRows = 0;
+function parseChunk(buf) {
+  const events = [];
+  let data = buf.toString("utf-8");
+  if (pasteSplitCarry.length > 0) {
+    data = pasteSplitCarry + data;
+    pasteSplitCarry = "";
+  }
+  let i = 0;
+  while (i < data.length) {
+    const ch = data[i];
+    if (pasteBuffer !== null) {
+      const closeIdx = data.indexOf(PASTE_CLOSE, i);
+      if (closeIdx === -1) {
+        const remaining = data.slice(i);
+        let overlap = 0;
+        for (let k = 1; k < PASTE_CLOSE.length && k <= remaining.length; k++) {
+          if (remaining.slice(remaining.length - k) === PASTE_CLOSE.slice(0, k)) {
+            overlap = k;
+          }
+        }
+        pasteBuffer += remaining.slice(0, remaining.length - overlap);
+        pasteSplitCarry = overlap > 0 ? remaining.slice(remaining.length - overlap) : "";
+        i = data.length;
+      } else {
+        pasteBuffer += data.slice(i, closeIdx);
+        const text = pasteBuffer.replace(/[\r\n]+/g, " ");
+        events.push({ type: "paste", text });
+        pasteBuffer = null;
+        pasteSplitCarry = "";
+        i = closeIdx + PASTE_CLOSE.length;
+      }
+      continue;
+    }
+    if (data.startsWith(PASTE_OPEN, i)) {
+      pasteBuffer = "";
+      i += PASTE_OPEN.length;
+      continue;
+    }
+    if (ch === "\x1B") {
+      if (i + 1 < data.length && data[i + 1] === "[") {
+        let j = i + 2;
+        while (j < data.length && !/[a-zA-Z~]/.test(data[j])) j++;
+        if (j < data.length) {
+          const seq = data.slice(i + 2, j + 1);
+          i = j + 1;
+          switch (seq) {
+            case "A":
+              events.push({ type: "key", key: "up", ctrl: false });
+              break;
+            case "B":
+              events.push({ type: "key", key: "down", ctrl: false });
+              break;
+            case "C":
+              events.push({ type: "key", key: "right", ctrl: false });
+              break;
+            case "D":
+              events.push({ type: "key", key: "left", ctrl: false });
+              break;
+            case "H":
+            case "1~":
+              events.push({ type: "key", key: "home", ctrl: false });
+              break;
+            case "F":
+            case "4~":
+              events.push({ type: "key", key: "end", ctrl: false });
+              break;
+            case "3~":
+              events.push({ type: "key", key: "delete", ctrl: false });
+              break;
+          }
+        } else {
+          i = data.length;
+        }
+      } else if (i + 1 >= data.length) {
+        if (pendingEscTimer) clearTimeout(pendingEscTimer);
+        pendingEscTimer = setTimeout(() => {
+          pendingEscTimer = null;
+          handleBareEscape();
+        }, 50);
+        i++;
+      } else {
+        handleBareEscape();
+        i++;
+      }
+      continue;
+    }
+    const code2 = ch.charCodeAt(0);
+    if (code2 === 3) {
+      events.push({ type: "key", key: "c", ctrl: true });
+    } else if (code2 === 1) {
+      events.push({ type: "key", key: "home", ctrl: false });
+    } else if (code2 === 5) {
+      events.push({ type: "key", key: "end", ctrl: false });
+    } else if (code2 === 127 || code2 === 8) {
+      events.push({ type: "key", key: "backspace", ctrl: false });
+    } else if (code2 === 13) {
+      events.push({ type: "key", key: "return", ctrl: false });
+    } else if (code2 === 21) {
+      events.push({ type: "key", key: "u", ctrl: true });
+    } else if (code2 >= 32) {
+      events.push({ type: "key", key: ch, ctrl: false });
+    }
+    i++;
+  }
+  return events;
+}
+function handleBareEscape() {
+  if (!inputActive) return;
+  const now = Date.now();
+  if (now - lastEscTime < 300) {
+    lastEscTime = 0;
+    inputState = { ...inputState, line: "", cursor: 0 };
+    redrawInput();
+  } else {
+    lastEscTime = now;
+  }
+}
+function applyEvent(state, event) {
+  switch (event.type) {
+    case "key": {
+      if (event.ctrl) {
+        if (event.key === "c") return "exit";
+        if (event.key === "u") return { state: { ...state, line: "", cursor: 0 } };
+        return { state };
+      }
+      switch (event.key) {
+        case "return":
+          return "submit";
+        case "backspace":
+          if (state.cursor > 0) {
+            return {
+              state: {
+                ...state,
+                line: state.line.slice(0, state.cursor - 1) + state.line.slice(state.cursor),
+                cursor: state.cursor - 1
+              }
+            };
+          }
+          return { state };
+        case "delete":
+          if (state.cursor < state.line.length) {
+            return {
+              state: {
+                ...state,
+                line: state.line.slice(0, state.cursor) + state.line.slice(state.cursor + 1)
+              }
+            };
+          }
+          return { state };
+        case "left":
+          return { state: { ...state, cursor: Math.max(0, state.cursor - 1) } };
+        case "right":
+          return { state: { ...state, cursor: Math.min(state.line.length, state.cursor + 1) } };
+        case "home":
+          return { state: { ...state, cursor: 0 } };
+        case "end":
+          return { state: { ...state, cursor: state.line.length } };
+        case "up":
+        case "down":
+          return { state };
+        // No history (yet)
+        default:
+          if (event.key.length === 1) {
+            return {
+              state: {
+                ...state,
+                line: state.line.slice(0, state.cursor) + event.key + state.line.slice(state.cursor),
+                cursor: state.cursor + 1
+              }
+            };
+          }
+          return { state };
+      }
+    }
+    case "paste": {
+      return {
+        state: {
+          ...state,
+          line: state.line.slice(0, state.cursor) + event.text + state.line.slice(state.cursor),
+          cursor: state.cursor + event.text.length
+        }
+      };
+    }
+    case "resize":
+      return { state };
+  }
+}
+function redrawInput() {
+  const cols = process.stdout.columns || 80;
+  const fullLine = inputState.prompt + inputState.line;
+  const totalLen = inputState.promptWidth + inputState.line.length;
+  const newRows = Math.max(1, Math.ceil(totalLen / cols) || 1);
+  if (inputRows > 1) {
+    process.stdout.write(`\x1B[${inputRows - 1}A`);
+  }
+  process.stdout.write("\r");
+  process.stdout.write("\x1B[J");
+  process.stdout.write(fullLine);
+  const cursorPos = inputState.promptWidth + inputState.cursor;
+  const cursorRow = Math.floor(cursorPos / cols);
+  const cursorCol = cursorPos % cols;
+  const endRow = Math.floor(Math.max(0, totalLen - 1) / cols);
+  if (endRow > cursorRow) {
+    process.stdout.write(`\x1B[${endRow - cursorRow}A`);
+  }
+  process.stdout.write(`\r`);
+  if (cursorCol > 0) {
+    process.stdout.write(`\x1B[${cursorCol}C`);
+  }
+  inputRows = newRows;
+}
+function writeOutput(text) {
+  if (!inputActive) {
+    process.stdout.write(text);
+    return;
+  }
+  if (inputRows > 1) {
+    process.stdout.write(`\x1B[${inputRows - 1}A`);
+  }
+  process.stdout.write("\r\x1B[J");
+  process.stdout.write(text);
+  inputRows = 1;
+  redrawInput();
+}
+function onStdinData(buf) {
+  const events = parseChunk(buf);
+  for (const event of events) {
+    if (!inputActive) continue;
+    if (event.type === "resize") {
+      redrawInput();
+      continue;
+    }
+    const result = applyEvent(inputState, event);
+    if (result === "submit") {
+      const line = inputState.line;
+      process.stdout.write("\n");
+      inputActive = false;
+      inputRows = 0;
+      if (inputResolver) {
+        const resolve7 = inputResolver;
+        inputResolver = null;
+        resolve7(line);
+      }
+    } else if (result === "exit") {
+      process.stdout.write("\n");
+      process.exit(0);
+    } else {
+      inputState = result.state;
+      redrawInput();
+    }
+  }
+}
+var resizeTimer = null;
+function onResize() {
+  if (!inputActive) return;
+  if (resizeTimer) clearTimeout(resizeTimer);
+  resizeTimer = setTimeout(() => {
+    resizeTimer = null;
+    if (!inputActive) return;
+    process.stdout.write("\n");
+    inputRows = 1;
+    redrawInput();
+  }, 100);
+}
+function initTerminal() {
+  if (initialized) return;
+  initialized = true;
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  process.stdin.on("data", onStdinData);
+  process.stdout.on("resize", onResize);
+  if (process.stdout.isTTY) {
+    process.stdout.write("\x1B[?2004h");
+  }
+}
+function destroyTerminal() {
+  if (!initialized) return;
+  initialized = false;
+  process.stdin.removeListener("data", onStdinData);
+  process.stdout.removeListener("resize", onResize);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false);
+  }
+  if (process.stdout.isTTY) {
+    process.stdout.write("\x1B[?2004l");
+  }
+}
+function readInput(promptText) {
   return new Promise((resolve7) => {
-    rl.question(prompt2, (answer) => resolve7(answer));
+    inputState = {
+      line: "",
+      cursor: 0,
+      prompt: promptText,
+      promptWidth: visibleLength(promptText)
+    };
+    inputRows = 1;
+    inputActive = true;
+    inputResolver = resolve7;
+    redrawInput();
   });
 }
-async function consumeStream(stream, runtime, rl) {
+function askQuestion(promptText) {
+  return readInput(promptText);
+}
+
+// src/stream.ts
+function startDotAnimation() {
+  let dots = 1;
+  const timer = setInterval(() => {
+    dots = dots % 3 + 1;
+    writeOutput(`\x1B[${3}D${meta(".".repeat(dots) + " ".repeat(3 - dots))}`);
+  }, 400);
+  return () => {
+    clearInterval(timer);
+    writeOutput(`\x1B[${3}D${meta("...")} ${meta("done")}
+`);
+  };
+}
+async function consumeStream(stream, runtime) {
   let pendingApproval = null;
+  let stopAnimation = null;
   for await (const chunk of stream) {
     switch (chunk.type) {
       case "text":
-        process.stdout.write(chunk.text);
+        writeOutput(chunk.text);
         break;
       case "tool_status":
+        if (chunk.name === "delegate_to_agent") break;
         if (chunk.status === "calling") {
-          process.stdout.write(`
+          writeOutput(`
   ${action("\u25CF")} ${action(chunk.name)}${meta("...")}`);
+          stopAnimation = startDotAnimation();
         } else {
-          process.stdout.write(meta(" done") + "\n");
+          if (stopAnimation) {
+            stopAnimation();
+            stopAnimation = null;
+          } else writeOutput(meta(" done") + "\n");
         }
         break;
       case "approval_request":
@@ -17265,40 +17778,42 @@ async function consumeStream(stream, runtime, rl) {
         };
         break;
       case "delegation_start":
-        process.stdout.write(
+        writeOutput(
           `
   ${action("\u25CF")} ${dim("[delegating]")} ${action(chunk.tool)}${meta("...")}`
         );
+        stopAnimation = startDotAnimation();
         break;
       case "delegation_complete":
-        process.stdout.write(meta(" done") + "\n");
+        if (stopAnimation) {
+          stopAnimation();
+          stopAnimation = null;
+        } else writeOutput(meta(" done") + "\n");
         break;
       case "injection_warning":
-        process.stdout.write(
-          `
+        writeOutput(`
   ${warn("\u26A0")} ${warn("suspicious content in " + chunk.tool_name)}
-`
-        );
+`);
         break;
       case "result": {
         const result = chunk.result;
-        console.log("\n");
+        writeOutput("\n\n");
         if (result.memoriesFormed.length > 0) {
-          console.log(
+          writeOutput(
             meta(
               `  [memories: ${result.memoriesFormed.map((m) => m.content).join(", ")}]`
-            )
+            ) + "\n"
           );
         }
         const s = result.stateAfter;
-        console.log(
+        writeOutput(
           meta(
             `  [state: attention=${s.attention.toFixed(2)} confidence=${s.confidence.toFixed(2)} valence=${s.affect_valence.toFixed(2)} curiosity=${s.curiosity.toFixed(2)}]`
-          )
+          ) + "\n"
         );
         const bodyLine = formatBodyAwareness(result.cues);
-        if (bodyLine) console.log(meta(`  ${bodyLine}`));
-        console.log();
+        if (bodyLine) writeOutput(meta(`  ${bodyLine}`) + "\n");
+        writeOutput("\n");
         break;
       }
     }
@@ -17306,149 +17821,16 @@ async function consumeStream(stream, runtime, rl) {
   if (pendingApproval) {
     const argsPreview = JSON.stringify(pendingApproval.args).slice(0, 80);
     const quorumInfo = pendingApproval.quorum && pendingApproval.quorum.required > 1 ? ` [${pendingApproval.quorum.collected.length}/${pendingApproval.quorum.required} approvals]` : "";
-    const answer = await rlQuestion(
-      rl,
+    const answer = await askQuestion(
       `  ${warn("?")} ${pendingApproval.name}(${argsPreview})${quorumInfo}
   Allow? (y/n) `
     );
     const approved = answer.trim().toLowerCase() === "y";
-    process.stdout.write("\n" + prompt("mote>") + " ");
-    await consumeStream(runtime.resolveApprovalVote(approved, runtime.motebitId), runtime, rl);
+    writeOutput("\n" + prompt("mote>") + " ");
+    await consumeStream(runtime.resolveApprovalVote(approved, runtime.motebitId), runtime);
   }
 }
 
-// src/input.ts
-init_esm_shims();
-init_colors();
-function visibleLength(s) {
-  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
-}
-var PASTE_OPEN = "\x1B[200~";
-var PASTE_CLOSE = "\x1B[201~";
-function enableBracketedPaste() {
-  if (process.stdout.isTTY) {
-    process.stdout.write("\x1B[?2004h");
-  }
-}
-function disableBracketedPaste() {
-  if (process.stdout.isTTY) {
-    process.stdout.write("\x1B[?2004l");
-  }
-}
-function readInput(promptText) {
-  return new Promise((resolve7) => {
-    const stdin = process.stdin;
-    const stdout = process.stdout;
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.setEncoding("utf8");
-    process.stdout.write(promptText);
-    let value = "";
-    let pasteBuffer = "";
-    let inPaste = false;
-    let pasteLineCount = 0;
-    let lastEscTime = 0;
-    const promptVisibleLen = visibleLength(promptText);
-    let lastDisplayLen = 0;
-    const redrawLine = (text) => {
-      const cols = stdout.columns || 80;
-      const prevTotal = promptVisibleLen + lastDisplayLen;
-      const wrappedLines = Math.max(0, Math.ceil(prevTotal / cols) - 1);
-      if (wrappedLines > 0) {
-        stdout.write(`\x1B[${wrappedLines}A`);
-      }
-      stdout.write(`\r\x1B[J${promptText}${text}`);
-      lastDisplayLen = visibleLength(text);
-    };
-    const finish = () => {
-      stdin.removeListener("data", onData);
-      stdin.setRawMode(false);
-      stdin.pause();
-      stdout.write("\n");
-      if (pasteBuffer) {
-        resolve7(pasteBuffer.replace(/\r?\n/g, " ").trim());
-      } else {
-        resolve7(value);
-      }
-    };
-    const onData = (ch) => {
-      const data = ch.toString();
-      if (data.includes(PASTE_OPEN)) {
-        inPaste = true;
-        pasteBuffer = value;
-        pasteLineCount = 0;
-        const afterOpen = data.slice(data.indexOf(PASTE_OPEN) + PASTE_OPEN.length);
-        if (afterOpen) {
-          processPasteData(afterOpen);
-        }
-        return;
-      }
-      if (inPaste) {
-        processPasteData(data);
-        return;
-      }
-      for (let i = 0; i < data.length; i++) {
-        const c = data[i];
-        if (c === "\r" || c === "\n") {
-          finish();
-          return;
-        } else if (c === "") {
-          stdin.removeListener("data", onData);
-          stdin.setRawMode(false);
-          stdout.write("\n");
-          resolve7("");
-          return;
-        } else if (c === "\x7F" || c === "\b") {
-          if (value.length > 0) {
-            value = value.slice(0, -1);
-            redrawLine(value);
-          }
-        } else if (c === "\x1B") {
-          const now = Date.now();
-          if (now - lastEscTime < 300) {
-            value = "";
-            pasteBuffer = "";
-            redrawLine("");
-            lastEscTime = 0;
-          } else {
-            lastEscTime = now;
-          }
-          return;
-        } else if (c.charCodeAt(0) >= 32) {
-          value += c;
-          stdout.write(c);
-          lastDisplayLen = value.length;
-        }
-      }
-    };
-    const processPasteData = (data) => {
-      const closeIdx = data.indexOf(PASTE_CLOSE);
-      if (closeIdx !== -1) {
-        const remaining = data.slice(0, closeIdx);
-        pasteBuffer += remaining;
-        pasteLineCount += (remaining.match(/\n/g) || []).length;
-        inPaste = false;
-        const charCount = pasteBuffer.length;
-        const summary = pasteLineCount > 0 ? dim(`[Pasted text #${charCount} +${pasteLineCount} lines]`) : pasteBuffer;
-        redrawLine(pasteLineCount > 0 ? summary : pasteBuffer);
-        if (pasteLineCount === 0) {
-          value = pasteBuffer;
-          pasteBuffer = "";
-        }
-        return;
-      }
-      pasteBuffer += data;
-      pasteLineCount += (data.match(/\n/g) || []).length;
-      if (pasteLineCount > 0) {
-        const charCount = pasteBuffer.length;
-        const summary = dim(`[Pasted text #${charCount} +${pasteLineCount} lines]`);
-        redrawLine(summary);
-      }
-    };
-    stdin.on("data", onData);
-  });
-}
-
 // src/index.ts
 init_colors();
 
@@ -21749,6 +22131,11 @@ var McpServerAdapter = class _McpServerAdapter {
   deps;
   httpServer;
   lastVerifiedCaller = null;
+  /**
+   * Hook for relay re-registration on health checks. Set by startServiceServer
+   * to close the stale-registration window when platforms freeze/resume processes.
+   */
+  ensureRegistered;
   constructor(config, deps) {
     this.config = config;
     this.deps = deps;
@@ -22082,9 +22469,6 @@ var McpServerAdapter = class _McpServerAdapter {
               isError: true
             };
           }
-          if (delegatedScope) {
-            receipt.delegated_scope = delegatedScope;
-          }
           this.deps.logToolCall("motebit_task", args, { ok: true, data: receipt });
           return fmt(receipt);
         }
@@ -22309,6 +22693,9 @@ var McpServerAdapter = class _McpServerAdapter {
         return;
       }
       if (url.pathname === "/health" && req.method === "GET") {
+        if (this.ensureRegistered) {
+          void this.ensureRegistered();
+        }
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({
           status: "ok",
@@ -22920,7 +23307,7 @@ Unknown model: ${cyan(args)}
       const mid = repl.motebitId;
       runtime.enableInteractiveDelegation({
         syncUrl: connectUrl,
-        authToken: async () => {
+        authToken: async (audience = "task:submit") => {
           const now = Date.now();
           return createSignedToken(
             {
@@ -22929,7 +23316,7 @@ Unknown model: ${cyan(args)}
               iat: now,
               exp: now + 5 * 60 * 1e3,
               jti: crypto.randomUUID(),
-              aud: "task:submit"
+              aud: audience
             },
             pk
           );
@@ -27822,19 +28209,19 @@ var GoalScheduler = class _GoalScheduler {
       }
       switch (chunk.type) {
         case "text":
-          process.stdout.write(chunk.text);
+          writeOutput(chunk.text);
           responseText += chunk.text;
           break;
         case "tool_status":
           if (chunk.status === "calling") {
-            process.stdout.write(`
+            writeOutput(`
   [tool] ${chunk.name}...`);
             toolCallsMade++;
             if (toolCallsMade > MAX_TOOL_CALLS_PER_RUN) {
               throw new Error(`Goal exceeded ${MAX_TOOL_CALLS_PER_RUN} tool calls \u2014 run stopped`);
             }
           } else {
-            process.stdout.write(" done\n");
+            writeOutput(" done\n");
           }
           break;
         case "approval_request": {
@@ -27951,18 +28338,18 @@ var GoalScheduler = class _GoalScheduler {
           break;
         case "step_chunk":
           if (chunk.chunk.type === "text") {
-            process.stdout.write(chunk.chunk.text);
+            writeOutput(chunk.chunk.text);
             responseText += chunk.chunk.text;
           } else if (chunk.chunk.type === "tool_status") {
             if (chunk.chunk.status === "calling") {
-              process.stdout.write(`
+              writeOutput(`
   [tool] ${chunk.chunk.name}...`);
               toolCallsMade++;
               if (toolCallsMade > MAX_TOOL_CALLS_PER_RUN) {
                 throw new Error(`Goal exceeded ${MAX_TOOL_CALLS_PER_RUN} tool calls \u2014 run stopped`);
               }
             } else {
-              process.stdout.write(" done\n");
+              writeOutput(" done\n");
             }
           } else if (chunk.chunk.type === "injection_warning") {
             console.warn(`
@@ -28470,7 +28857,7 @@ Agent task received: ${task.task_id.slice(0, 8)}... prompt: "${task.prompt.slice
     wsAdapter.connect();
     if (privKeyBytes) {
       const privateKeyForDelegation = privKeyBytes;
-      const tokenFactory = async () => {
+      const tokenFactory = async (audience = "task:submit") => {
         if (!fullConfig.device_id) return syncToken ?? "";
         try {
           return await createSignedToken(
@@ -28480,7 +28867,7 @@ Agent task received: ${task.task_id.slice(0, 8)}... prompt: "${task.prompt.slice
               iat: Date.now(),
               exp: Date.now() + 5 * 60 * 1e3,
               jti: crypto.randomUUID(),
-              aud: "task:submit"
+              aud: audience
             },
             privateKeyForDelegation
           );
@@ -29001,10 +29388,32 @@ async function handleServe(config) {
             try {
               await new Promise((r) => setTimeout(r, 500));
               const firstToolName = toolNames[toolNames.length - 1] ?? "echo";
-              log("[self-test] submitting task via relay...");
+              const mintToken = async (audience) => {
+                if (servePrivateKey && fullConfigForServe.device_id) {
+                  return createSignedToken(
+                    {
+                      mid: motebitId,
+                      did: fullConfigForServe.device_id,
+                      iat: Date.now(),
+                      exp: Date.now() + 5 * 60 * 1e3,
+                      jti: crypto.randomUUID(),
+                      aud: audience
+                    },
+                    servePrivateKey
+                  );
+                }
+                return masterToken ?? "";
+              };
+              const submitToken = await mintToken("task:submit");
+              const queryToken = await mintToken("task:query");
+              const authMethod = servePrivateKey && fullConfigForServe.device_id ? "device token" : "master token";
+              log(`[self-test] submitting task via relay (auth: ${authMethod})...`);
               const taskResp = await fetch(`${syncUrl}/agent/${motebitId}/task`, {
                 method: "POST",
-                headers: regHeaders,
+                headers: {
+                  "Content-Type": "application/json",
+                  Authorization: `Bearer ${submitToken}`
+                },
                 body: JSON.stringify({
                   prompt: "self-test",
                   submitted_by: motebitId,
@@ -29018,6 +29427,8 @@ async function handleServe(config) {
                   `[self-test] failed \u2014 relay returned ${status}${body ? `: ${body.slice(0, 100)}` : ""}`
                 );
                 if (status === 402) log("[self-test] hint: fund the agent's budget on the relay");
+                if (status === 401 || status === 403)
+                  log("[self-test] hint: device may not be registered with relay");
                 return;
               }
               const taskData = await taskResp.json();
@@ -29032,7 +29443,7 @@ async function handleServe(config) {
               while (Date.now() < deadline) {
                 await new Promise((r) => setTimeout(r, 2e3));
                 const pollResp = await fetch(`${syncUrl}/agent/${motebitId}/task/${taskId}`, {
-                  headers: regHeaders
+                  headers: { Authorization: `Bearer ${queryToken}` }
                 });
                 if (!pollResp.ok) continue;
                 const pollData = await pollResp.json();
@@ -29290,6 +29701,8 @@ async function main() {
     saveFullConfig2(fullConfig);
     console.log(dim("  Encrypted. Plaintext removed."));
   } else {
+    console.log();
+    console.log(`  ${bold("Welcome to Motebit.")}`);
     console.log();
     console.log(dim("         ."));
     console.log(dim("       .:::."));
@@ -29319,18 +29732,7 @@ async function main() {
       }
     }
   }
-  enableBracketedPaste();
-  let rl = null;
-  const getOrCreateRl = () => {
-    if (!rl) {
-      rl = readline3.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        escapeCodeTimeout: 50
-      });
-    }
-    return rl;
-  };
+  initTerminal();
   const dbPath = getDbPath(config.dbPath);
   const tempDb = await openMotebitDatabase(dbPath);
   const { motebitId, isFirstLaunch } = await bootstrapIdentity2(tempDb, fullConfig, passphrase);
@@ -29388,31 +29790,9 @@ async function main() {
     }
   }
   await runtime.init();
-  const syncUrl = config.syncUrl ?? process.env["MOTEBIT_SYNC_URL"] ?? reloadedConfig.sync_url;
-  if (syncUrl && privateKeyBytes && deviceId) {
-    const pk = privateKeyBytes;
-    const did = deviceId;
-    runtime.enableInteractiveDelegation({
-      syncUrl,
-      authToken: async () => {
-        const now = Date.now();
-        return createSignedToken(
-          {
-            mid: motebitId,
-            did,
-            iat: now,
-            exp: now + 5 * 60 * 1e3,
-            jti: crypto.randomUUID(),
-            aud: "task:submit"
-          },
-          pk
-        );
-      },
-      routingStrategy: config.routingStrategy
-    });
-  }
-  const hasSyncRemote = config.syncUrl != null || process.env["MOTEBIT_SYNC_URL"] != null || reloadedConfig.sync_url != null && reloadedConfig.sync_url !== "";
-  if (hasSyncRemote) {
+  const DEFAULT_SYNC_URL2 = "https://motebit-sync.fly.dev";
+  const syncUrl = config.syncUrl ?? process.env["MOTEBIT_SYNC_URL"] ?? reloadedConfig.sync_url ?? DEFAULT_SYNC_URL2;
+  {
     try {
       console.log(dim("Syncing..."));
       const result = await runtime.sync.sync();
@@ -29444,6 +29824,39 @@ async function main() {
       } catch {
       }
     }
+    if (syncUrl) {
+      if (privateKeyBytes && deviceId) {
+        const pk = privateKeyBytes;
+        const did = deviceId;
+        runtime.enableInteractiveDelegation({
+          syncUrl,
+          authToken: async (audience = "task:submit") => {
+            const now = Date.now();
+            return createSignedToken(
+              {
+                mid: motebitId,
+                did,
+                iat: now,
+                exp: now + 5 * 60 * 1e3,
+                jti: crypto.randomUUID(),
+                aud: audience
+              },
+              pk
+            );
+          },
+          routingStrategy: config.routingStrategy
+        });
+      } else {
+        const apiToken = config.syncToken ?? process.env["MOTEBIT_API_TOKEN"];
+        if (apiToken) {
+          runtime.enableInteractiveDelegation({
+            syncUrl,
+            authToken: () => Promise.resolve(apiToken),
+            routingStrategy: config.routingStrategy
+          });
+        }
+      }
+    }
     if (syncUrl) {
       try {
         const token = config.syncToken ?? process.env["MOTEBIT_API_TOKEN"];
@@ -29473,7 +29886,7 @@ async function main() {
     }
   }
   const shutdown = async () => {
-    disableBracketedPaste();
+    destroyTerminal();
     runtime.stop();
     await Promise.allSettled(mcpAdapters.map((a) => a.disconnect()));
     try {
@@ -29500,6 +29913,24 @@ async function main() {
     operator: config.operator
   });
   console.log();
+  if (isFirstLaunch) {
+    try {
+      const activationRunId = crypto.randomUUID();
+      writeOutput(prompt("mote>") + " ");
+      await consumeStream(
+        runtime.generateActivation(
+          "You just came into existence. The person who created you is here. Speak first.",
+          activationRunId
+        ),
+        runtime
+      );
+      void runtime.autoTitle();
+    } catch (err3) {
+      const msg = err3 instanceof Error ? err3.message : String(err3);
+      console.error(dim(`  [activation failed: ${msg}]`));
+    }
+    console.log();
+  }
   const prompt2 = () => {
     readInput(prompt("you>") + " ").then(
       (line) => void handleLine(line),
@@ -29511,9 +29942,8 @@ async function main() {
   const handleLine = async (line) => {
     const trimmed = line.trim();
     if (trimmed === "quit" || trimmed === "exit") {
-      console.log("Goodbye!");
+      writeOutput("Goodbye!\n");
       await shutdown();
-      rl?.close();
       return;
     }
     if (trimmed === "") {
@@ -29555,11 +29985,8 @@ ${prompt("mote>")} ${result.response}
         if (bodyLine) console.log(meta(`  ${bodyLine}`));
         console.log();
       } else {
-        process.stdout.write("\n" + prompt("mote>") + " ");
-        const streamRl = getOrCreateRl();
-        await consumeStream(runtime.sendMessageStreaming(trimmed, chatRunId), runtime, streamRl);
-        streamRl.close();
-        rl = null;
+        writeOutput("\n" + prompt("mote>") + " ");
+        await consumeStream(runtime.sendMessageStreaming(trimmed, chatRunId), runtime);
       }
       void runtime.autoTitle();
     } catch (err3) {