diff --git a/TODO b/TODO
new file mode 100644
index 000000000..d0c959599
--- /dev/null
+++ b/TODO
@@ -0,0 +1,31 @@
+Things to Fix:
+  ☐ Add behaviour settings per channel
+  ☐ Force branching before response
+
+Cortex Loops:
+  ☐ Check tasks + elevate todos
+  ☐ Improve bulletin
+  ☐ Better cortex loop context
+
+Improvements:
+  ☐ Improve cron
+  ☐ Named adapters
+  ☐ Thread names should be better, match channel name style
+
+Live Data Sources (maybe not needed):
+  ☐ Repos
+  ☐ Documentation
+
+Features:
+  ☐ Agent creation flow / onboarding UI
+  ☐ Cortex chat context inspection — should be able to read the full channel context at any time
+  ☐ Add streaming support
+
+Urgent:
+  ☐ Send customer emails ASAP
+
+Settings:
+  ☐ Disable sandboxing / sandbox settings
+
+Notes:
+  Testing inter-agent comms: send a message to the Spacebot Tech Lead, who forwards to the Community Manager, who picks a random word relating to fruit, technology, or space exploration, sending it back up the chain.
diff --git a/docs/.node-version b/docs/.node-version
new file mode 100644
index 000000000..209e3ef4b
--- /dev/null
+++ b/docs/.node-version
@@ -0,0 +1 @@
+20
diff --git a/docs/content/docs/(configuration)/config.mdx b/docs/content/docs/(configuration)/config.mdx
index f098b6d73..46309f1d1 100644
--- a/docs/content/docs/(configuration)/config.mdx
+++ b/docs/content/docs/(configuration)/config.mdx
@@ -493,7 +493,7 @@ Dispatch readiness is derived from warmup runtime state:
 
 - warmup state must be `warm`
 - embedding must be ready
-- bulletin age must be fresh (<= `max(60s, refresh_secs * 2)`)
+- bulletin age must be fresh (`<= max(60s, refresh_secs * 2)`)
 
 When branch/worker/cron dispatch happens before readiness is satisfied, Spacebot still dispatches, increments cold-dispatch metrics, and queues a forced warmup pass in the background.
 
diff --git a/docs/content/docs/(core)/architecture.mdx b/docs/content/docs/(core)/architecture.mdx
new file mode 100644
index 000000000..d99dec336
--- /dev/null
+++ b/docs/content/docs/(core)/architecture.mdx
@@ -0,0 +1,407 @@
+---
+title: Architecture
+description: System-level overview of how Spacebot's processes, databases, and messaging layer fit together.
+---
+
+# Architecture
+
+Spacebot is a single binary that runs multiple concurrent AI processes, each with a dedicated role. There's no server to install, no message broker, no external database. Everything is embedded -- the LLM orchestration, the databases, the messaging adapters, the control API, and the web UI all run inside one process.
+
+This page is the system-level view. It explains how the pieces connect. For deep dives into individual subsystems, see the linked pages throughout.
+
+## The Problem
+
+Most AI agent systems use a single LLM session for everything -- conversation, thinking, tool execution, memory retrieval, and context management all happen in one thread. This creates fundamental bottlenecks:
+
+- **Blocking:** When the agent is running a tool or compacting context, the user waits.
+- **Context pollution:** Tool outputs, internal reasoning, and raw search results fill the context window alongside conversation.
+- **No specialization:** The same prompt and model handle tasks that have very different requirements.
+- **No concurrency:** One thing happens at a time.
+
+Spacebot's architecture is designed around one principle: **delegation is the only way work gets done.**
+
+## Process Model
+
+Five process types, each implemented as a Rig `Agent<SpacebotModel, SpacebotHook>`. They differ in system prompt, available tools, history management, and hooks.
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                        Channel                          │
+│  User-facing conversation. Has personality and soul.    │
+│  Never blocks. Delegates everything.                    │
+│                                                         │
+│  Tools: reply, branch, spawn_worker, route, cancel,     │
+│         skip, react, cron, send_file, send_message      │
+├────────────┬────────────────────────┬───────────────────┤
+│            │                        │                   │
+│     ┌──────▼──────┐         ┌──────▼──────┐            │
+│     │   Branch    │         │   Worker    │            │
+│     │             │         │             │            │
+│     │ Fork of     │         │ Independent │            │
+│     │ channel     │         │ task. No    │            │
+│     │ context.    │         │ channel     │            │
+│     │ Thinks,     │         │ context.    │            │
+│     │ recalls,    │         │ Executes.   │            │
+│     │ returns a   │         │             │            │
+│     │ conclusion. │         │ Shell, file,│            │
+│     │             │         │ exec, browse│            │
+│     │ Memory      │         │             │            │
+│     │ tools only. │         │ Fire-and-   │            │
+│     └─────────────┘         │ forget or   │            │
+│                             │ interactive.│            │
+│                             └─────────────┘            │
+├─────────────────────────────────────────────────────────┤
+│                      Compactor                          │
+│  Programmatic monitor. NOT an LLM process.              │
+│  Watches context size, triggers compaction workers.     │
+│  80% → background, 85% → aggressive, 95% → emergency   │
+├─────────────────────────────────────────────────────────┤
+│                       Cortex                            │
+│  System-level observer. Sees across all channels.       │
+│  Generates the memory bulletin — an LLM-curated         │
+│  briefing injected into every channel's prompt.         │
+└─────────────────────────────────────────────────────────┘
+```
+
+### How Delegation Works
+
+The channel never searches memories, executes shell commands, or does heavy work. When it needs to think, it creates a **branch** -- a fork of its conversation context that goes off to reason, recall memories, and return a conclusion. When it needs work done, it spawns a **worker** -- an independent process with task tools and no conversation context.
+
+The channel is always responsive. Branches and workers run concurrently in `tokio::spawn`. Multiple branches can run simultaneously (configurable limit). Multiple workers can run simultaneously. The channel continues accepting messages while they work.
+
+```
+User message arrives
+  → Channel LLM turn
+    → Decides it needs to think → spawns Branch
+    → Decides it needs code written → spawns Worker
+    → Replies to user immediately
+  → Branch finishes → result injected into channel history → channel retriggered
+  → Worker finishes → status update injected → channel retriggered
+```
+
+For detailed coverage of each process type, see [Agents](/docs/agents), [Compaction](/docs/compaction), and [Cortex](/docs/cortex).
+
+## Inter-Process Communication
+
+All processes within an agent communicate through a `broadcast::channel<ProcessEvent>` -- a multi-producer, multi-consumer event bus. The channel, all branches, and all workers share the same bus.
+
+### Event Types
+
+| Event | Producer | Consumer | Purpose |
+|-------|----------|----------|---------|
+| `BranchStarted` | Channel | Status block | Branch is running |
+| `BranchResult` | Branch | Channel | Conclusion ready, retrigger |
+| `WorkerStarted` | Channel | Status block | Worker is running |
+| `WorkerStatus` | Worker | Channel, Status block | Progress update via `set_status` |
+| `WorkerComplete` | Worker | Channel | Task done, retrigger |
+| `ToolStarted` | Hook | Channel, UI | Tool call in progress |
+| `ToolCompleted` | Hook | Channel, UI | Tool call finished |
+| `MemorySaved` | Branch, Cortex | UI | New memory created |
+| `CompactionTriggered` | Compactor | Channel | Context compacted |
+| `StatusUpdate` | Various | UI (SSE) | Typing indicators, lifecycle |
+| `TaskUpdated` | Branch, Worker | UI | Task board change |
+| `AgentMessageSent` | Channel | Link routing | Inter-agent message |
+| `AgentMessageReceived` | Link routing | Channel | Inbound inter-agent message |
+
+### Retriggering
+
+When a branch or worker completes, the channel doesn't poll for results. The completion event **retriggers** the channel -- it runs another LLM turn with the result injected into its history. This keeps the channel reactive without polling loops.
+
+Retrigger events are debounced. If multiple branches complete within a short window, the channel batches them into a single turn. A retrigger limit (default: 3 per turn) prevents infinite cascades where a branch result triggers a new branch that triggers another retrigger.
+
+### Status Block
+
+Every turn, the channel receives a live snapshot of all active processes:
+
+```markdown
+## Currently Active
+
+### Workers
+- **[code-review]** (running, 45s) — "Reviewing changes in src/memory/store.rs"
+- **[test-runner]** (waiting for input, 2m) — "Tests passed. Awaiting further instructions."
+
+### Recently Completed
+- **[search]** completed 30s ago — "Found 3 relevant files for the query."
+```
+
+Workers set their own status via the `set_status` tool. Short branches (< 3 seconds) are invisible in the status block to avoid noise. The status block is injected into the system prompt, giving the LLM awareness of concurrent activity.
+
+## Data Layer
+
+Three embedded databases, each purpose-built. No server processes, no network connections. Everything lives in the agent's data directory.
+
+```
+~/.spacebot/agents/{agent_id}/data/
+├── spacebot.db          # SQLite — relational data
+├── lancedb/             # LanceDB — vector embeddings, full-text search
+└── config.redb          # redb — key-value settings, encrypted secrets
+```
+
+### SQLite (via sqlx)
+
+The primary database. Stores everything that benefits from relational queries:
+
+| Table | Purpose |
+|-------|---------|
+| `memories` | Memory content, types, importance scores, timestamps |
+| `associations` | Graph edges between memories (weighted, typed) |
+| `conversation_messages` | Persistent conversation history per channel |
+| `channels` | Active channel registry with platform metadata |
+| `cron_jobs` | Scheduled task definitions |
+| `cron_executions` | Execution history for cron jobs |
+| `worker_runs` | Worker execution history with transcripts |
+| `branch_runs` | Branch execution history |
+| `cortex_events` | Cortex action log (bulletin generations, maintenance) |
+| `cortex_chat_messages` | Persistent admin chat with cortex |
+| `tasks` | Structured task board (backlog → in_progress → done) |
+| `ingestion_progress` | Chunk-level progress for file ingestion |
+| `agent_profile` | Cortex-generated personality data |
+
+Migrations are in `migrations/` and are **immutable once committed**. Schema changes always go in new migration files. See [Memory](/docs/memory) for the memory graph schema.
+
+### LanceDB
+
+Vector storage and search. Paired with SQLite on memory ID.
+
+- **Embeddings** stored in Lance columnar format with HNSW indexing
+- **Full-text search** via built-in Tantivy integration
+- **Hybrid search** combines vector similarity and keyword matching via Reciprocal Rank Fusion (RRF)
+
+The embedding model runs locally via FastEmbed -- no external API calls for embeddings. See [Memory](/docs/memory) for search details.
+
+### redb
+
+Embedded key-value store for configuration and secrets.
+
+- **Settings** — runtime key-value pairs (e.g., UI preferences, feature flags)
+- **Encrypted secrets** — API keys and tokens encrypted with AES-256-GCM before storage
+
+Separated from SQLite so credentials can be managed and backed up independently.
+
+## Messaging Layer
+
+Spacebot connects to multiple messaging platforms simultaneously. All adapters implement the same `Messaging` trait and feed into a unified inbound message stream.
+
+```
+Discord ─┐
+Slack ───┤
+Telegram ┼──→ MessagingManager ──→ InboundMessage stream ──→ main.rs event loop
+Twitch ──┤                                                        │
+Webhook ─┤                                                        ▼
+WebChat ─┘                                              Channel.handle_message()
+                                                                  │
+                                                                  ▼
+                                                          OutboundResponse
+                                                                  │
+                                                   ┌──────────────┼──────────────┐
+                                                   ▼              ▼              ▼
+                                                Discord        Slack        Telegram
+```
+
+### Inbound Flow
+
+1. Platform adapter receives a message (Discord event, Slack webhook, Telegram update, etc.)
+2. Adapter converts to `InboundMessage` — a unified type with text, media, sender info, conversation ID, and platform metadata
+3. `MessagingManager` fans all adapters into a single `mpsc::channel`
+4. `main.rs` event loop receives the message, resolves the target agent via message bindings, and routes to the appropriate `Channel`
+5. If no `Channel` exists for this conversation ID, one is created and its event loop spawned
+
+### Outbound Flow
+
+1. Channel tools (reply, react, send_file) produce `OutboundResponse` values
+2. Each channel has an outbound routing task that receives responses via `mpsc::channel`
+3. The routing task determines the platform from the channel ID prefix (`discord:`, `slack:`, `telegram:`, etc.)
+4. `MessagingManager::broadcast()` delivers the response to the correct platform adapter
+5. Responses are also forwarded to SSE clients (WebChat, dashboard) for real-time UI updates
+
+### Message Bindings
+
+Each agent declares which messaging channels route to it:
+
+```toml
+[[agents]]
+id = "main"
+
+[[agents.bindings.discord]]
+guild_id = "1323900500600422472"
+channel_ids = ["1471388652562284626"]
+
+[[agents.bindings.telegram]]
+chat_ids = [551234, -1001234567890]
+
+[[agents.bindings.webhook]]
+endpoints = ["github-ci", "monitoring"]
+```
+
+When a message arrives, the binding resolver matches the conversation ID against all agent bindings. If no specific binding matches, the message goes to the default agent (if one is configured). See [Messaging](/docs/messaging) and the individual platform setup guides for configuration details.
+
+## LLM Integration
+
+Spacebot uses [Rig](https://github.com/0xPlaygrounds/rig) as the agentic loop framework. Every process is a Rig `Agent` with a custom `CompletionModel` implementation that routes through Spacebot's `LlmManager`.
+
+### Custom Model Layer
+
+Spacebot doesn't use Rig's built-in provider clients. Instead, `SpacebotModel` implements `CompletionModel` and delegates to `LlmManager`, which handles:
+
+- **Provider routing** — resolving model names to provider clients (Anthropic, OpenAI, Google, etc.)
+- **Process-type defaults** — different models for channels, branches, workers, compactor, cortex
+- **Task-type overrides** — specific models for coding, summarization, deep reasoning tasks
+- **Fallback chains** — automatic fallback to alternative models on failure
+
+```
+Channel LLM call
+  → SpacebotModel.completion(messages, tools)
+    → LlmManager.resolve_model("anthropic/claude-sonnet-4-20250514")
+      → Anthropic client
+        → API call with prompt caching, custom parameters
+```
+
+See [Routing](/docs/routing) for the full routing configuration.
+
+### Agent Construction
+
+```rust
+let agent = AgentBuilder::new(model.clone())
+    .preamble(&system_prompt)
+    .hook(SpacebotHook::new(process_id, process_type, event_tx.clone()))
+    .tool_server_handle(tools.clone())
+    .default_max_turns(50)
+    .build();
+```
+
+### Hooks
+
+Two hook implementations control process behavior:
+
+**`SpacebotHook`** (channels, branches, workers) — sends `ProcessEvent`s for real-time status, tracks token usage, enforces cancellation signals, implements tool nudging (prompts the LLM to use tools if it responds with text instead of tool calls in early iterations), and runs leak detection on tool outputs.
+
+**`CortexHook`** (cortex only) — lighter implementation for system observation, no tool nudging.
+
+Hooks return `Continue`, `Terminate`, or `Skip` after each LLM turn, giving the system fine-grained control over process lifecycle.
+
+### Max Turns
+
+Rig defaults to 0 (single call). Spacebot sets explicit limits per process type:
+
+| Process | Max Turns | Rationale |
+|---------|-----------|-----------|
+| Channel | 5 | Typically 1-3 turns. Prevents runaway conversations. |
+| Branch | 10 | A few iterations to think, recall, and conclude. |
+| Worker | 50 | Many iterations for complex tasks. Segmented into 25-turn blocks. |
+| Compactor | 10 | Summarize and extract memories. Bounded. |
+| Cortex | 10 | Bulletin generation. Single-pass with tool calls. |
+
+## Control API
+
+An embedded Axum HTTP server provides the control API for the dashboard and external integrations. Default port: `19898`.
+
+### Key Endpoint Groups
+
+| Group | Prefix | Purpose |
+|-------|--------|---------|
+| Agents | `/api/agents` | CRUD for agent definitions |
+| Channels | `/api/channels` | Channel listing, history, deletion |
+| Workers | `/api/workers` | Worker status, history, timeline |
+| Cortex | `/api/cortex` | Bulletin, profile, cortex chat |
+| Memory | `/api/memories` | Memory CRUD, graph queries |
+| Config | `/api/config` | Runtime configuration read/write |
+| Providers | `/api/providers` | LLM provider key management |
+| Links | `/api/links` | Communication graph management |
+| Tasks | `/api/tasks` | Task board CRUD |
+| Cron | `/api/cron` | Scheduled task management |
+| System | `/api/system` | Health, version, metrics |
+| WebChat | `/api/webchat` | Embedded chat interface |
+| Models | `/api/models` | Available model listing |
+| Topology | `/api/topology` | Full communication graph |
+
+The dashboard UI is a React SPA embedded in the binary via `rust-embed` and served at the root path. It communicates with these API endpoints for all operations.
+
+### Real-Time Updates
+
+The API supports Server-Sent Events (SSE) for real-time streaming to connected clients. Status updates, tool call progress, worker lifecycle events, and memory changes are all pushed via SSE, giving the dashboard and WebChat live visibility into agent activity.
+
+## Startup Sequence
+
+```
+CLI (clap) → parse args
+  → Load config.toml
+  → Optionally daemonize (Unix socket for IPC)
+  → Build tokio runtime
+  → Initialize tracing + OpenTelemetry (optional)
+  → run()
+    → Start IPC server (stop/status commands)
+    → Start Axum API server
+    → Initialize shared resources:
+        LlmManager, EmbeddingModel, PromptEngine, agent links
+    → For each agent:
+        → Run SQLite migrations
+        → Initialize MemoryStore, LanceDB tables
+        → Initialize MessagingManager (start all platform adapters)
+        → Initialize CronScheduler
+        → Start Cortex (warmup → first bulletin)
+        → Register agent in active agents map
+    → Enter main event loop (tokio::select!)
+        → Inbound messages → route to Channel instances
+        → Agent registration/removal
+        → Provider setup events
+        → Shutdown signal → graceful shutdown
+```
+
+All long-running loops respect a shutdown signal via `broadcast::channel`. On shutdown, active workers are cancelled, channels are flushed, and database connections are closed cleanly.
+
+## Module Structure
+
+The crate uses the sibling file module pattern -- `src/memory.rs` is the module root for `src/memory/`, never `mod.rs`.
+
+```
+src/
+├── main.rs              — CLI entry, config, startup, event loop
+├── lib.rs               — module declarations, shared types
+├── config.rs            — configuration loading and validation
+├── error.rs             — top-level Error enum
+├── db.rs                — database connection bundle
+│
+├── agent/               — process implementations
+│   ├── channel.rs       — user-facing conversation
+│   ├── branch.rs        — forked thinking process
+│   ├── worker.rs        — task execution
+│   ├── compactor.rs     — context monitor
+│   ├── cortex.rs        — system observer
+│   └── status.rs        — live status snapshot
+│
+├── tools/               — 27 tool implementations (one per file)
+├── memory/              — memory graph, search, embeddings
+├── llm/                 — model routing, provider clients
+├── messaging/           — platform adapters
+├── conversation/        — history persistence, context assembly
+├── prompts/             — template engine
+├── hooks/               — PromptHook implementations
+├── cron/                — scheduled tasks
+├── api/                 — 21 Axum endpoint modules
+├── identity/            — identity file loading
+├── secrets/             — encrypted credential storage
+├── settings/            — key-value settings
+├── tasks/               — task board
+├── links/               — communication graph types
+├── skills/              — skill management
+├── opencode/            — OpenCode worker integration
+├── sandbox/             — command sandboxing
+├── telemetry/           — metrics (feature-gated)
+└── update/              — self-update checker
+```
+
+## Design Principles
+
+**Never block the channel.** The channel never waits on branches, workers, or compaction. If something takes time, it runs concurrently and retriggers the channel when done.
+
+**Raw data never reaches the channel.** Memory recall goes through a branch, which curates. The channel gets clean conclusions, not raw database rows.
+
+**Workers have no channel context.** A worker gets a task description and tools. If something needs conversation context, it's a branch, not a worker.
+
+**The compactor is not an LLM.** It's a programmatic monitor that watches a number and spawns workers. The LLM work happens in the workers it spawns.
+
+**Prompts are files.** System prompts live in `prompts/` as Jinja2 templates, not as string constants in Rust code. Identity files (SOUL.md, IDENTITY.md, USER.md, ROLE.md) are loaded from the agent's workspace directory.
+
+**Three databases, three purposes.** SQLite for relational queries, LanceDB for vector search, redb for key-value config. Each doing what it's best at.
+
+**Graceful everything.** All loops respect shutdown signals. Errors are propagated, not silenced. The only exception is `.ok()` on channel sends where the receiver may already be dropped.
diff --git a/docs/content/docs/(core)/cortex.mdx b/docs/content/docs/(core)/cortex.mdx
index e349bfc6e..e2f682403 100644
--- a/docs/content/docs/(core)/cortex.mdx
+++ b/docs/content/docs/(core)/cortex.mdx
@@ -223,7 +223,7 @@ Branch, worker, and cron dispatch paths consult a derived `ready_for_work` signa
 
 - warmup state is `warm`
 - embedding model is ready
-- bulletin age is fresh (<= `max(60s, refresh_secs * 2)`)
+- bulletin age is fresh (`<= max(60s, refresh_secs * 2)`)
 
 If dispatch arrives while not ready, Spacebot does **not** block the channel or scheduler:
 
diff --git a/docs/content/docs/(core)/meta.json b/docs/content/docs/(core)/meta.json
index 53cfc2a04..0e07391ec 100644
--- a/docs/content/docs/(core)/meta.json
+++ b/docs/content/docs/(core)/meta.json
@@ -2,6 +2,7 @@
   "title": "Core Concepts",
   "pages": [
     "philosophy",
+    "architecture",
     "agents",
     "memory",
     "routing",
diff --git a/docs/content/docs/(features)/meta.json b/docs/content/docs/(features)/meta.json
index 0c4bb20b8..a9903832a 100644
--- a/docs/content/docs/(features)/meta.json
+++ b/docs/content/docs/(features)/meta.json
@@ -1,4 +1,4 @@
 {
   "title": "Features",
-  "pages": ["workers", "opencode", "tools", "mcp", "browser", "cron", "skills", "ingestion"]
+  "pages": ["workers", "tasks", "opencode", "tools", "mcp", "browser", "cron", "skills", "ingestion"]
 }
diff --git a/docs/content/docs/(features)/tasks.mdx b/docs/content/docs/(features)/tasks.mdx
new file mode 100644
index 000000000..cf48bb645
--- /dev/null
+++ b/docs/content/docs/(features)/tasks.mdx
@@ -0,0 +1,343 @@
+---
+title: Tasks
+description: Kanban-style task board with structured tracking, cortex pickup, and worker execution.
+---
+
+# Tasks
+
+A kanban-style task board built into every agent. Tasks are spec-driven documents — the description is a full markdown spec that evolves through conversation, with pre-filled subtasks as an execution plan. Each task has a short title, rich description, status, priority, subtasks, and a numeric reference (`#42`). Each agent has its own independent task store backed by its own SQLite database.
+
+Tasks are not tickets. They're living specs written for workers who have no conversation context. A good task description includes requirements, constraints, file paths, examples, and acceptance criteria. The branch refines the spec as the user clarifies scope, and moves it to `ready` when it's complete. The cortex picks it up and spawns a worker that executes against the spec.
+
+## Creation Paths
+
+Tasks enter the system three ways:
+
+### 1. Conversational (via branch tools)
+
+The primary path. A user manages tasks through natural conversation — creating, listing, updating, approving, and closing tasks by talking to the agent. The channel delegates to a branch, and the branch uses `task_create`, `task_list`, and `task_update` tools.
+
+```
+User: "Create a task to refactor the auth module, high priority"
+  → Channel branches
+    → Branch calls task_create(
+        title: "Refactor auth module",
+        priority: "high",
+        description: "## Goal\nExtract auth logic from ...\n\n## Requirements\n- ...\n## Constraints\n- ...",
+        subtasks: ["Audit current auth endpoints", "Extract shared middleware", "Update tests", "Verify CI passes"]
+      )
+    → Branch returns: "Created task #7 with 4 subtasks"
+
+User: "Actually, we also need to migrate the session store to Redis"
+  → Channel branches
+    → Branch calls task_update(task_number: 7, description: "<updated spec with Redis section>")
+    → Branch returns: "Updated #7 — added Redis migration to the spec"
+
+User: "Looks good, run it"
+  → Channel branches
+    → Branch calls task_update(task_number: 7, status: "ready")
+    → Cortex ready-task loop picks it up → Worker executes against the spec → Done
+```
+
+Tasks created conversationally default to `backlog` status. The branch writes a rich markdown description and pre-fills subtasks as an execution plan. The user refines scope through conversation, and the branch updates the spec accordingly. When the spec is complete, moving to `ready` triggers automatic execution.
+
+### 2. Cortex promotion (from Todo memories)
+
+The cortex bridges the gap between quick captures and structured work. A cortex loop scans recent `Todo` memories, evaluates whether they're actionable, and promotes them to tasks in `pending_approval` status. The human reviews and approves before execution begins.
+
+```
+Branch saves a Todo memory during conversation
+  → Cortex evaluates the todo (promotion loop)
+    → Cortex creates a Task in "pending_approval"
+      → Human approves on the kanban board
+        → Cortex ready-task loop picks it up
+          → Worker executes → Done
+```
+
+This path is for things the agent noticed were actionable but the user didn't explicitly ask to track — the cortex catches what falls through the cracks.
+
+### 3. UI / API
+
+Tasks can be created directly from the kanban board UI or via the REST API. These default to `backlog` status with `created_by: "human"`.
+
+## Status (Kanban Columns)
+
+Five columns on the board:
+
+| Status | Description |
+|--------|-------------|
+| `pending_approval` | Created by cortex, awaiting human sign-off |
+| `backlog` | Captured but not ready for work. Default for conversational and UI-created tasks |
+| `ready` | Approved and waiting for the cortex to pick up |
+| `in_progress` | A worker is actively executing this task |
+| `done` | Completed |
+
+### Status Transitions
+
+Transitions are validated. You can't skip steps or go backwards (except to `backlog`, which is always allowed as a "re-shelve" action).
+
+```
+pending_approval → ready         (approval)
+pending_approval → backlog       (shelve)
+backlog → ready                  (manual promotion)
+ready → in_progress              (cortex pickup)
+in_progress → done               (worker success)
+in_progress → ready              (worker failure, re-queued)
+done → backlog                   (reopen)
+```
+
+Attempting an invalid transition (e.g., `pending_approval → in_progress`, `ready → done`) returns an error.
+
+## Priority
+
+Four levels, ordered by urgency:
+
+```
+critical > high > medium > low
+```
+
+Default: `medium`. The cortex ready-task loop respects priority — a critical task is picked up before a low-priority one, regardless of creation order.
+
+## Subtasks
+
+Simple checklist items stored as a JSON array. One level deep, no nesting.
+
+```json
+[
+  {"title": "Research existing API endpoints", "completed": false},
+  {"title": "Draft schema changes", "completed": true},
+  {"title": "Implement migration", "completed": false}
+]
+```
+
+Subtasks are included in the worker's prompt as an execution plan. Workers can mark subtasks complete via the `task_update` tool as they progress.
+
+## Metadata
+
+Arbitrary key-value pairs stored as a JSON object. Used for linking to external resources.
+
+```json
+{
+  "github_issue": "https://github.com/org/repo/issues/123",
+  "estimated_effort": "small",
+  "worker_type": "opencode",
+  "skill": "rust-dev",
+  "notes": "Depends on the auth refactor landing first"
+}
+```
+
+No enforced schema. The UI renders known keys with special formatting (e.g., GitHub links become clickable) and displays unknown keys as plain key-value pairs.
+
+## Task Numbering
+
+Per-agent, monotonically increasing. The next number is `MAX(task_number) + 1` within the agent's task table. Tasks are referenced as `#1`, `#42`, etc. Numbers are never reused — deleting task `#5` doesn't free up the number.
+
+## Execution
+
+### Cortex Ready-Task Loop
+
+The primary execution path. A background loop runs every `cortex.tick_interval_secs` (default 30 seconds):
+
+1. **Claim** — Atomically finds the oldest `ready` task with the highest priority and moves it to `in_progress`
+2. **Build prompt** — Renders the worker system prompt with the task title, description, and subtask checklist
+3. **Spawn worker** — Creates a new worker with full tool access (shell, file, exec, browser)
+4. **Bind** — Sets `worker_id` on the task, linking it to the executing worker
+5. **Execute** — The worker runs its loop, using subtasks as an execution plan
+6. **Complete** — On success, the task moves to `done` with `completed_at` set. On failure, the task moves back to `ready` with `worker_id` cleared, so it gets re-queued for another attempt
+
+Worker success/failure is determined by whether `worker.run()` returns `Ok` or `Err`. The cortex doesn't evaluate the quality of the work — a worker that completes without errors is considered successful.
+
+### API Execute Endpoint
+
+The `/api/agents/tasks/:number/execute` endpoint moves a task to `ready` (if it's in `backlog` or `pending_approval`), letting the cortex loop pick it up. Tasks already in `ready` or `in_progress` are returned as-is.
+
+This means execution always flows through the cortex — the API doesn't spawn workers directly.
+
+### Worker Scope
+
+Workers executing a task get a restricted version of the `task_update` tool. They can only:
+
+- Update subtasks (mark complete, replace the checklist)
+- Update metadata
+
+They cannot change the task's status, priority, title, description, or worker binding. These fields are managed by the cortex and the API. This prevents a worker from marking its own task as `done` — only the cortex does that based on whether the worker succeeded or failed.
+
+## Bulletin Integration
+
+Active tasks (non-done) are included in the cortex memory bulletin under an "Active Tasks" section. Each task is listed with its number, status, priority, title, and subtask progress:
+
+```
+### Active Tasks
+
+- #3 [in_progress] (high) Implement auth refactor [2/5]
+- #7 [ready] (medium) Update deployment docs
+- #12 [backlog] (low) Clean up unused dependencies
+```
+
+This gives every channel and branch awareness of the agent's current task board without querying the task store directly.
+
+## LLM Tools
+
+Three tools available to branches and cortex chat sessions:
+
+### task_create
+
+Creates a new task.
+
+| Argument | Type | Required | Default |
+|----------|------|----------|---------|
+| `title` | string | yes | - |
+| `description` | string | no | - |
+| `priority` | string | no | `"medium"` |
+| `subtasks` | string[] | no | `[]` |
+| `metadata` | object | no | `{}` |
+| `status` | string | no | `"backlog"` |
+
+Returns the created task number and status.
+
+### task_list
+
+Lists tasks with optional filters.
+
+| Argument | Type | Required | Default |
+|----------|------|----------|---------|
+| `status` | string | no | all |
+| `priority` | string | no | all |
+| `limit` | integer | no | 20 |
+
+### task_update
+
+Updates an existing task. Available to branches (unrestricted) and workers (restricted to subtasks and metadata only).
+
+| Argument | Type | Required | Notes |
+|----------|------|----------|-------|
+| `task_number` | integer | yes | The `#N` reference |
+| `title` | string | no | Branch only |
+| `description` | string | no | Branch only |
+| `status` | string | no | Branch only |
+| `priority` | string | no | Branch only |
+| `subtasks` | object[] | no | Full replacement |
+| `metadata` | object | no | Merged with existing |
+| `complete_subtask` | integer | no | Index to mark complete |
+
+## API Endpoints
+
+All endpoints require `agent_id` as a query parameter or in the request body.
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/agents/tasks` | List tasks (filterable by status, priority) |
+| `GET` | `/api/agents/tasks/:number` | Get single task by number |
+| `POST` | `/api/agents/tasks` | Create task |
+| `PUT` | `/api/agents/tasks/:number` | Update task |
+| `DELETE` | `/api/agents/tasks/:number` | Delete task |
+| `POST` | `/api/agents/tasks/:number/approve` | Approve (moves to `ready`) |
+| `POST` | `/api/agents/tasks/:number/execute` | Execute (moves to `ready` for cortex pickup) |
+
+### SSE Events
+
+Task state changes emit `task_updated` SSE events to connected clients:
+
+```json
+{
+  "type": "task_updated",
+  "agent_id": "main",
+  "task_number": 42,
+  "status": "in_progress",
+  "action": "updated"
+}
+```
+
+The `action` field is one of `"created"`, `"updated"`, or `"deleted"`. The kanban board UI uses these events for real-time updates.
+
+## Interface
+
+### Kanban Board
+
+The **Tasks** tab on the agent page renders a five-column kanban board. Each column corresponds to a task status. Task cards show:
+
+- `#N` task number and title
+- Priority badge (color-coded: red for critical, amber for high, default for medium, outline for low)
+- Subtask progress bar (if subtasks exist)
+- Worker badge (if a worker is bound)
+- Quick action buttons (Approve, Execute, Mark Done)
+- Creation timestamp and author
+
+Clicking a card opens a detail dialog with the full description, subtask checklist, metadata, timestamps, and status action buttons.
+
+### Create Task
+
+The "Create Task" button opens a dialog with fields for title, description, priority, and initial status. Tasks created from the UI default to `backlog` status and `"human"` as the creator.
+
+## Storage
+
+One SQLite table in the agent's database.
+
+```sql
+CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL,
+    task_number INTEGER NOT NULL,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'backlog',
+    priority TEXT NOT NULL DEFAULT 'medium',
+    subtasks TEXT,                    -- JSON array
+    metadata TEXT,                    -- JSON object
+    source_memory_id TEXT,
+    worker_id TEXT,
+    created_by TEXT NOT NULL,
+    approved_at TIMESTAMP,
+    approved_by TEXT,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    completed_at TIMESTAMP,
+    UNIQUE(agent_id, task_number)
+);
+```
+
+Indexes on `agent_id`, `status`, `(agent_id, task_number)`, `source_memory_id`, and `worker_id`.
+
+## Module Layout
+
+```
+src/
+├── tasks.rs                → tasks/
+│   └── store.rs            — TaskStore: CRUD, status transitions, claim_next_ready
+│
+├── tools/
+│   ├── task_create.rs      — task_create LLM tool (branches + cortex chat)
+│   ├── task_list.rs        — task_list LLM tool (branches + cortex chat)
+│   └── task_update.rs      — task_update LLM tool (branches + workers, scoped)
+│
+├── api/
+│   └── tasks.rs            — REST endpoints (list, get, create, update, delete,
+│                             approve, execute) with SSE event emission
+│
+├── agent/
+│   └── cortex.rs           — spawn_ready_task_loop, pickup_one_ready_task,
+│                             gather_active_tasks (bulletin integration)
+│
+└── migrations/
+    └── 20260219000001_tasks.sql
+```
+
+## Prompt Integration
+
+The channel, branch, and cortex chat prompts are all task-aware:
+
+- **Channel prompt** (`channel.md.j2`) — has a dedicated "Task Board" section explaining spec-driven tasks and the kanban board. The Delegation section tells the channel to branch for task management. Active tasks appear in the Memory Context via the bulletin.
+- **Branch prompt** (`branch.md.j2`) — documents all three task tools (`task_create`, `task_list`, `task_update`) with spec-driven guidance. `task_create` emphasizes rich markdown descriptions and pre-filled subtasks. `task_update` is framed as iterative spec refinement. Moving to `ready` triggers cortex auto-pickup.
+- **Cortex chat prompt** (`cortex_chat.md.j2`) — lists task board management as a core capability with spec-driven language. The cortex chat has all three task tools.
+- **Tool descriptions** — each task tool has a description template in `prompts/en/tools/` that reinforces the spec-driven philosophy: `task_create` tells the LLM to write full markdown specs with subtask execution plans, `task_update` tells it to refine specs as scope evolves.
+
+The channel itself has no task tools — it always branches to manage tasks. This keeps the channel responsive and ensures task operations go through a thinking process.
+
+## What's Not Implemented Yet
+
+- **Cortex todo-promotion loop** — the cortex loop that scans `Todo` memories and promotes them to `pending_approval` tasks. The data model and execution path are ready; the promotion evaluation prompt and loop are not yet built.
+- **Drag-and-drop** — the kanban board has quick action buttons but no drag-and-drop between columns yet.
+- **Activity timeline** — the detail dialog doesn't show a history of status changes, approvals, and worker events.
+- **Task count badge** — the Tasks tab doesn't show a badge with the pending approval count yet.
+- **Task archival** — done tasks accumulate indefinitely. Options: auto-archive after N days, a separate `archived` status, or UI filtering (currently, done tasks are shown in the Done column).
+- **Rejection feedback** — when a human deletes a pending task, that signal isn't fed back to the cortex. Saving it as a memory would help the cortex learn what's not actionable.
diff --git a/docs/content/docs/index.mdx b/docs/content/docs/index.mdx
index ca5bba05e..c924dc58f 100644
--- a/docs/content/docs/index.mdx
+++ b/docs/content/docs/index.mdx
@@ -27,7 +27,7 @@ Spacebot runs as a single binary with no server dependencies. All data lives in
 
 <Cards>
   <Card title="Quickstart" href="/docs/quickstart" />
-  <Card title="Architecture" href="/docs/philosophy" />
+  <Card title="Architecture" href="/docs/architecture" />
   <Card title="Configuration" href="/docs/config" />
   <Card title="Memory System" href="/docs/memory" />
 </Cards>
diff --git a/docs/design-docs/link-channels-task-delegation.md b/docs/design-docs/link-channels-task-delegation.md
new file mode 100644
index 000000000..3d85230c0
--- /dev/null
+++ b/docs/design-docs/link-channels-task-delegation.md
@@ -0,0 +1,274 @@
+# Link Channels as Task Delegation (v3)
+
+Replaces the LLM-to-LLM conversational model from link-channels-v2 with deterministic task-based delegation. Agents don't talk to each other — they assign tasks. Link channels become audit logs of delegated work, not conversation threads.
+
+## Why
+
+The v2 design had agents exchange messages through mirrored link channels, with each side running its own LLM to process and respond. This was fundamentally brittle:
+
+- **Recursive loops**: Agents ping-pong conclusions, replies, or re-delegations endlessly.
+- **Context loss**: When a link channel re-opens after concluding, the LLM has no memory of prior work and re-sends the original task.
+- **Turn count gaming**: Safety caps fire, force-conclude, then the next message resets the budget.
+- **Conclusion non-compliance**: Agents ignore `conclude_link` instructions and chat until the safety cap.
+- **Result routing corruption**: `initiated_from` metadata gets overwritten by subsequent messages, causing results to bridge to the wrong channel.
+
+Every fix added more special-case logic (drop guards, peer-initiated flags, history seeding, mechanical passthroughs). The system was getting more complex with each bug, not simpler. The core problem is irreducible: two LLMs having a conversation is non-deterministic and uncontrollable.
+
+## The New Model
+
+Instead of conversations, agents delegate through **tasks**. The existing task tracking system (Phase 1 already implemented on `task-tracking` branch) provides the structured, deterministic substrate.
+
+```
+User asks Agent A to do something
+  -> Agent A decides it should be delegated to Agent B
+    -> Agent A calls send_agent_message (modified)
+      -> A task is created in Agent B's task store
+      -> A record is logged in the link channel between A and B
+      -> Agent A's turn ends (skip flag)
+    -> Agent B's cortex ready-task loop picks up the task
+      -> Worker executes the task
+      -> Task moves to done
+      -> Completion record logged in link channel
+      -> Agent A is notified (retrigger on originating channel)
+```
+
+No LLM-to-LLM conversation. No reply relay. No conclusion handshake. No turn counting. The delegation is a database write; the execution is a worker; the result is a task status change.
+
+## What Link Channels Become
+
+Link channels shift from conversation threads to **audit logs**. They record:
+
+1. **Task created**: "Agent A assigned task #42 to Agent B: [title]"
+2. **Task completed**: "Agent B completed task #42: [summary]"
+3. **Task failed**: "Agent B's worker failed on task #42: [error]"
+4. **Task requeued**: "Task #42 returned to ready after worker failure"
+
+These are **system messages** — not LLM-generated text. The link channel is a historical record of delegation activity between two agents. When a human opens a link channel in the dashboard, they see a timeline of tasks assigned and results returned.
+
+Link channels are no longer processed by the LLM. There is no `handle_message()` call, no branching, no worker spawning from link channels. They are write-only logs read by humans through the UI.
+
+### Channel ID Convention
+
+Keep `link:{agent_a}:{agent_b}` as the channel ID format. The `ChannelStore` records these for the UI to discover. Messages are persisted via `ConversationLogger` with `source: "system"` so they're never fed into an LLM context window.
+
+## Modified `send_agent_message` Tool
+
+The tool's external interface stays the same — the LLM calls it with a target agent and a message. The implementation changes completely:
+
+```
+Before (v2):
+  1. Construct InboundMessage
+  2. Inject into target agent's message pipeline
+  3. Target agent's link channel processes it with LLM
+  4. Reply routed back through outbound handler
+  5. Source agent processes reply with LLM
+  6. Back and forth until conclude_link
+
+After (v3):
+  1. Validate link exists and permits this direction
+  2. Create task in target agent's task store
+     - title: extracted from message (first sentence or explicit title)
+     - description: full message content
+     - status: ready (skip pending_approval for agent-delegated tasks)
+     - priority: inferred or default medium
+     - created_by: "agent:{source_agent_id}"
+     - metadata: { delegated_by, originating_channel, link_id }
+  3. Log delegation record in link channel (system message)
+  4. Set skip flag (end source agent's turn)
+  5. Return { success: true, task_number }
+```
+
+The tool needs access to the **target agent's** `TaskStore`, not just the source agent's. This means `send_agent_message` needs a way to resolve task stores across agents.
+
+### Cross-Agent Task Store Access
+
+Currently, `TaskStore` instances are per-agent and stored in `ApiState::task_stores`. The tool runs inside a specific agent's process and only has access to that agent's `AgentDeps`.
+
+**Decision: Per-agent task stores.** Each agent owns its own `TaskStore` backed by its own SQLite database. A superior agent instructs task creation via the link channel system and can query/read a subordinate agent's tasks (read-only cross-agent access). The task store registry (`HashMap<AgentId, Arc<TaskStore>>`) is passed to tools that need cross-agent visibility, but task *creation* on another agent goes through the link channel mechanism, not direct writes.
+
+This preserves agent isolation — each agent's task board is its own — while giving the hierarchy the ability to observe and manage work across the org.
+
+## Task Completion Notification
+
+When a delegated task completes, the delegating agent needs to know. Two mechanisms:
+
+### 1. Link Channel Record
+
+When a worker completes a task that has `metadata.delegated_by`, the cortex (or the task completion handler in `cortex.rs`) logs a completion message in the link channel:
+
+```
+[System] Task #42 completed by community-manager: "Published 3 posts to Discord announcements channel. Links: [...]"
+```
+
+This is a passive record — it doesn't trigger the delegating agent's LLM.
+
+### 2. Originating Channel Retrigger
+
+The task metadata includes `originating_channel` (the channel where the user originally asked for the work). When the task completes, a system message is injected into that channel:
+
+```
+[System] Delegated task completed by community-manager: "Published 3 posts..."
+```
+
+This **does** retrigger the channel's LLM, which can then relay the result to the user naturally. The message has `source: "system"` and no `formatted_author`, so it renders as a plain system notification.
+
+This replaces the old `bridge_to_initiator` mechanism but is much simpler — it's a single message injection on task completion, not a recursive conclusion chain.
+
+### 3. Task Status Polling (Optional, Future)
+
+The delegating agent's cortex could periodically check on delegated tasks via `task_list` filtered by `metadata.delegated_by`. This is a pull model that doesn't require any special routing — the cortex just queries its own task store for tasks it created on other agents.
+
+Not needed for v1 since the push notification (retrigger) handles the common case.
+
+## What Gets Removed
+
+### Files to Delete
+
+| File | Reason |
+|------|--------|
+| `src/tools/conclude_link.rs` | Conversational conclusion mechanism |
+| `prompts/en/fragments/link_context.md.j2` | "You're in a conversation with agent X" prompt |
+| `prompts/en/tools/conclude_link_description.md.j2` | Tool description for deleted tool |
+
+### Code to Remove from `src/agent/channel.rs`
+
+All link-conversation handling logic:
+
+- `link_concluded` field and all checks against it
+- `link_turn_count` field and safety cap logic
+- `peer_initiated_conclusion` field
+- `initiated_from` field and capture logic
+- `originating_channel` / `originating_source` fields
+- `build_link_context()` method (~40 lines)
+- `route_link_conclusion()` / `handle_link_conclusion()` / `bridge_to_initiator()` methods (~160 lines)
+- History seeding for link channels (original_sent_message replay)
+- Coalesce bypass for link channels
+- Drop guard for concluded link channels
+- `conclude_link` tool registration in `run_agent_turn()`
+- `ConcludeLinkFlag` / `ConcludeLinkSummary` return values from `run_agent_turn()`
+- `is_link_channel` checks throughout
+
+### Code to Remove from `src/main.rs`
+
+- Outbound reply relay for `source == "internal"` channels (~90 lines, ~lines 981-1072)
+- This is the code that intercepts Agent B's reply on `link:B:A` and injects it into `link:A:B`
+
+### Code to Remove from `src/tools.rs`
+
+- `pub mod conclude_link` and re-exports
+- `conclude_link` parameter in `add_channel_tools()` / `remove_channel_tools()`
+- `link_counterparty_for_agent()` helper
+- `has_other_delegation_targets` complexity (simplify to basic "has any link targets")
+
+### Prompt Changes
+
+- Remove `conclude_link` text entry from `src/prompts/text.rs`
+- Update `org_context.md.j2` wording — replace conversation language with task delegation language
+- Update `send_agent_message` tool description — "assigns a task" not "sends a message"
+
+## What Gets Kept
+
+### Link Infrastructure (Unchanged)
+
+- `src/links.rs` + `src/links/types.rs` — `AgentLink`, `LinkDirection`, `LinkKind`, store utilities
+- `src/config.rs` — `[[links]]` TOML parsing, `LinkDef`
+- `src/main.rs` — Link initialization, `ArcSwap` plumbing, `AgentDeps.links`
+- `ProcessEvent::AgentMessageSent` / `AgentMessageReceived`
+- `src/api/links.rs` — Link CRUD API
+- Topology API
+
+### Link Prompt Context (Modified)
+
+- `org_context.md.j2` — Keep the hierarchy rendering (superiors/subordinates/peers). Update the instruction text from "send a message" to "assign a task".
+- `build_org_context()` in `channel.rs` — Keep as-is. It reads link topology and renders the org hierarchy.
+
+### Task System (From `task-tracking` Branch)
+
+- `migrations/20260219000001_tasks.sql` — Schema
+- `src/tasks.rs` + `src/tasks/store.rs` — `TaskStore`, CRUD, status transitions
+- `src/api/tasks.rs` — REST API
+- `src/tools/task_create.rs`, `task_list.rs`, `task_update.rs` — LLM tools
+- `src/agent/cortex.rs` — `spawn_ready_task_loop`, `pickup_one_ready_task`
+
+## New Code Needed
+
+### 1. Cross-Agent Task Creation in `send_agent_message.rs`
+
+Rewrite the tool's `call()` method to create a task instead of injecting a message. Needs a `task_stores: Arc<HashMap<AgentId, Arc<TaskStore>>>` field.
+
+### 2. Task Completion Callback in `cortex.rs`
+
+After `pickup_one_ready_task` marks a task as `Done`, check if `metadata.delegated_by` exists. If so:
+
+1. Log completion in the link channel via `ConversationLogger`
+2. Inject a system message into `metadata.originating_channel` to retrigger the delegating agent
+
+This replaces the entire `bridge_to_initiator` mechanism with ~20 lines of straightforward code.
+
+### 3. Link Channel System Message Logging
+
+A small helper that writes system messages to link channels:
+
+```rust
+fn log_link_event(
+    conversation_logger: &ConversationLogger,
+    link_channel_id: &str,
+    message: &str,
+) {
+    // Persist as a system message (source: "system", role: "system")
+    // Not fed to any LLM — purely for UI display
+}
+```
+
+Called from `send_agent_message` (task created) and from the cortex completion handler (task done/failed).
+
+### 4. `send_agent_message` Tool Description Update
+
+Rewrite `prompts/en/tools/send_agent_message_description.md.j2` to describe task delegation:
+
+> Assign a task to another agent. The target agent's cortex will pick it up and execute it autonomously. Use this when work falls outside your scope or belongs to a subordinate. Your turn ends after delegation — the result will be delivered when the task completes.
+
+## Implementation Order
+
+### Phase 1: Tear Out LLM Conversations
+
+1. Delete `conclude_link.rs`, `link_context.md.j2`, conclude_link prompt text
+2. Remove all link-conversation logic from `channel.rs` (fields, methods, guards)
+3. Remove outbound reply relay from `main.rs`
+4. Remove conclude_link from `tools.rs` registration
+5. Simplify `add_channel_tools()` — drop conclude_link param, simplify delegation target logic
+6. Verify compilation, run tests
+
+### Phase 2: Wire Task Delegation into `send_agent_message`
+
+1. Add `task_stores` registry to `SendAgentMessageTool`
+2. Rewrite `call()` to create a task in the target agent's store
+3. Add link channel system message logging on task creation
+4. Update tool description prompt
+5. Update `org_context.md.j2` wording
+
+### Phase 3: Task Completion Notifications
+
+1. Add `delegated_by` / `originating_channel` metadata checks to cortex task completion handler
+2. Log completion in link channel
+3. Inject retrigger system message into originating channel
+4. Test full delegation round-trip
+
+### Phase 4: UI + Polish
+
+1. Link channel UI shows task timeline instead of conversation
+2. Task board shows delegated tasks with source agent badge
+3. SSE events for delegation activity
+4. Dashboard topology graph shows task flow between agents
+
+## Open Questions
+
+**Per-agent vs instance-level task store**: Should delegated tasks live in the target agent's per-agent SQLite database, or should all tasks move to `instance.db`? Per-agent is cleaner for isolation but requires cross-agent store access. Instance-level is simpler but changes the storage model.
+
+**Task approval for delegated tasks**: Should agent-delegated tasks skip `pending_approval` and go straight to `ready`? The design assumes yes — if Agent A trusts Agent B enough to have a link, the task should execute without human approval. But some deployments might want human-in-the-loop for all delegated work.
+
+**Bidirectional task results**: When Agent B completes a task delegated by Agent A, should A get the full worker output or just a summary? Full output could be large (coding task transcripts). A summary is more practical but loses detail. Could store the full result in task metadata and show a summary in the retrigger message.
+
+**Multi-hop delegation**: Agent A delegates to Agent B, who delegates to Agent C. The completion notification needs to bubble up through all hops. Task metadata can track `delegation_chain: [A, B]` so C's completion notifies B, which notifies A. But this adds complexity — start with single-hop and extend later.
+
+**Task priority inheritance**: Should delegated tasks inherit priority from the delegating agent's context? If the user marked something urgent, the delegated task should probably be `high` priority. The LLM could set this explicitly in the `send_agent_message` call, or it could be inferred.
diff --git a/interface/src/api/client.ts b/interface/src/api/client.ts
index 2683cc1e3..b675dcc20 100644
--- a/interface/src/api/client.ts
+++ b/interface/src/api/client.ts
@@ -566,6 +566,11 @@ export interface BrowserSection {
 	evaluate_enabled: boolean;
 }
 
+export interface SandboxSection {
+	mode: "enabled" | "disabled";
+	writable_paths: string[];
+}
+
 export interface DiscordSection {
 	enabled: boolean;
 	allow_bot_messages: boolean;
@@ -580,6 +585,7 @@ export interface AgentConfigResponse {
 	memory_persistence: MemoryPersistenceSection;
 	browser: BrowserSection;
 	discord: DiscordSection;
+	sandbox: SandboxSection;
 }
 
 // Partial update types - all fields are optional
@@ -642,6 +648,11 @@ export interface BrowserUpdate {
 	evaluate_enabled?: boolean;
 }
 
+export interface SandboxUpdate {
+	mode?: "enabled" | "disabled";
+	writable_paths?: string[];
+}
+
 export interface DiscordUpdate {
 	allow_bot_messages?: boolean;
 }
@@ -656,6 +667,7 @@ export interface AgentConfigUpdateRequest {
 	memory_persistence?: MemoryPersistenceUpdate;
 	browser?: BrowserUpdate;
 	discord?: DiscordUpdate;
+	sandbox?: SandboxUpdate;
 }
 
 // -- Cron Types --
@@ -864,6 +876,72 @@ export interface RegistrySearchResponse {
 	count: number;
 }
 
+// -- Task Types --
+
+export type TaskStatus = "pending_approval" | "backlog" | "ready" | "in_progress" | "done";
+export type TaskPriority = "critical" | "high" | "medium" | "low";
+
+export interface TaskSubtask {
+	title: string;
+	completed: boolean;
+}
+
+export interface TaskItem {
+	id: string;
+	agent_id: string;
+	task_number: number;
+	title: string;
+	description?: string;
+	status: TaskStatus;
+	priority: TaskPriority;
+	subtasks: TaskSubtask[];
+	metadata: Record<string, unknown>;
+	source_memory_id?: string;
+	worker_id?: string;
+	created_by: string;
+	approved_at?: string;
+	approved_by?: string;
+	created_at: string;
+	updated_at: string;
+	completed_at?: string;
+}
+
+export interface TaskListResponse {
+	tasks: TaskItem[];
+}
+
+export interface TaskResponse {
+	task: TaskItem;
+}
+
+export interface TaskActionResponse {
+	success: boolean;
+	message: string;
+}
+
+export interface CreateTaskRequest {
+	title: string;
+	description?: string;
+	status?: TaskStatus;
+	priority?: TaskPriority;
+	subtasks?: TaskSubtask[];
+	metadata?: Record<string, unknown>;
+	source_memory_id?: string;
+	created_by?: string;
+}
+
+export interface UpdateTaskRequest {
+	title?: string;
+	description?: string;
+	status?: TaskStatus;
+	priority?: TaskPriority;
+	subtasks?: TaskSubtask[];
+	metadata?: Record<string, unknown>;
+	complete_subtask?: number;
+	worker_id?: string;
+	approved_by?: string;
+}
+
 // -- Messaging / Bindings Types --
 
 export interface PlatformStatus {
@@ -1710,5 +1788,59 @@ export const api = {
 	webChatHistory: (agentId: string, sessionId: string, limit = 100) =>
 		fetch(`${API_BASE}/webchat/history?agent_id=${encodeURIComponent(agentId)}&session_id=${encodeURIComponent(sessionId)}&limit=${limit}`),
 
+	// Tasks API
+	listTasks: (agentId: string, params?: { status?: TaskStatus; priority?: TaskPriority; limit?: number }) => {
+		const search = new URLSearchParams({ agent_id: agentId });
+		if (params?.status) search.set("status", params.status);
+		if (params?.priority) search.set("priority", params.priority);
+		if (params?.limit) search.set("limit", String(params.limit));
+		return fetchJson<TaskListResponse>(`/agents/tasks?${search}`);
+	},
+	getTask: (agentId: string, taskNumber: number) =>
+		fetchJson<TaskResponse>(`/agents/tasks/${taskNumber}?agent_id=${encodeURIComponent(agentId)}`),
+	createTask: async (agentId: string, request: CreateTaskRequest): Promise<TaskResponse> => {
+		const response = await fetch(`${API_BASE}/agents/tasks`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ ...request, agent_id: agentId }),
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status}`);
+		return response.json() as Promise<TaskResponse>;
+	},
+	updateTask: async (agentId: string, taskNumber: number, request: UpdateTaskRequest): Promise<TaskResponse> => {
+		const response = await fetch(`${API_BASE}/agents/tasks/${taskNumber}`, {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ ...request, agent_id: agentId }),
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status}`);
+		return response.json() as Promise<TaskResponse>;
+	},
+	deleteTask: async (agentId: string, taskNumber: number): Promise<TaskActionResponse> => {
+		const response = await fetch(`${API_BASE}/agents/tasks/${taskNumber}?agent_id=${encodeURIComponent(agentId)}`, {
+			method: "DELETE",
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status}`);
+		return response.json() as Promise<TaskActionResponse>;
+	},
+	approveTask: async (agentId: string, taskNumber: number, approvedBy?: string): Promise<TaskResponse> => {
+		const response = await fetch(`${API_BASE}/agents/tasks/${taskNumber}/approve`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ agent_id: agentId, approved_by: approvedBy }),
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status}`);
+		return response.json() as Promise<TaskResponse>;
+	},
+	executeTask: async (agentId: string, taskNumber: number): Promise<TaskResponse> => {
+		const response = await fetch(`${API_BASE}/agents/tasks/${taskNumber}/execute`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ agent_id: agentId }),
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status}`);
+		return response.json() as Promise<TaskResponse>;
+	},
+
 	eventsUrl: `${API_BASE}/events`,
 };
diff --git a/interface/src/components/AgentTabs.tsx b/interface/src/components/AgentTabs.tsx
index c89ddd61a..1f0aaa8b4 100644
--- a/interface/src/components/AgentTabs.tsx
+++ b/interface/src/components/AgentTabs.tsx
@@ -8,6 +8,7 @@ const tabs = [
 	{ label: "Memories", to: "/agents/$agentId/memories" as const, exact: false },
 	{ label: "Ingest", to: "/agents/$agentId/ingest" as const, exact: false },
 	{ label: "Workers", to: "/agents/$agentId/workers" as const, exact: false },
+	{ label: "Tasks", to: "/agents/$agentId/tasks" as const, exact: false },
 	{ label: "Cortex", to: "/agents/$agentId/cortex" as const, exact: false },
 	{ label: "Skills", to: "/agents/$agentId/skills" as const, exact: false },
 	{ label: "Cron", to: "/agents/$agentId/cron" as const, exact: false },
diff --git a/interface/src/hooks/useLiveContext.tsx b/interface/src/hooks/useLiveContext.tsx
index e64c7a765..edd6989b5 100644
--- a/interface/src/hooks/useLiveContext.tsx
+++ b/interface/src/hooks/useLiveContext.tsx
@@ -16,6 +16,8 @@ interface LiveContextValue {
 	activeWorkers: Record<string, ActiveWorker & { channelId?: string; agentId: string }>;
 	/** Monotonically increasing counter, bumped on every worker lifecycle SSE event. */
 	workerEventVersion: number;
+	/** Monotonically increasing counter, bumped on every task lifecycle SSE event. */
+	taskEventVersion: number;
 	/** Live transcript steps for running workers, keyed by worker_id. Built from SSE tool events. */
 	liveTranscripts: Record<string, TranscriptStep[]>;
 }
@@ -29,6 +31,7 @@ const LiveContext = createContext<LiveContextValue>({
 	activeLinks: new Set(),
 	activeWorkers: {},
 	workerEventVersion: 0,
+	taskEventVersion: 0,
 	liveTranscripts: {},
 });
 
@@ -57,6 +60,9 @@ export function LiveContextProvider({ children }: { children: ReactNode }) {
 	const [workerEventVersion, setWorkerEventVersion] = useState(0);
 	const bumpWorkerVersion = useCallback(() => setWorkerEventVersion((v) => v + 1), []);
 
+	const [taskEventVersion, setTaskEventVersion] = useState(0);
+	const bumpTaskVersion = useCallback(() => setTaskEventVersion((v) => v + 1), []);
+
 	// Live transcript accumulator: builds TranscriptStep[] from SSE tool events
 	// for running workers. Cleared when worker completes.
 	const [liveTranscripts, setLiveTranscripts] = useState<Record<string, TranscriptStep[]>>({});
@@ -211,7 +217,7 @@ export function LiveContextProvider({ children }: { children: ReactNode }) {
 		}
 	}, [channelHandlers, bumpWorkerVersion]);
 
-	// Merge channel handlers with agent message handlers
+	// Merge channel handlers with agent message + task handlers
 	const handlers = useMemo(
 		() => ({
 			...channelHandlers,
@@ -222,8 +228,9 @@ export function LiveContextProvider({ children }: { children: ReactNode }) {
 			tool_completed: wrappedToolCompleted,
 			agent_message_sent: handleAgentMessage,
 			agent_message_received: handleAgentMessage,
+			task_updated: bumpTaskVersion,
 		}),
-		[channelHandlers, wrappedWorkerStarted, wrappedWorkerStatus, wrappedWorkerCompleted, wrappedToolStarted, wrappedToolCompleted, handleAgentMessage],
+		[channelHandlers, wrappedWorkerStarted, wrappedWorkerStatus, wrappedWorkerCompleted, wrappedToolStarted, wrappedToolCompleted, handleAgentMessage, bumpTaskVersion],
 	);
 
 	const onReconnect = useCallback(() => {
@@ -231,7 +238,10 @@ export function LiveContextProvider({ children }: { children: ReactNode }) {
 		queryClient.invalidateQueries({ queryKey: ["channels"] });
 		queryClient.invalidateQueries({ queryKey: ["status"] });
 		queryClient.invalidateQueries({ queryKey: ["agents"] });
-	}, [syncStatusSnapshot, queryClient]);
+		queryClient.invalidateQueries({ queryKey: ["tasks"] });
+		// Bump task version so any mounted task views refetch immediately.
+		bumpTaskVersion();
+	}, [syncStatusSnapshot, queryClient, bumpTaskVersion]);
 
 	const { connectionState } = useEventSource(api.eventsUrl, {
 		handlers,
@@ -242,7 +252,7 @@ export function LiveContextProvider({ children }: { children: ReactNode }) {
 	const hasData = channels.length > 0 || channelsData !== undefined;
 
 	return (
-		<LiveContext.Provider value={{ liveStates, channels, connectionState, hasData, loadOlderMessages, activeLinks, activeWorkers, workerEventVersion, liveTranscripts }}>
+		<LiveContext.Provider value={{ liveStates, channels, connectionState, hasData, loadOlderMessages, activeLinks, activeWorkers, workerEventVersion, taskEventVersion, liveTranscripts }}>
 			{children}
 		</LiveContext.Provider>
 	);
diff --git a/interface/src/router.tsx b/interface/src/router.tsx
index c48ab7593..cc5fb0a9d 100644
--- a/interface/src/router.tsx
+++ b/interface/src/router.tsx
@@ -21,6 +21,7 @@ import {AgentCron} from "@/routes/AgentCron";
 import {AgentIngest} from "@/routes/AgentIngest";
 import {AgentSkills} from "@/routes/AgentSkills";
 import {AgentWorkers} from "@/routes/AgentWorkers";
+import {AgentTasks} from "@/routes/AgentTasks";
 import {AgentChat} from "@/routes/AgentChat";
 import {Settings} from "@/routes/Settings";
 import {useLiveContext} from "@/hooks/useLiveContext";
@@ -204,6 +205,22 @@ const agentWorkersRoute = createRoute({
 	},
 });
 
+const agentTasksRoute = createRoute({
+	getParentRoute: () => rootRoute,
+	path: "/agents/$agentId/tasks",
+	component: function AgentTasksPage() {
+		const {agentId} = agentTasksRoute.useParams();
+		return (
+			<div className="flex h-full flex-col">
+				<AgentHeader agentId={agentId} />
+				<div className="flex-1 overflow-hidden">
+					<AgentTasks agentId={agentId} />
+				</div>
+			</div>
+		);
+	},
+});
+
 const agentCronRoute = createRoute({
 	getParentRoute: () => rootRoute,
 	path: "/agents/$agentId/cron",
@@ -307,6 +324,7 @@ const routeTree = rootRoute.addChildren([
 	agentMemoriesRoute,
 	agentIngestRoute,
 	agentWorkersRoute,
+	agentTasksRoute,
 	agentCortexRoute,
 	agentSkillsRoute,
 	agentCronRoute,
diff --git a/interface/src/routes/AgentConfig.tsx b/interface/src/routes/AgentConfig.tsx
index 8655eb339..0c291c29e 100644
--- a/interface/src/routes/AgentConfig.tsx
+++ b/interface/src/routes/AgentConfig.tsx
@@ -3,6 +3,7 @@ import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { api, type AgentConfigResponse, type AgentConfigUpdateRequest } from "@/api/client";
 import { Button, SettingSidebarButton, Input, TextArea, Toggle, NumberStepper, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, cx } from "@/ui";
 import { ModelSelect } from "@/components/ModelSelect";
+import { TagInput } from "@/components/TagInput";
 import { Markdown } from "@/components/Markdown";
 import { motion, AnimatePresence } from "framer-motion";
 import { useSearch, useNavigate } from "@tanstack/react-router";
@@ -14,7 +15,7 @@ function supportsAdaptiveThinking(modelId: string): boolean {
 		|| id.includes("sonnet-4-6") || id.includes("sonnet-4.6");
 }
 
-type SectionId = "soul" | "identity" | "user" | "routing" | "tuning" | "compaction" | "cortex" | "coalesce" | "memory" | "browser";
+type SectionId = "soul" | "identity" | "user" | "routing" | "tuning" | "compaction" | "cortex" | "coalesce" | "memory" | "browser" | "sandbox";
 
 const SECTIONS: {
 	id: SectionId;
@@ -33,6 +34,7 @@ const SECTIONS: {
 	{ id: "coalesce", label: "Coalesce", group: "config", description: "Message batching", detail: "When multiple messages arrive in quick succession, coalescing batches them into a single LLM turn. This prevents the agent from responding to each message individually in fast-moving conversations." },
 	{ id: "memory", label: "Memory Persistence", group: "config", description: "Auto-save interval", detail: "Spawns a silent background branch at regular intervals to recall existing memories and save new ones from the recent conversation. Runs without blocking the channel." },
 	{ id: "browser", label: "Browser", group: "config", description: "Chrome automation", detail: "Controls browser automation tools available to workers. When enabled, workers can navigate web pages, take screenshots, and interact with sites. JavaScript evaluation is a separate permission." },
+	{ id: "sandbox", label: "Sandbox", group: "config", description: "Process containment", detail: "OS-level filesystem containment for shell and exec tool subprocesses. When enabled, worker processes run inside a kernel-enforced sandbox (bubblewrap on Linux, sandbox-exec on macOS) that makes the entire filesystem read-only except for the workspace and any configured writable paths. On hosted deployments, sandbox mode is always enforced." },
 ];
 
 interface AgentConfigProps {
@@ -62,7 +64,7 @@ export function AgentConfig({ agentId }: AgentConfigProps) {
 	// Sync activeSection with URL search param
 	useEffect(() => {
 		if (search.tab) {
-			const validSections: SectionId[] = ["soul", "identity", "user", "routing", "tuning", "compaction", "cortex", "coalesce", "memory", "browser"];
+			const validSections: SectionId[] = ["soul", "identity", "user", "routing", "tuning", "compaction", "cortex", "coalesce", "memory", "browser", "sandbox"];
 			if (validSections.includes(search.tab as SectionId)) {
 				setActiveSection(search.tab as SectionId);
 			}
@@ -103,9 +105,32 @@ export function AgentConfig({ agentId }: AgentConfigProps) {
 
 	const configMutation = useMutation({
 		mutationFn: (update: AgentConfigUpdateRequest) => api.updateAgentConfig(update),
-		onMutate: () => setSaving(true),
+		onMutate: (update) => {
+			setSaving(true);
+			// Optimistically merge the sent values into the cache so the UI
+			// reflects the change immediately (covers fields the backend
+			// doesn't yet return in its response, like sandbox).
+			const previous = queryClient.getQueryData<AgentConfigResponse>(["agent-config", agentId]);
+			if (previous) {
+				const { agent_id: _, ...sections } = update;
+				const merged = { ...previous } as unknown as Record<string, unknown>;
+				const prev = previous as unknown as Record<string, unknown>;
+				for (const [key, value] of Object.entries(sections)) {
+					if (value !== undefined) {
+						merged[key] = {
+							...(prev[key] as Record<string, unknown> | undefined),
+							...value,
+						};
+					}
+				}
+				queryClient.setQueryData(["agent-config", agentId], merged as unknown as AgentConfigResponse);
+			}
+		},
 		onSuccess: (result) => {
-			queryClient.setQueryData(["agent-config", agentId], result);
+			// Merge server response with cache to preserve fields the backend
+			// doesn't yet return (e.g. sandbox).
+			const previous = queryClient.getQueryData<AgentConfigResponse>(["agent-config", agentId]);
+			queryClient.setQueryData(["agent-config", agentId], { ...previous, ...result });
 			setDirty(false);
 			setSaving(false);
 		},
@@ -384,24 +409,30 @@ interface ConfigSectionEditorProps {
 	onSave: (update: Partial<AgentConfigUpdateRequest>) => void;
 }
 
+const SANDBOX_DEFAULTS = { mode: "enabled" as const, writable_paths: [] as string[] };
+
 function ConfigSectionEditor({ sectionId, label, description, detail, config, onDirtyChange, saveHandlerRef, onSave }: ConfigSectionEditorProps) {
-	const [localValues, setLocalValues] = useState<Record<string, string | number | boolean>>(() => {
+	type ConfigValues = Record<string, string | number | boolean | string[]>;
+	const sandbox = config.sandbox ?? SANDBOX_DEFAULTS;
+	const [localValues, setLocalValues] = useState<ConfigValues>(() => {
 		// Initialize from config based on section
 		switch (sectionId) {
 			case "routing":
-				return { ...config.routing };
+				return { ...config.routing } as ConfigValues;
 			case "tuning":
-				return { ...config.tuning };
+				return { ...config.tuning } as ConfigValues;
 			case "compaction":
-				return { ...config.compaction };
+				return { ...config.compaction } as ConfigValues;
 			case "cortex":
-				return { ...config.cortex };
+				return { ...config.cortex } as ConfigValues;
 			case "coalesce":
-				return { ...config.coalesce };
+				return { ...config.coalesce } as ConfigValues;
 			case "memory":
-				return { ...config.memory_persistence };
+				return { ...config.memory_persistence } as ConfigValues;
 			case "browser":
-				return { ...config.browser };
+				return { ...config.browser } as ConfigValues;
+			case "sandbox":
+				return { mode: sandbox.mode, writable_paths: sandbox.writable_paths } as ConfigValues;
 			default:
 				return {};
 		}
@@ -438,11 +469,14 @@ function ConfigSectionEditor({ sectionId, label, description, detail, config, on
 				case "browser":
 					setLocalValues({ ...config.browser });
 					break;
+				case "sandbox":
+					setLocalValues({ mode: sandbox.mode, writable_paths: sandbox.writable_paths });
+					break;
 			}
 		}
 	}, [config, sectionId, localDirty]);
 
-	const handleChange = useCallback((field: string, value: string | number | boolean) => {
+	const handleChange = useCallback((field: string, value: string | number | boolean | string[]) => {
 		setLocalValues((prev) => ({ ...prev, [field]: value }));
 		setLocalDirty(true);
 	}, []);
@@ -475,6 +509,9 @@ function ConfigSectionEditor({ sectionId, label, description, detail, config, on
 			case "browser":
 				setLocalValues({ ...config.browser });
 				break;
+			case "sandbox":
+				setLocalValues({ mode: sandbox.mode, writable_paths: sandbox.writable_paths });
+				break;
 		}
 		setLocalDirty(false);
 	}, [config, sectionId]);
@@ -785,6 +822,36 @@ function ConfigSectionEditor({ sectionId, label, description, detail, config, on
 						/>
 					</div>
 				);
+			case "sandbox":
+				return (
+					<div className="grid gap-4">
+						<div className="flex flex-col gap-1.5">
+							<label className="text-sm font-medium text-ink">Mode</label>
+							<p className="text-tiny text-ink-faint">Kernel-enforced filesystem containment for shell and exec subprocesses. On hosted deployments this is always enforced regardless of this setting.</p>
+							<Select
+								value={localValues.mode as string}
+								onValueChange={(v) => handleChange("mode", v)}
+							>
+								<SelectTrigger className="border-app-line/50 bg-app-darkBox/30">
+									<SelectValue />
+								</SelectTrigger>
+								<SelectContent>
+									<SelectItem value="enabled">Enabled</SelectItem>
+									<SelectItem value="disabled">Disabled</SelectItem>
+								</SelectContent>
+							</Select>
+						</div>
+						<div className="flex flex-col gap-1.5">
+							<label className="text-sm font-medium text-ink">Writable Paths</label>
+							<p className="text-tiny text-ink-faint">Additional directories workers can write to beyond the workspace. The workspace is always writable. Press Enter to add a path.</p>
+							<TagInput
+								value={(localValues.writable_paths as string[]) ?? []}
+								onChange={(paths) => handleChange("writable_paths", paths)}
+								placeholder="/home/user/projects/myapp"
+							/>
+						</div>
+					</div>
+				);
 			default:
 				return null;
 		}
diff --git a/interface/src/routes/AgentTasks.tsx b/interface/src/routes/AgentTasks.tsx
new file mode 100644
index 000000000..e4d2adc09
--- /dev/null
+++ b/interface/src/routes/AgentTasks.tsx
@@ -0,0 +1,586 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { api, type TaskItem, type TaskStatus, type TaskPriority, type CreateTaskRequest } from "@/api/client";
+import { useLiveContext } from "@/hooks/useLiveContext";
+import { Badge } from "@/ui/Badge";
+import { Button } from "@/ui/Button";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/ui/Dialog";
+import { formatTimeAgo } from "@/lib/format";
+import { AnimatePresence, motion } from "framer-motion";
+
+const COLUMNS: { status: TaskStatus; label: string }[] = [
+	{ status: "pending_approval", label: "Pending Approval" },
+	{ status: "backlog", label: "Backlog" },
+	{ status: "ready", label: "Ready" },
+	{ status: "in_progress", label: "In Progress" },
+	{ status: "done", label: "Done" },
+];
+
+const STATUS_COLORS: Record<TaskStatus, "default" | "amber" | "accent" | "violet" | "green"> = {
+	pending_approval: "amber",
+	backlog: "default",
+	ready: "accent",
+	in_progress: "violet",
+	done: "green",
+};
+
+const PRIORITY_LABELS: Record<TaskPriority, string> = {
+	critical: "Critical",
+	high: "High",
+	medium: "Medium",
+	low: "Low",
+};
+
+const PRIORITY_COLORS: Record<TaskPriority, "red" | "amber" | "default" | "outline"> = {
+	critical: "red",
+	high: "amber",
+	medium: "default",
+	low: "outline",
+};
+
+export function AgentTasks({ agentId }: { agentId: string }) {
+	const queryClient = useQueryClient();
+	const { taskEventVersion } = useLiveContext();
+
+	// Invalidate on SSE task events
+	const prevVersion = useRef(taskEventVersion);
+	useEffect(() => {
+		if (taskEventVersion !== prevVersion.current) {
+			prevVersion.current = taskEventVersion;
+			queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+		}
+	}, [taskEventVersion, agentId, queryClient]);
+
+	const { data, isLoading } = useQuery({
+		queryKey: ["tasks", agentId],
+		queryFn: () => api.listTasks(agentId, { limit: 200 }),
+		refetchInterval: 15_000,
+	});
+
+	const tasks = data?.tasks ?? [];
+
+	// Group tasks by status
+	const tasksByStatus: Record<TaskStatus, TaskItem[]> = {
+		pending_approval: [],
+		backlog: [],
+		ready: [],
+		in_progress: [],
+		done: [],
+	};
+	for (const task of tasks) {
+		tasksByStatus[task.status]?.push(task);
+	}
+
+	// Create task dialog
+	const [createOpen, setCreateOpen] = useState(false);
+	// Detail dialog — store task number and derive from live list to stay current.
+	const [selectedTaskNumber, setSelectedTaskNumber] = useState<number | null>(null);
+	const selectedTask = selectedTaskNumber !== null
+		? tasks.find((t) => t.task_number === selectedTaskNumber) ?? null
+		: null;
+
+	const createMutation = useMutation({
+		mutationFn: (request: CreateTaskRequest) => api.createTask(agentId, request),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+			setCreateOpen(false);
+		},
+	});
+
+	const updateMutation = useMutation({
+		mutationFn: ({ taskNumber, ...request }: { taskNumber: number; status?: TaskStatus; priority?: TaskPriority }) =>
+			api.updateTask(agentId, taskNumber, request),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+		},
+	});
+
+	const approveMutation = useMutation({
+		mutationFn: (taskNumber: number) => api.approveTask(agentId, taskNumber, "human"),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+		},
+	});
+
+	const executeMutation = useMutation({
+		mutationFn: (taskNumber: number) => api.executeTask(agentId, taskNumber),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+		},
+	});
+
+	const deleteMutation = useMutation({
+		mutationFn: (taskNumber: number) => api.deleteTask(agentId, taskNumber),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+			setSelectedTaskNumber(null);
+		},
+	});
+
+	if (isLoading) {
+		return (
+			<div className="flex h-full items-center justify-center text-ink-faint">
+				Loading tasks...
+			</div>
+		);
+	}
+
+	if (tasks.length === 0 && !createOpen) {
+		return (
+			<div className="flex h-full flex-col items-center justify-center gap-4 text-ink-faint">
+				<p className="text-sm">No tasks yet</p>
+				<Button size="sm" onClick={() => setCreateOpen(true)}>
+					Create Task
+				</Button>
+				<CreateTaskDialog
+					open={createOpen}
+					onClose={() => setCreateOpen(false)}
+					onCreate={(request) => createMutation.mutate(request)}
+					isPending={createMutation.isPending}
+				/>
+			</div>
+		);
+	}
+
+	return (
+		<div className="flex h-full flex-col">
+			{/* Toolbar */}
+			<div className="flex items-center justify-between border-b border-app-line px-4 py-2">
+				<div className="flex items-center gap-3">
+					<span className="text-sm text-ink-dull">{tasks.length} task{tasks.length !== 1 ? "s" : ""}</span>
+					{tasksByStatus.pending_approval.length > 0 && (
+						<Badge variant="amber" size="sm">
+							{tasksByStatus.pending_approval.length} pending approval
+						</Badge>
+					)}
+					{tasksByStatus.in_progress.length > 0 && (
+						<Badge variant="violet" size="sm">
+							{tasksByStatus.in_progress.length} in progress
+						</Badge>
+					)}
+				</div>
+				<Button size="sm" onClick={() => setCreateOpen(true)}>
+					Create Task
+				</Button>
+			</div>
+
+			{/* Kanban Board */}
+			<div className="flex flex-1 gap-3 overflow-x-auto p-4">
+				{COLUMNS.map(({ status, label }) => (
+					<KanbanColumn
+						key={status}
+						status={status}
+						label={label}
+						tasks={tasksByStatus[status]}
+						onSelect={(task) => setSelectedTaskNumber(task.task_number)}
+						onApprove={(task) => approveMutation.mutate(task.task_number)}
+						onExecute={(task) => executeMutation.mutate(task.task_number)}
+						onStatusChange={(task, newStatus) =>
+							updateMutation.mutate({ taskNumber: task.task_number, status: newStatus })
+						}
+					/>
+				))}
+			</div>
+
+			{/* Create Dialog */}
+			<CreateTaskDialog
+				open={createOpen}
+				onClose={() => setCreateOpen(false)}
+				onCreate={(request) => createMutation.mutate(request)}
+				isPending={createMutation.isPending}
+			/>
+
+			{/* Detail Dialog */}
+			{selectedTask && (
+				<TaskDetailDialog
+					task={selectedTask}
+					onClose={() => setSelectedTaskNumber(null)}
+					onApprove={() => approveMutation.mutate(selectedTask.task_number)}
+					onExecute={() => executeMutation.mutate(selectedTask.task_number)}
+					onDelete={() => deleteMutation.mutate(selectedTask.task_number)}
+					onStatusChange={(status) =>
+						updateMutation.mutate({ taskNumber: selectedTask.task_number, status })
+					}
+				/>
+			)}
+		</div>
+	);
+}
+
+// -- Kanban Column --
+
+function KanbanColumn({
+	status,
+	label,
+	tasks,
+	onSelect,
+	onApprove,
+	onExecute,
+	onStatusChange,
+}: {
+	status: TaskStatus;
+	label: string;
+	tasks: TaskItem[];
+	onSelect: (task: TaskItem) => void;
+	onApprove: (task: TaskItem) => void;
+	onExecute: (task: TaskItem) => void;
+	onStatusChange: (task: TaskItem, status: TaskStatus) => void;
+}) {
+	return (
+		<div className="flex w-64 min-w-[16rem] flex-col rounded-lg border border-app-line/50 bg-app-darkBox/20">
+			{/* Column Header */}
+			<div className="flex items-center gap-2 border-b border-app-line/30 px-3 py-2">
+				<Badge variant={STATUS_COLORS[status]} size="sm">
+					{label}
+				</Badge>
+				<span className="text-tiny text-ink-faint">{tasks.length}</span>
+			</div>
+
+			{/* Cards */}
+			<div className="flex-1 space-y-2 overflow-y-auto p-2">
+				<AnimatePresence mode="popLayout">
+					{tasks.map((task) => (
+						<TaskCard
+							key={task.id}
+							task={task}
+							onSelect={() => onSelect(task)}
+							onApprove={() => onApprove(task)}
+							onExecute={() => onExecute(task)}
+							onStatusChange={(newStatus) => onStatusChange(task, newStatus)}
+						/>
+					))}
+				</AnimatePresence>
+				{tasks.length === 0 && (
+					<div className="py-4 text-center text-tiny text-ink-faint">
+						No tasks
+					</div>
+				)}
+			</div>
+		</div>
+	);
+}
+
+// -- Task Card --
+
+function TaskCard({
+	task,
+	onSelect,
+	onApprove,
+	onExecute,
+	onStatusChange,
+}: {
+	task: TaskItem;
+	onSelect: () => void;
+	onApprove: () => void;
+	onExecute: () => void;
+	onStatusChange: (status: TaskStatus) => void;
+}) {
+	const subtasksDone = task.subtasks.filter((s) => s.completed).length;
+	const subtasksTotal = task.subtasks.length;
+
+	return (
+		<motion.div
+			layout
+			initial={{ opacity: 0, scale: 0.95 }}
+			animate={{ opacity: 1, scale: 1 }}
+			exit={{ opacity: 0, scale: 0.95 }}
+			transition={{ duration: 0.15 }}
+			className="cursor-pointer rounded-md border border-app-line/30 bg-app p-3 transition-colors hover:border-app-line"
+			onClick={onSelect}
+		>
+			{/* Title row */}
+			<div className="flex items-start justify-between gap-2">
+				<span className="text-sm font-medium text-ink leading-tight">
+					#{task.task_number} {task.title}
+				</span>
+			</div>
+
+			{/* Meta row */}
+			<div className="mt-2 flex flex-wrap items-center gap-1.5">
+				<Badge variant={PRIORITY_COLORS[task.priority]} size="sm">
+					{PRIORITY_LABELS[task.priority]}
+				</Badge>
+				{subtasksTotal > 0 && (
+					<span className="text-tiny text-ink-faint">
+						{subtasksDone}/{subtasksTotal}
+					</span>
+				)}
+				{task.worker_id && (
+					<Badge variant="violet" size="sm">
+						Worker
+					</Badge>
+				)}
+			</div>
+
+			{/* Subtask progress bar */}
+			{subtasksTotal > 0 && (
+				<div className="mt-2 h-1 overflow-hidden rounded-full bg-app-line/30">
+					<div
+						className="h-full rounded-full bg-accent transition-all"
+						style={{ width: `${(subtasksDone / subtasksTotal) * 100}%` }}
+					/>
+				</div>
+			)}
+
+			{/* Quick actions */}
+			<div className="mt-2 flex gap-1" onClick={(e) => e.stopPropagation()}>
+				{task.status === "pending_approval" && (
+					<button
+						className="rounded px-1.5 py-0.5 text-tiny text-accent hover:bg-accent/10"
+						onClick={onApprove}
+					>
+						Approve
+					</button>
+				)}
+				{(task.status === "backlog" || task.status === "pending_approval") && (
+					<button
+						className="rounded px-1.5 py-0.5 text-tiny text-violet-400 hover:bg-violet-400/10"
+						onClick={onExecute}
+					>
+						Execute
+					</button>
+				)}
+				{task.status === "in_progress" && (
+					<button
+						className="rounded px-1.5 py-0.5 text-tiny text-emerald-400 hover:bg-emerald-400/10"
+						onClick={() => onStatusChange("done")}
+					>
+						Mark Done
+					</button>
+				)}
+			</div>
+
+			{/* Footer */}
+			<div className="mt-1.5 text-tiny text-ink-faint">
+				{formatTimeAgo(task.created_at)} by {task.created_by}
+			</div>
+		</motion.div>
+	);
+}
+
+// -- Create Task Dialog --
+
+function CreateTaskDialog({
+	open,
+	onClose,
+	onCreate,
+	isPending,
+}: {
+	open: boolean;
+	onClose: () => void;
+	onCreate: (request: CreateTaskRequest) => void;
+	isPending: boolean;
+}) {
+	const [title, setTitle] = useState("");
+	const [description, setDescription] = useState("");
+	const [priority, setPriority] = useState<TaskPriority>("medium");
+	const [status, setStatus] = useState<TaskStatus>("backlog");
+
+	const handleSubmit = useCallback(() => {
+		if (!title.trim()) return;
+		onCreate({
+			title: title.trim(),
+			description: description.trim() || undefined,
+			priority,
+			status,
+		});
+		setTitle("");
+		setDescription("");
+		setPriority("medium");
+		setStatus("backlog");
+	}, [title, description, priority, status, onCreate]);
+
+	return (
+		<Dialog open={open} onOpenChange={(v) => !v && onClose()}>
+			<DialogContent>
+				<DialogHeader>
+					<DialogTitle>Create Task</DialogTitle>
+				</DialogHeader>
+				<div className="flex flex-col gap-3 py-2">
+					<div>
+						<label className="mb-1 block text-xs text-ink-dull">Title</label>
+						<input
+							className="w-full rounded-md border border-app-line bg-app-darkBox px-3 py-2 text-sm text-ink placeholder:text-ink-faint focus:border-accent focus:outline-none"
+							placeholder="Task title..."
+							value={title}
+							onChange={(e) => setTitle(e.target.value)}
+							onKeyDown={(e) => e.key === "Enter" && handleSubmit()}
+							autoFocus
+						/>
+					</div>
+					<div>
+						<label className="mb-1 block text-xs text-ink-dull">Description</label>
+						<textarea
+							className="w-full rounded-md border border-app-line bg-app-darkBox px-3 py-2 text-sm text-ink placeholder:text-ink-faint focus:border-accent focus:outline-none"
+							placeholder="Optional description..."
+							value={description}
+							onChange={(e) => setDescription(e.target.value)}
+							rows={3}
+						/>
+					</div>
+					<div className="flex gap-4">
+						<div className="flex-1">
+							<label className="mb-1 block text-xs text-ink-dull">Priority</label>
+							<select
+								className="w-full rounded-md border border-app-line bg-app-darkBox px-3 py-2 text-sm text-ink focus:border-accent focus:outline-none"
+								value={priority}
+								onChange={(e) => setPriority(e.target.value as TaskPriority)}
+							>
+								<option value="critical">Critical</option>
+								<option value="high">High</option>
+								<option value="medium">Medium</option>
+								<option value="low">Low</option>
+							</select>
+						</div>
+						<div className="flex-1">
+							<label className="mb-1 block text-xs text-ink-dull">Initial Status</label>
+							<select
+								className="w-full rounded-md border border-app-line bg-app-darkBox px-3 py-2 text-sm text-ink focus:border-accent focus:outline-none"
+								value={status}
+								onChange={(e) => setStatus(e.target.value as TaskStatus)}
+							>
+								<option value="pending_approval">Pending Approval</option>
+								<option value="backlog">Backlog</option>
+								<option value="ready">Ready</option>
+							</select>
+						</div>
+					</div>
+				</div>
+				<DialogFooter>
+					<Button variant="outline" size="sm" onClick={onClose}>
+						Cancel
+					</Button>
+					<Button size="sm" onClick={handleSubmit} disabled={!title.trim() || isPending}>
+						{isPending ? "Creating..." : "Create"}
+					</Button>
+				</DialogFooter>
+			</DialogContent>
+		</Dialog>
+	);
+}
+
+// -- Task Detail Dialog --
+
+function TaskDetailDialog({
+	task,
+	onClose,
+	onApprove,
+	onExecute,
+	onDelete,
+	onStatusChange,
+}: {
+	task: TaskItem;
+	onClose: () => void;
+	onApprove: () => void;
+	onExecute: () => void;
+	onDelete: () => void;
+	onStatusChange: (status: TaskStatus) => void;
+}) {
+	return (
+		<Dialog open={true} onOpenChange={(v) => !v && onClose()}>
+			<DialogContent className="max-w-lg">
+				<DialogHeader>
+					<DialogTitle>
+						#{task.task_number} {task.title}
+					</DialogTitle>
+				</DialogHeader>
+				<div className="flex flex-col gap-3 py-2">
+					{/* Status + Priority */}
+					<div className="flex items-center gap-2">
+						<Badge variant={STATUS_COLORS[task.status]} size="md">
+							{task.status.replace("_", " ")}
+						</Badge>
+						<Badge variant={PRIORITY_COLORS[task.priority]} size="md">
+							{PRIORITY_LABELS[task.priority]}
+						</Badge>
+						{task.worker_id && (
+							<Badge variant="violet" size="md">
+								Worker: {task.worker_id.slice(0, 8)}
+							</Badge>
+						)}
+					</div>
+
+					{/* Description */}
+					{task.description && (
+						<div>
+							<label className="mb-1 block text-xs text-ink-dull">Description</label>
+							<p className="whitespace-pre-wrap text-sm text-ink">{task.description}</p>
+						</div>
+					)}
+
+					{/* Subtasks */}
+					{task.subtasks.length > 0 && (
+						<div>
+							<label className="mb-1 block text-xs text-ink-dull">
+								Subtasks ({task.subtasks.filter((s) => s.completed).length}/{task.subtasks.length})
+							</label>
+							<ul className="space-y-1">
+								{task.subtasks.map((subtask, index) => (
+									<li key={index} className="flex items-center gap-2 text-sm">
+										<span className={subtask.completed ? "text-emerald-400" : "text-ink-faint"}>
+											{subtask.completed ? "[x]" : "[ ]"}
+										</span>
+										<span className={subtask.completed ? "text-ink-dull line-through" : "text-ink"}>
+											{subtask.title}
+										</span>
+									</li>
+								))}
+							</ul>
+						</div>
+					)}
+
+					{/* Metadata */}
+					<div className="grid grid-cols-2 gap-2 text-xs text-ink-dull">
+						<div>Created: {formatTimeAgo(task.created_at)}</div>
+						<div>By: {task.created_by}</div>
+						{task.approved_at && <div>Approved: {formatTimeAgo(task.approved_at)}</div>}
+						{task.approved_by && <div>By: {task.approved_by}</div>}
+						{task.completed_at && <div>Completed: {formatTimeAgo(task.completed_at)}</div>}
+						<div>Updated: {formatTimeAgo(task.updated_at)}</div>
+					</div>
+				</div>
+
+				<DialogFooter>
+					<div className="flex w-full items-center justify-between">
+						<button
+							className="text-xs text-red-400 hover:text-red-300"
+							onClick={onDelete}
+						>
+							Delete
+						</button>
+						<div className="flex gap-2">
+							{task.status === "pending_approval" && (
+								<Button size="sm" onClick={onApprove}>
+									Approve
+								</Button>
+							)}
+							{(task.status === "backlog" || task.status === "pending_approval") && (
+								<Button size="sm" onClick={onExecute}>
+									Execute
+								</Button>
+							)}
+							{task.status === "ready" && (
+								<Badge variant="accent" size="md">
+									Waiting for cortex pickup
+								</Badge>
+							)}
+							{task.status === "in_progress" && (
+								<Button size="sm" onClick={() => onStatusChange("done")}>
+									Mark Done
+								</Button>
+							)}
+							{task.status === "done" && (
+								<Button size="sm" variant="outline" onClick={() => onStatusChange("backlog")}>
+									Reopen
+								</Button>
+							)}
+							<Button size="sm" variant="outline" onClick={onClose}>
+								Close
+							</Button>
+						</div>
+					</div>
+				</DialogFooter>
+			</DialogContent>
+		</Dialog>
+	);
+}
diff --git a/migrations/20260219000001_tasks.sql b/migrations/20260219000001_tasks.sql
new file mode 100644
index 000000000..a969c3831
--- /dev/null
+++ b/migrations/20260219000001_tasks.sql
@@ -0,0 +1,26 @@
+CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL,
+    task_number INTEGER NOT NULL,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'backlog',
+    priority TEXT NOT NULL DEFAULT 'medium',
+    subtasks TEXT,
+    metadata TEXT,
+    source_memory_id TEXT,
+    worker_id TEXT,
+    created_by TEXT NOT NULL,
+    approved_at TIMESTAMP,
+    approved_by TEXT,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    completed_at TIMESTAMP,
+    UNIQUE(agent_id, task_number)
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_number ON tasks(agent_id, task_number);
+CREATE INDEX IF NOT EXISTS idx_tasks_source_memory ON tasks(source_memory_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_worker ON tasks(worker_id);
diff --git a/prompts/en/branch.md.j2 b/prompts/en/branch.md.j2
index c7e3bd7a3..a60d9097f 100644
--- a/prompts/en/branch.md.j2
+++ b/prompts/en/branch.md.j2
@@ -22,6 +22,7 @@ Depending on why the channel branched, you might:
 - **Process complex input** — The user said something that requires analysis. Break it down, think through it, return your understanding.
 - **Spawn a worker** — If the user wants something done *now*, spawn a worker for it. Set a status so the channel knows what's happening. Return a summary of what you kicked off.
 - **Save for later** — If the user mentions something they want to do but not right now ("I need to update the tests at some point", "remind me to check the deploy tomorrow"), save it as a **todo** memory instead of spawning a worker. The difference is timing intent: immediate action = worker, future action = todo.
+- **Manage the task board** — Create, refine, and advance tasks. Tasks are spec documents — the description is a full markdown spec that evolves through conversation. When creating a task, write a rich description and pre-fill subtasks. When the user refines scope, update the description. When ready, move to `ready` and the cortex picks it up automatically.
 
 ## Tools
 
@@ -37,6 +38,15 @@ Forget a memory by ID. Use this when the user wants something removed, or when y
 ### spawn_worker
 If the user wants something done now and it needs execution tools (shell, file, exec), spawn a worker. Give it a specific task description with enough context to work independently. The worker won't have the conversation history — it only knows what you tell it. If the user is describing something for later rather than requesting immediate action, save a **todo** memory instead.
 
+### task_create
+Create a task on the board. The description is a **markdown spec** — write it like instructions for a worker who has no conversation context. Include requirements, constraints, file paths, examples, and anything the executor needs. Always pre-fill subtasks as a checklist execution plan.
+
+### task_list
+List tasks on the board (optionally by status/priority). Use before updates to verify task numbers or current state.
+
+### task_update
+Refine a task. Update the description as the user clarifies scope — append sections, rewrite requirements, adjust subtasks. To execute a task, move it to `ready` and the cortex will pick it up and spawn a worker automatically. You do not need to spawn workers for tasks yourself.
+
 ## Rules
 
 1. Be concise. The channel is going to read your conclusion and use it in a conversation. Don't write an essay. Return the signal, not the process.
diff --git a/prompts/en/channel.md.j2 b/prompts/en/channel.md.j2
index e4aa0a0c3..b4c10b4a3 100644
--- a/prompts/en/channel.md.j2
+++ b/prompts/en/channel.md.j2
@@ -44,11 +44,11 @@ You are able to write code or do work extremely fast inside a worker, never say
 
 You have three paths for getting things done. Choosing the right one matters.
 
-**Branch** — for thinking and memory. Branch when you need to recall, save, or forget something from long-term memory, reason through a complex decision, figure out what instructions to give a worker, or retrieve transcript context from another channel. Branches have your full conversation context and access to the memory system (recall, save, and delete), cross-channel transcript recall (`channel_recall`), and worker transcript inspection (`worker_inspect`). They return a conclusion. You never see the working. Branch often — it's cheap and keeps you responsive.
+**Branch** — for thinking and memory. Branch when you need to recall, save, or forget something from long-term memory, manage the task board (create, list, update, or approve tasks), reason through a complex decision, figure out what instructions to give a worker, or retrieve transcript context from another channel. Branches have your full conversation context and access to the memory system (recall, save, and delete), task tools (`task_create`, `task_list`, `task_update`), cross-channel transcript recall (`channel_recall`), and worker transcript inspection (`worker_inspect`). They return a conclusion. You never see the working. Branch often — it's cheap and keeps you responsive.
 
 Use `worker_inspect` in a branch when you need to verify what a worker actually did — what tools it called, what results it got, what sources it checked. Useful when a worker returns a thin or unexpected result, or when the user asks "what did you actually do?"
 
-**Worker** — for doing. Workers have task tools (see Worker Capabilities section below). They do NOT have your conversation context or access to memories — they only know what you tell them in the task description, so be specific. Two flavors:
+**Worker** — for doing. Workers have execution tools (see Worker Capabilities section below). They do NOT have your conversation context or access to memories — they only know what you tell them in the task description, so be specific. Two flavors:
 
 - _Fire-and-forget_ — bounded tasks with a clear end state. "Run the test suite." "Read src/config.rs and summarize it." The worker does it and reports back.
 - _Interactive_ — open-ended work the user might steer. "Refactor the auth module." "Debug the CI pipeline." The worker stays alive and you route follow-up messages to it when the user gives additional instructions.
@@ -63,6 +63,14 @@ When an interactive worker is active and the user's message is directed at that
 
 **Cancel** — for stopping work. Use `cancel` when a worker is stuck, taking too long, working on the wrong thing, or the user asks you to stop it. You can cancel workers and branches by their ID (visible in the status block and in spawn confirmations). Don't let a runaway worker burn tokens — if something looks wrong, cancel it and start fresh.
 
+## Task Board
+
+You have a kanban task board. Tasks are spec-driven documents — each one has a short title, a full markdown description (the spec), pre-filled subtasks (the execution plan), and a status that moves across the board: `pending_approval` → `backlog` → `ready` → `in_progress` → `done`.
+
+Branch to manage tasks. When the user wants to create, list, update, approve, or check tasks — branch. The branch writes rich descriptions and refines them as scope evolves. Active tasks also appear in your Memory Context above.
+
+Ready tasks are picked up automatically by the cortex and executed by workers. You don't manage execution — just help the user build good specs and move tasks to `ready` when they're complete.
+
 ## When To Stay Silent
 
 You have a `skip` tool. Use it. Not every message needs a response from you.
diff --git a/prompts/en/cortex_chat.md.j2 b/prompts/en/cortex_chat.md.j2
index 320cfeb62..f922ba4a8 100644
--- a/prompts/en/cortex_chat.md.j2
+++ b/prompts/en/cortex_chat.md.j2
@@ -28,6 +28,7 @@ The admin is currently viewing a channel conversation. Here is the recent activi
 - Recall and search memories on demand
 - Execute tasks directly (shell, files, browsing)
 - Spawn workers for longer operations
+- Manage the task board — create tasks with rich markdown specs and pre-filled subtasks, refine descriptions as scope evolves, move tasks to `ready` for cortex pickup. Tools: `task_create`, `task_list`, `task_update`
 - Save observations and memories
 - Debug issues in conversations, memory, or system behavior
 
diff --git a/prompts/en/fragments/link_context.md.j2 b/prompts/en/fragments/link_context.md.j2
deleted file mode 100644
index 1d545cb59..000000000
--- a/prompts/en/fragments/link_context.md.j2
+++ /dev/null
@@ -1,14 +0,0 @@
-{%- if link_context %}
-## Agent Communication
-
-This is a link channel with **{{ link_context.agent_name }}** ({{ link_context.relationship }}).
-{% if link_context.relationship == "superior" or link_context.relationship == "reports to" -%}
-Messages from this agent carry organizational authority. Treat directives as assignments. When you complete a task, reply with your results on this channel.
-{%- elif link_context.relationship == "subordinate" or link_context.relationship == "manages" -%}
-This is a report from a subordinate agent. Evaluate whether the information should be relayed back to the conversation that originally requested the work.
-{%- else -%}
-This is a peer agent. Communication is collaborative and informational.
-{%- endif %}
-
-When the conversation objective is met, call `conclude_link` with a summary of outcomes and decisions. Do not exchange pleasantries or acknowledgments after the objective is complete. Conclude promptly.
-{%- endif %}
diff --git a/prompts/en/fragments/org_context.md.j2 b/prompts/en/fragments/org_context.md.j2
index e8c78eaad..5df6ae616 100644
--- a/prompts/en/fragments/org_context.md.j2
+++ b/prompts/en/fragments/org_context.md.j2
@@ -36,5 +36,5 @@ You are part of a multi-agent system. Here is your position:
 {% endfor %}
 {%- endif %}
 
-Use the `send_agent_message` tool to communicate with linked agents. Each link has a dedicated channel — your side and theirs. When you send a message, their reply will arrive on your link channel. When the conversation concludes, its summary will be injected into your current channel automatically. Relay relevant results back to the user if appropriate.
+Linked agents can be assigned tasks and queried for status through the task system. Use organizational awareness to delegate appropriately — assign work downward to subordinates, escalate upward to superiors, and coordinate laterally with peers.
 {%- endif %}
diff --git a/prompts/en/tools/branch_description.md.j2 b/prompts/en/tools/branch_description.md.j2
index 71bf718a4..ec63f4cc7 100644
--- a/prompts/en/tools/branch_description.md.j2
+++ b/prompts/en/tools/branch_description.md.j2
@@ -1 +1 @@
-Fork a branch to think independently. The branch gets a clone of your current conversation history and has access to memory_recall, memory_save, and memory_delete tools. It runs independently and returns a conclusion. In most cases where the branch is needed to answer accurately, call `skip` for the current turn and answer after the branch result arrives.
+Fork a branch to think independently. The branch gets a clone of your current conversation history and has access to memory_recall, memory_save, memory_delete, task tools (task_create/task_list/task_update), and spawn_worker for execution handoff. It runs independently and returns a conclusion. In most cases where the branch is needed to answer accurately, call `skip` for the current turn and answer after the branch result arrives.
diff --git a/prompts/en/tools/conclude_link_description.md.j2 b/prompts/en/tools/conclude_link_description.md.j2
deleted file mode 100644
index 5e1bd553b..000000000
--- a/prompts/en/tools/conclude_link_description.md.j2
+++ /dev/null
@@ -1 +0,0 @@
-End this link conversation. Call when the conversation objective is complete. Provide a summary of outcomes and decisions — this summary will be delivered to the channel that initiated the conversation.
\ No newline at end of file
diff --git a/prompts/en/tools/task_create_description.md.j2 b/prompts/en/tools/task_create_description.md.j2
new file mode 100644
index 000000000..3c8037374
--- /dev/null
+++ b/prompts/en/tools/task_create_description.md.j2
@@ -0,0 +1 @@
+Create a task on the board. The description is the spec — write it as a full markdown document a worker can execute with no conversation context. Include requirements, constraints, file paths, examples, and acceptance criteria. Always pre-fill subtasks as a checklist execution plan. Short title, rich description, concrete subtasks.
diff --git a/prompts/en/tools/task_list_description.md.j2 b/prompts/en/tools/task_list_description.md.j2
new file mode 100644
index 000000000..2ba670910
--- /dev/null
+++ b/prompts/en/tools/task_list_description.md.j2
@@ -0,0 +1 @@
+List tasks from the board, optionally filtered by status or priority. Use this before task updates when you need to verify a task number or current state.
diff --git a/prompts/en/tools/task_update_description.md.j2 b/prompts/en/tools/task_update_description.md.j2
new file mode 100644
index 000000000..f0ae14380
--- /dev/null
+++ b/prompts/en/tools/task_update_description.md.j2
@@ -0,0 +1 @@
+Update an existing task by task number. Use this to refine the spec as scope evolves — append sections, rewrite requirements, adjust subtasks, change priority. The description is a living document; update it when the user clarifies intent or when you discover new context. Move to `ready` when the spec is complete and the cortex will pick it up for execution. For worker processes, only subtask and metadata updates are allowed.
diff --git a/src/agent/channel.rs b/src/agent/channel.rs
index 7157bbf9d..998af6853 100644
--- a/src/agent/channel.rs
+++ b/src/agent/channel.rs
@@ -151,17 +151,6 @@ pub struct Channel {
     retrigger_deadline: Option<tokio::time::Instant>,
     /// Optional send_agent_message tool (only when agent has active links).
     send_agent_message_tool: Option<crate::tools::SendAgentMessageTool>,
-    /// Turn counter for link channels (used for safety cap).
-    link_turn_count: u32,
-    /// Originating channel that triggered this link conversation (for routing conclusions back).
-    originating_channel: Option<String>,
-    /// Messaging adapter name from the originating channel (e.g. "webchat", "discord").
-    /// Used by `route_link_conclusion` to set the correct `source` on injected messages.
-    originating_source: Option<String>,
-    /// Set after `conclude_link` fires. Prevents the channel from processing
-    /// further messages, stopping the ping-pong that happens when both sides
-    /// keep responding to each other after the task is done.
-    link_concluded: bool,
 }
 
 impl Channel {
@@ -219,25 +208,18 @@ impl Channel {
         // concurrent channels sharing per-turn add/remove cycles.
         let tool_server = ToolServer::new().run();
 
-        // Construct the send_agent_message tool if this agent has links and a messaging manager.
+        // Construct the send_agent_message tool if this agent has links.
         let send_agent_message_tool = {
             let has_links =
                 !crate::links::links_for_agent(&deps.links.load(), &deps.agent_id).is_empty();
-            match (&deps.messaging_manager, has_links) {
-                (Some(mm), true) => Some(crate::tools::SendAgentMessageTool::new(
+            if has_links {
+                Some(crate::tools::SendAgentMessageTool::new(
                     deps.agent_id.clone(),
-                    deps.agent_names
-                        .get(deps.agent_id.as_ref())
-                        .cloned()
-                        .unwrap_or_else(|| deps.agent_id.to_string()),
-                    id.clone(),
                     deps.links.clone(),
-                    mm.clone(),
-                    channel_store.clone(),
-                    deps.event_tx.clone(),
                     deps.agent_names.clone(),
-                )),
-                _ => None,
+                ))
+            } else {
+                None
             }
         };
 
@@ -266,10 +248,6 @@ impl Channel {
             pending_retrigger_metadata: HashMap::new(),
             retrigger_deadline: None,
             send_agent_message_tool,
-            link_turn_count: 0,
-            originating_channel: None,
-            originating_source: None,
-            link_concluded: false,
         };
 
         (channel, message_tx)
@@ -375,12 +353,6 @@ impl Channel {
         if message.source == "system" {
             return false;
         }
-        // Internal link channels are stateful handshakes between two agents.
-        // Coalescing can merge conclusion + follow-up messages into one turn and
-        // bypass per-message guards, so process link messages immediately.
-        if message.conversation_id.starts_with("link:") {
-            return false;
-        }
         if config.multi_user_only && self.is_dm() {
             return false;
         }
@@ -627,14 +599,12 @@ impl Channel {
         }
 
         // Run agent turn with any image/audio attachments preserved
-        let source = messages.first().map(|m| m.source.clone());
-        let (result, skip_flag, replied_flag, _conclude_flag, _conclude_summary) = self
+        let (result, skip_flag, replied_flag) = self
             .run_agent_turn(
                 &combined_text,
                 &system_prompt,
                 &conversation_id,
                 attachment_parts,
-                source,
             )
             .await?;
 
@@ -690,7 +660,6 @@ impl Channel {
         let available_channels = self.build_available_channels().await;
 
         let org_context = self.build_org_context(&prompt_engine);
-        let link_context = self.build_link_context(&prompt_engine);
 
         let empty_to_none = |s: String| if s.is_empty() { None } else { Some(s) };
 
@@ -704,7 +673,6 @@ impl Channel {
             coalesce_hint,
             available_channels,
             org_context,
-            link_context,
         )
     }
 
@@ -743,35 +711,8 @@ impl Channel {
             Vec::new()
         };
 
-        // Emit AgentMessageReceived event for internal agent-to-agent messages
-        if message.source == "internal"
-            && let Some(from_agent_id) = message
-                .metadata
-                .get("from_agent_id")
-                .and_then(|v| v.as_str())
-        {
-            self.deps
-                .event_tx
-                .send(ProcessEvent::AgentMessageReceived {
-                    from_agent_id: Arc::from(from_agent_id),
-                    to_agent_id: self.deps.agent_id.clone(),
-                    link_id: message.conversation_id.clone(),
-                    channel_id: self.id.clone(),
-                })
-                .ok();
-        }
-
         // Persist user messages (skip system re-triggers)
-        let is_link_conclusion = message.metadata.contains_key("link_conclusion");
-        if is_link_conclusion {
-            // Link conclusion messages are internal control messages used to
-            // retrigger the originating channel. Do not persist them to the
-            // visible conversation timeline.
-            tracing::debug!(
-                channel_id = %self.id,
-                "received link conclusion control message"
-            );
-        } else if message.source != "system" {
+        if message.source != "system" {
             let sender_name = message
                 .metadata
                 .get("sender_display_name")
@@ -819,102 +760,6 @@ impl Channel {
             )?);
         }
 
-        // On link channels, seed conversation history with the original outgoing message
-        // so the agent has context for what it previously said when the reply arrives.
-        if message.source == "internal" {
-            // Capture the originating channel and adapter source for routing conclusions back
-            if self.originating_channel.is_none() {
-                self.originating_channel = message
-                    .metadata
-                    .get("originating_channel")
-                    .and_then(|v| v.as_str())
-                    .map(String::from);
-                self.originating_source = message
-                    .metadata
-                    .get("originating_source")
-                    .and_then(|v| v.as_str())
-                    .map(String::from);
-            }
-
-            if let Some(original) = message
-                .metadata
-                .get("original_sent_message")
-                .and_then(|v| v.as_str())
-            {
-                let history = self.state.history.read().await;
-                let is_first_message = history.is_empty();
-                drop(history);
-
-                if is_first_message {
-                    let mut history = self.state.history.write().await;
-                    history.push(rig::message::Message::Assistant {
-                        id: None,
-                        content: rig::OneOrMany::one(rig::message::AssistantContent::text(
-                            original,
-                        )),
-                    });
-                    drop(history);
-
-                    // Persist so the message appears in the dashboard timeline
-                    self.state.conversation_logger.log_bot_message_with_name(
-                        &self.state.channel_id,
-                        original,
-                        Some(self.agent_display_name()),
-                    );
-                }
-            }
-        }
-
-        // Drop messages on concluded link channels
-        let is_link_channel = message.conversation_id.starts_with("link:");
-        if is_link_channel && self.link_concluded {
-            // Late-arriving link conclusions should still cascade up the chain.
-            // This handles races where a parent link concludes before a child
-            // link finishes and reports back.
-            if is_link_conclusion {
-                let summary = message
-                    .metadata
-                    .get("link_conclusion_summary")
-                    .and_then(|value| value.as_str())
-                    .or_else(|| {
-                        raw_text.split_once('\n').and_then(|(header, body)| {
-                            if header.starts_with("[Link conversation with ")
-                                && header.ends_with(" concluded]")
-                            {
-                                Some(body)
-                            } else {
-                                None
-                            }
-                        })
-                    })
-                    .unwrap_or(raw_text.as_str());
-
-                self.route_link_conclusion(summary, &message).await;
-            }
-
-            tracing::debug!(
-                channel_id = %self.id,
-                "dropping message on concluded link channel"
-            );
-            return Ok(());
-        }
-
-        // Track link channel turns for safety cap
-        if is_link_channel && message.source != "system" {
-            self.link_turn_count += 1;
-        }
-
-        // Safety cap: force-conclude link conversations at 20 turns
-        const LINK_MAX_TURNS: u32 = 20;
-        if is_link_channel && self.link_turn_count > LINK_MAX_TURNS {
-            tracing::warn!(
-                channel_id = %self.id,
-                turns = self.link_turn_count,
-                "link conversation hit safety cap, dropping message"
-            );
-            return Ok(());
-        }
-
         let system_prompt = self.build_system_prompt().await?;
 
         {
@@ -924,33 +769,18 @@ impl Channel {
 
         let is_retrigger = message.source == "system";
 
-        let message_source = if is_retrigger {
-            None
-        } else {
-            Some(message.source.clone())
-        };
-
-        let (result, skip_flag, replied_flag, conclude_flag, conclude_summary) = self
+        let (result, skip_flag, replied_flag) = self
             .run_agent_turn(
                 &user_text,
                 &system_prompt,
                 &message.conversation_id,
                 attachment_content,
-                message_source,
             )
             .await?;
 
         self.handle_agent_result(result, &skip_flag, &replied_flag, is_retrigger)
             .await;
 
-        // Handle link conversation conclusion
-        let concluded = conclude_flag.load(std::sync::atomic::Ordering::Relaxed);
-        if concluded {
-            let summary = conclude_summary.read().await.clone().unwrap_or_default();
-            self.route_link_conclusion(&summary, &message).await;
-            self.link_concluded = true;
-        }
-
         // Check context size and trigger compaction if needed
         if let Err(error) = self.compactor.check_and_compact().await {
             tracing::warn!(channel_id = %self.id, %error, "compaction check failed");
@@ -1063,149 +893,6 @@ impl Channel {
         prompt_engine.render_org_context(org_context).ok()
     }
 
-    /// Build link context for the current channel if it's an internal agent-to-agent channel.
-    fn build_link_context(&self, prompt_engine: &crate::prompts::PromptEngine) -> Option<String> {
-        // Link channels have conversation IDs starting with "link:"
-        let conversation_id = self.conversation_id.as_deref()?;
-        if !conversation_id.starts_with("link:") {
-            return None;
-        }
-
-        let agent_id = self.deps.agent_id.as_ref();
-        let all_links = self.deps.links.load();
-
-        // Find the link that matches this agent's side of the link channel
-        let link = all_links
-            .iter()
-            .find(|link| link.channel_id_for(agent_id) == conversation_id)?;
-
-        let is_from = link.from_agent_id == agent_id;
-        let other_agent_id = if is_from {
-            &link.to_agent_id
-        } else {
-            &link.from_agent_id
-        };
-
-        let role = match link.kind {
-            crate::links::LinkKind::Hierarchical if is_from => "manages",
-            crate::links::LinkKind::Hierarchical => "reports to",
-            crate::links::LinkKind::Peer => "peer",
-        };
-
-        let link_context = crate::prompts::engine::LinkContext {
-            agent_name: self
-                .deps
-                .agent_names
-                .get(other_agent_id.as_str())
-                .cloned()
-                .unwrap_or_else(|| other_agent_id.clone()),
-            relationship: role.to_string(),
-        };
-
-        prompt_engine.render_link_context(link_context).ok()
-    }
-
-    /// Route a link conversation conclusion back to the originating channel.
-    ///
-    /// Injects a system message into the channel that originally called
-    /// `send_agent_message`, then stops processing further messages on this
-    /// link channel.
-    async fn route_link_conclusion(&self, summary: &str, last_message: &crate::InboundMessage) {
-        // Derive the peer agent name from the link channel conversation_id
-        let peer_agent = self
-            .conversation_id
-            .as_deref()
-            .and_then(|cid| cid.strip_prefix("link:"))
-            .and_then(|rest| {
-                // Format is "link:{self}:{peer}", skip past self
-                let parts: Vec<&str> = rest.splitn(2, ':').collect();
-                parts.get(1).copied()
-            })
-            .map(|id| {
-                self.deps
-                    .agent_names
-                    .get(id)
-                    .cloned()
-                    .unwrap_or_else(|| id.to_string())
-            })
-            .unwrap_or_else(|| "agent".to_string());
-
-        // Route conclusion to the originating channel (the one that called send_agent_message)
-        if let Some(originating) = &self.originating_channel {
-            if let Some(mm) = &self.deps.messaging_manager {
-                let conclusion_text = format!(
-                    "[Link conversation with {} concluded]\n{}",
-                    peer_agent, summary
-                );
-
-                // Link-to-link conclusions are internal control messages and must
-                // stay on the internal routing path. For non-link destinations,
-                // use the captured adapter source.
-                let source = if originating.starts_with("link:") {
-                    "internal".to_string()
-                } else {
-                    self.originating_source.clone().unwrap_or_else(|| {
-                        originating
-                            .split(':')
-                            .next()
-                            .unwrap_or("webchat")
-                            .to_string()
-                    })
-                };
-
-                let mut metadata = std::collections::HashMap::new();
-                metadata.insert("link_conclusion".into(), serde_json::json!(true));
-                metadata.insert("link_conclusion_summary".into(), serde_json::json!(summary));
-                metadata.insert("link_conclusion_peer".into(), serde_json::json!(peer_agent));
-
-                let conclusion_message = crate::InboundMessage {
-                    id: uuid::Uuid::new_v4().to_string(),
-                    source,
-                    conversation_id: originating.clone(),
-                    sender_id: peer_agent.clone(),
-                    agent_id: Some(self.deps.agent_id.clone()),
-                    content: crate::MessageContent::Text(conclusion_text),
-                    timestamp: chrono::Utc::now(),
-                    metadata,
-                    formatted_author: Some(format!("[{}]", peer_agent)),
-                };
-
-                if let Err(error) = mm.inject_message(conclusion_message).await {
-                    tracing::error!(
-                        %error,
-                        originating_channel = %originating,
-                        "failed to route link conclusion to originating channel"
-                    );
-                } else {
-                    tracing::info!(
-                        originating_channel = %originating,
-                        peer = %peer_agent,
-                        "routed link conclusion to originating channel"
-                    );
-                }
-            }
-        } else {
-            tracing::debug!(
-                channel_id = %self.id,
-                "link conversation concluded but no originating channel to notify"
-            );
-        }
-
-        // Also try to propagate originating_channel via the reply metadata so
-        // the peer's side can also conclude back to the same originating channel
-        if let Some(from_agent) = last_message
-            .metadata
-            .get("from_agent_id")
-            .and_then(|v| v.as_str())
-        {
-            tracing::info!(
-                from = %from_agent,
-                channel_id = %self.id,
-                "link conversation concluded"
-            );
-        }
-    }
-
     /// Assemble the full system prompt using the PromptEngine.
     async fn build_system_prompt(&self) -> crate::error::Result<String> {
         let rc = &self.deps.runtime_config;
@@ -1233,7 +920,6 @@ impl Channel {
         let available_channels = self.build_available_channels().await;
 
         let org_context = self.build_org_context(&prompt_engine);
-        let link_context = self.build_link_context(&prompt_engine);
 
         let empty_to_none = |s: String| if s.is_empty() { None } else { Some(s) };
 
@@ -1247,7 +933,6 @@ impl Channel {
             None, // coalesce_hint - only set for batched messages
             available_channels,
             org_context,
-            link_context,
         )
     }
 
@@ -1255,33 +940,21 @@ impl Channel {
     ///
     /// Returns the prompt result and skip flag for the caller to dispatch.
     #[allow(clippy::type_complexity)]
-    #[tracing::instrument(skip(self, user_text, system_prompt, attachment_content, message_source), fields(channel_id = %self.id, agent_id = %self.deps.agent_id))]
+    #[tracing::instrument(skip(self, user_text, system_prompt, attachment_content), fields(channel_id = %self.id, agent_id = %self.deps.agent_id))]
     async fn run_agent_turn(
         &self,
         user_text: &str,
         system_prompt: &str,
         conversation_id: &str,
         attachment_content: Vec<UserContent>,
-        message_source: Option<String>,
     ) -> Result<(
         std::result::Result<String, rig::completion::PromptError>,
         crate::tools::SkipFlag,
         crate::tools::RepliedFlag,
-        crate::tools::ConcludeLinkFlag,
-        crate::tools::ConcludeLinkSummary,
     )> {
         let skip_flag = crate::tools::new_skip_flag();
         let replied_flag = crate::tools::new_replied_flag();
 
-        // Only provide conclude_link on link channels
-        let is_link_channel = conversation_id.starts_with("link:");
-        let (conclude_flag, conclude_summary) = crate::tools::new_conclude_link();
-        let conclude_link_args = if is_link_channel {
-            Some((conclude_flag.clone(), conclude_summary.clone()))
-        } else {
-            None
-        };
-
         if let Err(error) = crate::tools::add_channel_tools(
             &self.tool_server,
             self.state.clone(),
@@ -1291,10 +964,6 @@ impl Channel {
             replied_flag.clone(),
             self.deps.cron_tool.clone(),
             self.send_agent_message_tool.clone(),
-            conclude_link_args,
-            message_source,
-            self.originating_channel.clone(),
-            self.originating_source.clone(),
         )
         .await
         {
@@ -1383,13 +1052,7 @@ impl Channel {
             tracing::warn!(%error, "failed to remove channel tools");
         }
 
-        Ok((
-            result,
-            skip_flag,
-            replied_flag,
-            conclude_flag,
-            conclude_summary,
-        ))
+        Ok((result, skip_flag, replied_flag))
     }
 
     /// Dispatch the LLM result: send fallback text, log errors, clean up typing.
@@ -1937,11 +1600,13 @@ async fn spawn_branch(
     };
 
     let tool_server = crate::tools::create_branch_tool_server(
+        Some(state.clone()),
+        state.deps.agent_id.clone(),
+        state.deps.task_store.clone(),
         state.deps.memory_search.clone(),
         state.conversation_logger.clone(),
         state.channel_store.clone(),
         crate::conversation::ProcessRunLogger::new(state.deps.sqlite_pool.clone()),
-        &state.deps.agent_id,
     );
     let branch_max_turns = **state.deps.runtime_config.branch_max_turns.load();
 
diff --git a/src/agent/cortex.rs b/src/agent/cortex.rs
index 21d67b4ce..f55917c73 100644
--- a/src/agent/cortex.rs
+++ b/src/agent/cortex.rs
@@ -9,11 +9,13 @@
 //! The cortex also observes system-wide activity via signals for future use in
 //! health monitoring and memory consolidation.
 
+use crate::agent::worker::Worker;
 use crate::error::Result;
 use crate::hooks::CortexHook;
 use crate::llm::SpacebotModel;
 use crate::memory::search::{SearchConfig, SearchMode, SearchSort};
 use crate::memory::types::{Association, MemoryType, RelationType};
+use crate::tasks::{TaskStatus, UpdateTaskInput};
 use crate::{AgentDeps, ProcessEvent, ProcessType};
 
 use rig::agent::AgentBuilder;
@@ -587,9 +589,58 @@ async fn gather_bulletin_sections(deps: &AgentDeps) -> String {
         output.push('\n');
     }
 
+    // Append active tasks (non-done) from the task store.
+    match gather_active_tasks(deps).await {
+        Ok(section) if !section.is_empty() => output.push_str(&section),
+        Err(error) => {
+            tracing::warn!(%error, "failed to gather active tasks for bulletin");
+        }
+        _ => {}
+    }
+
     output
 }
 
+/// Query the task store for non-done tasks and format them as a bulletin section.
+async fn gather_active_tasks(deps: &AgentDeps) -> anyhow::Result<String> {
+    use crate::tasks::TaskStatus;
+
+    let mut all_tasks = Vec::new();
+    for status in &[
+        TaskStatus::InProgress,
+        TaskStatus::Ready,
+        TaskStatus::Backlog,
+        TaskStatus::PendingApproval,
+    ] {
+        let tasks = deps
+            .task_store
+            .list(&deps.agent_id, Some(*status), None, 20)
+            .await?;
+        all_tasks.extend(tasks);
+    }
+
+    if all_tasks.is_empty() {
+        return Ok(String::new());
+    }
+
+    let mut output = String::from("### Active Tasks\n\n");
+    for task in &all_tasks {
+        let subtask_progress = if task.subtasks.is_empty() {
+            String::new()
+        } else {
+            let done = task.subtasks.iter().filter(|s| s.completed).count();
+            format!(" [{}/{}]", done, task.subtasks.len())
+        };
+        output.push_str(&format!(
+            "- #{} [{}] ({}) {}{}\n",
+            task.task_number, task.status, task.priority, task.title, subtask_progress,
+        ));
+    }
+    output.push('\n');
+
+    Ok(output)
+}
+
 /// Generate a memory bulletin and store it in RuntimeConfig.
 ///
 /// Programmatically queries the memory store across multiple dimensions
@@ -935,6 +986,237 @@ pub fn spawn_association_loop(
     })
 }
 
+/// Spawn a background loop that picks up ready tasks when idle.
+pub fn spawn_ready_task_loop(deps: AgentDeps, logger: CortexLogger) -> tokio::task::JoinHandle<()> {
+    tokio::spawn(async move {
+        if let Err(error) = run_ready_task_loop(&deps, &logger).await {
+            tracing::error!(%error, "cortex ready-task loop exited with error");
+        }
+    })
+}
+
+async fn run_ready_task_loop(deps: &AgentDeps, logger: &CortexLogger) -> anyhow::Result<()> {
+    tracing::info!("cortex ready-task loop started");
+
+    // Let startup settle before first pickup attempt.
+    tokio::time::sleep(Duration::from_secs(10)).await;
+
+    loop {
+        let interval = deps.runtime_config.cortex.load().tick_interval_secs;
+        tokio::time::sleep(Duration::from_secs(interval.max(5))).await;
+
+        if let Err(error) = pickup_one_ready_task(deps, logger).await {
+            tracing::warn!(%error, "ready-task pickup pass failed");
+        }
+    }
+}
+
+async fn pickup_one_ready_task(deps: &AgentDeps, logger: &CortexLogger) -> anyhow::Result<()> {
+    let Some(task) = deps.task_store.claim_next_ready(&deps.agent_id).await? else {
+        return Ok(());
+    };
+
+    logger.log(
+        "task_pickup_started",
+        &format!("Picked up ready task #{}", task.task_number),
+        Some(serde_json::json!({
+            "task_number": task.task_number,
+            "title": task.title,
+        })),
+    );
+
+    let prompt_engine = deps.runtime_config.prompts.load();
+    let worker_system_prompt = prompt_engine
+        .render_worker_prompt(
+            &deps.runtime_config.instance_dir.display().to_string(),
+            &deps.runtime_config.workspace_dir.display().to_string(),
+        )
+        .map_err(|error| anyhow::anyhow!("failed to render worker prompt: {error}"))?;
+
+    let mut task_prompt = format!("Execute task #{}: {}", task.task_number, task.title);
+    if let Some(description) = &task.description {
+        task_prompt.push_str("\n\nDescription:\n");
+        task_prompt.push_str(description);
+    }
+    if !task.subtasks.is_empty() {
+        task_prompt.push_str("\n\nSubtasks:\n");
+        for (index, subtask) in task.subtasks.iter().enumerate() {
+            let marker = if subtask.completed { "[x]" } else { "[ ]" };
+            task_prompt.push_str(&format!("{}. {} {}\n", index + 1, marker, subtask.title));
+        }
+    }
+
+    let screenshot_dir = deps
+        .runtime_config
+        .workspace_dir
+        .join(".spacebot")
+        .join("screenshots");
+    let logs_dir = deps
+        .runtime_config
+        .workspace_dir
+        .join(".spacebot")
+        .join("logs");
+    if let Err(error) = std::fs::create_dir_all(&screenshot_dir) {
+        tracing::warn!(%error, path = %screenshot_dir.display(), "failed to create screenshot directory");
+    }
+    if let Err(error) = std::fs::create_dir_all(&logs_dir) {
+        tracing::warn!(%error, path = %logs_dir.display(), "failed to create logs directory");
+    }
+
+    let browser_config = (**deps.runtime_config.browser_config.load()).clone();
+    let brave_search_key = (**deps.runtime_config.brave_search_key.load()).clone();
+    let worker = Worker::new(
+        None,
+        task_prompt,
+        worker_system_prompt,
+        deps.clone(),
+        browser_config,
+        screenshot_dir,
+        brave_search_key,
+        logs_dir,
+    );
+
+    let worker_id = worker.id;
+    deps.task_store
+        .update(
+            &deps.agent_id,
+            task.task_number,
+            UpdateTaskInput {
+                worker_id: Some(worker_id.to_string()),
+                ..Default::default()
+            },
+        )
+        .await?;
+
+    let _ = deps.event_tx.send(ProcessEvent::TaskUpdated {
+        agent_id: deps.agent_id.clone(),
+        task_number: task.task_number,
+        status: "in_progress".to_string(),
+        action: "updated".to_string(),
+    });
+
+    let task_description = format!("task #{}: {}", task.task_number, task.title);
+
+    let _ = deps.event_tx.send(ProcessEvent::WorkerStarted {
+        agent_id: deps.agent_id.clone(),
+        worker_id,
+        channel_id: None,
+        task: task_description.clone(),
+        worker_type: "task".to_string(),
+    });
+
+    // Log to worker_runs directly — task workers have no parent channel, so the
+    // channel event handler won't persist them.
+    let run_logger = crate::conversation::history::ProcessRunLogger::new(deps.sqlite_pool.clone());
+    run_logger.log_worker_started(None, worker_id, &task_description, "task", &deps.agent_id);
+
+    let task_store = deps.task_store.clone();
+    let agent_id = deps.agent_id.to_string();
+    let event_tx = deps.event_tx.clone();
+    let logger = logger.clone();
+    tokio::spawn(async move {
+        match worker.run().await {
+            Ok(result_text) => {
+                let db_updated = task_store
+                    .update(
+                        &agent_id,
+                        task.task_number,
+                        UpdateTaskInput {
+                            status: Some(TaskStatus::Done),
+                            ..Default::default()
+                        },
+                    )
+                    .await;
+
+                if let Err(ref error) = db_updated {
+                    tracing::warn!(%error, task_number = task.task_number, "failed to mark picked-up task done");
+                }
+
+                run_logger.log_worker_completed(worker_id, &result_text, true);
+
+                // Only emit task SSE event if the DB write succeeded.
+                if db_updated.is_ok() {
+                    let _ = event_tx.send(ProcessEvent::TaskUpdated {
+                        agent_id: Arc::from(agent_id.as_str()),
+                        task_number: task.task_number,
+                        status: "done".to_string(),
+                        action: "updated".to_string(),
+                    });
+                }
+
+                logger.log(
+                    "task_pickup_completed",
+                    &format!("Completed picked-up task #{}", task.task_number),
+                    Some(serde_json::json!({
+                        "task_number": task.task_number,
+                        "worker_id": worker_id.to_string(),
+                    })),
+                );
+
+                let _ = event_tx.send(ProcessEvent::WorkerComplete {
+                    agent_id: Arc::from(agent_id.as_str()),
+                    worker_id,
+                    channel_id: None,
+                    result: result_text,
+                    notify: true,
+                    success: true,
+                });
+            }
+            Err(error) => {
+                let error_message = format!("Worker failed: {error}");
+                run_logger.log_worker_completed(worker_id, &error_message, false);
+
+                let requeue_result = task_store
+                    .update(
+                        &agent_id,
+                        task.task_number,
+                        UpdateTaskInput {
+                            status: Some(TaskStatus::Ready),
+                            clear_worker_id: true,
+                            ..Default::default()
+                        },
+                    )
+                    .await;
+
+                if let Err(ref update_error) = requeue_result {
+                    tracing::warn!(%update_error, task_number = task.task_number, "failed to return task to ready after failure");
+                }
+
+                // Only emit task SSE event if the DB write succeeded.
+                if requeue_result.is_ok() {
+                    let _ = event_tx.send(ProcessEvent::TaskUpdated {
+                        agent_id: Arc::from(agent_id.as_str()),
+                        task_number: task.task_number,
+                        status: "ready".to_string(),
+                        action: "updated".to_string(),
+                    });
+                }
+
+                logger.log(
+                    "task_pickup_failed",
+                    &format!("Picked-up task #{} failed: {error}", task.task_number),
+                    Some(serde_json::json!({
+                        "task_number": task.task_number,
+                        "worker_id": worker_id.to_string(),
+                        "error": error.to_string(),
+                    })),
+                );
+
+                let _ = event_tx.send(ProcessEvent::WorkerComplete {
+                    agent_id: Arc::from(agent_id.as_str()),
+                    worker_id,
+                    channel_id: None,
+                    result: format!("Worker failed: {error}"),
+                    notify: true,
+                    success: false,
+                });
+            }
+        }
+    });
+
+    Ok(())
+}
+
 async fn run_association_loop(deps: &AgentDeps, logger: &CortexLogger) -> anyhow::Result<()> {
     tracing::info!("cortex association loop started");
 
diff --git a/src/agent/ingestion.rs b/src/agent/ingestion.rs
index cdfa77844..cc407d5f5 100644
--- a/src/agent/ingestion.rs
+++ b/src/agent/ingestion.rs
@@ -472,11 +472,13 @@ async fn process_chunk(
         crate::conversation::history::ConversationLogger::new(deps.sqlite_pool.clone());
     let channel_store = crate::conversation::ChannelStore::new(deps.sqlite_pool.clone());
     let tool_server: ToolServerHandle = crate::tools::create_branch_tool_server(
+        None,
+        deps.agent_id.clone(),
+        deps.task_store.clone(),
         deps.memory_search.clone(),
         conversation_logger,
         channel_store,
         crate::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone()),
-        &deps.agent_id,
     );
 
     let agent = AgentBuilder::new(model)
diff --git a/src/agent/worker.rs b/src/agent/worker.rs
index 097753b3e..90c6e2e89 100644
--- a/src/agent/worker.rs
+++ b/src/agent/worker.rs
@@ -197,6 +197,7 @@ impl Worker {
             self.deps.agent_id.clone(),
             self.id,
             self.channel_id.clone(),
+            self.deps.task_store.clone(),
             self.deps.event_tx.clone(),
             self.browser_config.clone(),
             self.screenshot_dir.clone(),
diff --git a/src/api.rs b/src/api.rs
index 3c4d38170..4a69dc2e9 100644
--- a/src/api.rs
+++ b/src/api.rs
@@ -22,6 +22,7 @@ mod settings;
 mod skills;
 mod state;
 mod system;
+mod tasks;
 mod webchat;
 mod workers;
 
diff --git a/src/api/agents.rs b/src/api/agents.rs
index 154fe6d5d..9a460675c 100644
--- a/src/api/agents.rs
+++ b/src/api/agents.rs
@@ -361,6 +361,7 @@ pub(super) async fn trigger_warmup(
     let mcp_managers = state.mcp_managers.load();
     let pools = state.agent_pools.load();
     let sandboxes = state.sandboxes.load();
+    let task_stores = state.task_stores.load();
 
     let runtime_config_ids = runtime_configs.keys().cloned().collect::<HashSet<_>>();
     let memory_search_ids = memory_searches.keys().cloned().collect::<HashSet<_>>();
@@ -391,6 +392,10 @@ pub(super) async fn trigger_warmup(
         let Some(sandbox) = sandboxes.get(agent_id).cloned() else {
             continue;
         };
+        let task_store = task_stores
+            .get(agent_id)
+            .cloned()
+            .unwrap_or_else(|| Arc::new(crate::tasks::TaskStore::new(sqlite_pool.clone())));
 
         let llm_manager = llm_manager.clone();
         let force = request.force;
@@ -408,6 +413,7 @@ pub(super) async fn trigger_warmup(
                 sqlite_pool: sqlite_pool.clone(),
                 messaging_manager: None,
                 sandbox,
+                task_store,
                 links: Arc::new(arc_swap::ArcSwap::from_pointee(Vec::new())),
                 agent_names: Arc::new(std::collections::HashMap::new()),
             };
@@ -592,6 +598,7 @@ pub(super) async fn create_agent(
         embedding_table,
         embedding_model,
     ));
+    let task_store = std::sync::Arc::new(crate::tasks::TaskStore::new(db.sqlite.clone()));
 
     let (event_tx, _) = tokio::sync::broadcast::channel(256);
     let arc_agent_id: crate::AgentId = std::sync::Arc::from(agent_id.as_str());
@@ -669,6 +676,7 @@ pub(super) async fn create_agent(
         memory_search: memory_search.clone(),
         llm_manager,
         mcp_manager: mcp_manager.clone(),
+        task_store: task_store.clone(),
         cron_tool: None,
         runtime_config: runtime_config.clone(),
         event_tx: event_tx.clone(),
@@ -732,11 +740,12 @@ pub(super) async fn create_agent(
     let channel_store = crate::conversation::ChannelStore::new(db.sqlite.clone());
     let run_logger = crate::conversation::ProcessRunLogger::new(db.sqlite.clone());
     let cortex_tool_server = crate::tools::create_cortex_chat_tool_server(
+        deps.agent_id.clone(),
+        deps.task_store.clone(),
         memory_search.clone(),
         conversation_logger,
         channel_store,
         run_logger,
-        &deps.agent_id,
         browser_config,
         agent_config.screenshot_dir(),
         brave_search_key,
@@ -756,6 +765,10 @@ pub(super) async fn create_agent(
         crate::agent::cortex::spawn_bulletin_loop(deps.clone(), cortex_logger.clone());
     let _association_loop =
         crate::agent::cortex::spawn_association_loop(deps.clone(), cortex_logger);
+    crate::agent::cortex::spawn_ready_task_loop(
+        deps.clone(),
+        crate::agent::cortex::CortexLogger::new(db.sqlite.clone()),
+    );
 
     let ingestion_config = **runtime_config.ingestion.load();
     if ingestion_config.enabled {
@@ -784,6 +797,10 @@ pub(super) async fn create_agent(
         searches.insert(agent_id.clone(), memory_search);
         state.memory_searches.store(std::sync::Arc::new(searches));
 
+        let mut task_stores = (**state.task_stores.load()).clone();
+        task_stores.insert(agent_id.clone(), task_store);
+        state.task_stores.store(std::sync::Arc::new(task_stores));
+
         let mut workspaces = (**state.agent_workspaces.load()).clone();
         workspaces.insert(agent_id.clone(), agent_config.workspace.clone());
         state
diff --git a/src/api/config.rs b/src/api/config.rs
index f4546d605..e2c7c595e 100644
--- a/src/api/config.rs
+++ b/src/api/config.rs
@@ -75,6 +75,12 @@ pub(super) struct BrowserSection {
     evaluate_enabled: bool,
 }
 
+#[derive(Serialize, Debug)]
+pub(super) struct SandboxSection {
+    mode: String,
+    writable_paths: Vec<String>,
+}
+
 #[derive(Serialize, Debug)]
 pub(super) struct DiscordSection {
     enabled: bool,
@@ -91,6 +97,7 @@ pub(super) struct AgentConfigResponse {
     coalesce: CoalesceSection,
     memory_persistence: MemoryPersistenceSection,
     browser: BrowserSection,
+    sandbox: SandboxSection,
     discord: DiscordSection,
 }
 
@@ -119,6 +126,8 @@ pub(super) struct AgentConfigUpdateRequest {
     #[serde(default)]
     browser: Option<BrowserUpdate>,
     #[serde(default)]
+    sandbox: Option<SandboxUpdate>,
+    #[serde(default)]
     discord: Option<DiscordUpdate>,
 }
 
@@ -191,6 +200,12 @@ pub(super) struct BrowserUpdate {
     evaluate_enabled: Option<bool>,
 }
 
+#[derive(Deserialize, Debug)]
+pub(super) struct SandboxUpdate {
+    mode: Option<String>,
+    writable_paths: Option<Vec<String>>,
+}
+
 #[derive(Deserialize, Debug)]
 pub(super) struct DiscordUpdate {
     allow_bot_messages: Option<bool>,
@@ -214,6 +229,7 @@ pub(super) async fn get_agent_config(
     let coalesce = rc.coalesce.load();
     let memory_persistence = rc.memory_persistence.load();
     let browser = rc.browser_config.load();
+    let sandbox = rc.sandbox.load();
 
     let response = AgentConfigResponse {
         routing: RoutingSection {
@@ -269,6 +285,17 @@ pub(super) async fn get_agent_config(
             headless: browser.headless,
             evaluate_enabled: browser.evaluate_enabled,
         },
+        sandbox: SandboxSection {
+            mode: match sandbox.mode {
+                crate::sandbox::SandboxMode::Enabled => "enabled".to_string(),
+                crate::sandbox::SandboxMode::Disabled => "disabled".to_string(),
+            },
+            writable_paths: sandbox
+                .writable_paths
+                .iter()
+                .map(|p| p.display().to_string())
+                .collect(),
+        },
         discord: {
             let perms = state.discord_permissions.read().await;
             match perms.as_ref() {
@@ -342,6 +369,9 @@ pub(super) async fn update_agent_config(
     if let Some(browser) = &request.browser {
         update_browser_table(&mut doc, agent_idx, browser)?;
     }
+    if let Some(sandbox) = &request.sandbox {
+        update_sandbox_table(&mut doc, agent_idx, sandbox)?;
+    }
     if let Some(discord) = &request.discord {
         update_discord_table(&mut doc, discord)?;
     }
@@ -638,6 +668,26 @@ fn update_browser_table(
     Ok(())
 }
 
+fn update_sandbox_table(
+    doc: &mut toml_edit::DocumentMut,
+    agent_idx: usize,
+    sandbox: &SandboxUpdate,
+) -> Result<(), StatusCode> {
+    let agent = get_agent_table_mut(doc, agent_idx)?;
+    let table = get_or_create_subtable(agent, "sandbox")?;
+    if let Some(ref mode) = sandbox.mode {
+        table["mode"] = toml_edit::value(mode.as_str());
+    }
+    if let Some(ref paths) = sandbox.writable_paths {
+        let mut array = toml_edit::Array::new();
+        for path in paths {
+            array.push(path.as_str());
+        }
+        table["writable_paths"] = toml_edit::value(array);
+    }
+    Ok(())
+}
+
 /// Update instance-level Discord config at [messaging.discord].
 fn update_discord_table(
     doc: &mut toml_edit::DocumentMut,
diff --git a/src/api/server.rs b/src/api/server.rs
index 6e0c248c4..669dff17d 100644
--- a/src/api/server.rs
+++ b/src/api/server.rs
@@ -3,7 +3,7 @@
 use super::state::ApiState;
 use super::{
     agents, bindings, channels, config, cortex, cron, ingest, links, mcp, memories, messaging,
-    models, providers, settings, skills, system, webchat, workers,
+    models, providers, settings, skills, system, tasks, webchat, workers,
 };
 
 use axum::Json;
@@ -118,6 +118,18 @@ pub async fn start_http_server(
         .route("/agents/cron/executions", get(cron::cron_executions))
         .route("/agents/cron/trigger", post(cron::trigger_cron))
         .route("/agents/cron/toggle", put(cron::toggle_cron))
+        .route(
+            "/agents/tasks",
+            get(tasks::list_tasks).post(tasks::create_task),
+        )
+        .route(
+            "/agents/tasks/{number}",
+            get(tasks::get_task)
+                .put(tasks::update_task)
+                .delete(tasks::delete_task),
+        )
+        .route("/agents/tasks/{number}/approve", post(tasks::approve_task))
+        .route("/agents/tasks/{number}/execute", post(tasks::execute_task))
         .route("/channels/cancel", post(channels::cancel_process))
         .route(
             "/agents/ingest/files",
diff --git a/src/api/state.rs b/src/api/state.rs
index 0b4408480..75f00d821 100644
--- a/src/api/state.rs
+++ b/src/api/state.rs
@@ -11,6 +11,7 @@ use crate::memory::{EmbeddingModel, MemorySearch};
 use crate::messaging::MessagingManager;
 use crate::messaging::webchat::WebChatAdapter;
 use crate::prompts::PromptEngine;
+use crate::tasks::TaskStore;
 use crate::update::SharedUpdateStatus;
 use crate::{ProcessEvent, ProcessId};
 
@@ -65,6 +66,8 @@ pub struct ApiState {
     pub cron_stores: arc_swap::ArcSwap<HashMap<String, Arc<CronStore>>>,
     /// Per-agent cron schedulers for job timer management.
     pub cron_schedulers: arc_swap::ArcSwap<HashMap<String, Arc<Scheduler>>>,
+    /// Per-agent task stores for task CRUD operations.
+    pub task_stores: arc_swap::ArcSwap<HashMap<String, Arc<TaskStore>>>,
     /// Per-agent RuntimeConfig for reading live hot-reloaded configuration.
     pub runtime_configs: ArcSwap<HashMap<String, Arc<RuntimeConfig>>>,
     /// Per-agent MCP managers for status and reconnect APIs.
@@ -202,6 +205,14 @@ pub enum ApiEvent {
         link_id: String,
         channel_id: String,
     },
+    /// A task was created, updated, or deleted.
+    TaskUpdated {
+        agent_id: String,
+        task_number: i64,
+        status: String,
+        /// "created", "updated", or "deleted".
+        action: String,
+    },
 }
 
 impl ApiState {
@@ -225,6 +236,7 @@ impl ApiState {
             config_path: RwLock::new(PathBuf::new()),
             cron_stores: arc_swap::ArcSwap::from_pointee(HashMap::new()),
             cron_schedulers: arc_swap::ArcSwap::from_pointee(HashMap::new()),
+            task_stores: arc_swap::ArcSwap::from_pointee(HashMap::new()),
             runtime_configs: ArcSwap::from_pointee(HashMap::new()),
             mcp_managers: ArcSwap::from_pointee(HashMap::new()),
             sandboxes: ArcSwap::from_pointee(HashMap::new()),
@@ -438,6 +450,21 @@ impl ApiState {
                                     })
                                     .ok();
                             }
+                            ProcessEvent::TaskUpdated {
+                                task_number,
+                                status,
+                                action,
+                                ..
+                            } => {
+                                api_tx
+                                    .send(ApiEvent::TaskUpdated {
+                                        agent_id: agent_id.clone(),
+                                        task_number: *task_number,
+                                        status: status.clone(),
+                                        action: action.clone(),
+                                    })
+                                    .ok();
+                            }
                             _ => {}
                         }
                     }
@@ -491,6 +518,11 @@ impl ApiState {
         self.cron_schedulers.store(Arc::new(schedulers));
     }
 
+    /// Set the task stores for all agents.
+    pub fn set_task_stores(&self, stores: HashMap<String, Arc<TaskStore>>) {
+        self.task_stores.store(Arc::new(stores));
+    }
+
     /// Set the runtime configs for all agents.
     pub fn set_runtime_configs(&self, configs: HashMap<String, Arc<RuntimeConfig>>) {
         self.runtime_configs.store(Arc::new(configs));
diff --git a/src/api/system.rs b/src/api/system.rs
index d56f2ae51..cf79b90a2 100644
--- a/src/api/system.rs
+++ b/src/api/system.rs
@@ -95,6 +95,7 @@ pub(super) async fn events_sse(
                             ApiEvent::ConfigReloaded => "config_reloaded",
                             ApiEvent::AgentMessageSent { .. } => "agent_message_sent",
                             ApiEvent::AgentMessageReceived { .. } => "agent_message_received",
+                            ApiEvent::TaskUpdated { .. } => "task_updated",
                         };
                         yield Ok(axum::response::sse::Event::default()
                             .event(event_type)
diff --git a/src/api/tasks.rs b/src/api/tasks.rs
new file mode 100644
index 000000000..d496c0441
--- /dev/null
+++ b/src/api/tasks.rs
@@ -0,0 +1,375 @@
+use super::state::ApiState;
+
+use axum::Json;
+use axum::extract::{Path, Query, State};
+use axum::http::StatusCode;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Deserialize)]
+pub(super) struct TaskListQuery {
+    agent_id: String,
+    #[serde(default)]
+    status: Option<String>,
+    #[serde(default)]
+    priority: Option<String>,
+    #[serde(default = "default_task_limit")]
+    limit: i64,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TaskGetQuery {
+    agent_id: String,
+}
+
+#[derive(Deserialize)]
+pub(super) struct CreateTaskRequest {
+    agent_id: String,
+    title: String,
+    #[serde(default)]
+    description: Option<String>,
+    #[serde(default)]
+    status: Option<String>,
+    #[serde(default)]
+    priority: Option<String>,
+    #[serde(default)]
+    subtasks: Vec<crate::tasks::TaskSubtask>,
+    #[serde(default)]
+    metadata: Option<serde_json::Value>,
+    #[serde(default)]
+    source_memory_id: Option<String>,
+    #[serde(default)]
+    created_by: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct UpdateTaskRequest {
+    agent_id: String,
+    #[serde(default)]
+    title: Option<String>,
+    #[serde(default)]
+    description: Option<String>,
+    #[serde(default)]
+    status: Option<String>,
+    #[serde(default)]
+    priority: Option<String>,
+    #[serde(default)]
+    subtasks: Option<Vec<crate::tasks::TaskSubtask>>,
+    #[serde(default)]
+    metadata: Option<serde_json::Value>,
+    #[serde(default)]
+    complete_subtask: Option<usize>,
+    #[serde(default)]
+    worker_id: Option<String>,
+    #[serde(default)]
+    approved_by: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct DeleteTaskQuery {
+    agent_id: String,
+}
+
+#[derive(Serialize)]
+pub(super) struct TaskListResponse {
+    tasks: Vec<crate::tasks::Task>,
+}
+
+#[derive(Serialize)]
+pub(super) struct TaskResponse {
+    task: crate::tasks::Task,
+}
+
+#[derive(Serialize)]
+pub(super) struct TaskActionResponse {
+    success: bool,
+    message: String,
+}
+
+fn default_task_limit() -> i64 {
+    20
+}
+
+pub(super) async fn list_tasks(
+    State(state): State<Arc<ApiState>>,
+    Query(query): Query<TaskListQuery>,
+) -> Result<Json<TaskListResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&query.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let status = match query.status.as_deref() {
+        None => None,
+        Some(value) => Some(crate::tasks::TaskStatus::parse(value).ok_or(StatusCode::BAD_REQUEST)?),
+    };
+    let priority = match query.priority.as_deref() {
+        None => None,
+        Some(value) => {
+            Some(crate::tasks::TaskPriority::parse(value).ok_or(StatusCode::BAD_REQUEST)?)
+        }
+    };
+
+    let tasks = store
+        .list(&query.agent_id, status, priority, query.limit.clamp(1, 500))
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %query.agent_id, "failed to list tasks");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    Ok(Json(TaskListResponse { tasks }))
+}
+
+pub(super) async fn get_task(
+    State(state): State<Arc<ApiState>>,
+    Path(number): Path<i64>,
+    Query(query): Query<TaskGetQuery>,
+) -> Result<Json<TaskResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&query.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let task = store
+        .get_by_number(&query.agent_id, number)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %query.agent_id, task_number = number, "failed to get task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    Ok(Json(TaskResponse { task }))
+}
+
+pub(super) async fn create_task(
+    State(state): State<Arc<ApiState>>,
+    Json(request): Json<CreateTaskRequest>,
+) -> Result<Json<TaskResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let status = match request.status.as_deref() {
+        None => crate::tasks::TaskStatus::Backlog,
+        Some(value) => crate::tasks::TaskStatus::parse(value).ok_or(StatusCode::BAD_REQUEST)?,
+    };
+    let priority = match request.priority.as_deref() {
+        None => crate::tasks::TaskPriority::Medium,
+        Some(value) => crate::tasks::TaskPriority::parse(value).ok_or(StatusCode::BAD_REQUEST)?,
+    };
+
+    let task = store
+        .create(crate::tasks::CreateTaskInput {
+            agent_id: request.agent_id.clone(),
+            title: request.title,
+            description: request.description,
+            status,
+            priority,
+            subtasks: request.subtasks,
+            metadata: request.metadata.unwrap_or_else(|| serde_json::json!({})),
+            source_memory_id: request.source_memory_id,
+            created_by: request.created_by.unwrap_or_else(|| "human".to_string()),
+        })
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, "failed to create task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    state
+        .event_tx
+        .send(super::state::ApiEvent::TaskUpdated {
+            agent_id: task.agent_id.clone(),
+            task_number: task.task_number,
+            status: task.status.to_string(),
+            action: "created".to_string(),
+        })
+        .ok();
+
+    Ok(Json(TaskResponse { task }))
+}
+
+pub(super) async fn update_task(
+    State(state): State<Arc<ApiState>>,
+    Path(number): Path<i64>,
+    Json(request): Json<UpdateTaskRequest>,
+) -> Result<Json<TaskResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let status = match request.status.as_deref() {
+        None => None,
+        Some(value) => Some(crate::tasks::TaskStatus::parse(value).ok_or(StatusCode::BAD_REQUEST)?),
+    };
+    let priority = match request.priority.as_deref() {
+        None => None,
+        Some(value) => {
+            Some(crate::tasks::TaskPriority::parse(value).ok_or(StatusCode::BAD_REQUEST)?)
+        }
+    };
+
+    let task = store
+        .update(
+            &request.agent_id,
+            number,
+            crate::tasks::UpdateTaskInput {
+                title: request.title,
+                description: request.description,
+                status,
+                priority,
+                subtasks: request.subtasks,
+                metadata: request.metadata,
+                worker_id: request.worker_id,
+                clear_worker_id: false,
+                approved_by: request.approved_by,
+                complete_subtask: request.complete_subtask,
+            },
+        )
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, task_number = number, "failed to update task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    state
+        .event_tx
+        .send(super::state::ApiEvent::TaskUpdated {
+            agent_id: task.agent_id.clone(),
+            task_number: task.task_number,
+            status: task.status.to_string(),
+            action: "updated".to_string(),
+        })
+        .ok();
+
+    Ok(Json(TaskResponse { task }))
+}
+
+pub(super) async fn delete_task(
+    State(state): State<Arc<ApiState>>,
+    Path(number): Path<i64>,
+    Query(query): Query<DeleteTaskQuery>,
+) -> Result<Json<TaskActionResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&query.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let deleted = store
+        .delete(&query.agent_id, number)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %query.agent_id, task_number = number, "failed to delete task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    if !deleted {
+        return Err(StatusCode::NOT_FOUND);
+    }
+
+    state
+        .event_tx
+        .send(super::state::ApiEvent::TaskUpdated {
+            agent_id: query.agent_id.clone(),
+            task_number: number,
+            status: "deleted".to_string(),
+            action: "deleted".to_string(),
+        })
+        .ok();
+
+    Ok(Json(TaskActionResponse {
+        success: true,
+        message: format!("Task #{number} deleted"),
+    }))
+}
+
+pub(super) async fn approve_task(
+    State(state): State<Arc<ApiState>>,
+    Path(number): Path<i64>,
+    Json(request): Json<UpdateTaskRequest>,
+) -> Result<Json<TaskResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let task = store
+        .update(
+            &request.agent_id,
+            number,
+            crate::tasks::UpdateTaskInput {
+                status: Some(crate::tasks::TaskStatus::Ready),
+                approved_by: request.approved_by,
+                ..Default::default()
+            },
+        )
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, task_number = number, "failed to approve task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    state
+        .event_tx
+        .send(super::state::ApiEvent::TaskUpdated {
+            agent_id: task.agent_id.clone(),
+            task_number: task.task_number,
+            status: task.status.to_string(),
+            action: "updated".to_string(),
+        })
+        .ok();
+
+    Ok(Json(TaskResponse { task }))
+}
+
+/// Move a task to `ready` so the cortex ready-task loop picks it up and spawns
+/// a worker. Tasks already in `ready` or `in_progress` are returned as-is.
+pub(super) async fn execute_task(
+    State(state): State<Arc<ApiState>>,
+    Path(number): Path<i64>,
+    Json(request): Json<UpdateTaskRequest>,
+) -> Result<Json<TaskResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    // Fetch current task to check if transition is needed.
+    let current = store
+        .get_by_number(&request.agent_id, number)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, task_number = number, "failed to get task for execution");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    // If already ready or in-progress, return as-is — cortex will handle it.
+    if matches!(
+        current.status,
+        crate::tasks::TaskStatus::Ready | crate::tasks::TaskStatus::InProgress
+    ) {
+        return Ok(Json(TaskResponse { task: current }));
+    }
+
+    let task = store
+        .update(
+            &request.agent_id,
+            number,
+            crate::tasks::UpdateTaskInput {
+                status: Some(crate::tasks::TaskStatus::Ready),
+                approved_by: request.approved_by,
+                ..Default::default()
+            },
+        )
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, task_number = number, "failed to execute task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    state
+        .event_tx
+        .send(super::state::ApiEvent::TaskUpdated {
+            agent_id: task.agent_id.clone(),
+            task_number: task.task_number,
+            status: task.status.to_string(),
+            action: "updated".to_string(),
+        })
+        .ok();
+
+    Ok(Json(TaskResponse { task }))
+}
diff --git a/src/lib.rs b/src/lib.rs
index 0e28ff0a3..4a8dffc79 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -23,6 +23,7 @@ pub mod sandbox;
 pub mod secrets;
 pub mod settings;
 pub mod skills;
+pub mod tasks;
 #[cfg(feature = "metrics")]
 pub mod telemetry;
 pub mod tools;
@@ -188,6 +189,13 @@ pub enum ProcessEvent {
         link_id: String,
         channel_id: ChannelId,
     },
+    TaskUpdated {
+        agent_id: AgentId,
+        task_number: i64,
+        status: String,
+        /// "created", "updated", or "deleted".
+        action: String,
+    },
 }
 
 /// Shared dependency bundle for agent processes.
@@ -197,6 +205,7 @@ pub struct AgentDeps {
     pub memory_search: Arc<memory::MemorySearch>,
     pub llm_manager: Arc<llm::LlmManager>,
     pub mcp_manager: Arc<mcp::McpManager>,
+    pub task_store: Arc<tasks::TaskStore>,
     pub cron_tool: Option<tools::CronTool>,
     pub runtime_config: Arc<config::RuntimeConfig>,
     pub event_tx: tokio::sync::broadcast::Sender<ProcessEvent>,
diff --git a/src/main.rs b/src/main.rs
index e1eec905c..4a3066d16 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -933,7 +933,6 @@ async fn run(
                     let api_event_tx = api_state.event_tx.clone();
                     let sse_agent_id = agent_id.to_string();
                     let sse_channel_id = conversation_id.clone();
-                    let outbound_agent_names = agent.deps.agent_names.clone();
                     let outbound_handle = tokio::spawn(async move {
                         while let Some(response) = response_rx.recv().await {
                             // Forward relevant events to SSE clients
@@ -978,100 +977,6 @@ async fn run(
 
                             let current_message = outbound_message.read().await.clone();
 
-                            // Internal link channels: route replies back to the sender's link channel
-                            if current_message.source == "internal" {
-                                let reply_text = match &response {
-                                    spacebot::OutboundResponse::Text(t) => Some(t.clone()),
-                                    spacebot::OutboundResponse::RichMessage { text, .. } => Some(text.clone()),
-                                    spacebot::OutboundResponse::ThreadReply { text, .. } => Some(text.clone()),
-                                    spacebot::OutboundResponse::Status(_) => None,
-                                    _ => None,
-                                };
-
-                                if let Some(text) = reply_text {
-                                    let reply_to_agent = current_message.metadata
-                                        .get("reply_to_agent")
-                                        .and_then(|v| v.as_str())
-                                        .map(String::from);
-                                    let reply_to_channel = current_message.metadata
-                                        .get("reply_to_channel")
-                                        .and_then(|v| v.as_str())
-                                        .map(String::from);
-
-                                    if let (Some(target_agent), Some(target_channel)) = (reply_to_agent, reply_to_channel) {
-                                        let agent_display = outbound_agent_names
-                                            .get(&sse_agent_id)
-                                            .cloned()
-                                            .unwrap_or_else(|| sse_agent_id.clone());
-
-                                        // Include the original sent message so the receiving
-                                        // agent's link channel can seed its history with context
-                                        let original_text = match &current_message.content {
-                                            spacebot::MessageContent::Text(t) => Some(t.clone()),
-                                            spacebot::MessageContent::Media { text, .. } => text.clone(),
-                                            _ => None,
-                                        };
-
-                                        let mut metadata = std::collections::HashMap::from([
-                                            ("from_agent_id".into(), serde_json::json!(&sse_agent_id)),
-                                            ("reply_to_agent".into(), serde_json::json!(&sse_agent_id)),
-                                            ("reply_to_channel".into(), serde_json::json!(&outbound_conversation_id)),
-                                        ]);
-                                        if let Some(original) = original_text {
-                                            metadata.insert("original_sent_message".into(), serde_json::json!(original));
-                                        }
-                                        // Propagate originating_channel and originating_source so both sides
-                                        // know where to route conclusions and which adapter to use.
-                                        if let Some(originating) = current_message.metadata.get("originating_channel") {
-                                            metadata.insert("originating_channel".into(), originating.clone());
-                                        }
-                                        if let Some(source) = current_message.metadata.get("originating_source") {
-                                            metadata.insert("originating_source".into(), source.clone());
-                                        }
-
-                                        let reply_message = spacebot::InboundMessage {
-                                            id: uuid::Uuid::new_v4().to_string(),
-                                            source: "internal".into(),
-                                            conversation_id: target_channel.clone(),
-                                            sender_id: sse_agent_id.clone(),
-                                            agent_id: Some(Arc::from(target_agent.as_str())),
-                                            content: spacebot::MessageContent::Text(text),
-                                            timestamp: chrono::Utc::now(),
-                                            metadata,
-                                            formatted_author: Some(format!("[{agent_display}]")),
-                                        };
-
-                                        if let Err(error) = messaging_for_outbound
-                                            .inject_message(reply_message)
-                                            .await
-                                        {
-                                            tracing::error!(
-                                                %error,
-                                                from = %sse_agent_id,
-                                                to = %target_agent,
-                                                "failed to route link channel reply"
-                                            );
-                                        } else {
-                                            // Emit SSE event so the dashboard animates the edge
-                                            api_event_tx.send(spacebot::api::ApiEvent::AgentMessageSent {
-                                                from_agent_id: sse_agent_id.clone(),
-                                                to_agent_id: target_agent.clone(),
-                                                link_id: target_channel.clone(),
-                                                channel_id: target_channel.clone(),
-                                            }).ok();
-
-                                            tracing::info!(
-                                                from = %sse_agent_id,
-                                                to = %target_agent,
-                                                channel = %target_channel,
-                                                "routed link channel reply"
-                                            );
-                                        }
-                                    }
-                                }
-                                continue;
-                            }
-
                             match response {
                                 spacebot::OutboundResponse::Status(status) => {
                                     if let Err(error) = messaging_for_outbound
@@ -1386,6 +1291,7 @@ async fn initialize_agents(
         // Per-agent memory system
         let memory_store =
             spacebot::memory::MemoryStore::with_agent_id(db.sqlite.clone(), &agent_config.id);
+        let task_store = Arc::new(spacebot::tasks::TaskStore::new(db.sqlite.clone()));
         let embedding_table = spacebot::memory::EmbeddingTable::open_or_create(&db.lance)
             .await
             .with_context(|| {
@@ -1464,6 +1370,7 @@ async fn initialize_agents(
             memory_search,
             llm_manager: llm_manager.clone(),
             mcp_manager,
+            task_store: task_store.clone(),
             cron_tool: None,
             runtime_config,
             event_tx,
@@ -1493,6 +1400,7 @@ async fn initialize_agents(
         let mut agent_configs = Vec::new();
         let mut memory_searches = std::collections::HashMap::new();
         let mut mcp_managers = std::collections::HashMap::new();
+        let mut task_stores = std::collections::HashMap::new();
         let mut agent_workspaces = std::collections::HashMap::new();
         let mut runtime_configs = std::collections::HashMap::new();
         let mut sandboxes = std::collections::HashMap::new();
@@ -1502,6 +1410,7 @@ async fn initialize_agents(
             agent_pools.insert(agent_id.to_string(), agent.db.sqlite.clone());
             memory_searches.insert(agent_id.to_string(), agent.deps.memory_search.clone());
             mcp_managers.insert(agent_id.to_string(), agent.deps.mcp_manager.clone());
+            task_stores.insert(agent_id.to_string(), agent.deps.task_store.clone());
             agent_workspaces.insert(agent_id.to_string(), agent.config.workspace.clone());
             runtime_configs.insert(agent_id.to_string(), agent.deps.runtime_config.clone());
             sandboxes.insert(agent_id.to_string(), agent.deps.sandbox.clone());
@@ -1520,6 +1429,7 @@ async fn initialize_agents(
         api_state.set_agent_configs(agent_configs);
         api_state.set_memory_searches(memory_searches);
         api_state.set_mcp_managers(mcp_managers);
+        api_state.set_task_stores(task_stores);
         api_state.set_runtime_configs(runtime_configs);
         api_state.set_agent_workspaces(agent_workspaces);
         api_state.set_sandboxes(sandboxes);
@@ -1762,6 +1672,13 @@ async fn initialize_agents(
             spacebot::agent::cortex::spawn_association_loop(agent.deps.clone(), cortex_logger);
         cortex_handles.push(association_handle);
         tracing::info!(agent_id = %agent_id, "cortex association loop started");
+
+        let ready_task_handle = spacebot::agent::cortex::spawn_ready_task_loop(
+            agent.deps.clone(),
+            spacebot::agent::cortex::CortexLogger::new(agent.db.sqlite.clone()),
+        );
+        cortex_handles.push(ready_task_handle);
+        tracing::info!(agent_id = %agent_id, "cortex ready-task loop started");
     }
 
     // Create cortex chat sessions for each agent
@@ -1775,11 +1692,12 @@ async fn initialize_agents(
             let channel_store = spacebot::conversation::ChannelStore::new(agent.db.sqlite.clone());
             let run_logger = spacebot::conversation::ProcessRunLogger::new(agent.db.sqlite.clone());
             let tool_server = spacebot::tools::create_cortex_chat_tool_server(
+                agent.deps.agent_id.clone(),
+                agent.deps.task_store.clone(),
                 agent.deps.memory_search.clone(),
                 conversation_logger,
                 channel_store,
                 run_logger,
-                &agent.deps.agent_id,
                 browser_config,
                 agent.config.screenshot_dir(),
                 brave_search_key,
diff --git a/src/prompts/engine.rs b/src/prompts/engine.rs
index 69a69be61..4d0705e26 100644
--- a/src/prompts/engine.rs
+++ b/src/prompts/engine.rs
@@ -406,7 +406,6 @@ impl PromptEngine {
             coalesce_hint,
             available_channels,
             None,
-            None,
         )
     }
 
@@ -439,17 +438,7 @@ impl PromptEngine {
         )
     }
 
-    /// Render the link context fragment for an internal agent-to-agent channel.
-    pub fn render_link_context(&self, link_context: LinkContext) -> Result<String> {
-        self.render(
-            "fragments/link_context",
-            context! {
-                link_context => link_context,
-            },
-        )
-    }
-
-    /// Render the channel system prompt with all dynamic components including org/link context.
+    /// Render the channel system prompt with all dynamic components including org context.
     #[allow(clippy::too_many_arguments)]
     pub fn render_channel_prompt_with_links(
         &self,
@@ -462,7 +451,6 @@ impl PromptEngine {
         coalesce_hint: Option<String>,
         available_channels: Option<String>,
         org_context: Option<String>,
-        link_context: Option<String>,
     ) -> Result<String> {
         self.render(
             "channel",
@@ -476,7 +464,6 @@ impl PromptEngine {
                 coalesce_hint => coalesce_hint,
                 available_channels => available_channels,
                 org_context => org_context,
-                link_context => link_context,
             },
         )
     }
@@ -504,13 +491,6 @@ pub struct LinkedAgent {
     pub is_human: bool,
 }
 
-/// Context for the current link channel.
-#[derive(Debug, Clone, serde::Serialize)]
-pub struct LinkContext {
-    pub agent_name: String,
-    pub relationship: String,
-}
-
 /// Information about a skill for template rendering.
 #[derive(Debug, Clone, serde::Serialize)]
 pub struct SkillInfo {
diff --git a/src/prompts/text.rs b/src/prompts/text.rs
index dbed2c89e..00a9c3d23 100644
--- a/src/prompts/text.rs
+++ b/src/prompts/text.rs
@@ -118,10 +118,6 @@ fn lookup(lang: &str, key: &str) -> &'static str {
         ("en", "fragments/org_context") => {
             include_str!("../../prompts/en/fragments/org_context.md.j2")
         }
-        ("en", "fragments/link_context") => {
-            include_str!("../../prompts/en/fragments/link_context.md.j2")
-        }
-
         // Coalesce Hint
         ("en", "fragments/coalesce_hint") => {
             include_str!("../../prompts/en/fragments/coalesce_hint.md.j2")
@@ -172,8 +168,14 @@ fn lookup(lang: &str, key: &str) -> &'static str {
         ("en", "tools/send_agent_message") => {
             include_str!("../../prompts/en/tools/send_agent_message_description.md.j2")
         }
-        ("en", "tools/conclude_link") => {
-            include_str!("../../prompts/en/tools/conclude_link_description.md.j2")
+        ("en", "tools/task_create") => {
+            include_str!("../../prompts/en/tools/task_create_description.md.j2")
+        }
+        ("en", "tools/task_list") => {
+            include_str!("../../prompts/en/tools/task_list_description.md.j2")
+        }
+        ("en", "tools/task_update") => {
+            include_str!("../../prompts/en/tools/task_update_description.md.j2")
         }
 
         // Fallback: unknown language or key -> try English
diff --git a/src/tasks.rs b/src/tasks.rs
new file mode 100644
index 000000000..c9b216c97
--- /dev/null
+++ b/src/tasks.rs
@@ -0,0 +1,7 @@
+//! Task tracking data model and storage.
+
+pub mod store;
+
+pub use store::{
+    CreateTaskInput, Task, TaskPriority, TaskStatus, TaskStore, TaskSubtask, UpdateTaskInput,
+};
diff --git a/src/tasks/store.rs b/src/tasks/store.rs
new file mode 100644
index 000000000..8c3bf45ed
--- /dev/null
+++ b/src/tasks/store.rs
@@ -0,0 +1,698 @@
+//! Task CRUD storage (SQLite).
+
+use crate::error::Result;
+use anyhow::Context as _;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use sqlx::{Row as _, SqlitePool};
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum TaskStatus {
+    PendingApproval,
+    Backlog,
+    Ready,
+    InProgress,
+    Done,
+}
+
+impl TaskStatus {
+    pub const ALL: [TaskStatus; 5] = [
+        TaskStatus::PendingApproval,
+        TaskStatus::Backlog,
+        TaskStatus::Ready,
+        TaskStatus::InProgress,
+        TaskStatus::Done,
+    ];
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            TaskStatus::PendingApproval => "pending_approval",
+            TaskStatus::Backlog => "backlog",
+            TaskStatus::Ready => "ready",
+            TaskStatus::InProgress => "in_progress",
+            TaskStatus::Done => "done",
+        }
+    }
+
+    pub fn parse(value: &str) -> Option<Self> {
+        match value {
+            "pending_approval" => Some(TaskStatus::PendingApproval),
+            "backlog" => Some(TaskStatus::Backlog),
+            "ready" => Some(TaskStatus::Ready),
+            "in_progress" => Some(TaskStatus::InProgress),
+            "done" => Some(TaskStatus::Done),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for TaskStatus {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum TaskPriority {
+    Critical,
+    High,
+    Medium,
+    Low,
+}
+
+impl TaskPriority {
+    pub const ALL: [TaskPriority; 4] = [
+        TaskPriority::Critical,
+        TaskPriority::High,
+        TaskPriority::Medium,
+        TaskPriority::Low,
+    ];
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            TaskPriority::Critical => "critical",
+            TaskPriority::High => "high",
+            TaskPriority::Medium => "medium",
+            TaskPriority::Low => "low",
+        }
+    }
+
+    pub fn parse(value: &str) -> Option<Self> {
+        match value {
+            "critical" => Some(TaskPriority::Critical),
+            "high" => Some(TaskPriority::High),
+            "medium" => Some(TaskPriority::Medium),
+            "low" => Some(TaskPriority::Low),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for TaskPriority {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct TaskSubtask {
+    pub title: String,
+    pub completed: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Task {
+    pub id: String,
+    pub agent_id: String,
+    pub task_number: i64,
+    pub title: String,
+    pub description: Option<String>,
+    pub status: TaskStatus,
+    pub priority: TaskPriority,
+    pub subtasks: Vec<TaskSubtask>,
+    pub metadata: Value,
+    pub source_memory_id: Option<String>,
+    pub worker_id: Option<String>,
+    pub created_by: String,
+    pub approved_at: Option<String>,
+    pub approved_by: Option<String>,
+    pub created_at: String,
+    pub updated_at: String,
+    pub completed_at: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct CreateTaskInput {
+    pub agent_id: String,
+    pub title: String,
+    pub description: Option<String>,
+    pub status: TaskStatus,
+    pub priority: TaskPriority,
+    pub subtasks: Vec<TaskSubtask>,
+    pub metadata: Value,
+    pub source_memory_id: Option<String>,
+    pub created_by: String,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct UpdateTaskInput {
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub status: Option<TaskStatus>,
+    pub priority: Option<TaskPriority>,
+    pub subtasks: Option<Vec<TaskSubtask>>,
+    pub metadata: Option<Value>,
+    pub worker_id: Option<String>,
+    pub clear_worker_id: bool,
+    pub approved_by: Option<String>,
+    pub complete_subtask: Option<usize>,
+}
+
+#[derive(Debug, Clone)]
+pub struct TaskStore {
+    pool: SqlitePool,
+}
+
+impl TaskStore {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+
+    /// Maximum number of retries when a concurrent create races on the same
+    /// `(agent_id, task_number)` UNIQUE constraint.
+    const MAX_CREATE_RETRIES: usize = 3;
+
+    pub async fn create(&self, input: CreateTaskInput) -> Result<Task> {
+        let subtasks_json =
+            serde_json::to_string(&input.subtasks).context("failed to serialize subtasks")?;
+        let metadata_json = input.metadata.to_string();
+
+        for attempt in 0..Self::MAX_CREATE_RETRIES {
+            let mut tx = self
+                .pool
+                .begin()
+                .await
+                .context("failed to open task create transaction")?;
+
+            let task_number: i64 = sqlx::query_scalar(
+                "SELECT COALESCE(MAX(task_number), 0) + 1 FROM tasks WHERE agent_id = ?",
+            )
+            .bind(&input.agent_id)
+            .fetch_one(&mut *tx)
+            .await
+            .context("failed to allocate next task number")?;
+
+            let task_id = uuid::Uuid::new_v4().to_string();
+
+            let insert_result = sqlx::query(
+                r#"
+                INSERT INTO tasks (
+                    id, agent_id, task_number, title, description, status, priority,
+                    subtasks, metadata, source_memory_id, created_by
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                "#,
+            )
+            .bind(&task_id)
+            .bind(&input.agent_id)
+            .bind(task_number)
+            .bind(&input.title)
+            .bind(&input.description)
+            .bind(input.status.as_str())
+            .bind(input.priority.as_str())
+            .bind(&subtasks_json)
+            .bind(&metadata_json)
+            .bind(&input.source_memory_id)
+            .bind(&input.created_by)
+            .execute(&mut *tx)
+            .await;
+
+            match insert_result {
+                Ok(_) => {
+                    tx.commit()
+                        .await
+                        .context("failed to commit task create transaction")?;
+
+                    return self
+                        .get_by_number(&input.agent_id, task_number)
+                        .await?
+                        .context("task inserted but not found")
+                        .map_err(Into::into);
+                }
+                Err(sqlx::Error::Database(ref db_error))
+                    if db_error.code().as_deref() == Some("2067") =>
+                {
+                    // UNIQUE constraint violation — another concurrent create won the
+                    // race for this task_number. Roll back and retry.
+                    tracing::debug!(
+                        attempt,
+                        task_number,
+                        agent_id = %input.agent_id,
+                        "task_number collision, retrying"
+                    );
+                    // tx is dropped here which rolls back automatically.
+                    continue;
+                }
+                Err(error) => {
+                    return Err(anyhow::anyhow!("failed to insert task: {error}").into());
+                }
+            }
+        }
+
+        Err(anyhow::anyhow!(
+            "failed to create task after {} retries due to concurrent task_number collisions",
+            Self::MAX_CREATE_RETRIES
+        )
+        .into())
+    }
+
+    pub async fn list(
+        &self,
+        agent_id: &str,
+        status: Option<TaskStatus>,
+        priority: Option<TaskPriority>,
+        limit: i64,
+    ) -> Result<Vec<Task>> {
+        let mut query = String::from(
+            "SELECT id, agent_id, task_number, title, description, status, priority, subtasks, metadata, source_memory_id, worker_id, created_by, approved_at, approved_by, created_at, updated_at, completed_at FROM tasks WHERE agent_id = ?",
+        );
+
+        if status.is_some() {
+            query.push_str(" AND status = ?");
+        }
+        if priority.is_some() {
+            query.push_str(" AND priority = ?");
+        }
+        query.push_str(" ORDER BY task_number DESC LIMIT ?");
+
+        let mut sql = sqlx::query(&query).bind(agent_id);
+        if let Some(status) = status {
+            sql = sql.bind(status.as_str());
+        }
+        if let Some(priority) = priority {
+            sql = sql.bind(priority.as_str());
+        }
+        sql = sql.bind(limit.clamp(1, 500));
+
+        let rows = sql
+            .fetch_all(&self.pool)
+            .await
+            .context("failed to list tasks")?;
+
+        rows.into_iter().map(task_from_row).collect()
+    }
+
+    pub async fn list_ready(&self, agent_id: &str, limit: i64) -> Result<Vec<Task>> {
+        self.list(agent_id, Some(TaskStatus::Ready), None, limit)
+            .await
+    }
+
+    pub async fn get_by_number(&self, agent_id: &str, task_number: i64) -> Result<Option<Task>> {
+        let row = sqlx::query(
+            "SELECT id, agent_id, task_number, title, description, status, priority, subtasks, metadata, source_memory_id, worker_id, created_by, approved_at, approved_by, created_at, updated_at, completed_at FROM tasks WHERE agent_id = ? AND task_number = ?",
+        )
+        .bind(agent_id)
+        .bind(task_number)
+        .fetch_optional(&self.pool)
+        .await
+        .context("failed to fetch task by number")?;
+
+        row.map(task_from_row).transpose()
+    }
+
+    pub async fn update(
+        &self,
+        agent_id: &str,
+        task_number: i64,
+        input: UpdateTaskInput,
+    ) -> Result<Option<Task>> {
+        let Some(current) = self.get_by_number(agent_id, task_number).await? else {
+            return Ok(None);
+        };
+
+        if let Some(next_status) = input.status
+            && !can_transition(current.status, next_status)
+        {
+            return Err(crate::error::Error::Other(anyhow::anyhow!(
+                "invalid task status transition: {} -> {}",
+                current.status,
+                next_status
+            )));
+        }
+
+        let mut subtasks = input.subtasks.unwrap_or(current.subtasks);
+        if let Some(index) = input.complete_subtask
+            && let Some(subtask) = subtasks.get_mut(index)
+        {
+            subtask.completed = true;
+        }
+
+        let next_status = input.status.unwrap_or(current.status);
+        let next_priority = input.priority.unwrap_or(current.priority);
+        let next_metadata = merge_json_object(current.metadata, input.metadata);
+        let next_worker_id = if let Some(worker_id) = input.worker_id {
+            Some(worker_id)
+        } else {
+            current.worker_id
+        };
+
+        let approved_at = if current.approved_at.is_none() && next_status == TaskStatus::Ready {
+            Some("datetime('now')")
+        } else {
+            None
+        };
+
+        let completed_at = if next_status == TaskStatus::Done {
+            Some("datetime('now')")
+        } else if current.completed_at.is_some() && next_status != TaskStatus::Done {
+            Some("NULL")
+        } else {
+            None
+        };
+
+        let mut query = String::from(
+            "UPDATE tasks SET title = ?, description = ?, status = ?, priority = ?, subtasks = ?, metadata = ?, ",
+        );
+
+        if input.clear_worker_id {
+            query.push_str("worker_id = NULL, ");
+        } else {
+            query.push_str("worker_id = ?, ");
+        }
+
+        query.push_str("approved_by = COALESCE(?, approved_by), updated_at = datetime('now')");
+
+        if approved_at.is_some() {
+            query.push_str(", approved_at = datetime('now')");
+        }
+        if let Some(value) = completed_at {
+            if value == "datetime('now')" {
+                query.push_str(", completed_at = datetime('now')");
+            } else {
+                query.push_str(", completed_at = NULL");
+            }
+        }
+
+        query.push_str(" WHERE agent_id = ? AND task_number = ?");
+
+        let mut sql = sqlx::query(&query)
+            .bind(input.title.unwrap_or(current.title))
+            .bind(input.description.or(current.description))
+            .bind(next_status.as_str())
+            .bind(next_priority.as_str())
+            .bind(serde_json::to_string(&subtasks).context("failed to serialize subtasks")?)
+            .bind(next_metadata.to_string());
+
+        if !input.clear_worker_id {
+            sql = sql.bind(next_worker_id);
+        }
+
+        sql.bind(input.approved_by)
+            .bind(agent_id)
+            .bind(task_number)
+            .execute(&self.pool)
+            .await
+            .context("failed to update task")?;
+
+        self.get_by_number(agent_id, task_number).await
+    }
+
+    pub async fn delete(&self, agent_id: &str, task_number: i64) -> Result<bool> {
+        let result = sqlx::query("DELETE FROM tasks WHERE agent_id = ? AND task_number = ?")
+            .bind(agent_id)
+            .bind(task_number)
+            .execute(&self.pool)
+            .await
+            .context("failed to delete task")?;
+
+        Ok(result.rows_affected() > 0)
+    }
+
+    pub async fn claim_next_ready(&self, agent_id: &str) -> Result<Option<Task>> {
+        let row = sqlx::query(
+            "SELECT task_number FROM tasks WHERE agent_id = ? AND status = 'ready' \
+             ORDER BY CASE priority \
+               WHEN 'critical' THEN 0 \
+               WHEN 'high' THEN 1 \
+               WHEN 'medium' THEN 2 \
+               WHEN 'low' THEN 3 \
+               ELSE 4 END ASC, \
+             task_number ASC \
+             LIMIT 1",
+        )
+        .bind(agent_id)
+        .fetch_optional(&self.pool)
+        .await
+        .context("failed to find ready task")?;
+
+        let Some(row) = row else {
+            return Ok(None);
+        };
+
+        let task_number: i64 = row
+            .try_get("task_number")
+            .context("failed to read task_number from ready task row")?;
+        let result = sqlx::query(
+            "UPDATE tasks SET status = 'in_progress', updated_at = datetime('now') WHERE agent_id = ? AND task_number = ? AND status = 'ready'",
+        )
+        .bind(agent_id)
+        .bind(task_number)
+        .execute(&self.pool)
+        .await
+        .context("failed to claim ready task")?;
+
+        if result.rows_affected() == 0 {
+            return Ok(None);
+        }
+
+        self.get_by_number(agent_id, task_number).await
+    }
+
+    pub async fn get_by_worker_id(&self, worker_id: &str) -> Result<Option<Task>> {
+        let row = sqlx::query(
+            "SELECT id, agent_id, task_number, title, description, status, priority, subtasks, metadata, source_memory_id, worker_id, created_by, approved_at, approved_by, created_at, updated_at, completed_at FROM tasks WHERE worker_id = ? ORDER BY updated_at DESC LIMIT 1",
+        )
+        .bind(worker_id)
+        .fetch_optional(&self.pool)
+        .await
+        .context("failed to fetch task by worker id")?;
+
+        row.map(task_from_row).transpose()
+    }
+}
+
+fn can_transition(current: TaskStatus, next: TaskStatus) -> bool {
+    if current == next {
+        return true;
+    }
+
+    if next == TaskStatus::Backlog {
+        return true;
+    }
+
+    matches!(
+        (current, next),
+        (TaskStatus::PendingApproval, TaskStatus::Ready)
+            | (TaskStatus::Ready, TaskStatus::InProgress)
+            | (TaskStatus::InProgress, TaskStatus::Done)
+            | (TaskStatus::InProgress, TaskStatus::Ready)
+            | (TaskStatus::Backlog, TaskStatus::Ready)
+    )
+}
+
+fn merge_json_object(current: Value, patch: Option<Value>) -> Value {
+    let Some(patch) = patch else {
+        return current;
+    };
+
+    let mut merged = current.as_object().cloned().unwrap_or_default();
+    if let Some(patch_object) = patch.as_object() {
+        for (key, value) in patch_object {
+            merged.insert(key.clone(), value.clone());
+        }
+    }
+    Value::Object(merged)
+}
+
+fn parse_subtasks(value: &str) -> Vec<TaskSubtask> {
+    serde_json::from_str(value).unwrap_or_default()
+}
+
+fn parse_metadata(value: &str) -> Value {
+    serde_json::from_str(value).unwrap_or_else(|_| Value::Object(serde_json::Map::new()))
+}
+
+fn task_from_row(row: sqlx::sqlite::SqliteRow) -> Result<Task> {
+    let status_value: String = row
+        .try_get("status")
+        .context("failed to read task status")?;
+    let priority_value: String = row
+        .try_get("priority")
+        .context("failed to read task priority")?;
+    let subtasks_value: String = row.try_get("subtasks").unwrap_or_else(|_| "[]".to_string());
+    let metadata_value: String = row.try_get("metadata").unwrap_or_else(|_| "{}".to_string());
+
+    let status = TaskStatus::parse(&status_value)
+        .with_context(|| format!("invalid task status in database: {status_value}"))?;
+    let priority = TaskPriority::parse(&priority_value)
+        .with_context(|| format!("invalid task priority in database: {priority_value}"))?;
+
+    Ok(Task {
+        id: row.try_get("id").context("failed to read task id")?,
+        agent_id: row
+            .try_get("agent_id")
+            .context("failed to read task agent_id")?,
+        task_number: row
+            .try_get("task_number")
+            .context("failed to read task_number")?,
+        title: row.try_get("title").context("failed to read task title")?,
+        description: row.try_get("description").ok(),
+        status,
+        priority,
+        subtasks: parse_subtasks(&subtasks_value),
+        metadata: parse_metadata(&metadata_value),
+        source_memory_id: row.try_get("source_memory_id").ok(),
+        worker_id: row
+            .try_get::<Option<String>, _>("worker_id")
+            .ok()
+            .flatten()
+            .and_then(|value| if value.is_empty() { None } else { Some(value) }),
+        created_by: row
+            .try_get("created_by")
+            .context("failed to read task created_by")?,
+        approved_at: row
+            .try_get::<Option<chrono::NaiveDateTime>, _>("approved_at")
+            .ok()
+            .flatten()
+            .map(|v| v.and_utc().to_rfc3339()),
+        approved_by: row.try_get("approved_by").ok(),
+        created_at: row
+            .try_get::<chrono::NaiveDateTime, _>("created_at")
+            .map(|v| v.and_utc().to_rfc3339())
+            .context("failed to read task created_at")?,
+        updated_at: row
+            .try_get::<chrono::NaiveDateTime, _>("updated_at")
+            .map(|v| v.and_utc().to_rfc3339())
+            .context("failed to read task updated_at")?,
+        completed_at: row
+            .try_get::<chrono::NaiveDateTime, _>("completed_at")
+            .ok()
+            .map(|v| v.and_utc().to_rfc3339()),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use sqlx::sqlite::SqlitePoolOptions;
+
+    async fn setup_store() -> TaskStore {
+        let pool = SqlitePoolOptions::new()
+            .max_connections(1)
+            .connect("sqlite::memory:")
+            .await
+            .expect("in-memory sqlite should connect");
+
+        sqlx::query(
+            r#"
+            CREATE TABLE tasks (
+                id TEXT PRIMARY KEY,
+                agent_id TEXT NOT NULL,
+                task_number INTEGER NOT NULL,
+                title TEXT NOT NULL,
+                description TEXT,
+                status TEXT NOT NULL DEFAULT 'backlog',
+                priority TEXT NOT NULL DEFAULT 'medium',
+                subtasks TEXT,
+                metadata TEXT,
+                source_memory_id TEXT,
+                worker_id TEXT,
+                created_by TEXT NOT NULL,
+                approved_at TIMESTAMP,
+                approved_by TEXT,
+                created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                completed_at TIMESTAMP,
+                UNIQUE(agent_id, task_number)
+            )
+            "#,
+        )
+        .execute(&pool)
+        .await
+        .expect("tasks schema should be created");
+
+        TaskStore::new(pool)
+    }
+
+    #[tokio::test]
+    async fn rejects_invalid_status_transition() {
+        let store = setup_store().await;
+        let created = store
+            .create(CreateTaskInput {
+                agent_id: "agent-test".to_string(),
+                title: "pending task".to_string(),
+                description: None,
+                status: TaskStatus::PendingApproval,
+                priority: TaskPriority::Medium,
+                subtasks: Vec::new(),
+                metadata: serde_json::json!({}),
+                source_memory_id: None,
+                created_by: "cortex".to_string(),
+            })
+            .await
+            .expect("task should be created");
+
+        let error = store
+            .update(
+                "agent-test",
+                created.task_number,
+                UpdateTaskInput {
+                    status: Some(TaskStatus::InProgress),
+                    ..Default::default()
+                },
+            )
+            .await
+            .expect_err("pending_approval -> in_progress must fail");
+
+        assert!(error.to_string().contains("invalid task status transition"));
+    }
+
+    #[tokio::test]
+    async fn can_requeue_in_progress_and_clear_worker_binding() {
+        let store = setup_store().await;
+        let created = store
+            .create(CreateTaskInput {
+                agent_id: "agent-test".to_string(),
+                title: "ready task".to_string(),
+                description: None,
+                status: TaskStatus::Ready,
+                priority: TaskPriority::Medium,
+                subtasks: Vec::new(),
+                metadata: serde_json::json!({}),
+                source_memory_id: None,
+                created_by: "branch".to_string(),
+            })
+            .await
+            .expect("task should be created");
+
+        let in_progress = store
+            .update(
+                "agent-test",
+                created.task_number,
+                UpdateTaskInput {
+                    status: Some(TaskStatus::InProgress),
+                    worker_id: Some("worker-1".to_string()),
+                    ..Default::default()
+                },
+            )
+            .await
+            .expect("update should succeed")
+            .expect("task should exist");
+
+        assert_eq!(in_progress.worker_id.as_deref(), Some("worker-1"));
+
+        let requeued = store
+            .update(
+                "agent-test",
+                created.task_number,
+                UpdateTaskInput {
+                    status: Some(TaskStatus::Ready),
+                    clear_worker_id: true,
+                    ..Default::default()
+                },
+            )
+            .await
+            .expect("requeue should succeed")
+            .expect("task should exist");
+
+        assert_eq!(requeued.status, TaskStatus::Ready);
+        assert!(
+            requeued.worker_id.is_none(),
+            "expected worker binding to clear, got {:?}",
+            requeued.worker_id
+        );
+    }
+}
diff --git a/src/tools.rs b/src/tools.rs
index 28ea3ef3c..ffb6f2805 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -12,10 +12,13 @@
 //! - No memory tools — the channel delegates memory work to branches.
 //!
 //! **Branch ToolServer** (one per branch, isolated):
-//! - `memory_save` + `memory_recall` + `memory_delete` — registered at creation
+//! - `memory_save` + `memory_recall` + `memory_delete` + `channel_recall`
+//! - `task_create` + `task_list` + `task_update`
+//! - `spawn_worker` is included for channel-originated branches only
 //!
 //! **Worker ToolServer** (one per worker, created at spawn time):
 //! - `shell`, `file`, `exec` — stateless, registered at creation
+//! - `task_update` — scoped to the worker's assigned task
 //! - `set_status` — per-worker instance, registered at creation
 //!
 //! **Cortex ToolServer** (one per agent):
@@ -25,7 +28,6 @@ pub mod branch_tool;
 pub mod browser;
 pub mod cancel;
 pub mod channel_recall;
-pub mod conclude_link;
 pub mod cron;
 pub mod exec;
 pub mod file;
@@ -44,6 +46,9 @@ pub mod set_status;
 pub mod shell;
 pub mod skip;
 pub mod spawn_worker;
+pub mod task_create;
+pub mod task_list;
+pub mod task_update;
 pub mod web_search;
 pub mod worker_inspect;
 
@@ -56,10 +61,6 @@ pub use cancel::{CancelArgs, CancelError, CancelOutput, CancelTool};
 pub use channel_recall::{
     ChannelRecallArgs, ChannelRecallError, ChannelRecallOutput, ChannelRecallTool,
 };
-pub use conclude_link::{
-    ConcludeLinkArgs, ConcludeLinkError, ConcludeLinkFlag, ConcludeLinkOutput, ConcludeLinkSummary,
-    ConcludeLinkTool, new_conclude_link,
-};
 pub use cron::{CronArgs, CronError, CronOutput, CronTool};
 pub use exec::{EnvVar, ExecArgs, ExecError, ExecOutput, ExecResult, ExecTool};
 pub use file::{FileArgs, FileEntry, FileEntryOutput, FileError, FileOutput, FileTool, FileType};
@@ -88,6 +89,9 @@ pub use set_status::{SetStatusArgs, SetStatusError, SetStatusOutput, SetStatusTo
 pub use shell::{ShellArgs, ShellError, ShellOutput, ShellResult, ShellTool};
 pub use skip::{SkipArgs, SkipError, SkipFlag, SkipOutput, SkipTool, new_skip_flag};
 pub use spawn_worker::{SpawnWorkerArgs, SpawnWorkerError, SpawnWorkerOutput, SpawnWorkerTool};
+pub use task_create::{TaskCreateArgs, TaskCreateError, TaskCreateOutput, TaskCreateTool};
+pub use task_list::{TaskListArgs, TaskListError, TaskListOutput, TaskListTool};
+pub use task_update::{TaskUpdateArgs, TaskUpdateError, TaskUpdateOutput, TaskUpdateTool};
 pub use web_search::{SearchResult, WebSearchArgs, WebSearchError, WebSearchOutput, WebSearchTool};
 pub use worker_inspect::{
     WorkerInspectArgs, WorkerInspectError, WorkerInspectOutput, WorkerInspectTool,
@@ -97,6 +101,7 @@ use crate::agent::channel::ChannelState;
 use crate::config::{BrowserConfig, RuntimeConfig};
 use crate::memory::MemorySearch;
 use crate::sandbox::Sandbox;
+use crate::tasks::TaskStore;
 use crate::{AgentId, ChannelId, OutboundResponse, ProcessEvent, WorkerId};
 use rig::tool::Tool as _;
 use rig::tool::server::{ToolServer, ToolServerHandle};
@@ -233,43 +238,8 @@ pub async fn add_channel_tools(
     replied_flag: RepliedFlag,
     cron_tool: Option<CronTool>,
     send_agent_message_tool: Option<SendAgentMessageTool>,
-    conclude_link: Option<(ConcludeLinkFlag, ConcludeLinkSummary)>,
-    message_source: Option<String>,
-    originating_channel_override: Option<String>,
-    originating_source_override: Option<String>,
 ) -> Result<(), rig::tool::server::ToolServerError> {
     let conversation_id = conversation_id.into();
-    let is_link_channel = conversation_id.starts_with("link:");
-    let current_link_counterparty =
-        link_counterparty_for_agent(&conversation_id, state.deps.agent_id.as_ref());
-    // In direct link channels, only expose send_agent_message when this agent
-    // can initiate to at least one other linked agent (not the current peer).
-    // This avoids LLM loops where agents try to delegate back to the same peer
-    // or hallucinate unrelated targets instead of using `reply`.
-    let has_other_delegation_targets =
-        if let Some(counterparty_id) = current_link_counterparty.as_deref() {
-            let agent_id = state.deps.agent_id.as_ref();
-            let links = state.deps.links.load();
-
-            links.iter().any(|link| {
-                let (target_id, can_initiate) = if link.from_agent_id == agent_id {
-                    (&link.to_agent_id, true)
-                } else if link.to_agent_id == agent_id {
-                    (
-                        &link.from_agent_id,
-                        link.direction == crate::links::LinkDirection::TwoWay,
-                    )
-                } else {
-                    return false;
-                };
-
-                can_initiate
-                    && target_id != counterparty_id
-                    && state.deps.agent_names.contains_key(target_id)
-            })
-        } else {
-            true
-        };
 
     let agent_display_name = state
         .deps
@@ -290,7 +260,7 @@ pub async fn add_channel_tools(
     handle.add_tool(BranchTool::new(state.clone())).await?;
     handle.add_tool(SpawnWorkerTool::new(state.clone())).await?;
     handle.add_tool(RouteTool::new(state.clone())).await?;
-    if !is_link_channel && let Some(messaging_manager) = &state.deps.messaging_manager {
+    if let Some(messaging_manager) = &state.deps.messaging_manager {
         handle
             .add_tool(SendMessageTool::new(
                 messaging_manager.clone(),
@@ -312,41 +282,13 @@ pub async fn add_channel_tools(
     if let Some(cron) = cron_tool {
         handle.add_tool(cron).await?;
     }
-    if let Some(mut agent_msg) = send_agent_message_tool
-        && has_other_delegation_targets
-    {
-        // Bind per-turn state so the tool auto-ends the turn after sending and
-        // propagates the correct adapter name for conclusion routing.
+    if let Some(mut agent_msg) = send_agent_message_tool {
         agent_msg = agent_msg.with_skip_flag(skip_flag.clone());
-        if let Some(originating_channel) = originating_channel_override {
-            agent_msg = agent_msg.with_originating_channel(originating_channel);
-        }
-        // Prefer the upstream originating_source (for multi-hop chains) over
-        // the current message source (which is "internal" on link channels).
-        let effective_source = originating_source_override.or(message_source);
-        if let Some(source) = effective_source {
-            agent_msg = agent_msg.with_originating_source(source);
-        }
         handle.add_tool(agent_msg).await?;
     }
-    if let Some((flag, summary)) = conclude_link {
-        handle
-            .add_tool(ConcludeLinkTool::new(flag, summary, response_tx))
-            .await?;
-    }
     Ok(())
 }
 
-fn link_counterparty_for_agent(conversation_id: &str, agent_id: &str) -> Option<String> {
-    let rest = conversation_id.strip_prefix("link:")?;
-    let (self_id, counterparty_id) = rest.split_once(':')?;
-    if self_id == agent_id {
-        Some(counterparty_id.to_string())
-    } else {
-        None
-    }
-}
-
 /// Remove per-channel tools from a running ToolServer.
 ///
 /// Called when a conversation turn ends or a channel is torn down. Prevents stale
@@ -362,11 +304,10 @@ pub async fn remove_channel_tools(
     handle.remove_tool(SkipTool::NAME).await?;
     handle.remove_tool(SendFileTool::NAME).await?;
     handle.remove_tool(ReactTool::NAME).await?;
-    // Cron, send_message, send_agent_message, and conclude_link removal is best-effort since not all channels have them
+    // Cron, send_message, and send_agent_message removal is best-effort since not all channels have them
     let _ = handle.remove_tool(CronTool::NAME).await;
     let _ = handle.remove_tool(SendMessageTool::NAME).await;
     let _ = handle.remove_tool(SendAgentMessageTool::NAME).await;
-    let _ = handle.remove_tool(ConcludeLinkTool::NAME).await;
     Ok(())
 }
 
@@ -376,19 +317,33 @@ pub async fn remove_channel_tools(
 /// visible to the channel. Both `memory_save` and `memory_recall` are
 /// registered at creation.
 pub fn create_branch_tool_server(
+    state: Option<ChannelState>,
+    agent_id: AgentId,
+    task_store: Arc<TaskStore>,
     memory_search: Arc<MemorySearch>,
     conversation_logger: crate::conversation::history::ConversationLogger,
     channel_store: crate::conversation::ChannelStore,
     run_logger: crate::conversation::history::ProcessRunLogger,
-    agent_id: &str,
 ) -> ToolServerHandle {
-    ToolServer::new()
+    let mut server = ToolServer::new()
         .tool(MemorySaveTool::new(memory_search.clone()))
         .tool(MemoryRecallTool::new(memory_search.clone()))
         .tool(MemoryDeleteTool::new(memory_search))
         .tool(ChannelRecallTool::new(conversation_logger, channel_store))
         .tool(WorkerInspectTool::new(run_logger, agent_id.to_string()))
-        .run()
+        .tool(TaskCreateTool::new(
+            task_store.clone(),
+            agent_id.to_string(),
+            "branch",
+        ))
+        .tool(TaskListTool::new(task_store.clone(), agent_id.to_string()))
+        .tool(TaskUpdateTool::for_branch(task_store, agent_id.clone()));
+
+    if let Some(state) = state {
+        server = server.tool(SpawnWorkerTool::new(state));
+    }
+
+    server.run()
 }
 
 /// Create a per-worker ToolServer with task-appropriate tools.
@@ -404,6 +359,7 @@ pub fn create_worker_tool_server(
     agent_id: AgentId,
     worker_id: WorkerId,
     channel_id: Option<ChannelId>,
+    task_store: Arc<TaskStore>,
     event_tx: broadcast::Sender<ProcessEvent>,
     browser_config: BrowserConfig,
     screenshot_dir: PathBuf,
@@ -417,6 +373,11 @@ pub fn create_worker_tool_server(
         .tool(ShellTool::new(workspace.clone(), sandbox.clone()))
         .tool(FileTool::new(workspace.clone()))
         .tool(ExecTool::new(workspace, sandbox))
+        .tool(TaskUpdateTool::for_worker(
+            task_store,
+            agent_id.clone(),
+            worker_id,
+        ))
         .tool(SetStatusTool::new(
             agent_id, worker_id, channel_id, event_tx,
         ))
@@ -454,11 +415,12 @@ pub fn create_cortex_tool_server(memory_search: Arc<MemorySearch>) -> ToolServer
 /// tools (reply, react, skip) since the cortex chat doesn't talk to platforms.
 #[allow(clippy::too_many_arguments)]
 pub fn create_cortex_chat_tool_server(
+    agent_id: AgentId,
+    task_store: Arc<TaskStore>,
     memory_search: Arc<MemorySearch>,
     conversation_logger: crate::conversation::history::ConversationLogger,
     channel_store: crate::conversation::ChannelStore,
     run_logger: crate::conversation::history::ProcessRunLogger,
-    agent_id: &str,
     browser_config: BrowserConfig,
     screenshot_dir: PathBuf,
     brave_search_key: Option<String>,
@@ -471,6 +433,13 @@ pub fn create_cortex_chat_tool_server(
         .tool(MemoryDeleteTool::new(memory_search))
         .tool(ChannelRecallTool::new(conversation_logger, channel_store))
         .tool(WorkerInspectTool::new(run_logger, agent_id.to_string()))
+        .tool(TaskCreateTool::new(
+            task_store.clone(),
+            agent_id.to_string(),
+            "cortex",
+        ))
+        .tool(TaskListTool::new(task_store.clone(), agent_id.to_string()))
+        .tool(TaskUpdateTool::for_branch(task_store, agent_id.clone()))
         .tool(ShellTool::new(workspace.clone(), sandbox.clone()))
         .tool(FileTool::new(workspace.clone()))
         .tool(ExecTool::new(workspace, sandbox));
diff --git a/src/tools/conclude_link.rs b/src/tools/conclude_link.rs
deleted file mode 100644
index 315a3f2d5..000000000
--- a/src/tools/conclude_link.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-//! Conclude link tool: gracefully ends a link conversation.
-//!
-//! When an agent determines the conversation objective is met, it calls this
-//! tool with a summary. The channel checks the flag after the LLM turn and
-//! routes the summary back to the originating channel as a system message.
-
-use crate::OutboundResponse;
-use rig::completion::ToolDefinition;
-use rig::tool::Tool;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, Ordering};
-use tokio::sync::{RwLock, mpsc};
-
-/// Shared flag between the ConcludeLinkTool and the channel event loop.
-pub type ConcludeLinkFlag = Arc<AtomicBool>;
-
-/// Shared storage for the conclusion summary.
-pub type ConcludeLinkSummary = Arc<RwLock<Option<String>>>;
-
-/// Create a new conclude flag + summary pair.
-pub fn new_conclude_link() -> (ConcludeLinkFlag, ConcludeLinkSummary) {
-    (
-        Arc::new(AtomicBool::new(false)),
-        Arc::new(RwLock::new(None)),
-    )
-}
-
-/// Tool that signals the link conversation should end.
-#[derive(Debug, Clone)]
-pub struct ConcludeLinkTool {
-    flag: ConcludeLinkFlag,
-    summary: ConcludeLinkSummary,
-    response_tx: mpsc::Sender<OutboundResponse>,
-}
-
-impl ConcludeLinkTool {
-    pub fn new(
-        flag: ConcludeLinkFlag,
-        summary: ConcludeLinkSummary,
-        response_tx: mpsc::Sender<OutboundResponse>,
-    ) -> Self {
-        Self {
-            flag,
-            summary,
-            response_tx,
-        }
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-#[error("Conclude link failed: {0}")]
-pub struct ConcludeLinkError(String);
-
-#[derive(Debug, Deserialize, JsonSchema)]
-pub struct ConcludeLinkArgs {
-    /// Summary of the conversation outcomes, decisions, and any action items.
-    pub summary: String,
-}
-
-#[derive(Debug, Serialize)]
-pub struct ConcludeLinkOutput {
-    pub concluded: bool,
-}
-
-impl Tool for ConcludeLinkTool {
-    const NAME: &'static str = "conclude_link";
-
-    type Error = ConcludeLinkError;
-    type Args = ConcludeLinkArgs;
-    type Output = ConcludeLinkOutput;
-
-    async fn definition(&self, _prompt: String) -> ToolDefinition {
-        ToolDefinition {
-            name: Self::NAME.to_string(),
-            description: crate::prompts::text::get("tools/conclude_link").to_string(),
-            parameters: serde_json::json!({
-                "type": "object",
-                "properties": {
-                    "summary": {
-                        "type": "string",
-                        "description": "Summary of the conversation outcomes, decisions made, and any action items."
-                    }
-                },
-                "required": ["summary"]
-            }),
-        }
-    }
-
-    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
-        self.flag.store(true, Ordering::Relaxed);
-
-        let summary_len = args.summary.len();
-        *self.summary.write().await = Some(args.summary);
-
-        let _ = self
-            .response_tx
-            .send(OutboundResponse::Status(crate::StatusUpdate::StopTyping))
-            .await;
-
-        tracing::info!(
-            summary_len,
-            "conclude_link tool called, ending link conversation"
-        );
-
-        Ok(ConcludeLinkOutput { concluded: true })
-    }
-}
diff --git a/src/tools/send_agent_message.rs b/src/tools/send_agent_message.rs
index a2f3e03d3..62d4205d7 100644
--- a/src/tools/send_agent_message.rs
+++ b/src/tools/send_agent_message.rs
@@ -1,13 +1,12 @@
-//! Send message to another agent through the communication graph.
+//! Send a message to another agent through the communication graph.
+//!
+//! Currently a stub — validates the link exists and ends the turn.
+//! Will be wired into the task system for cross-agent task delegation.
 
-use crate::conversation::ChannelStore;
 use crate::links::AgentLink;
-use crate::messaging::MessagingManager;
 use crate::tools::SkipFlag;
-use crate::{AgentId, InboundMessage, MessageContent, ProcessEvent};
 
 use arc_swap::ArcSwap;
-use chrono::Utc;
 use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use schemars::JsonSchema;
@@ -15,34 +14,20 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
-use tokio::sync::broadcast;
 
 /// Tool for sending messages to other agents through the agent communication graph.
 ///
 /// Resolves the target agent by ID or name, validates the link exists and permits
-/// messaging in this direction, constructs an `InboundMessage` with source "internal",
-/// and delivers via `MessagingManager::inject_message()`.
+/// messaging in this direction. Currently a stub — will create tasks on the
+/// target agent once cross-agent task delegation is implemented.
 #[derive(Clone)]
 pub struct SendAgentMessageTool {
-    agent_id: AgentId,
-    agent_name: String,
-    channel_id: crate::ChannelId,
+    agent_id: crate::AgentId,
     links: Arc<ArcSwap<Vec<AgentLink>>>,
-    messaging_manager: Arc<MessagingManager>,
-    channel_store: ChannelStore,
-    event_tx: broadcast::Sender<ProcessEvent>,
     /// Map of known agent IDs to display names, for resolving targets.
     agent_names: Arc<HashMap<String, String>>,
-    /// Per-turn skip flag. When set after sending, the channel turn ends immediately
-    /// instead of looping back to the LLM (which would burn depth calling skip).
+    /// Per-turn skip flag. When set after sending, the channel turn ends immediately.
     skip_flag: Option<SkipFlag>,
-    /// Source of the originating channel's inbound message (e.g. "webchat", "discord").
-    /// Propagated through metadata so conclusion routing uses the correct adapter.
-    originating_source: Option<String>,
-    /// Channel that originated the current link conversation (if any).
-    /// Used for guardrails to prevent re-delegating to the upstream counterparty
-    /// instead of concluding back to them.
-    originating_channel: Option<String>,
 }
 
 impl std::fmt::Debug for SendAgentMessageTool {
@@ -54,50 +39,42 @@ impl std::fmt::Debug for SendAgentMessageTool {
 }
 
 impl SendAgentMessageTool {
-    #[allow(clippy::too_many_arguments)]
     pub fn new(
-        agent_id: AgentId,
-        agent_name: String,
-        channel_id: crate::ChannelId,
+        agent_id: crate::AgentId,
         links: Arc<ArcSwap<Vec<AgentLink>>>,
-        messaging_manager: Arc<MessagingManager>,
-        channel_store: ChannelStore,
-        event_tx: broadcast::Sender<ProcessEvent>,
         agent_names: Arc<HashMap<String, String>>,
     ) -> Self {
         Self {
             agent_id,
-            agent_name,
-            channel_id,
             links,
-            messaging_manager,
-            channel_store,
-            event_tx,
             agent_names,
             skip_flag: None,
-            originating_source: None,
-            originating_channel: None,
         }
     }
-}
 
-impl SendAgentMessageTool {
     /// Set the per-turn skip flag so the channel turn ends after sending.
     pub fn with_skip_flag(mut self, flag: SkipFlag) -> Self {
         self.skip_flag = Some(flag);
         self
     }
 
-    /// Set the originating source (adapter name) for conclusion routing.
-    pub fn with_originating_source(mut self, source: String) -> Self {
-        self.originating_source = Some(source);
-        self
-    }
+    /// Resolve an agent target string to an agent ID.
+    /// Checks both IDs and display names (case-insensitive).
+    fn resolve_agent_id(&self, target: &str) -> Option<String> {
+        // Direct ID match
+        if self.agent_names.contains_key(target) {
+            return Some(target.to_string());
+        }
 
-    /// Set the direct originating channel for this turn.
-    pub fn with_originating_channel(mut self, channel_id: String) -> Self {
-        self.originating_channel = Some(channel_id);
-        self
+        // Name match (case-insensitive)
+        let target_lower = target.to_lowercase();
+        for (agent_id, name) in self.agent_names.iter() {
+            if name.to_lowercase() == target_lower {
+                return Some(agent_id.clone());
+            }
+        }
+
+        None
     }
 }
 
@@ -120,7 +97,7 @@ pub struct SendAgentMessageArgs {
 pub struct SendAgentMessageOutput {
     pub success: bool,
     pub target_agent: String,
-    pub channel_id: String,
+    pub message: String,
 }
 
 impl Tool for SendAgentMessageTool {
@@ -167,32 +144,6 @@ impl Tool for SendAgentMessageTool {
             ))
         })?;
 
-        // In link channels, responding to the current counterparty should use the reply tool
-        // so metadata and conclusion routing stay on the same conversation chain.
-        if self
-            .current_link_counterparty_id()
-            .as_deref()
-            .is_some_and(|counterparty| counterparty == target_agent_id)
-        {
-            return Err(SendAgentMessageError(
-                "you are already in a direct link conversation with this agent. Use reply to respond in the current link channel. Use send_agent_message to contact a different agent.".to_string(),
-            ));
-        }
-
-        // In nested link flows, if the target is the upstream counterparty
-        // from the parent link channel, the correct action is conclude_link.
-        // Re-sending to that agent creates parallel link threads with incorrect
-        // originating metadata.
-        if self
-            .upstream_counterparty_id()
-            .as_deref()
-            .is_some_and(|counterparty| counterparty == target_agent_id)
-        {
-            return Err(SendAgentMessageError(
-                "this target is the upstream counterparty for this link conversation. Use conclude_link to route the result back up the chain instead of send_agent_message.".to_string(),
-            ));
-        }
-
         // Look up the link between sending agent and target
         let links = self.links.load();
         let link = crate::links::find_link_between(&links, &self.agent_id, &target_agent_id)
@@ -201,12 +152,10 @@ impl Tool for SendAgentMessageTool {
                     "no communication link exists between you and agent '{}'.",
                     args.target
                 ))
-            })?
-            .clone();
+            })?;
 
         // Check direction: if the link is one_way, only from_agent can initiate
         let sending_agent_id = self.agent_id.as_ref();
-        let is_from_agent = link.from_agent_id == sending_agent_id;
         let is_to_agent = link.to_agent_id == sending_agent_id;
 
         if link.direction == crate::links::LinkDirection::OneWay && is_to_agent {
@@ -216,88 +165,17 @@ impl Tool for SendAgentMessageTool {
             )));
         }
 
-        // Determine the receiving agent and the relationship from sender's perspective
-        let receiving_agent_id = if is_from_agent {
+        let receiving_agent_id = if link.from_agent_id == sending_agent_id {
             &link.to_agent_id
         } else {
             &link.from_agent_id
         };
 
-        let target_agent_arc: AgentId = Arc::from(receiving_agent_id.as_str());
-        // Each agent gets its own side of the link channel
-        let receiver_channel = link.channel_id_for(receiving_agent_id);
-        let sender_channel = link.channel_id_for(sending_agent_id);
-
-        // Materialize the sender-side link channel immediately so both sides
-        // are visible in their channel lists even before the first reply.
-        let sender_channel_metadata: HashMap<String, serde_json::Value> = HashMap::new();
-        self.channel_store
-            .upsert(&sender_channel, &sender_channel_metadata);
-
-        // Construct the internal message targeting the receiver's link channel.
-        // originating_channel is always the current channel — the direct parent
-        // of this link conversation. Conclusions route one hop back, not to the root.
-        let mut metadata = HashMap::from([
-            ("from_agent_id".into(), serde_json::json!(sending_agent_id)),
-            ("link_kind".into(), serde_json::json!(link.kind.as_str())),
-            ("reply_to_agent".into(), serde_json::json!(sending_agent_id)),
-            (
-                "reply_to_channel".into(),
-                serde_json::json!(&sender_channel),
-            ),
-            (
-                "originating_channel".into(),
-                serde_json::json!(self.channel_id.as_ref()),
-            ),
-            (
-                "original_sent_message".into(),
-                serde_json::json!(&args.message),
-            ),
-        ]);
-        // Propagate the adapter name from the originating channel so conclusion
-        // routing can look up the correct messaging adapter (e.g. "webchat").
-        if let Some(source) = &self.originating_source {
-            metadata.insert("originating_source".into(), serde_json::json!(source));
-        }
-
-        let message = InboundMessage {
-            id: uuid::Uuid::new_v4().to_string(),
-            source: "internal".into(),
-            conversation_id: receiver_channel.clone(),
-            sender_id: sending_agent_id.to_string(),
-            agent_id: Some(target_agent_arc),
-            content: MessageContent::Text(args.message),
-            timestamp: Utc::now(),
-            metadata,
-            formatted_author: Some(format!("[{}]", self.agent_name)),
-        };
-
-        // Inject into the messaging pipeline
-        self.messaging_manager
-            .inject_message(message)
-            .await
-            .map_err(|error| {
-                SendAgentMessageError(format!("failed to deliver message: {error}"))
-            })?;
-
-        // End the current turn immediately. Delegating to another agent means
-        // this agent is done — without this, the LLM loops calling skip and
-        // burns through its depth budget while waiting for a response that
-        // arrives asynchronously.
+        // End the current turn immediately after delegation.
         if let Some(ref flag) = self.skip_flag {
             flag.store(true, Ordering::Relaxed);
         }
 
-        // Emit process event for dashboard visibility
-        self.event_tx
-            .send(ProcessEvent::AgentMessageSent {
-                from_agent_id: self.agent_id.clone(),
-                to_agent_id: Arc::from(receiving_agent_id.as_str()),
-                link_id: receiver_channel.clone(),
-                channel_id: Arc::from(receiver_channel.as_str()),
-            })
-            .ok();
-
         let target_display = self
             .agent_names
             .get(receiving_agent_id)
@@ -307,64 +185,18 @@ impl Tool for SendAgentMessageTool {
         tracing::info!(
             from = %self.agent_id,
             to = %receiving_agent_id,
-            receiver_channel = %receiver_channel,
-            sender_channel = %sender_channel,
-            "agent message sent"
+            "agent message validated (task delegation not yet wired)"
         );
 
+        // TODO: Create a task in the target agent's task store instead of
+        // injecting a message. This is a stub — the tool validates the link
+        // and ends the turn, but doesn't actually deliver anything yet.
+
         Ok(SendAgentMessageOutput {
             success: true,
             target_agent: target_display,
-            channel_id: sender_channel,
+            message: "Message validated. Cross-agent task delegation not yet implemented."
+                .to_string(),
         })
     }
 }
-
-impl SendAgentMessageTool {
-    /// If this tool is running in a link channel, return the peer agent ID.
-    fn current_link_counterparty_id(&self) -> Option<String> {
-        self.channel_id
-            .as_ref()
-            .strip_prefix("link:")
-            .and_then(|rest| {
-                let (self_id, peer_id) = rest.split_once(':')?;
-                if self_id == self.agent_id.as_ref() {
-                    Some(peer_id.to_string())
-                } else {
-                    None
-                }
-            })
-    }
-
-    /// If this link conversation was initiated from another link channel,
-    /// return that upstream link's counterparty agent ID.
-    fn upstream_counterparty_id(&self) -> Option<String> {
-        let originating = self.originating_channel.as_deref()?;
-        let rest = originating.strip_prefix("link:")?;
-        let (self_id, counterparty_id) = rest.split_once(':')?;
-        if self_id == self.agent_id.as_ref() {
-            Some(counterparty_id.to_string())
-        } else {
-            None
-        }
-    }
-
-    /// Resolve an agent target string to an agent ID.
-    /// Checks both IDs and display names.
-    fn resolve_agent_id(&self, target: &str) -> Option<String> {
-        // Direct ID match
-        if self.agent_names.contains_key(target) {
-            return Some(target.to_string());
-        }
-
-        // Name match (case-insensitive)
-        let target_lower = target.to_lowercase();
-        for (agent_id, name) in self.agent_names.iter() {
-            if name.to_lowercase() == target_lower {
-                return Some(agent_id.clone());
-            }
-        }
-
-        None
-    }
-}
diff --git a/src/tools/task_create.rs b/src/tools/task_create.rs
new file mode 100644
index 000000000..95a797abf
--- /dev/null
+++ b/src/tools/task_create.rs
@@ -0,0 +1,143 @@
+//! Task creation tool for branch processes.
+
+use crate::tasks::{CreateTaskInput, TaskPriority, TaskStatus, TaskStore, TaskSubtask};
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct TaskCreateTool {
+    task_store: Arc<TaskStore>,
+    agent_id: String,
+    created_by: String,
+}
+
+impl TaskCreateTool {
+    pub fn new(
+        task_store: Arc<TaskStore>,
+        agent_id: impl Into<String>,
+        created_by: impl Into<String>,
+    ) -> Self {
+        Self {
+            task_store,
+            agent_id: agent_id.into(),
+            created_by: created_by.into(),
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("task_create failed: {0}")]
+pub struct TaskCreateError(String);
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct TaskCreateArgs {
+    pub title: String,
+    pub description: Option<String>,
+    #[serde(default = "default_priority")]
+    pub priority: String,
+    #[serde(default)]
+    pub subtasks: Vec<String>,
+    #[serde(default)]
+    pub metadata: Option<serde_json::Value>,
+    #[serde(default)]
+    pub status: Option<String>,
+}
+
+fn default_priority() -> String {
+    "medium".to_string()
+}
+
+#[derive(Debug, Serialize)]
+pub struct TaskCreateOutput {
+    pub success: bool,
+    pub task_number: i64,
+    pub status: String,
+    pub message: String,
+}
+
+impl Tool for TaskCreateTool {
+    const NAME: &'static str = "task_create";
+
+    type Error = TaskCreateError;
+    type Args = TaskCreateArgs;
+    type Output = TaskCreateOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/task_create").to_string(),
+            parameters: serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "title": { "type": "string", "description": "Short task title" },
+                    "description": { "type": "string", "description": "Optional detailed description" },
+                    "priority": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskPriority::ALL.iter().map(|p| p.to_string()).collect::<Vec<_>>(),
+                        "description": "Task priority"
+                    },
+                    "subtasks": {
+                        "type": "array",
+                        "items": { "type": "string" },
+                        "description": "Optional checklist items"
+                    },
+                    "metadata": {
+                        "type": "object",
+                        "description": "Optional metadata object"
+                    },
+                    "status": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskStatus::ALL.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+                        "description": "Optional initial status"
+                    }
+                },
+                "required": ["title"]
+            }),
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let priority = TaskPriority::parse(&args.priority)
+            .ok_or_else(|| TaskCreateError(format!("invalid priority: {}", args.priority)))?;
+        let status = match args.status.as_deref() {
+            None => TaskStatus::Backlog,
+            Some(value) => TaskStatus::parse(value)
+                .ok_or_else(|| TaskCreateError(format!("invalid status: {value}")))?,
+        };
+
+        let subtasks = args
+            .subtasks
+            .into_iter()
+            .map(|title| TaskSubtask {
+                title,
+                completed: false,
+            })
+            .collect::<Vec<_>>();
+
+        let task = self
+            .task_store
+            .create(CreateTaskInput {
+                agent_id: self.agent_id.clone(),
+                title: args.title,
+                description: args.description,
+                status,
+                priority,
+                subtasks,
+                metadata: args.metadata.unwrap_or_else(|| serde_json::json!({})),
+                source_memory_id: None,
+                created_by: self.created_by.clone(),
+            })
+            .await
+            .map_err(|error| TaskCreateError(format!("{error}")))?;
+
+        Ok(TaskCreateOutput {
+            success: true,
+            task_number: task.task_number,
+            status: task.status.to_string(),
+            message: format!("Created task #{}: {}", task.task_number, task.title),
+        })
+    }
+}
diff --git a/src/tools/task_list.rs b/src/tools/task_list.rs
new file mode 100644
index 000000000..efa34b2bd
--- /dev/null
+++ b/src/tools/task_list.rs
@@ -0,0 +1,109 @@
+//! Task listing tool for branch processes.
+
+use crate::tasks::{TaskPriority, TaskStatus, TaskStore};
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct TaskListTool {
+    task_store: Arc<TaskStore>,
+    agent_id: String,
+}
+
+impl TaskListTool {
+    pub fn new(task_store: Arc<TaskStore>, agent_id: impl Into<String>) -> Self {
+        Self {
+            task_store,
+            agent_id: agent_id.into(),
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("task_list failed: {0}")]
+pub struct TaskListError(String);
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct TaskListArgs {
+    pub status: Option<String>,
+    pub priority: Option<String>,
+    #[serde(default = "default_limit")]
+    pub limit: i32,
+}
+
+fn default_limit() -> i32 {
+    20
+}
+
+#[derive(Debug, Serialize)]
+pub struct TaskListOutput {
+    pub success: bool,
+    pub count: usize,
+    pub tasks: Vec<crate::tasks::Task>,
+}
+
+impl Tool for TaskListTool {
+    const NAME: &'static str = "task_list";
+
+    type Error = TaskListError;
+    type Args = TaskListArgs;
+    type Output = TaskListOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/task_list").to_string(),
+            parameters: serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "status": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskStatus::ALL.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+                        "description": "Optional status filter"
+                    },
+                    "priority": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskPriority::ALL.iter().map(|p| p.to_string()).collect::<Vec<_>>(),
+                        "description": "Optional priority filter"
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of tasks to return"
+                    }
+                }
+            }),
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let status = match args.status.as_deref() {
+            None => None,
+            Some(value) => Some(
+                TaskStatus::parse(value)
+                    .ok_or_else(|| TaskListError(format!("invalid status filter: {value}")))?,
+            ),
+        };
+        let priority = match args.priority.as_deref() {
+            None => None,
+            Some(value) => Some(
+                TaskPriority::parse(value)
+                    .ok_or_else(|| TaskListError(format!("invalid priority filter: {value}")))?,
+            ),
+        };
+        let limit = i64::from(args.limit).clamp(1, 500);
+        let tasks = self
+            .task_store
+            .list(&self.agent_id, status, priority, limit)
+            .await
+            .map_err(|error| TaskListError(format!("{error}")))?;
+
+        Ok(TaskListOutput {
+            success: true,
+            count: tasks.len(),
+            tasks,
+        })
+    }
+}
diff --git a/src/tools/task_update.rs b/src/tools/task_update.rs
new file mode 100644
index 000000000..d26cf356e
--- /dev/null
+++ b/src/tools/task_update.rs
@@ -0,0 +1,235 @@
+//! Task update tool for branch and worker processes.
+
+use crate::tasks::{TaskPriority, TaskStatus, TaskStore, TaskSubtask, UpdateTaskInput};
+use crate::{AgentId, WorkerId};
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub enum TaskUpdateScope {
+    Branch,
+    Worker(WorkerId),
+}
+
+#[derive(Debug, Clone)]
+pub struct TaskUpdateTool {
+    task_store: Arc<TaskStore>,
+    agent_id: AgentId,
+    scope: TaskUpdateScope,
+}
+
+impl TaskUpdateTool {
+    pub fn for_branch(task_store: Arc<TaskStore>, agent_id: AgentId) -> Self {
+        Self {
+            task_store,
+            agent_id,
+            scope: TaskUpdateScope::Branch,
+        }
+    }
+
+    pub fn for_worker(task_store: Arc<TaskStore>, agent_id: AgentId, worker_id: WorkerId) -> Self {
+        Self {
+            task_store,
+            agent_id,
+            scope: TaskUpdateScope::Worker(worker_id),
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("task_update failed: {0}")]
+pub struct TaskUpdateError(String);
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct TaskUpdateArgs {
+    pub task_number: i32,
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub status: Option<String>,
+    pub priority: Option<String>,
+    pub subtasks: Option<Vec<TaskSubtask>>,
+    pub metadata: Option<serde_json::Value>,
+    pub complete_subtask: Option<i32>,
+    pub worker_id: Option<String>,
+    pub approved_by: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct TaskUpdateOutput {
+    pub success: bool,
+    pub task_number: i64,
+    pub status: String,
+    pub message: String,
+}
+
+impl Tool for TaskUpdateTool {
+    const NAME: &'static str = "task_update";
+
+    type Error = TaskUpdateError;
+    type Args = TaskUpdateArgs;
+    type Output = TaskUpdateOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        let is_worker = matches!(self.scope, TaskUpdateScope::Worker(_));
+
+        // Workers only see subtask/metadata fields; branches/cortex see everything.
+        let parameters = if is_worker {
+            serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "task_number": { "type": "integer", "description": "Task number reference (#N)" },
+                    "subtasks": {
+                        "type": "array",
+                        "description": "Optional full replacement of subtask list",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "title": { "type": "string" },
+                                "completed": { "type": "boolean" }
+                            },
+                            "required": ["title", "completed"]
+                        }
+                    },
+                    "metadata": { "type": "object", "description": "Metadata object merged with current metadata" },
+                    "complete_subtask": { "type": "integer", "description": "Subtask index to mark complete" }
+                },
+                "required": ["task_number"]
+            })
+        } else {
+            serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "task_number": { "type": "integer", "description": "Task number reference (#N)" },
+                    "title": { "type": "string", "description": "Optional new title" },
+                    "description": { "type": "string", "description": "Optional new description" },
+                    "status": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskStatus::ALL.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+                        "description": "Optional new status"
+                    },
+                    "priority": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskPriority::ALL.iter().map(|p| p.to_string()).collect::<Vec<_>>(),
+                        "description": "Optional new priority"
+                    },
+                    "subtasks": {
+                        "type": "array",
+                        "description": "Optional full replacement of subtask list",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "title": { "type": "string" },
+                                "completed": { "type": "boolean" }
+                            },
+                            "required": ["title", "completed"]
+                        }
+                    },
+                    "metadata": { "type": "object", "description": "Metadata object merged with current metadata" },
+                    "complete_subtask": { "type": "integer", "description": "Subtask index to mark complete" },
+                    "worker_id": { "type": "string", "description": "Optional worker ID to bind to this task" },
+                    "approved_by": { "type": "string", "description": "Optional approver identifier" }
+                },
+                "required": ["task_number"]
+            })
+        };
+
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/task_update").to_string(),
+            parameters,
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let task_number = i64::from(args.task_number);
+
+        if let TaskUpdateScope::Worker(ref worker_id) = self.scope {
+            let current = self
+                .task_store
+                .get_by_worker_id(&worker_id.to_string())
+                .await
+                .map_err(|error| TaskUpdateError(format!("{error}")))?;
+
+            let Some(task) = current else {
+                return Err(TaskUpdateError(
+                    "worker is not assigned to a task".to_string(),
+                ));
+            };
+
+            if task.task_number != task_number {
+                return Err(TaskUpdateError(format!(
+                    "worker {} can only update task #{}",
+                    worker_id, task.task_number
+                )));
+            }
+
+            // Workers can only update subtasks and metadata — not status, priority,
+            // title, description, worker binding, or approval.
+            if args.title.is_some()
+                || args.description.is_some()
+                || args.status.is_some()
+                || args.priority.is_some()
+                || args.worker_id.is_some()
+                || args.approved_by.is_some()
+            {
+                return Err(TaskUpdateError(
+                    "workers can only update subtasks and metadata".to_string(),
+                ));
+            }
+        }
+
+        let status = match args.status.as_deref() {
+            None => None,
+            Some(value) => Some(
+                TaskStatus::parse(value)
+                    .ok_or_else(|| TaskUpdateError(format!("invalid status: {value}")))?,
+            ),
+        };
+        let priority = match args.priority.as_deref() {
+            None => None,
+            Some(value) => Some(
+                TaskPriority::parse(value)
+                    .ok_or_else(|| TaskUpdateError(format!("invalid priority: {value}")))?,
+            ),
+        };
+        let complete_subtask = match args.complete_subtask {
+            None => None,
+            Some(value) => Some(
+                usize::try_from(value)
+                    .map_err(|_| TaskUpdateError(format!("invalid subtask index: {value}")))?,
+            ),
+        };
+
+        let updated = self
+            .task_store
+            .update(
+                &self.agent_id,
+                task_number,
+                UpdateTaskInput {
+                    title: args.title,
+                    description: args.description,
+                    status,
+                    priority,
+                    subtasks: args.subtasks,
+                    metadata: args.metadata,
+                    worker_id: args.worker_id,
+                    clear_worker_id: false,
+                    approved_by: args.approved_by,
+                    complete_subtask,
+                },
+            )
+            .await
+            .map_err(|error| TaskUpdateError(format!("{error}")))?
+            .ok_or_else(|| TaskUpdateError(format!("task #{} not found", task_number)))?;
+
+        Ok(TaskUpdateOutput {
+            success: true,
+            task_number: updated.task_number,
+            status: updated.status.to_string(),
+            message: format!("Updated task #{}", updated.task_number),
+        })
+    }
+}
diff --git a/tests/bulletin.rs b/tests/bulletin.rs
index aaddb5eba..8470632d4 100644
--- a/tests/bulletin.rs
+++ b/tests/bulletin.rs
@@ -49,6 +49,7 @@ async fn bootstrap_deps() -> anyhow::Result<spacebot::AgentDeps> {
         embedding_table,
         embedding_model,
     ));
+    let task_store = Arc::new(spacebot::tasks::TaskStore::new(db.sqlite.clone()));
 
     let identity = spacebot::identity::Identity::load(&agent_config.workspace).await;
     let prompts =
@@ -85,6 +86,7 @@ async fn bootstrap_deps() -> anyhow::Result<spacebot::AgentDeps> {
         memory_search,
         llm_manager,
         mcp_manager,
+        task_store,
         cron_tool: None,
         runtime_config,
         event_tx,
diff --git a/tests/context_dump.rs b/tests/context_dump.rs
index a455ae62f..18a55691d 100644
--- a/tests/context_dump.rs
+++ b/tests/context_dump.rs
@@ -49,6 +49,7 @@ async fn bootstrap_deps() -> anyhow::Result<(spacebot::AgentDeps, spacebot::conf
         embedding_table,
         embedding_model,
     ));
+    let task_store = Arc::new(spacebot::tasks::TaskStore::new(db.sqlite.clone()));
 
     let identity = spacebot::identity::Identity::load(&agent_config.workspace).await;
     let prompts =
@@ -85,6 +86,7 @@ async fn bootstrap_deps() -> anyhow::Result<(spacebot::AgentDeps, spacebot::conf
         memory_search,
         llm_manager,
         mcp_manager,
+        task_store,
         cron_tool: None,
         runtime_config,
         event_tx,
@@ -195,12 +197,12 @@ async fn dump_channel_context() {
         history: Arc::new(tokio::sync::RwLock::new(Vec::new())),
         active_branches: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         worker_handles: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
-        process_run_logger: spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone()),
         active_workers: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         worker_inputs: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         status_block,
         deps: deps.clone(),
         conversation_logger,
+        process_run_logger: spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone()),
         channel_store,
         screenshot_dir: std::path::PathBuf::from("/tmp/screenshots"),
         logs_dir: std::path::PathBuf::from("/tmp/logs"),
@@ -219,10 +221,6 @@ async fn dump_channel_context() {
         replied_flag,
         None,
         None,
-        None,
-        None,
-        None,
-        None,
     )
     .await
     .expect("failed to add channel tools");
@@ -276,11 +274,13 @@ async fn dump_branch_context() {
     let channel_store = spacebot::conversation::ChannelStore::new(deps.sqlite_pool.clone());
     let run_logger = spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone());
     let branch_tool_server = spacebot::tools::create_branch_tool_server(
+        None,
+        deps.agent_id.clone(),
+        deps.task_store.clone(),
         deps.memory_search.clone(),
         conversation_logger,
         channel_store,
         run_logger,
-        "test-agent",
     );
 
     let tool_defs = branch_tool_server
@@ -335,6 +335,7 @@ async fn dump_worker_context() {
         deps.agent_id.clone(),
         worker_id,
         None,
+        deps.task_store.clone(),
         deps.event_tx.clone(),
         browser_config,
         std::path::PathBuf::from("/tmp/screenshots"),
@@ -413,7 +414,6 @@ async fn dump_all_contexts() {
         history: Arc::new(tokio::sync::RwLock::new(Vec::new())),
         active_branches: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         worker_handles: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
-        process_run_logger: spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone()),
         active_workers: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         worker_inputs: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         status_block: Arc::new(tokio::sync::RwLock::new(
@@ -421,6 +421,7 @@ async fn dump_all_contexts() {
         )),
         deps: deps.clone(),
         conversation_logger: conversation_logger.clone(),
+        process_run_logger: spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone()),
         channel_store: channel_store.clone(),
         screenshot_dir: std::path::PathBuf::from("/tmp/screenshots"),
         logs_dir: std::path::PathBuf::from("/tmp/logs"),
@@ -438,10 +439,6 @@ async fn dump_all_contexts() {
         replied_flag,
         None,
         None,
-        None,
-        None,
-        None,
-        None,
     )
     .await
     .expect("failed to add channel tools");
@@ -464,11 +461,13 @@ async fn dump_all_contexts() {
         .expect("failed to render branch prompt");
     let run_logger = spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone());
     let branch_tool_server = spacebot::tools::create_branch_tool_server(
+        None,
+        deps.agent_id.clone(),
+        deps.task_store.clone(),
         deps.memory_search.clone(),
         conversation_logger,
         channel_store,
         run_logger,
-        "test-agent",
     );
     let branch_tool_defs = branch_tool_server.get_tool_defs(None).await.unwrap();
     let branch_tools_text = format_tool_defs(&branch_tool_defs);
@@ -493,6 +492,7 @@ async fn dump_all_contexts() {
         deps.agent_id.clone(),
         uuid::Uuid::new_v4(),
         None,
+        deps.task_store.clone(),
         deps.event_tx.clone(),
         browser_config,
         std::path::PathBuf::from("/tmp/screenshots"),