feat: import agents_and_robots platform as unibots (Matrix-out, unibus transport)

Reemplaza el scaffold del echobot por la plataforma completa de bots traida
desde ~/DataProyects/Github/agents_and_robots tras la operacion Matrix-out:
los bots ya no hablan por Matrix sino por el bus unibus (modelo todo-rooms +
E2E via shell/transportunibus sobre github.com/enmanuel/unibus/pkg/client).

- go.mod: replace de unibus -> ../unibus y de fn-registry -> ../../../.. (paths
  relativos reajustados a la nueva ubicacion dentro de fn_registry).
- app.md: bump a 0.2.0, descripcion + arquitectura + comandos + gotchas reales.
- modulo Go conservado como github.com/enmanuel/agents (sin reescribir imports).

agents_and_robots queda archivado como museo de la era Matrix.

shell/bus/bus.go

@@ -0,0 +1,143 @@
+// Package bus provides in-process agent-to-agent message passing.
+package bus
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"sync"
+	"time"
+)
+
+// Well-known message kinds used by the orchestrator.
+const (
+	KindTask       = "task"        // orchestrator → bot: handle this question
+	KindTaskResult = "task_result" // bot → orchestrator: here is my answer
+)
+
+// AgentID identifies an agent.
+type AgentID string
+
+// AgentMessage is a message between agents.
+type AgentMessage struct {
+	From    AgentID
+	To      AgentID
+	Kind    string
+	Payload map[string]string
+}
+
+// Bus manages channels for inter-agent communication.
+type Bus struct {
+	mu       sync.RWMutex
+	channels map[AgentID]chan AgentMessage
+
+	replyMu  sync.Mutex
+	replyChs map[string]chan AgentMessage // taskID → one-shot reply channel
+
+	logger *slog.Logger
+}
+
+// New creates a new Bus.
+func New(logger *slog.Logger) *Bus {
+	return &Bus{
+		channels: make(map[AgentID]chan AgentMessage),
+		replyChs: make(map[string]chan AgentMessage),
+		logger:   logger.With("component", "bus"),
+	}
+}
+
+// Subscribe registers an agent and returns its receive channel.
+func (b *Bus) Subscribe(id AgentID) <-chan AgentMessage {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	ch := make(chan AgentMessage, 64)
+	b.channels[id] = ch
+	b.logger.Info("bus_subscribe", "agent", id)
+	return ch
+}
+
+// Send delivers a message to an agent's channel.
+func (b *Bus) Send(msg AgentMessage) error {
+	b.mu.RLock()
+	ch, ok := b.channels[msg.To]
+	b.mu.RUnlock()
+	if !ok {
+		b.logger.Warn("bus_not_found", "to", msg.To, "from", msg.From, "kind", msg.Kind)
+		return fmt.Errorf("agent %q not registered on bus", msg.To)
+	}
+	select {
+	case ch <- msg:
+		b.logger.Debug("bus_send", "from", msg.From, "to", msg.To, "kind", msg.Kind)
+		return nil
+	default:
+		b.logger.Warn("bus_queue_full", "to", msg.To, "from", msg.From, "kind", msg.Kind)
+		return fmt.Errorf("agent %q message queue full", msg.To)
+	}
+}
+
+// SendAndWait sends a task message and blocks until a reply with the matching
+// taskID arrives or the context expires. The caller must ensure the reply is
+// routed via Reply().
+func (b *Bus) SendAndWait(ctx context.Context, msg AgentMessage, taskID string, timeout time.Duration) (AgentMessage, error) {
+	ch := make(chan AgentMessage, 1)
+	b.replyMu.Lock()
+	b.replyChs[taskID] = ch
+	b.replyMu.Unlock()
+
+	defer func() {
+		b.replyMu.Lock()
+		delete(b.replyChs, taskID)
+		b.replyMu.Unlock()
+	}()
+
+	if err := b.Send(msg); err != nil {
+		return AgentMessage{}, err
+	}
+
+	b.logger.Debug("bus_send_and_wait", "task", taskID, "to", msg.To, "timeout", timeout)
+
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+
+	select {
+	case reply := <-ch:
+		return reply, nil
+	case <-timer.C:
+		b.logger.Warn("bus_timeout", "task", taskID, "to", msg.To, "timeout", timeout)
+		return AgentMessage{}, fmt.Errorf("task %s: delegation timeout after %s", taskID, timeout)
+	case <-ctx.Done():
+		return AgentMessage{}, ctx.Err()
+	}
+}
+
+// Reply routes a task_result message to the waiting SendAndWait caller.
+// If no one is waiting for this taskID, it falls back to regular Send.
+func (b *Bus) Reply(taskID string, msg AgentMessage) error {
+	b.replyMu.Lock()
+	ch, ok := b.replyChs[taskID]
+	b.replyMu.Unlock()
+
+	if ok {
+		select {
+		case ch <- msg:
+			b.logger.Debug("bus_reply", "task", taskID, "from", msg.From)
+			return nil
+		default:
+			b.logger.Warn("bus_reply_full", "task", taskID)
+			return fmt.Errorf("reply channel full for task %s", taskID)
+		}
+	}
+	// Fallback: deliver via regular channel
+	return b.Send(msg)
+}
+
+// Unsubscribe removes an agent from the bus.
+func (b *Bus) Unsubscribe(id AgentID) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if ch, ok := b.channels[id]; ok {
+		close(ch)
+		delete(b.channels, id)
+		b.logger.Info("bus_unsubscribe", "agent", id)
+	}
+}