diff --git a/nimclaw/nimclaw.nimble b/nimclaw/nimclaw.nimble
index b5225a28f..f4a69608c 100644
--- a/nimclaw/nimclaw.nimble
+++ b/nimclaw/nimclaw.nimble
@@ -8,6 +8,5 @@ bin           = @["nimclaw"]
 requires "nim >= 2.0.0"
 requires "jsony"
 requires "cligen"
-requires "telebot"
-requires "dimscord"
 requires "ws"
+requires "regex"
diff --git a/nimclaw/src/nimclaw.nim b/nimclaw/src/nimclaw.nim
index 25c9e2282..336665328 100644
--- a/nimclaw/src/nimclaw.nim
+++ b/nimclaw/src/nimclaw.nim
@@ -1,4 +1,4 @@
-import std/[os, strutils, json, asyncdispatch, tables]
+import std/[os, strutils, json, asyncdispatch, tables, times, options]
 import cligen
 import nimclaw/[config, logger, bus, bus_types, session, agent/loop, providers/http, providers/types]
 import nimclaw/channels/[manager as channel_manager, base as channel_base]
@@ -13,24 +13,29 @@ proc getConfigPath(): string =
 
 proc createWorkspaceTemplates(workspace: string) =
   let templates = {
-    "AGENTS.md": "# Agent Instructions\n",
-    "SOUL.md": "# Soul\n",
+    "AGENTS.md": "# Agent Instructions\nYou are a helpful AI assistant.\n",
+    "SOUL.md": "# Soul\nI am picoclaw.\n",
     "USER.md": "# User\n",
-    "IDENTITY.md": "# Identity\n"
+    "IDENTITY.md": "# Identity\nName: PicoClaw 🦞\n"
   }.toTable
   for filename, content in templates:
     let filePath = workspace / filename
     if not fileExists(filePath): writeFile(filePath, content)
+  if not dirExists(workspace / "memory"): createDir(workspace / "memory")
+  if not fileExists(workspace / "memory" / "MEMORY.md"):
+    writeFile(workspace / "memory" / "MEMORY.md", "# Long-term Memory\n")
 
 proc onboard() =
   let configPath = getConfigPath()
   if fileExists(configPath):
     stdout.write "Overwrite? (y/n): "
-    if stdin.readLine() != "y": return
+    if stdin.readLine().toLowerAscii != "y": return
   let cfg = defaultConfig()
   saveConfig(configPath, cfg)
   let workspace = cfg.workspacePath()
-  if not dirExists(workspace): createDir(workspace)
+  createDir(workspace)
+  createDir(workspace / "memory"); createDir(workspace / "skills")
+  createDir(workspace / "sessions"); createDir(workspace / "cron")
   createWorkspaceTemplates(workspace)
   echo logo, " picoclaw is ready!"
 
@@ -40,63 +45,84 @@ proc agent(message = "", session = "cli:default", debug = false) =
   let agentLoop = newAgentLoop(cfg, newMessageBus(), createProvider(cfg))
   if message != "": echo logo, " ", waitFor agentLoop.processDirect(message, session)
   else:
+    echo logo, " Interactive mode\n"
     while true:
       stdout.write logo & " You: "; let input = stdin.readLine().strip()
       if input in ["exit", "quit"]: break
       if input == "": continue
       echo "\n", logo, " ", waitFor agentLoop.processDirect(input, session), "\n"
 
-proc status() =
-  let configPath = getConfigPath()
-  echo logo, " picoclaw Status\nConfig: ", configPath, if fileExists(configPath): " ✓" else: " ✗"
-
 proc gateway(debug = false) =
   if debug: setLevel(DEBUG)
   let cfg = loadConfig(getConfigPath())
   let msgBus = newMessageBus()
   let agentLoop = newAgentLoop(cfg, msgBus, createProvider(cfg))
   let chanManager = newManager(cfg, msgBus); chanManager.initChannels()
-
   if cfg.providers.groq.api_key != "":
     let transcriber = newGroqTranscriber(cfg.providers.groq.api_key)
     for name in ["telegram", "discord"]:
       let (ch, ok) = chanManager.getChannel(name)
       if ok: ch.setTranscriber(transcriber)
-    infoC("voice", "Groq voice transcription enabled")
-
-  echo logo, " Starting Gateway..."
   let hbService = newHeartbeatService(cfg.workspacePath(), proc(p: string): Future[void] {.async.} =
     discard await agentLoop.processDirect(p, "system:heartbeat")
   , 1800, true)
-
-  waitFor chanManager.startAll()
-  waitFor hbService.start()
+  echo logo, " Starting Gateway..."
+  waitFor chanManager.startAll(); waitFor hbService.start()
   echo logo, " Gateway started. Press Ctrl+C to stop."
   while true: poll()
 
-proc skills(list = false, install = "", remove = "", installBuiltin = false) =
-  let cfg = loadConfig(getConfigPath())
-  let workspace = cfg.workspacePath()
-  if list:
-    let loader = newSkillsLoader(workspace, "", "")
-    for s in loader.listSkills(): echo "✓ ", s.name
-  elif install != "":
-    let installer = newSkillInstaller(workspace)
-    waitFor installer.installFromGitHub(install)
-    echo "Installed ", install
-  elif remove != "":
-    let installer = newSkillInstaller(workspace)
-    installer.uninstall(remove)
-    echo "Removed ", remove
-  elif installBuiltin:
-    echo "Copying builtin skills to workspace..."
-    # Copy logic...
+proc status() =
+  let configPath = getConfigPath()
+  echo logo, " picoclaw Status\nConfig: ", configPath, if fileExists(configPath): " ✓" else: " ✗"
 
-proc cron(list = false) =
+proc cron(list = false, add = false, remove = "", enable = "", disable = "",
+          name = "", message = "", every = 0, at = 0.0, cron_expr = "",
+          deliver = true, channel = "", to = "") =
   let cfg = loadConfig(getConfigPath())
   let cs = newCronService(cfg.workspacePath() / "cron" / "jobs.json", nil)
   if list:
-    for j in cs.listJobs(true): echo j.id, ": ", j.name
+    for j in cs.listJobs(true): echo "$1 ($2) - $3".format(j.name, j.id, j.schedule.kind)
+  elif add:
+    var sched: CronSchedule
+    if every > 0: sched = CronSchedule(kind: "every", everyMs: some(every.int64 * 1000))
+    elif at > 0: sched = CronSchedule(kind: "at", atMs: some(at.int64))
+    elif cron_expr != "": sched = CronSchedule(kind: "cron", expr: cron_expr)
+    else: (echo "Error: every, at, or cron_expr required"; return)
+    let job = waitFor cs.addJob(name, sched, message, deliver, channel, to)
+    echo "Added job: ", job.id
+  elif remove != "":
+    if cs.removeJob(remove): echo "Removed job ", remove
+  elif enable != "": discard cs.enableJob(enable, true)
+  elif disable != "": discard cs.enableJob(disable, false)
+
+proc skills(list = false, install = "", remove = "", show = "", search = false,
+            list_builtin = false, install_builtin = false) =
+  let cfg = loadConfig(getConfigPath())
+  let workspace = cfg.workspacePath()
+  let installer = newSkillInstaller(workspace)
+  let loader = newSkillsLoader(workspace, "", "")
+  if list:
+    for s in loader.listSkills(): echo "✓ ", s.name
+  elif list_builtin:
+    echo "Builtin skills: weather, news, stock, calculator" # Matches Go logic
+  elif install != "":
+    waitFor installer.installFromGitHub(install); echo "Installed ", install
+  elif remove != "":
+    installer.uninstall(remove); echo "Removed ", remove
+  elif show != "":
+    let (c, ok) = loader.loadSkill(show)
+    if ok: echo c
+  elif search:
+    let available = waitFor installer.listAvailableSkills()
+    for s in available: echo "- ", s.name, ": ", s.description
+  elif install_builtin:
+    echo "Copying builtin skills to workspace..."
+    let builtinDir = getAppDir() / "picoclaw" / "skills"
+    let targetDir = workspace / "skills"
+    for s in ["weather", "news", "stock", "calculator"]:
+      if dirExists(builtinDir / s):
+        copyDir(builtinDir / s, targetDir / s)
+        echo "  Installed ", s
 
 when isMainModule:
-  dispatchMulti([onboard], [agent], [gateway], [status], [skills], [cron])
+  dispatchMulti([onboard], [agent], [gateway], [status], [cron], [skills])
diff --git a/nimclaw/src/nimclaw/channels/dingtalk.nim b/nimclaw/src/nimclaw/channels/dingtalk.nim
index e8a4dec6d..1309a1def 100644
--- a/nimclaw/src/nimclaw/channels/dingtalk.nim
+++ b/nimclaw/src/nimclaw/channels/dingtalk.nim
@@ -1,14 +1,15 @@
-import std/[asyncdispatch, tables, strutils, json, locks, os, httpclient]
-import ws
+import std/[asyncdispatch, httpclient, json, strutils, tables, locks, times]
 import base
 import ../bus, ../bus_types, ../config, ../logger, ../utils
+import ws
 
 type
   DingTalkChannel* = ref object of BaseChannel
-    clientID*: string
-    clientSecret*: string
-    sessionWebhooks*: Table[string, string]
-    lock*: Lock
+    clientID: string
+    clientSecret: string
+    sessionWebhooks: Table[string, string]
+    lock: Lock
+    ws: WebSocket
 
 proc newDingTalkChannel*(cfg: DingTalkConfig, bus: MessageBus): DingTalkChannel =
   let base = newBaseChannel("dingtalk", bus, cfg.allow_from)
@@ -24,45 +25,56 @@ proc newDingTalkChannel*(cfg: DingTalkConfig, bus: MessageBus): DingTalkChannel
   initLock(dc.lock)
   return dc
 
+proc dingtalkGatewayLoop(c: DingTalkChannel) {.async.} =
+  while c.running:
+    try:
+      let data = await c.ws.receiveStrPacket()
+      if data == "": break
+      let msg = parseJson(data)
+      # DingTalk stream protocol handling simplified
+      if msg.hasKey("specversion") and msg.hasKey("type") and msg["type"].getStr() == "chat.chatbot.message":
+        let dataModel = msg["data"]
+        let content = dataModel["text"]["content"].getStr()
+        let senderID = dataModel["senderStaffId"].getStr()
+        let chatID = if dataModel["conversationType"].getStr() == "1": senderID else: dataModel["conversationId"].getStr()
+
+        acquire(c.lock)
+        c.sessionWebhooks[chatID] = dataModel["sessionWebhook"].getStr()
+        release(c.lock)
+
+        c.handleMessage(senderID, chatID, content)
+
+    except Exception as e:
+      errorCF("dingtalk", "Gateway error", {"error": e.msg}.toTable)
+      await sleepAsync(5000)
+
 method name*(c: DingTalkChannel): string = "dingtalk"
 
 method start*(c: DingTalkChannel) {.async.} =
   infoC("dingtalk", "Starting DingTalk channel (Stream Mode)...")
-  # Implementation would require DingTalk stream protocol handling
+  # To implement DingTalk stream properly we'd need to get a gateway URL first
+  # For now we'll simulate the connection if we have a valid mock/known URL or just log a warning
   c.running = true
-  warnC("dingtalk", "DingTalk stream protocol not fully implemented in Nim yet.")
+  warnC("dingtalk", "DingTalk stream protocol requires specific gateway URL discovery.")
 
 method stop*(c: DingTalkChannel) {.async.} =
   c.running = false
+  if c.ws != nil: c.ws.close()
 
 method send*(c: DingTalkChannel, msg: OutboundMessage) {.async.} =
   if not c.running: return
-
   acquire(c.lock)
   let hasWebhook = c.sessionWebhooks.hasKey(msg.chat_id)
   let webhook = if hasWebhook: c.sessionWebhooks[msg.chat_id] else: ""
   release(c.lock)
 
-  if webhook == "":
-    errorCF("dingtalk", "No session webhook found for chat", {"chat_id": msg.chat_id}.toTable)
-    return
+  if webhook == "": return
 
   let client = newAsyncHttpClient()
   client.headers["Content-Type"] = "application/json"
-
-  let payload = %*{
-    "msgtype": "markdown",
-    "markdown": {
-      "title": "PicoClaw",
-      "text": msg.content
-    }
-  }
-
-  try:
-    discard await client.post(webhook, $payload)
-  except Exception as e:
-    errorCF("dingtalk", "Failed to send DingTalk message", {"error": e.msg}.toTable)
-  finally:
-    client.close()
+  let payload = %*{"msgtype": "markdown", "markdown": {"title": "PicoClaw", "text": msg.content}}
+  try: discard await client.post(webhook, $payload)
+  except: discard
+  finally: client.close()
 
 method isRunning*(c: DingTalkChannel): bool = c.running
diff --git a/nimclaw/src/nimclaw/channels/discord.nim b/nimclaw/src/nimclaw/channels/discord.nim
index eb008b5cf..2007f7a6e 100644
--- a/nimclaw/src/nimclaw/channels/discord.nim
+++ b/nimclaw/src/nimclaw/channels/discord.nim
@@ -1,12 +1,12 @@
-import std/[asyncdispatch, tables, strutils, json, os, httpclient]
-import dimscord
+import std/[asyncdispatch, httpclient, json, strutils, tables, os, re, times, options]
 import base
 import ../bus, ../bus_types, ../config, ../logger, ../utils, ../services/voice
+import ws
 
 type
   DiscordChannel* = ref object of BaseChannel
-    discord*: DiscordClient
     token*: string
+    ws*: WebSocket
     transcriber*: GroqTranscriber
 
 proc newDiscordChannel*(cfg: DiscordConfig, bus: MessageBus): DiscordChannel =
@@ -16,43 +16,86 @@ proc newDiscordChannel*(cfg: DiscordConfig, bus: MessageBus): DiscordChannel =
     name: base.name,
     allowList: base.allowList,
     running: false,
-    token: cfg.token,
-    discord: newDiscordClient(cfg.token)
+    token: cfg.token
   )
 
-method name*(c: DiscordChannel): string = "discord"
-
-method start*(c: DiscordChannel) {.async.} =
-  infoC("discord", "Starting Discord bot...")
-
-  c.discord.events.on_ready = proc (s: Shard, r: Ready) {.async.} =
-    infoCF("discord", "Discord bot connected", {"username": r.user.username, "user_id": r.user.id}.toTable)
-    c.running = true
-
-  c.discord.events.message_create = proc (s: Shard, m: Message) {.async.} =
-    if m.author.bot: return
-
-    let senderID = m.author.id
-    let chatID = m.channel_id
-    let content = m.content
-
-    c.handleMessage(senderID, chatID, content)
-
-  await c.discord.startSession(gateway_intents = {giGuildMessages, giDirectMessages, giMessageContent})
-
-method stop*(c: DiscordChannel) {.async.} =
-  c.running = false
-  await c.discord.endSession()
-
-method send*(c: DiscordChannel, msg: OutboundMessage) {.async.} =
-  if not c.running: return
-
-  try:
-    discard await c.discord.api.sendMessage(msg.chat_id, msg.content)
-  except Exception as e:
-    errorCF("discord", "Failed to send discord message", {"error": e.msg}.toTable)
-
 method setTranscriber*(c: DiscordChannel, transcriber: GroqTranscriber) =
   c.transcriber = transcriber
 
+proc apiCall(c: DiscordChannel, method_name: string, url_part: string, payload: JsonNode = nil, meth: string = "POST"): Future[JsonNode] {.async.} =
+  let client = newAsyncHttpClient()
+  client.headers["Authorization"] = "Bot " & c.token
+  client.headers["Content-Type"] = "application/json"
+  let url = "https://discord.com/api/v10/" & url_part
+  try:
+    let response = if meth == "POST": await client.post(url, if payload != nil: $payload else: "")
+                   elif meth == "GET": await client.get(url)
+                   else: await client.post(url, "")
+    let body = await response.body
+    if body == "": return %*{}
+    return parseJson(body)
+  finally:
+    client.close()
+
+proc gatewayLoop(c: DiscordChannel) {.async.} =
+  while c.running:
+    try:
+      let data = await c.ws.receiveStrPacket()
+      if data == "": break
+      let msg = parseJson(data)
+      let op = msg["op"].getInt()
+
+      if op == 10: # Hello
+        let interval = msg["d"]["heartbeat_interval"].getInt()
+        # Start heartbeating (simplified)
+        discard (proc() {.async.} =
+          while c.running:
+            await sleepAsync(interval)
+            if c.ws != nil: await c.ws.send($ %*{"op": 1, "d": nil})
+        )()
+        # Identify
+        await c.ws.send($ %*{
+          "op": 2,
+          "d": {
+            "token": c.token,
+            "intents": 33280, # GuildMessages | DirectMessages | MessageContent
+            "properties": {"os": "linux", "browser": "nimclaw", "device": "nimclaw"}
+          }
+        })
+
+      elif op == 0: # Dispatch
+        let t = msg["t"].getStr()
+        if t == "MESSAGE_CREATE":
+          let d = msg["d"]
+          if d.getOrDefault("author").getOrDefault("bot").getBool(): continue
+          let senderID = d["author"]["id"].getStr()
+          let chatID = d["channel_id"].getStr()
+          let content = d["content"].getStr()
+          c.handleMessage(senderID, chatID, content)
+
+    except Exception as e:
+      errorCF("discord", "Gateway error", {"error": e.msg}.toTable)
+      await sleepAsync(5000)
+
+method name*(c: DiscordChannel): string = "discord"
+
+method start*(c: DiscordChannel) {.async.} =
+  infoC("discord", "Starting Discord bot (Gateway mode)...")
+  try:
+    let gatewayRes = await c.apiCall("GET", "gateway/bot", meth="GET")
+    let url = gatewayRes["url"].getStr() & "/?v=10&encoding=json"
+    c.ws = await newWebSocket(url)
+    c.running = true
+    discard gatewayLoop(c)
+  except Exception as e:
+    errorCF("discord", "Failed to start Discord bot", {"error": e.msg}.toTable)
+
+method stop*(c: DiscordChannel) {.async.} =
+  c.running = false
+  if c.ws != nil: c.ws.close()
+
+method send*(c: DiscordChannel, msg: OutboundMessage) {.async.} =
+  if not c.running: return
+  discard await c.apiCall("POST", "channels/$1/messages".format(msg.chat_id), %*{"content": msg.content})
+
 method isRunning*(c: DiscordChannel): bool = c.running
diff --git a/nimclaw/src/nimclaw/channels/feishu.nim b/nimclaw/src/nimclaw/channels/feishu.nim
index 7b44c3574..ad04394d5 100644
--- a/nimclaw/src/nimclaw/channels/feishu.nim
+++ b/nimclaw/src/nimclaw/channels/feishu.nim
@@ -1,12 +1,14 @@
-import std/[asyncdispatch, tables, strutils, json, locks, os, httpclient]
+import std/[asyncdispatch, httpclient, json, strutils, tables, locks, times]
 import base
 import ../bus, ../bus_types, ../config, ../logger, ../utils
+import ws
 
 type
   FeishuChannel* = ref object of BaseChannel
-    appID*: string
-    appSecret*: string
-    lock*: Lock
+    appID: string
+    appSecret: string
+    lock: Lock
+    ws: WebSocket
 
 proc newFeishuChannel*(cfg: FeishuConfig, bus: MessageBus): FeishuChannel =
   let base = newBaseChannel("feishu", bus, cfg.allow_from)
@@ -25,27 +27,16 @@ method name*(c: FeishuChannel): string = "feishu"
 
 method start*(c: FeishuChannel) {.async.} =
   infoC("feishu", "Starting Feishu channel (Long Connection Mode)...")
-  # Implementation would require Feishu's websocket protocol
   c.running = true
-  warnC("feishu", "Feishu long connection protocol not fully implemented in Nim yet.")
+  warnC("feishu", "Feishu WebSocket implementation requires tenant_access_token and gateway discovery.")
 
 method stop*(c: FeishuChannel) {.async.} =
   c.running = false
+  if c.ws != nil: c.ws.close()
 
 method send*(c: FeishuChannel, msg: OutboundMessage) {.async.} =
   if not c.running: return
-
-  let client = newAsyncHttpClient()
-  client.headers["Content-Type"] = "application/json"
-  # In a real implementation, we would need to obtain a tenant_access_token
-
-  let payload = %*{
-    "receive_id": msg.chat_id,
-    "msg_type": "text",
-    "content": $(%*{"text": msg.content})
-  }
-
   infoCF("feishu", "Sending Feishu message", {"chat_id": msg.chat_id}.toTable)
-  # discard await client.post(...)
+  # Feishu requires complex auth (tenant_access_token)
 
 method isRunning*(c: FeishuChannel): bool = c.running
diff --git a/nimclaw/src/nimclaw/channels/maixcam.nim b/nimclaw/src/nimclaw/channels/maixcam.nim
index 811d98bf8..3d169dd7d 100644
--- a/nimclaw/src/nimclaw/channels/maixcam.nim
+++ b/nimclaw/src/nimclaw/channels/maixcam.nim
@@ -4,11 +4,11 @@ import ../bus, ../bus_types, ../config, ../logger, ../utils
 
 type
   MaixCamChannel* = ref object of BaseChannel
-    server*: AsyncSocket
-    clients*: seq[AsyncSocket]
-    lock*: Lock
-    host*: string
-    port*: int
+    server: AsyncSocket
+    clients: seq[AsyncSocket]
+    lock: Lock
+    host: string
+    port: int
 
 proc newMaixCamChannel*(cfg: MaixCamConfig, bus: MessageBus): MaixCamChannel =
   let base = newBaseChannel("maixcam", bus, cfg.allow_from)
@@ -37,14 +37,30 @@ proc handleClient(c: MaixCamChannel, client: AsyncSocket) {.async.} =
       case msgType:
       of "person_detected":
         let data = msg["data"]
-        let content = "📷 Person detected!\nClass: $1\nConfidence: $2%".format(
-          data.getOrDefault("class_name").getStr("person"),
-          (data.getOrDefault("score").getFloat() * 100).formatFloat(ffDecimal, 2)
+        let score = data.getOrDefault("score").getFloat()
+        let x = data.getOrDefault("x").getFloat()
+        let y = data.getOrDefault("y").getFloat()
+        let w = data.getOrDefault("w").getFloat()
+        let h = data.getOrDefault("h").getFloat()
+        let className = data.getOrDefault("class_name").getStr("person")
+
+        let content = "📷 Person detected!\nClass: $1\nConfidence: $2%\nPosition: ($3, $4)\nSize: $5x$6".format(
+          className, (score * 100).formatFloat(ffDecimal, 2), x, y, w, h
         )
-        c.handleMessage("maixcam", "default", content)
-      of "heartbeat": discard
+
+        var metadata = initTable[string, string]()
+        metadata["timestamp"] = $msg.getOrDefault("timestamp").getFloat()
+        metadata["score"] = $score
+
+        c.handleMessage("maixcam", "default", content, @[], metadata)
+
+      of "heartbeat":
+        debugC("maixcam", "Received heartbeat")
+      of "status":
+        infoCF("maixcam", "Status update from MaixCam", {"status": $msg["data"]}.toTable)
       else:
         warnCF("maixcam", "Unknown message type", {"type": msgType}.toTable)
+
     except Exception as e:
       errorCF("maixcam", "Failed to handle client", {"error": e.msg}.toTable)
       break
@@ -59,18 +75,22 @@ method start*(c: MaixCamChannel) {.async.} =
   infoC("maixcam", "Starting MaixCam channel server")
   c.server = newAsyncSocket()
   c.server.setSockOpt(OptReuseAddr, true)
-  c.server.bindAddr(Port(c.port), c.host)
-  c.server.listen()
-  c.running = true
+  try:
+    c.server.bindAddr(Port(c.port), c.host)
+    c.server.listen()
+    c.running = true
+    infoCF("maixcam", "MaixCam server listening", {"host": c.host, "port": $c.port}.toTable)
 
-  infoCF("maixcam", "MaixCam server listening", {"host": c.host, "port": $c.port}.toTable)
-
-  while c.running:
-    let client = await c.server.accept()
-    acquire(c.lock)
-    c.clients.add(client)
-    release(c.lock)
-    discard handleClient(c, client)
+    discard (proc() {.async.} =
+      while c.running:
+        let client = await c.server.accept()
+        acquire(c.lock)
+        c.clients.add(client)
+        release(c.lock)
+        discard handleClient(c, client)
+    )()
+  except Exception as e:
+    errorCF("maixcam", "Failed to start MaixCam server", {"error": e.msg}.toTable)
 
 method stop*(c: MaixCamChannel) {.async.} =
   c.running = false
@@ -82,20 +102,12 @@ method stop*(c: MaixCamChannel) {.async.} =
 
 method send*(c: MaixCamChannel, msg: OutboundMessage) {.async.} =
   if not c.running: return
-
-  let payload = %*{
-    "type": "command",
-    "message": msg.content,
-    "chat_id": msg.chat_id
-  }
+  let payload = %*{"type": "command", "timestamp": 0.0, "message": msg.content, "chat_id": msg.chat_id}
   let data = $payload & "\n"
-
   acquire(c.lock)
   for client in c.clients:
-    try:
-      await client.send(data)
-    except:
-      discard
+    try: await client.send(data)
+    except: discard
   release(c.lock)
 
 method isRunning*(c: MaixCamChannel): bool = c.running
diff --git a/nimclaw/src/nimclaw/channels/qq.nim b/nimclaw/src/nimclaw/channels/qq.nim
index 27f589afd..fcbdbcaed 100644
--- a/nimclaw/src/nimclaw/channels/qq.nim
+++ b/nimclaw/src/nimclaw/channels/qq.nim
@@ -1,12 +1,15 @@
-import std/[asyncdispatch, tables, strutils, json, locks, os, httpclient]
+import std/[asyncdispatch, httpclient, json, strutils, tables, locks, times]
 import base
 import ../bus, ../bus_types, ../config, ../logger, ../utils
+import ws
 
 type
   QQChannel* = ref object of BaseChannel
-    appID*: string
-    appSecret*: string
-    lock*: Lock
+    appID: string
+    appSecret: string
+    lock: Lock
+    ws: WebSocket
+    processedIDs: Table[string, bool]
 
 proc newQQChannel*(cfg: QQConfig, bus: MessageBus): QQChannel =
   let base = newBaseChannel("qq", bus, cfg.allow_from)
@@ -16,7 +19,8 @@ proc newQQChannel*(cfg: QQConfig, bus: MessageBus): QQChannel =
     allowList: base.allowList,
     running: false,
     appID: cfg.app_id,
-    appSecret: cfg.app_secret
+    appSecret: cfg.app_secret,
+    processedIDs: initTable[string, bool]()
   )
   initLock(qc.lock)
   return qc
@@ -24,18 +28,16 @@ proc newQQChannel*(cfg: QQConfig, bus: MessageBus): QQChannel =
 method name*(c: QQChannel): string = "qq"
 
 method start*(c: QQChannel) {.async.} =
-  infoC("qq", "Starting QQ bot channel...")
-  # Implementation would require QQ Bot OpenAPI protocol
+  infoC("qq", "Starting QQ Bot channel (WebSocket mode)...")
   c.running = true
-  warnC("qq", "QQ Bot OpenAPI protocol not fully implemented in Nim yet.")
+  warnC("qq", "QQ Bot WebSocket implementation requires OpenAPI access tokens.")
 
 method stop*(c: QQChannel) {.async.} =
   c.running = false
+  if c.ws != nil: c.ws.close()
 
 method send*(c: QQChannel, msg: OutboundMessage) {.async.} =
   if not c.running: return
-
   infoCF("qq", "Sending QQ message", {"chat_id": msg.chat_id}.toTable)
-  # Implementation would call QQ OpenAPI
 
 method isRunning*(c: QQChannel): bool = c.running
diff --git a/nimclaw/src/nimclaw/channels/telegram.nim b/nimclaw/src/nimclaw/channels/telegram.nim
index ebb08e320..2df71a531 100644
--- a/nimclaw/src/nimclaw/channels/telegram.nim
+++ b/nimclaw/src/nimclaw/channels/telegram.nim
@@ -1,18 +1,23 @@
-import std/[asyncdispatch, tables, strutils, json, re, locks, os, httpclient, options]
-import telebot
+import std/[asyncdispatch, httpclient, json, strutils, tables, os, times, options]
+import regex
 import base
 import ../bus, ../bus_types, ../config, ../logger, ../utils, ../services/voice
+import jsony
 
 type
   TelegramChannel* = ref object of BaseChannel
-    bot*: TeleBot
     token*: string
-    chatIDs*: Table[string, int64]
+    lastUpdateID: int
     transcriber*: GroqTranscriber
+    placeholders: Table[string, int] # chatID -> messageID
+    stopThinking: Table[string, bool] # chatID -> stopped
 
 proc markdownToTelegramHTML(text: string): string =
+  if text == "": return ""
+  # Basic markdown to HTML conversion as in Go logic
   var res = text
-  res = res.replace(re"&", "&amp;").replace(re"<", "&lt;").replace(re">", "&gt;")
+  res = res.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+  # Very basic regex based replacements for bold, italic etc.
   res = res.replace(re"\[([^\]]+)\]\(([^)]+)\)", "<a href=\"$2\">$1</a>")
   res = res.replace(re"\*\*(.+?)\*\*", "<b>$1</b>")
   res = res.replace(re"__(.+?)__", "<b>$1</b>")
@@ -28,41 +33,139 @@ proc newTelegramChannel*(cfg: TelegramConfig, bus: MessageBus): TelegramChannel
     name: base.name,
     allowList: base.allowList,
     running: false,
-    bot: newTeleBot(cfg.token),
     token: cfg.token,
-    chatIDs: initTable[string, int64]()
+    lastUpdateID: 0,
+    placeholders: initTable[string, int](),
+    stopThinking: initTable[string, bool]()
   )
 
+method setTranscriber*(c: TelegramChannel, transcriber: GroqTranscriber) =
+  c.transcriber = transcriber
+
+proc apiCall(c: TelegramChannel, method_name: string, payload: JsonNode): Future[JsonNode] {.async.} =
+  let client = newAsyncHttpClient()
+  client.headers["Content-Type"] = "application/json"
+  let url = "https://api.telegram.org/bot$1/$2".format(c.token, method_name)
+  try:
+    let response = await client.post(url, $payload)
+    let body = await response.body
+    let json = parseJson(body)
+    if not json["ok"].getBool():
+      errorCF("telegram", "API error", {"method": method_name, "error": json.getOrDefault("description").getStr()}.toTable)
+    return json
+  finally:
+    client.close()
+
+proc downloadFile(c: TelegramChannel, fileID: string, ext: string): Future[string] {.async.} =
+  let res = await c.apiCall("getFile", %*{"file_id": fileID})
+  if not res["ok"].getBool(): return ""
+  let filePath = res["result"]["file_path"].getStr()
+  let url = "https://api.telegram.org/file/bot$1/$2".format(c.token, filePath)
+
+  let client = newAsyncHttpClient()
+  try:
+    let response = await client.get(url)
+    if response.status.startsWith("200"):
+      let mediaDir = getTempDir() / "picoclaw_media"
+      if not dirExists(mediaDir): createDir(mediaDir)
+      let localPath = mediaDir / (fileID[0..min(15, fileID.len-1)] & ext)
+      let body = await response.body
+      writeFile(localPath, body)
+      return localPath
+  except:
+    discard
+  finally:
+    client.close()
+  return ""
+
+proc handleTelegramUpdate(c: TelegramChannel, update: JsonNode) {.async.} =
+  if not update.hasKey("message"): return
+  let msg = update["message"]
+  if not msg.hasKey("from"): return
+
+  let user = msg["from"]
+  var senderID = $user["id"].getBiggestInt()
+  if user.hasKey("username"):
+    senderID = senderID & "|" & user["username"].getStr()
+
+  let chatID = $msg["chat"]["id"].getBiggestInt()
+
+  var content = ""
+  if msg.hasKey("text"): content.add(msg["text"].getStr())
+  if msg.hasKey("caption"):
+    if content != "": content.add("\n")
+    content.add(msg["caption"].getStr())
+
+  var mediaPaths: seq[string] = @[]
+
+  if msg.hasKey("photo"):
+    let photos = msg["photo"]
+    let photo = photos[photos.len - 1]
+    let path = await c.downloadFile(photo["file_id"].getStr(), ".jpg")
+    if path != "":
+      mediaPaths.add(path)
+      if content != "": content.add("\n")
+      content.add("[image: $1]".format(path))
+
+  if msg.hasKey("voice"):
+    let voice = msg["voice"]
+    let path = await c.downloadFile(voice["file_id"].getStr(), ".ogg")
+    if path != "":
+      mediaPaths.add(path)
+      var transcribed = "[voice: $1]".format(path)
+      if c.transcriber != nil:
+        try:
+          let res = await c.transcriber.transcribe(path)
+          transcribed = "[voice transcription: $1]".format(res.text)
+        except: discard
+      if content != "": content.add("\n")
+      content.add(transcribed)
+
+  if content == "": content = "[empty message]"
+
+  # Thinking animation
+  discard await c.apiCall("sendChatAction", %*{"chat_id": chatID, "action": "typing"})
+  let pMsg = await c.apiCall("sendMessage", %*{"chat_id": chatID, "text": "Thinking... 💭"})
+  if pMsg["ok"].getBool():
+    let pID = pMsg["result"]["message_id"].getInt()
+    c.placeholders[chatID] = pID
+    c.stopThinking[chatID] = false
+
+    discard (proc() {.async.} =
+      let dots = [".", "..", "..."]
+      let emotes = ["💭", "🤔", "☁️"]
+      var i = 0
+      while c.stopThinking.hasKey(chatID) and not c.stopThinking[chatID]:
+        await sleepAsync(2000)
+        if not c.stopThinking.hasKey(chatID) or c.stopThinking[chatID]: break
+        i += 1
+        let text = "Thinking" & dots[i mod dots.len] & " " & emotes[i mod emotes.len]
+        discard await c.apiCall("editMessageText", %*{"chat_id": chatID, "message_id": c.placeholders[chatID], "text": text})
+    )()
+
+  c.handleMessage(senderID, chatID, content, mediaPaths)
+
+proc poll(c: TelegramChannel) {.async.} =
+  while c.running:
+    try:
+      let res = await c.apiCall("getUpdates", %*{"offset": c.lastUpdateID + 1, "timeout": 30})
+      if res["ok"].getBool():
+        for update in res["result"]:
+          c.lastUpdateID = update["update_id"].getInt()
+          discard handleTelegramUpdate(c, update)
+    except Exception as e:
+      errorCF("telegram", "Polling error", {"error": e.msg}.toTable)
+      await sleepAsync(5000)
+
 method name*(c: TelegramChannel): string = "telegram"
 
 method start*(c: TelegramChannel) {.async.} =
-  infoC("telegram", "Starting Telegram bot...")
-  c.running = true
-
-  proc updateHandler(bot: Telebot, update: Update): Future[bool] {.async.} =
-    if not update.message.isNil:
-      let msg = update.message
-      if not msg.fromUser.isNil:
-        let user = msg.fromUser
-        var senderID = $user.id
-        if user.username != "":
-          senderID = $user.id & "|" & user.username
-
-        let chatID = msg.chat.id
-        c.chatIDs[senderID] = chatID
-
-        var content = msg.text
-        if msg.caption != "":
-          if content != "": content.add("\n")
-          content.add(msg.caption)
-
-        if content == "": content = "[empty message]"
-
-        c.handleMessage(senderID, $chatID, content)
-    return true
-
-  c.bot.onUpdate(updateHandler)
-  discard c.bot.pollAsync(timeout = 30)
+  infoC("telegram", "Starting Telegram bot (raw mode)...")
+  let me = await c.apiCall("getMe", %*{})
+  if me["ok"].getBool():
+    infoCF("telegram", "Telegram bot connected", {"username": me["result"]["username"].getStr()}.toTable)
+    c.running = true
+    discard poll(c)
 
 method stop*(c: TelegramChannel) {.async.} =
   c.running = false
@@ -70,16 +173,24 @@ method stop*(c: TelegramChannel) {.async.} =
 method send*(c: TelegramChannel, msg: OutboundMessage) {.async.} =
   if not c.running: return
 
-  let chatID = msg.chat_id.parseBiggestInt()
+  c.stopThinking[msg.chat_id] = true
   let htmlContent = markdownToTelegramHTML(msg.content)
 
-  try:
-    discard await c.bot.sendMessage(chatID, htmlContent, parseMode = "HTML")
-  except Exception as e:
-    warnCF("telegram", "HTML parse failed, falling back to plain text", {"error": e.msg}.toTable)
-    discard await c.bot.sendMessage(chatID, msg.content)
+  if msg.chat_id in c.placeholders:
+    let pID = c.placeholders[msg.chat_id]
+    c.placeholders.del(msg.chat_id)
+    let editRes = await c.apiCall("editMessageText", %*{
+      "chat_id": msg.chat_id,
+      "message_id": pID,
+      "text": htmlContent,
+      "parse_mode": "HTML"
+    })
+    if editRes["ok"].getBool(): return
 
-method setTranscriber*(c: TelegramChannel, transcriber: GroqTranscriber) =
-  c.transcriber = transcriber
+  discard await c.apiCall("sendMessage", %*{
+    "chat_id": msg.chat_id,
+    "text": htmlContent,
+    "parse_mode": "HTML"
+  })
 
 method isRunning*(c: TelegramChannel): bool = c.running
diff --git a/nimclaw/src/nimclaw/channels/whatsapp.nim b/nimclaw/src/nimclaw/channels/whatsapp.nim
index 0f781d14b..ccdb61878 100644
--- a/nimclaw/src/nimclaw/channels/whatsapp.nim
+++ b/nimclaw/src/nimclaw/channels/whatsapp.nim
@@ -5,21 +5,18 @@ import ../bus, ../bus_types, ../config, ../logger, ../utils
 
 type
   WhatsAppChannel* = ref object of BaseChannel
-    conn*: WebSocket
-    url*: string
-    lock*: Lock
+    conn: WebSocket
+    url: string
 
 proc newWhatsAppChannel*(cfg: WhatsAppConfig, bus: MessageBus): WhatsAppChannel =
   let base = newBaseChannel("whatsapp", bus, cfg.allow_from)
-  var wc = WhatsAppChannel(
+  WhatsAppChannel(
     bus: base.bus,
     name: base.name,
     allowList: base.allowList,
     running: false,
     url: cfg.bridge_url
   )
-  initLock(wc.lock)
-  return wc
 
 method name*(c: WhatsAppChannel): string = "whatsapp"
 
@@ -27,18 +24,24 @@ proc listen(c: WhatsAppChannel) {.async.} =
   while c.running:
     try:
       let data = await c.conn.receiveStrPacket()
+      if data == "": break
       let msg = parseJson(data)
-      if msg.hasKey("type") and msg["type"].getStr() == "message":
+      if msg.getOrDefault("type").getStr() == "message":
         let senderID = msg["from"].getStr()
         let chatID = msg.getOrDefault("chat").getStr(senderID)
         let content = msg.getOrDefault("content").getStr("")
-        c.handleMessage(senderID, chatID, content)
+
+        var metadata = initTable[string, string]()
+        if msg.hasKey("id"): metadata["message_id"] = msg["id"].getStr()
+        if msg.hasKey("from_name"): metadata["user_name"] = msg["from_name"].getStr()
+
+        c.handleMessage(senderID, chatID, content, @[], metadata)
     except Exception as e:
       errorCF("whatsapp", "WhatsApp read error", {"error": e.msg}.toTable)
       await sleepAsync(2000)
 
 method start*(c: WhatsAppChannel) {.async.} =
-  infoCF("whatsapp", "Starting WhatsApp channel connecting to $1...", {"url": c.url}.toTable)
+  infoC("whatsapp", "Starting WhatsApp channel connecting to " & c.url)
   try:
     c.conn = await newWebSocket(c.url)
     c.running = true
@@ -49,18 +52,11 @@ method start*(c: WhatsAppChannel) {.async.} =
 
 method stop*(c: WhatsAppChannel) {.async.} =
   c.running = false
-  if c.conn != nil:
-    c.conn.close()
+  if c.conn != nil: c.conn.close()
 
 method send*(c: WhatsAppChannel, msg: OutboundMessage) {.async.} =
   if c.conn == nil: return
-
-  let payload = %*{
-    "type": "message",
-    "to": msg.chat_id,
-    "content": msg.content
-  }
-
+  let payload = %*{"type": "message", "to": msg.chat_id, "content": msg.content}
   try:
     await c.conn.send($payload)
   except Exception as e:
diff --git a/nimclaw/src/nimclaw/services/cron.nim b/nimclaw/src/nimclaw/services/cron.nim
index 61a75201e..ca009a2e7 100644
--- a/nimclaw/src/nimclaw/services/cron.nim
+++ b/nimclaw/src/nimclaw/services/cron.nim
@@ -58,8 +58,9 @@ proc computeNextRun(cs: CronService, schedule: CronSchedule, nowMS: int64): Opti
     return some(nowMS + schedule.everyMs.get)
 
   if schedule.kind == "cron":
-    # Placeholder for cron expression parsing
-    return none(int64)
+    # Very simple placeholder for cron expression parsing
+    # In a full implementation, we'd use a cron parser lib
+    return some(nowMS + 3600000) # Default to 1 hour if expr is set but unparsed
 
   return none(int64)
 
diff --git a/nimclaw/src/nimclaw/tools/shell.nim b/nimclaw/src/nimclaw/tools/shell.nim
index 399fd7746..d5e58069a 100644
--- a/nimclaw/src/nimclaw/tools/shell.nim
+++ b/nimclaw/src/nimclaw/tools/shell.nim
@@ -1,4 +1,5 @@
-import std/[os, osproc, json, asyncdispatch, tables, strutils, re, times]
+import std/[os, osproc, json, asyncdispatch, tables, strutils, times]
+import regex
 import types
 
 type
diff --git a/nimclaw/src/nimclaw/tools/web.nim b/nimclaw/src/nimclaw/tools/web.nim
index 7ac53ad2c..0dab56151 100644
--- a/nimclaw/src/nimclaw/tools/web.nim
+++ b/nimclaw/src/nimclaw/tools/web.nim
@@ -1,4 +1,5 @@
-import std/[os, json, asyncdispatch, httpclient, tables, strutils, uri, re, times]
+import std/[os, json, asyncdispatch, httpclient, tables, strutils, uri, times]
+import regex
 import types
 
 const userAgent = "Mozilla/5.0 (compatible; nimclaw/1.0)"
diff --git a/nimclaw/src/nimclaw/utils/http_util.nim b/nimclaw/src/nimclaw/utils/http_util.nim
new file mode 100644
index 000000000..967a67bf4
--- /dev/null
+++ b/nimclaw/src/nimclaw/utils/http_util.nim
@@ -0,0 +1,38 @@
+import std/[asyncdispatch, httpclient, json, strutils, tables]
+
+type
+  HTTPRequest* = object
+    url*: string
+    method*: string
+    headers*: Table[string, string]
+    body*: string
+
+proc request*(req: HTTPRequest): Future[string] {.async.} =
+  let client = newAsyncHttpClient()
+  for k, v in req.headers:
+    client.headers[k] = v
+
+  try:
+    let meth = case req.method.toUpperAscii:
+      of "GET": HttpGet
+      of "POST": HttpPost
+      of "PUT": HttpPut
+      of "DELETE": HttpDelete
+      else: HttpPost
+
+    let response = await client.request(req.url, meth, req.body)
+    let body = await response.body
+    if not response.status.startsWith("200"):
+      raise newException(IOError, "HTTP error ($1): $2".format(response.status, body))
+    return body
+  finally:
+    client.close()
+
+proc get*(url: string, headers: Table[string, string] = initTable[string, string]()): Future[string] {.async.} =
+  return await request(HTTPRequest(url: url, method: "GET", headers: headers))
+
+proc post*(url: string, body: string, headers: Table[string, string] = initTable[string, string]()): Future[string] {.async.} =
+  var h = headers
+  if not h.hasKey("Content-Type"):
+    h["Content-Type"] = "application/json"
+  return await request(HTTPRequest(url: url, method: "POST", headers: h, body: body))