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.

tools/registry.go

@@ -0,0 +1,144 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"sort"
+	"time"
+
+	coretypes "github.com/enmanuel/agents/pkg/llm"
+	"github.com/enmanuel/agents/shell/logger"
+)
+
+// Registry holds available tools keyed by name.
+type Registry struct {
+	tools       map[string]Tool
+	logger      *slog.Logger
+	rateLimiter *RateLimiter // nil when rate limiting is disabled
+}
+
+// NewRegistry creates an empty registry.
+func NewRegistry(log *slog.Logger) *Registry {
+	return &Registry{
+		tools:  make(map[string]Tool),
+		logger: log.With(logger.FieldComponent, "tools"),
+	}
+}
+
+// Register adds a tool to the registry.
+func (r *Registry) Register(t Tool) {
+	r.tools[t.Def.Name] = t
+	r.logger.Debug("tool_registered", "name", t.Def.Name)
+}
+
+// Get looks up a tool by name.
+func (r *Registry) Get(name string) (Tool, bool) {
+	t, ok := r.tools[name]
+	return t, ok
+}
+
+// Names returns all registered tool names in sorted order.
+func (r *Registry) Names() []string {
+	names := make([]string, 0, len(r.tools))
+	for k := range r.tools {
+		names = append(names, k)
+	}
+	sort.Strings(names)
+	return names
+}
+
+// Len returns the number of registered tools.
+func (r *Registry) Len() int {
+	return len(r.tools)
+}
+
+// SetRateLimiter attaches a rate limiter to the registry.
+// When set, ExecuteForRoom checks the limit before running the tool.
+func (r *Registry) SetRateLimiter(rl *RateLimiter) {
+	r.rateLimiter = rl
+}
+
+// ExecuteForRoom is like Execute but checks the per-room rate limit first.
+// If the rate limit is exceeded, it returns an error result without executing.
+func (r *Registry) ExecuteForRoom(ctx context.Context, name, argsJSON, roomID string) Result {
+	if r.rateLimiter != nil && roomID != "" {
+		if !r.rateLimiter.Allow(roomID) {
+			r.logger.Warn("tool_rate_limited", "tool", name, "room", roomID)
+			return Result{Err: fmt.Errorf("rate limit exceeded for room %s: too many tool calls per minute", roomID)}
+		}
+	}
+	return r.Execute(ctx, name, argsJSON)
+}
+
+// Execute looks up a tool by name and runs it. Returns an error result if not found.
+func (r *Registry) Execute(ctx context.Context, name string, argsJSON string) Result {
+	t, ok := r.tools[name]
+	if !ok {
+		r.logger.Warn("tool_not_found", "tool", name)
+		return Result{Err: fmt.Errorf("tool %q not found", name)}
+	}
+
+	var args map[string]any
+	if argsJSON != "" {
+		if err := json.Unmarshal([]byte(argsJSON), &args); err != nil {
+			r.logger.Warn("tool_args_invalid", "tool", name, "err", err)
+			return Result{Err: fmt.Errorf("parse args for %q: %w", name, err)}
+		}
+	}
+
+	r.logger.Info("tool_exec_start", "tool", name)
+	start := time.Now()
+	result := t.Exec(ctx, args)
+	ms := time.Since(start).Milliseconds()
+
+	if result.Err != nil {
+		r.logger.Warn("tool_exec_error", "tool", name, "err", result.Err, logger.FieldDurationMS, ms)
+	} else {
+		r.logger.Info("tool_exec_end", "tool", name, logger.FieldDurationMS, ms)
+	}
+
+	return result
+}
+
+// ToLLMSpecs converts all registered tools to the LLM-compatible ToolSpec format.
+// This is a pure transformation — no side effects.
+func (r *Registry) ToLLMSpecs() []coretypes.ToolSpec {
+	specs := make([]coretypes.ToolSpec, 0, len(r.tools))
+	for _, name := range r.Names() {
+		t := r.tools[name]
+		specs = append(specs, defToLLMSpec(t.Def))
+	}
+	return specs
+}
+
+// defToLLMSpec converts a pure Def to an LLM ToolSpec with JSON Schema.
+func defToLLMSpec(d Def) coretypes.ToolSpec {
+	properties := make(map[string]any, len(d.Parameters))
+	required := make([]string, 0)
+
+	for _, p := range d.Parameters {
+		properties[p.Name] = map[string]any{
+			"type":        p.Type,
+			"description": p.Description,
+		}
+		if p.Required {
+			required = append(required, p.Name)
+		}
+	}
+
+	schema := map[string]any{
+		"type":       "object",
+		"properties": properties,
+	}
+	if len(required) > 0 {
+		schema["required"] = required
+	}
+
+	return coretypes.ToolSpec{
+		Name:        d.Name,
+		Description: d.Description,
+		InputSchema: schema,
+	}
+}