ltcai 2.0.0 → 2.1.0

package/README.md

@@ -353,29 +353,29 @@ Supported routes include OpenAI-compatible APIs, OpenRouter, Groq, Together, xAI
 
 ## Current release
 
-**2.0.0 — Agentic Workspace Platform.** Lattice AI graduates from a local-first
-AI *workspace* to a local-first **Agentic Workspace Platform**: four new
-subsystems land as one cohesive, fully integrated platform — all additive, with
-every v1.x surface preserved.
-
-- **Plugin SDK** — versioned, permissioned plugins (`plugin.json` manifest,
-  allow-listed permissions, lifecycle, validation, and a safe execution
-  boundary) that **extend** existing skills/tools/workflows rather than replace
-  them. Ships two example plugins. See [docs/PLUGIN_SDK.md](docs/PLUGIN_SDK.md).
-- **Workflow Designer** — node-based workflows (trigger · tool · skill · plugin ·
-  agent · condition · output) with validation, execution, run history, and
-  export/import. Pre-2.0 workflow history keeps working.
-  See [docs/WORKFLOW_DESIGNER.md](docs/WORKFLOW_DESIGNER.md).
-- **Multi-Agent Runtime 2.0** — Planner · Executor · Reviewer · Researcher ·
-  Release roles with handoff, retry, and an observable timeline, connected to
-  workspace, memory, graph, and workflow runs.
-  See [docs/MULTI_AGENT_RUNTIME.md](docs/MULTI_AGENT_RUNTIME.md).
-- **Realtime Collaboration** — presence + an activity feed over SSE, fed
-  automatically from every workspace timeline event; single-user local mode and
-  workspace isolation preserved. See [docs/REALTIME_COLLABORATION.md](docs/REALTIME_COLLABORATION.md).
-- **Cross-system integration** — workflows run plugins/skills/agents, agent runs
-  run plugins/workflows, and all activity surfaces in the realtime feed, the
-  knowledge graph, and the workspace timeline. See [docs/V2_ARCHITECTURE.md](docs/V2_ARCHITECTURE.md).
+**2.1.0 — Agent Platform Maturity Release.** Lattice AI operationalizes the
+v2.0 platform without replacing it: agent handoff, context packets, review/retry,
+planning, memory, replay, marketplace templates, and realtime execution
+observability are now first-class and still additive.
+
+- **Agent handoff + context packets** — handoffs now carry `handoff_id`,
+  source/target agent ids, reason, status, timestamps, and safe structured
+  context packets for replayable role transfer.
+- **Review / retry loops** — Planner -> Executor -> Reviewer records plan
+  review, reviewer notes, retry history, retry limits, and failure propagation.
+- **Timeline / replay** — agent and workflow runs expose replay frames showing
+  who acted, when, why, input, output, and decisions.
+- **Agent memory + planning** — short-term, workspace, and long-term memory
+  kinds are supported with workspace-scoped snapshots; plans are persisted with
+  run history and plan-review metadata.
+- **Workflow / agent / plugin hardening** — plugin outputs enter agent context,
+  agent outputs enter workflow outputs, and plugin/workflow/agent failures emit
+  observable execution events.
+- **Marketplace foundation** — local Plugin, Workflow, and Agent templates have
+  metadata, export/import, install hooks, and a registry. No cloud marketplace
+  service is introduced.
+- **Realtime execution observability** — existing SSE feed now emits agent,
+  handoff, review, retry, workflow, plugin, and execution failure events.
 - **Compatibility preserved** — API schemas, `server:app`,
   `latticeai.server_app.app`, CLI, MCP, model, workspace, chat, KG, existing
   skills/snapshots/memories/agent history, and the VS Code extension remain
@@ -383,7 +383,8 @@ every v1.x surface preserved.
 
 | Version | Theme |
 |---|---|
-| **2.0.0** | Agentic Workspace Platform (Plugin SDK, Workflow Designer, Multi-Agent Runtime, Realtime) |
+| **2.1.0** | Agent Platform Maturity Release (handoff, context packets, review/retry, replay, memory, planning, marketplace foundation) |
+| 2.0.0 | Agentic Workspace Platform (Plugin SDK, Workflow Designer, Multi-Agent Runtime, Realtime) |
 | 1.7.0 | Graph & Collaboration Release |
 | 1.6.0 | Product Experience Deepening (UX + real screenshots) |
 | 1.5.0 | Unified Product Release (CI/VSIX recovery, model recommendation, Enterprise PoC) |

package/docs/CHANGELOG.md

@@ -1,5 +1,59 @@
 # Changelog
 
+## [2.1.0] - 2026-06-01
+
+> Agent Platform Maturity Release — v2.1 operationalizes the v2.0 platform
+> without redesigning it. Agent handoff, context packets, review/retry loops,
+> timeline replay, memory snapshots, planning records, marketplace templates,
+> and realtime execution observability are now first-class and additive.
+
+### Added
+
+- **Explicit agent handoff** — handoff records now include `handoff_id`,
+  source/target agent ids, reason, task summary, context packet, status, and
+  timestamps. Handoffs are workspace-scoped, persisted, inspectable, and replayable.
+- **Agent context packets** — structured transfer packets include objective,
+  task summary, workspace/graph/memory/workflow context, plugin outputs,
+  constraints, reviewer notes, and retry metadata with obvious secret fields
+  redacted before persistence.
+- **Review / retry loops** — Planner -> Executor -> Reviewer records plan review,
+  reviewer outcomes (`approve`, `reject`, `retry`), retry history, retry limits,
+  reviewer notes, and failure propagation.
+- **Timeline / replay** — agent and workflow runs expose replay support through
+  persisted frames that show actor, time, reason, input, output, and decision.
+  UI pages add replay viewers for agent and workflow runs.
+- **Agent memory and planning** — `short_term`, `workspace`, and `long_term`
+  memory scopes are supported, memory snapshots are workspace-scoped and
+  replayable, and agent plans persist with plan-review metadata.
+- **Workflow / agent / plugin hardening** — plugin output enters agent context,
+  agent output enters workflow output, retry paths are bounded, and failures
+  propagate into run status and realtime events.
+- **Marketplace foundation** — local Plugin, Workflow, and Agent templates with
+  metadata, export/import, install hooks, and a template registry. No cloud
+  marketplace service is introduced.
+- **Realtime execution observability** — existing SSE feed emits
+  `agent_started`, `handoff_created`, `handoff_accepted`, `handoff_completed`,
+  `review_requested`, `review_approved`, `retry_requested`,
+  `workflow_started`, `plugin_started`, `plugin_completed`, `execution_failed`,
+  and related workspace-scoped events.
+
+### Changed
+
+- Python package, npm package, VS Code extension, Workspace OS, FastAPI app, and
+  `/health` version metadata aligned at `2.1.0`.
+- Multi-Agent Runtime, Plugin SDK, Workflow Engine, and Realtime surface
+  versions now report `2.1.0`.
+- Platform UI pages for agents, workflows, plugins, and activity now expose
+  handoff chains, review panels, retry history, replay, templates, and plugin
+  execution visibility.
+
+### Validation
+
+- Unit coverage added for handoff/context persistence, review/retry history,
+  memory snapshots, replay, workflow-agent-plugin output propagation,
+  marketplace template install, and realtime execution events.
+- Package-store publishing remains manual; release artifacts are version-scoped.
+
 ## [2.0.0] - 2026-06-01
 
 > Agentic Workspace Platform — Lattice AI becomes a local-first **Agentic

package/docs/MULTI_AGENT_RUNTIME.md

@@ -1,19 +1,37 @@
-# Lattice AI Multi-Agent Runtime 2.0
+# Lattice AI Multi-Agent Runtime 2.1
 
-The Multi-Agent Runtime is the **orchestration layer** introduced in v2.0.0. It sits
+The Multi-Agent Runtime is the **orchestration layer** introduced in v2.0.0 and
+operationalized in v2.1.0. It sits
 *above* the v1.x single-agent state machine ([`AgentRuntime`](../latticeai/core/agent.py))
 and coordinates a pipeline of named **roles** that hand off work to one another,
-retry on a failing review, and emit a fully observable timeline.
+retry on a failing review, and emit a fully observable, replayable timeline.
 
 - **Source of truth:** `latticeai/core/multi_agent.py`
 - **HTTP surface:** `latticeai/api/agents.py`
 - **Persistence / Knowledge Graph integration:** `latticeai/core/workspace_os.py`
-  (`WorkspaceOSStore.record_agent_run`)
+  (`WorkspaceOSStore.record_agent_run`, `replay_agent_run`, `list_handoffs`)
 
 ```python
-MULTI_AGENT_VERSION = "2.0.0"
+MULTI_AGENT_VERSION = "2.1.0"
 ```
 
+## What v2.1 adds
+
+v2.1 does not replace the v2.0 runtime; it makes the runtime's operational
+objects durable and inspectable:
+
+- **Explicit handoff records**: `handoff_id`, source/target agent ids, reason,
+  task summary, context packet, status, and timestamps.
+- **Agent context packets**: objective, task summary, workspace/graph/memory/
+  workflow context, plugin outputs, constraints, reviewer notes, and retry
+  metadata with obvious secret keys redacted.
+- **Review / retry history**: reviewer outcomes normalize to `approve`,
+  `reject`, or `retry`; retry reasons, notes, counts, and limits are persisted.
+- **Planning records**: plans include a `plan_id`, ordered executable steps, and
+  plan-review metadata.
+- **Replay**: persisted runs can be replayed as frames showing actor, time,
+  reason, input, output, and decision via `/agents/api/runs/{run_id}/replay`.
+
 ## How it relates to the v1 single-agent runtime
 
 v1.x shipped a single-agent state machine — `AgentRuntime` driving

package/docs/PLUGIN_SDK.md

@@ -1,9 +1,11 @@
 # Lattice AI Plugin SDK
 
-The Plugin SDK is the v2.0.0 extension layer for the Lattice AI Agentic Workspace
-Platform. It lets you package skills, tools, workflow templates, and actions into
-one versioned, permissioned unit — a *plugin*. A plugin is a directory under the
-configured `plugins` root that ships a `plugin.json` manifest.
+The Plugin SDK is the extension layer for the Lattice AI Agentic Workspace
+Platform. v2.1.0 keeps the v2.0 plugin model and adds execution observability plus
+local marketplace-template foundations. It lets you package skills, tools,
+workflow templates, and actions into one versioned, permissioned unit — a
+*plugin*. A plugin is a directory under the configured `plugins` root that ships
+a `plugin.json` manifest.
 
 The SDK is intentionally **additive**. Plugins *extend* the existing Skill, Tool,
 and Workflow surfaces; they never replace them. Standalone skills that are already
@@ -20,9 +22,19 @@ through the existing skill registry rather than owning a parallel one.
 The host SDK version is exposed as:
 
 ```python
-PLUGIN_SDK_VERSION = "2.0.0"
+PLUGIN_SDK_VERSION = "2.1.0"
 ```
 
+## v2.1 additions
+
+- `execute_action(...)` emits `plugin_started`, `plugin_completed`, and
+  `execution_failed` through the existing Workspace OS timeline/realtime feed.
+- Plugin outputs can be carried inside agent context packets and replayed from
+  agent/workflow run history.
+- The local template catalog (`latticeai.core.marketplace`) adds Plugin,
+  Workflow, and Agent template metadata, export/import, install hooks, and a
+  template registry without introducing a cloud marketplace service.
+
 ---
 
 ## The `plugin.json` manifest
@@ -39,7 +51,7 @@ parsed and validated into an immutable `PluginManifest`.
 | `version` | string | yes | Semantic version (`^\d+\.\d+\.\d+([.-][0-9A-Za-z.]+)?$`). |
 | `description` | string | no | Short summary. |
 | `author` | string | no | Author or organization. |
-| `lattice_version` | string | no | Minimum host version this plugin requires. May be bare (`"2.0.0"`) or prefixed (`">=2.0.0"`). Empty means "any host". |
+| `lattice_version` | string | no | Minimum host version this plugin requires. May be bare (`"2.1.0"`) or prefixed (`">=2.1.0"`). Empty means "any host". |
 | `permissions` | string[] | no | Must be a subset of the [permission allow-list](#permissions). Unknown values are rejected. |
 | `provides` | object | no | What the plugin contributes. Keys must be in `("skills", "tools", "workflows", "actions")`; each value is a list of names. |
 | `entrypoint` | string | no | Reserved for an optional code entrypoint. |
@@ -193,12 +205,13 @@ identically:
 { "lattice_version": ">=2.0.0" }
 ```
 
-Examples against a host of `2.0.0`:
+Examples against a host of `2.1.0`:
 
 | Required | Compatible | Why |
 | --- | --- | --- |
 | `""` (missing) | yes | Any host. |
 | `2.0.0` / `>=2.0.0` | yes | Same major, host `>=` required. |
+| `2.1.0` / `>=2.1.0` | yes | Same major, exact current host. |
 | `2.1.0` | no | Host is lower than the required minimum. |
 | `1.0.0` | no | Major mismatch. |
 | `3.0.0` | no | Major mismatch. |

package/docs/REALTIME_COLLABORATION.md

@@ -1,8 +1,10 @@
 # Lattice AI Realtime Collaboration
 
-Realtime Collaboration is the v2.0.0 subsystem that gives a Lattice AI workspace
-a live **presence** registry and an **activity feed**. It is delivered over
-Server-Sent Events (SSE) by an in-process pub/sub bus, the
+Realtime Collaboration is the subsystem that gives a Lattice AI workspace a live
+**presence** registry and an **activity feed**. In v2.1.0 it also carries
+workspace-scoped execution observability for agents, handoffs, reviews,
+workflows, plugins, retries, and failures. It is delivered over Server-Sent
+Events (SSE) by an in-process pub/sub bus, the
 [`RealtimeBus`](../latticeai/core/realtime.py).
 
 The design goal is to surface "what is happening in the workspace right now"
@@ -10,6 +12,17 @@ The design goal is to surface "what is happening in the workspace right now"
 who is online) without adding a new transport, a new dependency, or a second
 event system.
 
+The bus version is:
+
+```python
+REALTIME_VERSION = "2.1.0"
+```
+
+v2.1 execution event types include `agent_started`, `handoff_created`,
+`handoff_accepted`, `handoff_completed`, `review_requested`, `review_approved`,
+`retry_requested`, `workflow_started`, `workflow_completed`, `plugin_started`,
+`plugin_completed`, `execution_failed`, and `execution_cancelled`.
+
 ---
 
 ## Why SSE
@@ -288,7 +301,7 @@ defaults to `50` and is clamped to the `200`-entry buffer. Returns newest-first:
 {
   "events": [ /* enriched events, newest first */ ],
   "stats": {
-    "version": "2.0.0",
+    "version": "2.1.0",
     "subscribers": 1,
     "presence": 2,
     "feed_size": 17,
@@ -312,7 +325,7 @@ Returns the scope-filtered presence registry plus the same `stats` block:
       "last_seen": "2026-06-01T10:15:30"
     }
   ],
-  "stats": { "version": "2.0.0", "subscribers": 1, "presence": 1, "feed_size": 17, "transport": "sse" }
+  "stats": { "version": "2.1.0", "subscribers": 1, "presence": 1, "feed_size": 17, "transport": "sse" }
 }
 ```
 
@@ -406,5 +419,5 @@ no client-side filtering is needed.
   on top of it, not a replacement.
 - **Single process.** The bus is in-process by design for the local-first
   deployment; it does not coordinate across multiple server processes.
-- **`stats()`** reports `version` (`2.0.0`), live `subscribers`, `presence`
+- **`stats()`** reports `version` (`2.1.0`), live `subscribers`, `presence`
   count, `feed_size`, and the `transport` (`"sse"`) for health/observability.

package/docs/V2_ARCHITECTURE.md

@@ -1,9 +1,11 @@
-# Lattice AI v2.0 Architecture — Agentic Workspace Platform
+# Lattice AI v2 Architecture — Agentic Workspace Platform
 
-Lattice AI v2.0.0 turns the local-first Workspace OS into a full **Agentic
-Workspace Platform**: a single FastAPI application in which plugins, designed
-workflows, multi-agent runs, and a realtime collaboration feed all compose over
-the same local-first JSON store and Knowledge Graph.
+Lattice AI v2.0.0 turned the local-first Workspace OS into a full **Agentic
+Workspace Platform**. v2.1.0 keeps that architecture and matures the operational
+layer: explicit handoffs, context packets, review/retry loops, memory snapshots,
+planning records, replay, marketplace templates, and realtime execution
+observability all compose over the same local-first JSON store and Knowledge
+Graph.
 
 This document describes how the four v2.0 pillars fit together, the small set of
 **additive integration seams** that wire them, the cross-integration matrix that
@@ -17,6 +19,7 @@ on. Every claim below is grounded in the shipping source:
 - Workflow engine: `latticeai/core/workflow_engine.py`, `latticeai/api/workflow_designer.py`
 - Multi-Agent runtime: `latticeai/core/multi_agent.py`, `latticeai/api/agents.py`
 - Realtime bus: `latticeai/core/realtime.py`, `latticeai/api/realtime.py`
+- Marketplace foundation: `latticeai/core/marketplace.py`, `latticeai/api/marketplace.py`
 - Project conventions: `AGENTS.md`
 
 All four subsystems share the same design rules from `AGENTS.md`: dependency
@@ -26,12 +29,13 @@ constructed by `server_app.py` and exposed through a router factory.
 
 ---
 
-## 1. The Four v2.0 Pillars
+## 1. The Four v2 Pillars
 
 The platform version is the single source of truth `WORKSPACE_OS_VERSION =
-"2.0.0"` (`latticeai/core/workspace_os.py`). Each pillar module re-declares the
+"2.1.0"` (`latticeai/core/workspace_os.py`). Each pillar module re-declares the
 same version for its own surface (`PLUGIN_SDK_VERSION`, `WORKFLOW_ENGINE_VERSION`,
-`MULTI_AGENT_VERSION`, `REALTIME_VERSION`).
+`MULTI_AGENT_VERSION`, `REALTIME_VERSION`) and the marketplace foundation exposes
+`MARKETPLACE_VERSION`.
 
 ### 1.1 Plugin SDK (`latticeai.core.plugins`)
 
@@ -418,9 +422,9 @@ guarantee every cross-system run terminates.
 
 ---
 
-## 5. HTTP Surface (v2.0 additions)
+## 5. HTTP Surface (v2 additions)
 
-All v2.0 routes are namespaced so they never collide with existing paths
+All v2 routes are namespaced so they never collide with existing paths
 (`/plugins/registry` vs. the marketplace `/plugins/directory`; `/workflows` vs.
 `/workspace/workflows`; `/agents` plural vs. the single-agent `/agent`).
 
@@ -435,10 +439,18 @@ All v2.0 routes are namespaced so they never collide with existing paths
 /workflows/api/definitions/{id}`, `POST /workflows/api/validate`,
 `POST /workflows/api/definitions/{id}/run`,
 `GET /workflows/api/definitions/{id}/runs`, `GET /workflows/api/runs`,
+`GET /workflows/api/runs/{run_id}/replay`,
 `GET /workflows/api/export/{id}`, `POST /workflows/api/import`.
 
 **Multi-Agent Runtime** (`latticeai/api/agents.py`): `GET /agents`,
-`GET /agents/api/roles`, `GET /agents/api/runs`, `POST /agents/api/run`.
+`GET /agents/api/roles`, `GET /agents/api/runs`,
+`GET /agents/api/runs/{run_id}/replay`, `GET /agents/api/handoffs`,
+`GET|POST /agents/api/memory/snapshots`, `POST /agents/api/run`.
+
+**Marketplace foundation** (`latticeai/api/marketplace.py`):
+`GET /marketplace/templates`, `GET /marketplace/templates/{kind}/{id}/export`,
+`POST /marketplace/templates/import`, `POST /marketplace/templates/install`,
+`GET /marketplace/templates/registry`.
 
 **Realtime Collaboration** (`latticeai/api/realtime.py`): `GET /activity`,
 `GET /realtime/stream` (SSE), `GET /realtime/feed`, `GET /realtime/presence`,
@@ -460,7 +472,7 @@ Representative run request/response (Workflow Designer):
 
 ```json
 // POST /agents/api/run
-{ "goal": "Draft v2.0 release notes", "roles": ["planner", "executor", "reviewer"], "max_retries": 2 }
+{ "goal": "Draft v2.1 release notes", "roles": ["planner", "executor", "reviewer"], "max_retries": 2 }
 ```
 
 ```json
@@ -474,7 +486,7 @@ Representative run request/response (Workflow Designer):
 
 ## 6. Compatibility
 
-> **Compatibility note.** v2.0.0 is **additive**. All v1.x data and APIs are
+> **Compatibility note.** v2.1.0 is **additive**. All v1.x and v2.0 data and APIs are
 > preserved; the platform layers new capabilities on top of unchanged surfaces.
 
 Preserved surfaces, verified against source:
@@ -482,7 +494,7 @@ Preserved surfaces, verified against source:
 - **ASGI entrypoints.** `server:app` and `latticeai.server_app.app` remain the
   application objects. `server_app.py` still exposes the module-level `app =
   FastAPI(...)` plus the `main()` / `uvicorn.run(app, ...)` entry point.
-- **Version wiring.** `WORKSPACE_OS_VERSION = "2.0.0"` drives both
+- **Version wiring.** `WORKSPACE_OS_VERSION = "2.1.0"` drives both
   `APP_VERSION` (and thus the FastAPI `app.version`) and the `/health`
   response — the health router is constructed with `app_version=APP_VERSION`.
 - **Existing routes.** Every v1.x router (`auth`, `admin`, `security_dashboard`,

package/docs/WORKFLOW_DESIGNER.md

@@ -1,11 +1,11 @@
 # Lattice AI Workflow Designer
 
-The Workflow Designer (introduced in **v2.0.0**) lets you build, validate, run,
-inspect, export, and import automations as a small **directed graph of typed
-nodes**. A workflow starts from a single `trigger` node and walks node-to-node
-to an `output`, dispatching each executable node to an injected *runner* that
-calls the real tool registry, skill registry, plugin registry, or multi-agent
-orchestrator.
+The Workflow Designer (introduced in **v2.0.0** and hardened in **v2.1.0**) lets
+you build, validate, run, inspect, replay, export, and import automations as a
+small **directed graph of typed nodes**. A workflow starts from a single
+`trigger` node and walks node-to-node to an `output`, dispatching each executable
+node to an injected *runner* that calls the real tool registry, skill registry,
+plugin registry, or multi-agent orchestrator.
 
 The execution model lives in
 [`latticeai/core/workflow_engine.py`](../latticeai/core/workflow_engine.py)
@@ -17,9 +17,19 @@ is preserved.
 The engine version is exported as:
 
 ```python
-WORKFLOW_ENGINE_VERSION = "2.0.0"
+WORKFLOW_ENGINE_VERSION = "2.1.0"
 ```
 
+## v2.1 hardening
+
+- Agent node output is captured in workflow context and can flow into a later
+  plugin or output node through `last_output`.
+- Plugin node failures mark the run failed and emit realtime execution events.
+- Workflow runs are replayable via `/workflows/api/runs/{run_id}/replay`, with
+  frames for actor, time, reason, input, output, and decision.
+- `record_workflow_run` emits `workflow_started`, `workflow_completed`, and
+  `execution_failed` events over the existing SSE activity feed.
+
 ---
 
 ## Node types
@@ -439,7 +449,7 @@ or scope), stamped with the engine version and stripped of the internal
 
 ```json
 {
-  "lattice_workflow_export": "2.0.0",
+  "lattice_workflow_export": "2.1.0",
   "name": "Daily digest",
   "nodes": [ /* ... */ ],
   "metadata": {}

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"

package/latticeai/api/agents.py

@@ -1,4 +1,4 @@
-"""Multi-Agent Runtime 2.0 API router (v2.0).
+"""Multi-Agent Runtime API router (v2).
 
 Exposes the built-in agent roles and an orchestrated run endpoint that connects
 to Workspace, Memory, Knowledge Graph, Workflow runs, and the Timeline. Paths
@@ -22,6 +22,12 @@ class AgentRunRequest(BaseModel):
     max_retries: int = 2
 
 
+class MemorySnapshotRequest(BaseModel):
+    label: str = "agent memory snapshot"
+    reason: str = ""
+    memory_ids: List[str] = []
+
+
 def create_agents_router(
     *,
     store,
@@ -66,6 +72,49 @@ def create_agents_router(
         scope = gate_read(request)
         return store.list_agents(workspace_id=scope)
 
+    @router.get("/agents/api/handoffs")
+    async def agent_handoffs(request: Request, run_id: str = ""):
+        require_user(request)
+        scope = gate_read(request)
+        return store.list_handoffs(workspace_id=scope, run_id=run_id or None)
+
+    @router.get("/agents/api/runs/{run_id}")
+    async def agent_run_detail(run_id: str, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        try:
+            return {"run": store.get_agent_run(run_id, workspace_id=scope)}
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Agent run not found: {run_id}") from exc
+
+    @router.get("/agents/api/runs/{run_id}/replay")
+    async def agent_run_replay(run_id: str, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        try:
+            return {"replay": store.replay_agent_run(run_id, workspace_id=scope)}
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Agent run not found: {run_id}") from exc
+
+    @router.get("/agents/api/memory/snapshots")
+    async def agent_memory_snapshots(request: Request, limit: int = 50):
+        require_user(request)
+        scope = gate_read(request)
+        return store.list_memory_snapshots(workspace_id=scope, limit=limit)
+
+    @router.post("/agents/api/memory/snapshots")
+    async def agent_memory_snapshot(req: MemorySnapshotRequest, request: Request):
+        current_user = require_user(request)
+        scope = gate_write(request)
+        snapshot = store.create_memory_snapshot(
+            label=req.label,
+            reason=req.reason,
+            memory_ids=req.memory_ids or None,
+            user_email=current_user or None,
+            workspace_id=scope,
+        )
+        return {"snapshot": snapshot}
+
     @router.post("/agents/api/run")
     async def agent_run(req: AgentRunRequest, request: Request):
         current_user = require_user(request)
@@ -88,6 +137,13 @@ def create_agents_router(
             output_text=result.output,
             timeline=result.timeline,
             relationships=[ROLE_AGENT_IDS.get(r, f"agent:{r}") for r in result.roles_run],
+            handoffs=result.handoffs,
+            context_packets=result.context_packets,
+            plan=result.plan,
+            plan_review=result.plan_review,
+            review_history=result.review_history,
+            retry_history=result.retry_history,
+            memory_snapshots=result.memory_snapshots,
             user_email=current_user or None,
             graph=workspace_graph(),
             workspace_id=scope,

package/latticeai/api/marketplace.py

@@ -0,0 +1,81 @@
+"""Marketplace foundation API (local templates only)."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+
+
+class TemplateImportRequest(BaseModel):
+    data: Dict[str, Any] = {}
+
+
+class TemplateInstallRequest(BaseModel):
+    data: Dict[str, Any] = {}
+
+
+def create_marketplace_router(
+    *,
+    store,
+    catalog,
+    require_user: Callable[[Request], str],
+    gate_read: Callable[[Request], Optional[str]],
+    gate_write: Callable[[Request], Optional[str]],
+    workspace_graph: Callable[[], Any],
+) -> APIRouter:
+    from latticeai.core.marketplace import MarketplaceError
+
+    router = APIRouter()
+
+    @router.get("/marketplace/templates")
+    async def list_templates(request: Request, kind: Optional[str] = None):
+        require_user(request)
+        gate_read(request)
+        try:
+            return catalog.list_templates(kind=kind)
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    @router.get("/marketplace/templates/{kind}/{template_id}/export")
+    async def export_template(kind: str, template_id: str, request: Request):
+        require_user(request)
+        gate_read(request)
+        try:
+            return catalog.export_template(kind, template_id)
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+    @router.post("/marketplace/templates/import")
+    async def import_template(req: TemplateImportRequest, request: Request):
+        require_user(request)
+        gate_read(request)
+        try:
+            return {"template": catalog.import_template(req.data)}
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    @router.post("/marketplace/templates/install")
+    async def install_template(req: TemplateInstallRequest, request: Request):
+        user = require_user(request)
+        scope = gate_write(request)
+        try:
+            installed = catalog.install_template(
+                req.data,
+                store=store,
+                user_email=user or None,
+                workspace_id=scope,
+                graph=workspace_graph(),
+            )
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return {"installed": installed}
+
+    @router.get("/marketplace/templates/registry")
+    async def template_registry(request: Request):
+        require_user(request)
+        gate_read(request)
+        return {"registry": store.list_template_registry()}
+
+    return router

package/latticeai/api/plugins.py

@@ -1,4 +1,4 @@
-"""Plugin SDK API router (v2.0).
+"""Plugin SDK API router (v2).
 
 Surfaces the :class:`latticeai.core.plugins.PluginRegistry` over HTTP using the
 same router-factory convention as the rest of ``latticeai.api`` (server_app

package/latticeai/api/realtime.py

@@ -1,4 +1,4 @@
-"""Realtime Collaboration API router (v2.0).
+"""Realtime Collaboration API router (v2).
 
 Server-Sent-Events stream + presence + activity feed over
 :class:`latticeai.core.realtime.RealtimeBus`. Workspace isolation is enforced by

package/latticeai/api/workflow_designer.py

@@ -1,4 +1,4 @@
-"""Workflow Designer API router (v2.0).
+"""Workflow Designer API router (v2).
 
 Create / edit / validate / execute / inspect / export / import workflows plus
 run history, layered on :mod:`latticeai.core.workflow_engine` and the existing
@@ -174,6 +174,15 @@ def create_workflow_designer_router(
         scope = gate_read(request)
         return store.list_workflow_runs(limit=limit, workspace_id=scope)
 
+    @router.get("/workflows/api/runs/{run_id}/replay")
+    async def workflow_run_replay(run_id: str, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        try:
+            return {"replay": store.replay_workflow_run(run_id, workspace_id=scope)}
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Workflow run not found: {run_id}") from exc
+
     @router.get("/workflows/api/export/{workflow_id}")
     async def export_definition(workflow_id: str, request: Request):
         require_user(request)