fix(cron): route cron jobs to correct agent and publish response to channel

cmd/picoclaw/internal/agent/helpers.go

@@ -47,9 +47,10 @@ func agentCmd(message, sessionKey, model string, debug bool) error {
 		cfg.Agents.Defaults.ModelName = modelID
 	}
 
+	dispatcher := providers.NewProviderDispatcher(cfg)
 	msgBus := bus.NewMessageBus()
 	defer msgBus.Close()
-	agentLoop := agent.NewAgentLoop(cfg, msgBus, provider)
+	agentLoop := agent.NewAgentLoop(cfg, msgBus, provider, dispatcher)
 	defer agentLoop.Close()
 
 	// Print agent startup info (only for interactive mode)

cmd/picoclaw/internal/cron/helpers.go

@@ -7,6 +7,8 @@ import (
 	"github.com/sipeed/picoclaw/pkg/cron"
 )
 
+const maxMessageDisplay = 80
+
 func cronListCmd(storePath string) {
 	cs := cron.NewCronService(storePath, nil)
 	jobs := cs.ListJobs(true) // Show all jobs, including disabled
@@ -41,8 +43,20 @@ func cronListCmd(storePath string) {
 
 		fmt.Printf("  %s (%s)\n", job.Name, job.ID)
 		fmt.Printf("    Schedule: %s\n", schedule)
-		fmt.Printf("    Status: %s\n", status)
+		fmt.Printf("    Status:   %s\n", status)
 		fmt.Printf("    Next run: %s\n", nextRun)
+		fmt.Printf("    Channel:  %s\n", job.Payload.Channel)
+		fmt.Printf("    To:       %s\n", job.Payload.To)
+		fmt.Printf("    Deliver:  %v\n", job.Payload.Deliver)
+		if job.Payload.Command != "" {
+			fmt.Printf("    Command:  %s\n", job.Payload.Command)
+		} else {
+			msg := job.Payload.Message
+			if len(msg) > maxMessageDisplay {
+				msg = msg[:maxMessageDisplay] + "..."
+			}
+			fmt.Printf("    Message:  %s\n", msg)
+		}
 	}
 }
 

cmd/picoclaw/internal/gateway/helpers.go

@@ -81,8 +81,9 @@ func gatewayCmd(debug bool) error {
 		cfg.Agents.Defaults.ModelName = modelID
 	}
 
+	dispatcher := providers.NewProviderDispatcher(cfg)
 	msgBus := bus.NewMessageBus()
-	agentLoop := agent.NewAgentLoop(cfg, msgBus, provider)
+	agentLoop := agent.NewAgentLoop(cfg, msgBus, provider, dispatcher)
 
 	// Print agent startup info
 	fmt.Println("\n📦 Agent Status:")

config/config.example.json

@@ -11,6 +11,17 @@
       "summarize_token_percent": 75
     }
   },
+  "bindings": [
+    {
+      "_comment": "Route each named Telegram bot to a specific agent. Remove this section if you only use one agent.",
+      "agent_id": "alice",
+      "match": { "channel": "telegram-alice" }
+    },
+    {
+      "agent_id": "bob",
+      "match": { "channel": "telegram-bob" }
+    }
+  ],
   "model_list": [
     {
       "model_name": "gpt-5.4",
@@ -83,6 +94,25 @@
       ],
       "reasoning_channel_id": ""
     },
+    "telegram_bots": [
+      {
+        "_comment": "Multiple named Telegram bots — each creates a separate channel (e.g. telegram-alice). Use bindings to route each bot to a different agent.",
+        "id": "alice",
+        "enabled": false,
+        "token": "ALICE_BOT_TOKEN",
+        "allow_from": ["YOUR_USER_ID"],
+        "typing": { "enabled": true },
+        "placeholder": { "enabled": true, "text": "Thinking... 💭" }
+      },
+      {
+        "id": "bob",
+        "enabled": false,
+        "token": "BOB_BOT_TOKEN",
+        "allow_from": ["YOUR_USER_ID"],
+        "typing": { "enabled": true },
+        "placeholder": { "enabled": true, "text": "Thinking... 💭" }
+      }
+    ],
     "discord": {
       "enabled": false,
       "token": "YOUR_DISCORD_BOT_TOKEN",

pkg/agent/loop.go

@@ -51,6 +51,7 @@ type AgentLoop struct {
 	mu             sync.RWMutex
 	// Track active requests for safe provider cleanup
 	activeRequests sync.WaitGroup
+	dispatcher     *providers.ProviderDispatcher
 }
 
 // processOptions configures how a message is processed
@@ -80,16 +81,17 @@ func NewAgentLoop(
 	cfg *config.Config,
 	msgBus *bus.MessageBus,
 	provider providers.LLMProvider,
+	dispatcher *providers.ProviderDispatcher,
 ) *AgentLoop {
 	registry := NewAgentRegistry(cfg, provider)
 
-	// Register shared tools to all agents
-	registerSharedTools(cfg, msgBus, registry, provider)
-
 	// Set up shared fallback chain
 	cooldown := providers.NewCooldownTracker()
 	fallbackChain := providers.NewFallbackChain(cooldown)
 
+	// Register shared tools to all agents
+	registerSharedTools(cfg, msgBus, registry, provider, dispatcher, fallbackChain)
+
 	// Create state manager using default agent's workspace for channel recording
 	defaultAgent := registry.GetDefaultAgent()
 	var stateManager *state.Manager
@@ -105,6 +107,7 @@ func NewAgentLoop(
 		summarizing: sync.Map{},
 		fallback:    fallbackChain,
 		cmdRegistry: commands.NewRegistry(commands.BuiltinDefinitions()),
+		dispatcher:  dispatcher,
 	}
 
 	return al
@@ -116,6 +119,8 @@ func registerSharedTools(
 	msgBus *bus.MessageBus,
 	registry *AgentRegistry,
 	provider providers.LLMProvider,
+	dispatcher *providers.ProviderDispatcher,
+	fallbackChain *providers.FallbackChain,
 ) {
 	for _, agentID := range registry.ListAgentIDs() {
 		agent, ok := registry.GetAgent(agentID)
@@ -225,10 +230,31 @@ func registerSharedTools(
 		// Spawn tool with allowlist checker
 		if cfg.Tools.IsToolEnabled("spawn") {
 			if cfg.Tools.IsToolEnabled("subagent") {
-				subagentManager := tools.NewSubagentManager(provider, agent.Model, agent.Workspace)
+				currentAgentID := agentID
+				// Build a resolver so the subagent manager can look up any target
+				// agent's candidates without importing the agent package from tools.
+				candidateResolver := func(targetAgentID string) ([]providers.FallbackCandidate, bool) {
+					target, ok := registry.GetAgent(targetAgentID)
+					if !ok {
+						return nil, false
+					}
+					if len(target.Candidates) == 0 {
+						return nil, false
+					}
+					return target.Candidates, true
+				}
+				subagentManager := tools.NewSubagentManager(tools.SubagentManagerConfig{
+					Provider:          provider,
+					DefaultModel:      agent.Model,
+					Workspace:         agent.Workspace,
+					Dispatcher:        dispatcher,
+					Fallback:          fallbackChain,
+					SelfCandidates:    agent.Candidates,
+					CallerAgentID:     currentAgentID,
+					CandidateResolver: candidateResolver,
+				})
 				subagentManager.SetLLMOptions(agent.MaxTokens, agent.Temperature)
 				spawnTool := tools.NewSpawnTool(subagentManager)
-				currentAgentID := agentID
 				spawnTool.SetAllowlistChecker(func(targetAgentID string) bool {
 					return registry.CanSpawnSubagent(currentAgentID, targetAgentID)
 				})
@@ -404,8 +430,10 @@ func (al *AgentLoop) ReloadProviderAndConfig(
 		return fmt.Errorf("context canceled after registry creation: %w", err)
 	}
 
-	// Ensure shared tools are re-registered on the new registry
-	registerSharedTools(cfg, al.bus, registry, provider)
+	// Ensure shared tools are re-registered on the new registry.
+	// Build a fresh fallback chain for the new registry's subagent managers.
+	newFallbackChain := providers.NewFallbackChain(providers.NewCooldownTracker())
+	registerSharedTools(cfg, al.bus, registry, provider, al.dispatcher, newFallbackChain)
 
 	// Atomically swap the config and registry under write lock
 	// This ensures readers see a consistent pair
@@ -421,6 +449,11 @@ func (al *AgentLoop) ReloadProviderAndConfig(
 
 	al.mu.Unlock()
 
+	// Flush the dispatcher cache so stale providers are evicted on config reload.
+	if al.dispatcher != nil {
+		al.dispatcher.Flush(cfg)
+	}
+
 	// Close old provider after releasing the lock
 	// This prevents blocking readers while closing
 	if oldProvider, ok := extractProvider(oldRegistry); ok {
@@ -646,6 +679,12 @@ func (al *AgentLoop) ProcessDirectWithChannel(
 		Content:    content,
 		SessionKey: sessionKey,
 	}
+	// Set peer so channel-based bindings (e.g. a specific Slack channel mapped
+	// to a named agent) are matched by the route resolver, exactly as they are
+	// for live inbound messages.
+	if chatID != "" && chatID != "direct" {
+		msg.Peer = bus.Peer{Kind: "channel", ID: chatID}
+	}
 
 	return al.processMessage(ctx, msg)
 }
@@ -1068,7 +1107,12 @@ func (al *AgentLoop) runLLMIteration(
 				fbResult, fbErr := al.fallback.Execute(
 					ctx,
 					activeCandidates,
-					func(ctx context.Context, provider, model string) (*providers.LLMResponse, error) {
+					func(ctx context.Context, providerName, model string) (*providers.LLMResponse, error) {
+						if al.dispatcher != nil {
+							if p, err := al.dispatcher.Get(providerName, model); err == nil {
+								return p.Chat(ctx, messages, providerToolDefs, model, llmOpts)
+							}
+						}
 						return agent.Provider.Chat(ctx, messages, providerToolDefs, model, llmOpts)
 					},
 				)
@@ -1218,6 +1262,18 @@ func (al *AgentLoop) runLLMIteration(
 				"iteration": iteration,
 			})
 
+		// If the LLM returned both text content and tool calls, publish the
+		// text to the user immediately so it is visible before tool execution.
+		if response.Content != "" && opts.Channel != "" {
+			pubCtx, pubCancel := context.WithTimeout(ctx, 5*time.Second)
+			_ = al.bus.PublishOutbound(pubCtx, bus.OutboundMessage{
+				Channel: opts.Channel,
+				ChatID:  opts.ChatID,
+				Content: response.Content,
+			})
+			pubCancel()
+		}
+
 		// Build assistant message with tool calls
 		assistantMsg := providers.Message{
 			Role:             "assistant",