From 7bd654c978c95bc19280906bf850ff94c06497c7 Mon Sep 17 00:00:00 2001
From: Goon <duy@wearetopgroup.com>
Date: Wed, 27 May 2026 14:16:17 +0700
Subject: [PATCH 1/2] plan(p6): add domain coverage P6 backend-unblocked CLI
 plan
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Mirrors issue #16 scope (7 command surfaces) as 4 grouped implementation
phases with TDD per the user's request. Backend evidence: digitopvn/goclaw
PR #37 + PR #44. Verified beta tag containing PR #44 is v3.12.0-beta.20.

Phases:
  1. Scope Lock — contract re-verification, drift sweep
  2. Traces Follow + Providers Reconnect (PR #37)
  3. Sessions Branch + Follow (PR #44 chat)
  4. Channels Writers Test (PR #44 channels)
  5. Activity + Logs Runtime Aggregate (PR #44 aggregation)
  6. Tests + Docs sweep with out-of-scope red-team
  7. Ship Readiness — single PR to dev

Out-of-scope list retained verbatim from issue #16: traces replay,
generic logs aggregate, WS/SSE chat history, watch loops.
---
 .../phase-01-scope-lock.md                    |  60 ++++++++
 ...2-traces-follow-and-providers-reconnect.md | 111 ++++++++++++++
 .../phase-03-sessions-branch-and-follow.md    | 115 ++++++++++++++
 .../phase-04-channels-writers-test.md         |  76 +++++++++
 .../phase-05-activity-and-logs-aggregate.md   | 114 ++++++++++++++
 .../phase-06-tests-and-docs.md                |  65 ++++++++
 .../phase-07-ship-readiness.md                |  70 +++++++++
 .../plan.md                                   | 144 ++++++++++++++++++
 8 files changed, 755 insertions(+)
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-01-scope-lock.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-02-traces-follow-and-providers-reconnect.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-03-sessions-branch-and-follow.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-04-channels-writers-test.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-05-activity-and-logs-aggregate.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-06-tests-and-docs.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-07-ship-readiness.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/plan.md

diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-01-scope-lock.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-01-scope-lock.md
new file mode 100644
index 0000000..dcec545
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-01-scope-lock.md
@@ -0,0 +1,60 @@
+---
+phase: 1
+title: "Scope Lock"
+status: pending
+priority: P2
+effort: "1h"
+dependencies: []
+---
+
+# Phase 1: Scope Lock
+
+## Overview
+
+Lock the 7-surface scope, re-verify backend contracts against `digitopvn/goclaw` `dev` tip, and produce the contract evidence file that subsequent phases reference. No CLI code changes.
+
+## Requirements
+
+- Re-fetch and read each backend handler to confirm path, method, query params, body shape, status enum, and error semantics.
+- Confirm beta tag `v3.12.0-beta.20` is the minimum that contains PR #44 commit `43049d3b` (already verified during plan creation; phase re-asserts).
+- Confirm no command-name collisions in current `cmd/` tree.
+- Produce `reports/scope-lock-260527-p6.md` summarizing contracts and any drift discovered.
+
+## Implementation Steps
+
+1. From the `digitopvn/goclaw` checkout (or via `gh api`), read:
+   - `internal/http/traces.go` — locate the `traces/follow` handler.
+   - `internal/http/providers.go` — locate the `providers/{id}/reconnect` handler.
+   - `internal/http/sessions.go` — locate the branch and history/follow handlers.
+   - `internal/http/channel_instances.go` — locate the writers/test handler.
+   - `internal/http/activity.go` — locate the aggregate handler.
+   - `internal/http/logs.go` — locate the runtime/aggregate handler.
+   - `internal/http/openapi_spec.json` for any documented schema differences.
+2. For each handler record: route, method, required vs optional inputs, response shape, status enum, error codes, admin-only flag.
+3. Compare against `plans/reports/codex-prompt-260522-p6-pr44-backend-unblocked-cli.md` (lives on `feat/claude-skill-v0.1` worktree) and the plan overview. Flag any drift.
+4. Re-verify beta tag: `gh api repos/digitopvn/goclaw/compare/v3.12.0-beta.20...43049d3b --jq '.status'` must return `identical`.
+5. Re-verify no naming collisions: `grep -in 'Use:.*"follow\|reconnect\|branch\|aggregate\|test"' cmd/*.go`.
+6. Write `reports/scope-lock-260527-p6.md` with the table of confirmed contracts.
+
+## Todo List
+
+- [ ] Backend contract re-read for all 7 endpoints.
+- [ ] Drift table populated (or zero-drift confirmed).
+- [ ] Beta tag re-confirmed.
+- [ ] Naming collision sweep run with output captured.
+- [ ] `reports/scope-lock-260527-p6.md` written.
+- [ ] Phase status flipped to Complete.
+
+## Success Criteria
+
+- Zero unresolved contract questions before phase 2 starts.
+- Scope file under `reports/` exists and is referenced from each implementation phase's "Evidence" section.
+
+## Out of Scope
+
+- Any CLI code change.
+- Any test scaffolding (phase 2+).
+
+## Next Steps
+
+Proceed to Phase 2 (Traces Follow + Providers Reconnect).
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-02-traces-follow-and-providers-reconnect.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-02-traces-follow-and-providers-reconnect.md
new file mode 100644
index 0000000..ffc5d3d
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-02-traces-follow-and-providers-reconnect.md
@@ -0,0 +1,111 @@
+---
+phase: 2
+title: "Traces Follow + Providers Reconnect (PR #37 surfaces)"
+status: pending
+priority: P2
+effort: "3h"
+dependencies: [1]
+---
+
+# Phase 2: Traces Follow + Providers Reconnect
+
+## Overview
+
+Implement two CLI surfaces from backend PR #37 (already in beta `v3.12.0-beta.16`+): polling-friendly trace follow and provider reconnect. Strict TDD — failing tests land before any Cobra command code.
+
+## Surfaces
+
+### 2.1 `goclaw traces follow`
+
+```bash
+goclaw traces follow --session-key <key> [--since <RFC3339>] [--limit N] [--include-spans] [--status <status>] [--channel <channel>] [-o json|yaml|table]
+goclaw traces follow --agent <uuid-or-key> [same flags]
+```
+
+- Endpoint: `GET /v1/traces/follow`
+- Require exactly one of `--session-key` or `--agent` (validate before HTTP call).
+- Optional: `status`, `channel`, `since`, `limit`, `include_spans`. `since` must be RFC3339.
+- Server default `limit=50`, max `200`. Don't enforce max client-side; let server respond.
+- Response shape:
+  ```json
+  {"traces":[],"spans_by_trace_id":{},"server_time":"...","next_since":"...","limit":50}
+  ```
+- JSON/YAML: print full envelope.
+- Table: rows like `traces list` — `TRACE_ID`, `AGENT`, `STATUS`, `DURATION_MS`, `INPUT_TOKENS`, `OUTPUT_TOKENS`, `COST`.
+- **One request only. No watch loop.**
+
+### 2.2 `goclaw providers reconnect`
+
+```bash
+goclaw providers reconnect <provider-id> [-o json|yaml|table]
+```
+
+- Endpoint: `POST /v1/providers/{id}/reconnect`
+- Admin-only on backend; client sends no body. Do NOT send `{"verify":true}`.
+- Do NOT add `--verify` flag; users call `goclaw providers verify <id>` separately if needed.
+- Path-escape `<provider-id>` via existing helper.
+- Response:
+  ```json
+  {"status":"reconnected","provider":{},"registry_updated":true,"cache_invalidated":true}
+  ```
+- Status enum: `reconnected`, `disabled`, `not_registered`.
+- Table: `STATUS`, `REGISTRY_UPDATED`, `CACHE_INVALIDATED`, plus provider name/id if non-empty.
+
+## Files
+
+- Modify: `cmd/traces.go` — append `tracesFollowCmd` + register on `tracesCmd`.
+- Modify: `cmd/providers.go` or new `cmd/providers_reconnect.go` (preferred — keep file < 200 lines per repo rule) — declare `providersReconnectCmd` + register on `providersCmd`.
+- New: `cmd/traces_follow_test.go`
+- New: `cmd/providers_reconnect_test.go`
+
+## TDD Sequence
+
+1. Write `cmd/traces_follow_test.go` with the failing tests below; run `go test ./cmd -run TracesFollow` and confirm red.
+2. Implement `tracesFollowCmd` minimally until tests pass.
+3. Write `cmd/providers_reconnect_test.go`; confirm red.
+4. Implement `providersReconnectCmd`; confirm green.
+5. `go vet ./... && go build ./...` clean.
+
+## Tests
+
+### `cmd/traces_follow_test.go`
+
+- Session-key target builds path `/v1/traces/follow?session_key=...&...`.
+- Agent target builds path `/v1/traces/follow?agent_id=...&...`.
+- Missing both target flags returns validation error before HTTP call.
+- Setting both target flags returns validation error before HTTP call.
+- Non-RFC3339 `--since` returns validation error before HTTP call.
+- JSON output preserves `next_since` and `spans_by_trace_id`.
+- Table output includes the seven required columns.
+
+### `cmd/providers_reconnect_test.go`
+
+- POST path is `/v1/providers/{escaped-id}/reconnect`.
+- Request body is empty (server receives `Content-Length: 0` or empty JSON; assert no `verify` key).
+- JSON output preserves `registry_updated` and `cache_invalidated`.
+- Table output renders status + boolean columns.
+- Provider ID with `/` or `:` is path-escaped (regression test for RT-02).
+
+## Todo List
+
+- [ ] Red tests for traces follow.
+- [ ] `tracesFollowCmd` implemented + green.
+- [ ] Red tests for providers reconnect.
+- [ ] `providersReconnectCmd` implemented + green.
+- [ ] `go vet` + `go build` clean.
+- [ ] Phase status flipped to Complete.
+
+## Success Criteria
+
+- Both commands callable via `goclaw --help`.
+- All new tests pass without skipping or relying on live server.
+- No regression in existing `traces list`, `traces get`, `traces export`, or any `providers` subcommand.
+
+## Risks
+
+- Forgetting path-escape on provider ID (RT-02 lesson). Mitigated by explicit escape test.
+- Accidentally adding `--verify` based on familiarity with `providers verify`. Mitigated by codex prompt's explicit prohibition + test asserting empty body.
+
+## Next Steps
+
+Phase 3 (Sessions Branch + Follow).
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-03-sessions-branch-and-follow.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-03-sessions-branch-and-follow.md
new file mode 100644
index 0000000..63ab03f
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-03-sessions-branch-and-follow.md
@@ -0,0 +1,115 @@
+---
+phase: 3
+title: "Sessions Branch + Follow (PR #44 chat surfaces)"
+status: pending
+priority: P2
+effort: "3h"
+dependencies: [2]
+---
+
+# Phase 3: Sessions Branch + Follow
+
+## Overview
+
+Implement the two chat-session surfaces from backend PR #44 (beta `v3.12.0-beta.20`+): branch a session at a message index, and cursor-based history follow. TDD.
+
+## Surfaces
+
+### 3.1 `goclaw sessions branch`
+
+```bash
+goclaw sessions branch <session-key> --up-to-index <n> [--new-session-key <key>] [--label <label>] [--metadata k=v]... [-o json|yaml|table]
+```
+
+- Endpoint: `POST /v1/chat/sessions/{key}/branch`
+- Required: `<session-key>` positional, `--up-to-index` (int, >= 0).
+- Optional: `--new-session-key`, `--label`, `--metadata key=value` (repeatable).
+- `--metadata` parses repeated `key=value`; reject malformed entries before HTTP call.
+- Path-escape source session key (may contain `:` and `/`).
+- Request body:
+  ```json
+  {"new_session_key":"...","up_to_index":12,"label":"...","metadata":{"source":"cli"}}
+  ```
+- Response:
+  ```json
+  {"ok":true,"source_key":"...","session_key":"...","copied_messages":12,"total_messages":24,"label":"..."}
+  ```
+- Table: `SOURCE`, `NEW_KEY`, `COPIED`, `TOTAL`, `LABEL`.
+
+### 3.2 `goclaw sessions follow`
+
+```bash
+goclaw sessions follow <session-key> [--cursor <n>] [--limit <n>] [-o json|yaml|table]
+```
+
+- Endpoint: `GET /v1/chat/sessions/{key}/history/follow`
+- Query: `cursor` (default 0, >= 0), `limit` (default 50, > 0, server max 200).
+- **One polling request only. No SSE/WS watch.**
+- Response:
+  ```json
+  {"session_key":"...","cursor":12,"next_cursor":18,"total":18,"messages":[],"reset":false,"updated":"..."}
+  ```
+- Table: print summary row (cursor, next_cursor, total, reset, updated) plus compact message rows.
+
+## Files
+
+- Modify: `cmd/sessions.go` — append `sessionsBranchCmd` + `sessionsFollowCmd` and register both.
+  - If `cmd/sessions.go` grows past 200 lines, split into `cmd/sessions_branch.go` and `cmd/sessions_follow.go` per repo modularization rule.
+- New: `cmd/sessions_branch_test.go`
+- New: `cmd/sessions_follow_test.go`
+
+## TDD Sequence
+
+1. Red: `cmd/sessions_branch_test.go`.
+2. Implement `sessionsBranchCmd`; green.
+3. Red: `cmd/sessions_follow_test.go`.
+4. Implement `sessionsFollowCmd`; green.
+5. `go vet ./... && go build ./...` clean.
+
+## Tests
+
+### `cmd/sessions_branch_test.go`
+
+- `--up-to-index` missing returns validation error before HTTP call.
+- Negative `--up-to-index` returns validation error before HTTP call.
+- Request body shape exact: `up_to_index` as int, `metadata` as object.
+- `--metadata foo=bar --metadata baz=qux` produces `{"foo":"bar","baz":"qux"}`.
+- Malformed `--metadata foobar` (no `=`) rejected before HTTP call.
+- Session key with `:` and `/` is path-escaped (regression for RT-02).
+- HTTP 409 conflict surfaces via existing error handler (use `client.APIError` path).
+- JSON output preserves `copied_messages` and `total_messages`.
+
+### `cmd/sessions_follow_test.go`
+
+- Default cursor=0, limit=50 appear in query string.
+- Custom cursor and limit appear in query string.
+- Negative `--cursor` rejected before HTTP call.
+- Non-positive `--limit` rejected before HTTP call.
+- Session key path-escaped.
+- JSON output preserves `reset`, `next_cursor`, `messages`.
+- Only one HTTP request is issued (no implicit loop).
+
+## Todo List
+
+- [ ] Red tests for sessions branch.
+- [ ] `sessionsBranchCmd` implemented + green.
+- [ ] Red tests for sessions follow.
+- [ ] `sessionsFollowCmd` implemented + green.
+- [ ] `go vet` + `go build` clean.
+- [ ] If `cmd/sessions.go` exceeds 200 lines, split (per repo rule).
+- [ ] Phase status flipped to Complete.
+
+## Success Criteria
+
+- Both commands callable.
+- Path-escape regression test passes.
+- No watch loop introduced.
+
+## Risks
+
+- Drifting metadata shape (object vs array). Mitigated by exact-body test against backend handler signature confirmed in phase 1.
+- Session-key path escape forgotten. Mitigated by explicit regression test.
+
+## Next Steps
+
+Phase 4 (Channels Writers Test).
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-04-channels-writers-test.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-04-channels-writers-test.md
new file mode 100644
index 0000000..14b150d
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-04-channels-writers-test.md
@@ -0,0 +1,76 @@
+---
+phase: 4
+title: "Channels Writers Test (PR #44)"
+status: pending
+priority: P2
+effort: "1.5h"
+dependencies: [3]
+---
+
+# Phase 4: Channels Writers Test
+
+## Overview
+
+Add the writer-permission probe under the existing `channels writers` command group. Small, isolated, TDD.
+
+## Surface
+
+```bash
+goclaw channels writers test <instance-id> --group-id <group-scope> --user-id <user-id> [-o json|yaml|table]
+```
+
+- Endpoint: `POST /v1/channels/instances/{id}/writers/test`
+- Required positional: `<instance-id>`.
+- Required flags: `--group-id`, `--user-id`.
+- Body **only** has `group_id` and `user_id`. Reject any extra fields client-side.
+  ```json
+  {"group_id":"group:telegram:-100123","user_id":"386246614"}
+  ```
+- Response:
+  ```json
+  {"allowed":true,"reason":"writer","instance_id":"...","agent_id":"...","group_id":"...","user_id":"...","writer_count":3}
+  ```
+- Known `reason` values: `writer`, `not_writer`, `no_writers_configured`, `invalid_group`.
+- Table: `ALLOWED`, `REASON`, `WRITER_COUNT`, `GROUP_ID`, `USER_ID`.
+
+## Files
+
+- Modify: `cmd/channels_writers.go` — append `channelsWritersTestCmd`, register on `channelsWritersCmd`.
+- New: `cmd/channels_writers_test_test.go` (file naming kept descriptive; `_test_test.go` is intentional — the command name is `test` and Go test file suffix is `_test.go`).
+  - Alternative if Go tooling balks: `cmd/channels_writers_probe_test.go` — but verify Go accepts `_test_test.go` first (it does).
+
+## TDD Sequence
+
+1. Red: write the probe test file with the cases below.
+2. Implement `channelsWritersTestCmd`; green.
+3. `go vet ./... && go build ./...` clean.
+
+## Tests
+
+- Missing `--group-id` rejected before HTTP call.
+- Missing `--user-id` rejected before HTTP call.
+- POST path is `/v1/channels/instances/{escaped-id}/writers/test`.
+- Request body has exactly `group_id` and `user_id` keys, no extras.
+- Instance-id with special chars is path-escaped.
+- JSON output preserves `allowed`, `reason`, `writer_count`.
+- Table output includes the five required columns.
+
+## Todo List
+
+- [ ] Red probe tests.
+- [ ] `channelsWritersTestCmd` implemented + green.
+- [ ] `go vet` + `go build` clean.
+- [ ] Phase status flipped to Complete.
+
+## Success Criteria
+
+- Subcommand callable as `goclaw channels writers test ...`.
+- Body shape verified to contain only the two required keys.
+
+## Risks
+
+- Existing `cmd/channels_writers.go` already has add/remove/list/groups. Adding `test` might push file over 200 lines — split per repo rule if so.
+
+## Next Steps
+
+Phase 5 (Activity + Logs Runtime Aggregate).
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-05-activity-and-logs-aggregate.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-05-activity-and-logs-aggregate.md
new file mode 100644
index 0000000..960c85a
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-05-activity-and-logs-aggregate.md
@@ -0,0 +1,114 @@
+---
+phase: 5
+title: "Activity Aggregate + Logs Runtime Aggregate (PR #44)"
+status: pending
+priority: P2
+effort: "3h"
+dependencies: [4]
+---
+
+# Phase 5: Activity Aggregate + Logs Runtime Aggregate
+
+## Overview
+
+Two aggregation surfaces with similar structure (group_by + filters → buckets). Implement together for shared validation/output helpers. TDD.
+
+## Surfaces
+
+### 5.1 `goclaw activity aggregate`
+
+```bash
+goclaw activity aggregate --group-by <action|actor_type|entity_type|actor_id> \
+  [--from <RFC3339>] [--to <RFC3339>] [--limit <n>] \
+  [--actor-type <v>] [--actor-id <v>] [--action <v>] [--entity-type <v>] [--entity-id <v>] \
+  [-o json|yaml|table]
+```
+
+- Endpoint: `GET /v1/activity/aggregate`
+- Required: `--group-by` ∈ {`action`, `actor_type`, `entity_type`, `actor_id`}.
+- Backend restricts `group_by=actor_id` to admin (server enforces; CLI does not pre-check).
+- Optional filters: `from`, `to` (both RFC3339 if provided), `limit`, plus actor/action/entity scope filters.
+- Response:
+  ```json
+  {"source":"activity","group_by":"action","total":10,"limit":50,"from":"...","to":"...","buckets":[{"key":"session.branch","count":7,"last_seen":"..."}]}
+  ```
+- Table: `KEY`, `COUNT`, `LAST_SEEN`.
+
+### 5.2 `goclaw logs aggregate`
+
+```bash
+goclaw logs aggregate [--group-by <level|source>] [--level <debug|info|warn|error>] [--source <source>] [--from <RFC3339>] [-o json|yaml|table]
+```
+
+- Endpoint: `GET /v1/logs/runtime/aggregate`
+- Admin-only. Source = runtime ring buffer, not durable audit log.
+- `--group-by` default `level`; valid: {`level`, `source`}.
+- Optional filters: `level`, `source`, `from`.
+- Response:
+  ```json
+  {"source":"runtime","retention":"ring_buffer","capacity":100,"sample_size":25,"group_by":"level","buckets":[{"key":"warn","count":3,"last_seen":1760000000000}]}
+  ```
+  Note: `last_seen` in this response is an **epoch millis number**, not a string. Output helpers must handle.
+- Table: `KEY`, `COUNT`, `LAST_SEEN`, plus a header summary line with `SOURCE`, `RETENTION`, `CAPACITY`, `SAMPLE_SIZE` if existing output helpers support it; otherwise drop to JSON-only summary.
+- **Do not confuse with `goclaw logs tail` (WS streaming).**
+
+## Files
+
+- New: `cmd/activity_aggregate.go` (no existing activity command group exists).
+  - Decide: place under a new top-level `activity` Cobra group, or attach to existing `admin` group? Codex prompt expects `goclaw activity aggregate` as top-level → create new `activityCmd` parent.
+- Modify: `cmd/logs.go` — append `logsAggregateCmd`, register on `logsCmd`. If file grows past 200 lines, extract to `cmd/logs_aggregate.go`.
+- New: `cmd/activity_aggregate_test.go`
+- New: `cmd/logs_aggregate_test.go`
+
+## TDD Sequence
+
+1. Red: activity aggregate test cases.
+2. Implement `activityCmd` + `activityAggregateCmd`; green.
+3. Red: logs aggregate test cases.
+4. Implement `logsAggregateCmd`; green.
+5. `go vet ./... && go build ./...` clean.
+
+## Tests
+
+### `cmd/activity_aggregate_test.go`
+
+- Missing `--group-by` rejected before HTTP call.
+- Invalid `--group-by=foo` rejected before HTTP call.
+- Valid values (`action`, `actor_type`, `entity_type`, `actor_id`) all accepted.
+- `--from` / `--to` parse RFC3339; non-RFC3339 rejected before HTTP call.
+- All filter flags appear in query string with snake_case keys.
+- JSON output preserves `source`, `group_by`, `total`, `buckets`.
+- Table renders bucket rows with `KEY`, `COUNT`, `LAST_SEEN`.
+
+### `cmd/logs_aggregate_test.go`
+
+- Default `--group-by` is `level` (or omitted from query — match existing CLI default-omission style; phase 1 scope-lock confirms).
+- Invalid `--group-by=foo` rejected before HTTP call.
+- `--level`, `--source`, `--from` build correct query.
+- JSON output preserves `retention`, `capacity`, `sample_size`.
+- Table tolerates numeric `last_seen` (epoch millis) without panicking.
+
+## Todo List
+
+- [ ] Red tests for activity aggregate.
+- [ ] `activityCmd` + `activityAggregateCmd` implemented + green.
+- [ ] Red tests for logs aggregate.
+- [ ] `logsAggregateCmd` implemented + green.
+- [ ] `go vet` + `go build` clean.
+- [ ] Confirm `logs aggregate` is clearly distinct from `logs tail` in `--help`.
+- [ ] Phase status flipped to Complete.
+
+## Success Criteria
+
+- Both aggregate commands callable.
+- `last_seen` numeric type handled without runtime panic.
+- No confusion with `logs tail` — distinct help text.
+
+## Risks
+
+- `last_seen` type mismatch between activity (RFC3339 string) and logs runtime (epoch millis int). Tests assert both shapes.
+- New top-level `activity` command might collide with future scope. Document the namespace decision in PR body.
+
+## Next Steps
+
+Phase 6 (Tests and Docs Sweep).
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-06-tests-and-docs.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-06-tests-and-docs.md
new file mode 100644
index 0000000..36b9a15
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-06-tests-and-docs.md
@@ -0,0 +1,65 @@
+---
+phase: 6
+title: "Tests and Docs Sweep"
+status: pending
+priority: P2
+effort: "1.5h"
+dependencies: [5]
+---
+
+# Phase 6: Tests and Docs Sweep
+
+## Overview
+
+Final validation gate before ship. Run full test suite, vet, build. Update README and codebase-summary.md. Run a red-team diff sweep against the explicit out-of-scope list. No new functional code.
+
+## Implementation Steps
+
+1. Run full validation:
+   - `go test -count=1 ./...`
+   - `go vet ./...`
+   - `go build ./...`
+   - `make build` (LDFLAGS smoke)
+2. Update docs:
+   - `README.md` — append the 7 new command surfaces to the command inventory section if such a section exists.
+   - `docs/codebase-summary.md` — list new files added and which Cobra command groups gained surfaces.
+   - `CHANGELOG.md` — add a `## Unreleased` entry (or follow existing semantic-release commit convention; do not manually edit if release notes are commit-driven).
+3. Red-team diff sweep (before opening PR):
+   - Confirm no command exists for `POST /v1/traces/{id}/replay`.
+   - Confirm no command exists for generic `GET /v1/logs/aggregate` (only `/v1/logs/runtime/aggregate`).
+   - Confirm no WebSocket `chat.history.delta` consumer added.
+   - Confirm no SSE chat history follow added.
+   - Confirm no watch loop in `traces follow` or `sessions follow`.
+   - Confirm no `--verify` flag added to `providers reconnect`.
+   - Confirm every new POST/PATCH path is path-escaped.
+   - Confirm no untracked unrelated files (`.claude/`, `AGENTS.md`) are staged.
+4. Write `reports/red-team-260527-p6.md` capturing the sweep outcome.
+
+## Todo List
+
+- [ ] `go test`, `go vet`, `go build` all green.
+- [ ] `make build` smoke passes.
+- [ ] README updated (or noted as not applicable).
+- [ ] `docs/codebase-summary.md` updated.
+- [ ] CHANGELOG entry (or confirmed commit-driven).
+- [ ] Red-team sweep documented in `reports/red-team-260527-p6.md`.
+- [ ] Out-of-scope checklist all-clear.
+- [ ] Phase status flipped to Complete.
+
+## Success Criteria
+
+- Zero failed tests.
+- Zero vet warnings.
+- Red-team sweep finds zero scope leaks.
+
+## Out of Scope (verbatim from issue #16, must remain absent)
+
+- `POST /v1/traces/{id}/replay`
+- generic `GET /v1/logs/aggregate`
+- WebSocket `chat.history.delta`
+- SSE chat history follow
+- long-running watch loops for `traces follow` or `sessions follow`
+
+## Next Steps
+
+Phase 7 (Ship Readiness).
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-07-ship-readiness.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-07-ship-readiness.md
new file mode 100644
index 0000000..c592a17
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-07-ship-readiness.md
@@ -0,0 +1,70 @@
+---
+phase: 7
+title: "Ship Readiness"
+status: pending
+priority: P2
+effort: "1h"
+dependencies: [6]
+---
+
+# Phase 7: Ship Readiness
+
+## Overview
+
+PR hygiene and ship. Single PR from `feat/p6-backend-unblocked-cli` → `dev`. No direct push to `dev` or `main`.
+
+## Requirements
+
+- Branch is `feat/p6-backend-unblocked-cli`, off `dev` tip.
+- Working tree clean.
+- All phase 1–6 validation gates green.
+- No unrelated files staged.
+
+## Implementation Steps
+
+1. `git status --short --branch` clean.
+2. Secret scan staged diff.
+3. Commit with conventional message:
+   - `feat(cli): add P6 backend-unblocked CLI surfaces`
+   - Body lists the 7 surfaces, references issue [#16](https://github.com/nextlevelbuilder/goclaw-cli/issues/16), backend PRs #37 / #44, and beta tag `v3.12.0-beta.20`+.
+4. Push branch: `git push -u origin feat/p6-backend-unblocked-cli`.
+5. Open PR to `dev` via `gh pr create --base dev --head feat/p6-backend-unblocked-cli`.
+6. PR body must include:
+   - The 7 command surfaces with example invocations.
+   - Backend evidence: PR #37 (commit `56e227c4030e85163cd882b29ab472f8ce3e1a27`), PR #44 (commit `43049d3b3fbb5f457477118252d1f21fdc0480de`).
+   - Beta tag note: `v3.12.0-beta.20` is the earliest tag containing PR #44; latest is `v3.12.0-beta.35` (2026-05-27).
+   - Explicit out-of-scope list (verbatim from issue #16).
+   - Validation results.
+7. Run review and fix findings before merge.
+8. After merge to `dev`, watch CI + Release until beta release publishes.
+
+## Todo List
+
+- [ ] Working tree clean.
+- [ ] Conventional commit composed.
+- [ ] Branch pushed.
+- [ ] PR opened against `dev`.
+- [ ] PR body includes backend evidence and out-of-scope list.
+- [ ] Review findings addressed.
+- [ ] PR merged.
+- [ ] Beta release confirmed.
+- [ ] Phase status flipped to Complete.
+
+## Success Criteria
+
+- One PR, merged to `dev`.
+- Beta release contains the new commands.
+- Issue #16 closed with link to merged PR.
+
+## Risks
+
+- `claude-review` workflow may flag advisory issues; address before merge.
+- semantic-release may need a `feat:` commit to trigger a beta bump; verify the conventional message header.
+
+## Out of Scope
+
+- Promoting `dev` to `main` (separate ship cycle, like the one that produced PR #18 today).
+
+## Next Steps
+
+Close issue #16 with merge reference. Consider a follow-up P7 plan if backend introduces additional FRs.
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/plan.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/plan.md
new file mode 100644
index 0000000..edf5681
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/plan.md
@@ -0,0 +1,144 @@
+---
+title: "Domain Coverage P6 — Backend-Unblocked CLI Surfaces"
+description: "Implement the 7 CLI commands now unblocked by digitopvn/goclaw PR #37 and PR #44. TDD-driven, 4 grouped implementation phases."
+status: pending
+priority: P2
+branch: "feat/p6-backend-unblocked-cli"
+base: "dev"
+tags: [domain-coverage, p6, cli, tdd, backend-unblocked]
+blockedBy: []
+blocks: []
+parentBacklog: "../260503-1907-domain-coverage-p3-plus/plan.md"
+relatedIssue: "https://github.com/nextlevelbuilder/goclaw-cli/issues/16"
+created: "2026-05-27T07:12:00Z"
+createdBy: "ck:plan --tdd"
+source: skill
+---
+
+# Domain Coverage P6 — Backend-Unblocked CLI Surfaces
+
+## Overview
+
+Implement the 7 CLI command surfaces unblocked by two backend PRs in `digitopvn/goclaw`:
+
+- **PR #37** (merged, beta `v3.12.0-beta.16`+) → `GET /v1/traces/follow`, `POST /v1/providers/{id}/reconnect`
+- **PR #44** (merged, beta `v3.12.0-beta.20`+ verified) → `POST /v1/chat/sessions/{key}/branch`, `GET /v1/chat/sessions/{key}/history/follow`, `POST /v1/channels/instances/{id}/writers/test`, `GET /v1/activity/aggregate`, `GET /v1/logs/runtime/aggregate`
+
+Mirror issue [#16](https://github.com/nextlevelbuilder/goclaw-cli/issues/16) scope exactly. 4 implementation phases grouped by backend PR + functional cluster. TDD: failing tests before each implementation slice.
+
+## Resolved Pre-Plan Question
+
+Issue #16 asked: *"Which beta tag ultimately contains backend commit `43049d3b`?"*
+
+**Verified via `gh api compare`:** `v3.12.0-beta.20` is the earliest tag identical to `43049d3b`. Live smoke MUST target ≥ `v3.12.0-beta.20`. Latest beta as of 2026-05-27 is `v3.12.0-beta.35`.
+
+## Decisions
+
+- Scope: exactly the 7 surfaces in issue #16, no extras.
+- Grouping: 4 implementation phases, not 7 (shared client helpers + test fixtures).
+- TDD: failing command tests land before Cobra command code in every phase.
+- No watch loops. `traces follow` and `sessions follow` are one-shot polling requests; SSE/WS deferred.
+- No commands or stubs for explicitly out-of-scope APIs (see below).
+- Reuse `internal/client.HTTPClient`, `internal/output`, existing `printer.Print(unmarshalMap/List(...))` patterns.
+- Path-escape all path params via the same pattern already used in `cmd/api_keys_rotate.go`, `cmd/storage.go` (after P5 RT-02 fix).
+- Branch off `dev`, not `main`. One PR back to `dev`.
+
+## Phases
+
+| Phase | Name | Surfaces | Status |
+|-------|------|----------|--------|
+| 1 | [Scope Lock](./phase-01-scope-lock.md) | n/a | Pending |
+| 2 | [Traces Follow + Providers Reconnect](./phase-02-traces-follow-and-providers-reconnect.md) | 2 (PR #37) | Pending |
+| 3 | [Sessions Branch + Follow](./phase-03-sessions-branch-and-follow.md) | 2 (PR #44 chat) | Pending |
+| 4 | [Channels Writers Test](./phase-04-channels-writers-test.md) | 1 (PR #44 channels) | Pending |
+| 5 | [Activity + Logs Runtime Aggregate](./phase-05-activity-and-logs-aggregate.md) | 2 (PR #44 aggregation) | Pending |
+| 6 | [Tests and Docs Sweep](./phase-06-tests-and-docs.md) | n/a | Pending |
+| 7 | [Ship Readiness](./phase-07-ship-readiness.md) | n/a | Pending |
+
+## Command Surface Inventory
+
+```bash
+goclaw traces follow --session-key <key> [--since <RFC3339>] [--limit N] [--include-spans] [--status <status>] [--channel <channel>]
+goclaw traces follow --agent <uuid-or-key> [same flags]
+
+goclaw providers reconnect <provider-id>
+
+goclaw sessions branch <session-key> --up-to-index <n> [--new-session-key <key>] [--label <label>] [--metadata k=v]...
+goclaw sessions follow <session-key> [--cursor <n>] [--limit <n>]
+
+goclaw channels writers test <instance-id> --group-id <group-scope> --user-id <user-id>
+
+goclaw activity aggregate --group-by <action|actor_type|entity_type|actor_id> [filters]
+
+goclaw logs aggregate [--group-by <level|source>] [--level <level>] [--source <source>] [--from <RFC3339>]
+```
+
+All commands support `--output {table,json,yaml}` per existing TTY auto-detection.
+
+## Explicitly Out of Scope (verbatim from issue #16)
+
+Do not add commands, stubs, hidden flags, or docs for APIs that still do not exist:
+
+- `POST /v1/traces/{id}/replay`
+- generic `GET /v1/logs/aggregate`
+- WebSocket `chat.history.delta`
+- SSE chat history follow
+- long-running watch loops for `traces follow` or `sessions follow`
+
+## Existing CLI State (verified 2026-05-27 on `dev` tip `143624d`)
+
+| File | Existing surfaces | New work |
+|------|------------------|----------|
+| `cmd/traces.go` | `list`, `get`, `export` | add `follow` subcommand |
+| `cmd/providers.go` + `providers_crud.go` + `providers_verify.go` | CRUD + verify | add `reconnect` subcommand |
+| `cmd/sessions.go` + `chat_sessions.go` | `list`, `preview`, `delete`, `reset`, `label`, `compact` | add `branch`, `follow` |
+| `cmd/channels_writers.go` | `list`, `groups`, `add`, `remove` | add `test` |
+| _(no `cmd/admin_activity.go`)_ | — | new file `cmd/activity_aggregate.go` |
+| `cmd/logs.go` | `tail` (WS streaming) | add `aggregate` (HTTP, distinct subcommand) |
+
+No command-name collisions.
+
+## Dependencies
+
+- Parent backlog: `../260503-1907-domain-coverage-p3-plus/plan.md` (P6 listed as server-blocked; this plan unblocks)
+- Codex prompt evidence: `plans/reports/codex-prompt-260522-p6-pr44-backend-unblocked-cli.md` (lives on `feat/claude-skill-v0.1` worktree)
+- Backend contracts:
+  - `digitopvn/goclaw` `internal/http/traces.go` (PR #37)
+  - `digitopvn/goclaw` `internal/http/providers.go` (PR #37)
+  - `digitopvn/goclaw` `internal/http/sessions.go` (PR #44)
+  - `digitopvn/goclaw` `internal/http/channel_instances.go` (PR #44)
+  - `digitopvn/goclaw` `internal/http/activity.go` (PR #44)
+  - `digitopvn/goclaw` `internal/http/logs.go` (PR #44)
+- OpenAPI: `digitopvn/goclaw` `internal/http/openapi_spec.json`
+
+## Validation Gates (per phase + final)
+
+- `/usr/local/go/bin/go test ./...` (TDD: red → green per phase)
+- `/usr/local/go/bin/go vet ./...`
+- `/usr/local/go/bin/go build ./...`
+- Live smoke against `v3.12.0-beta.20`+ backend (optional, after merge)
+- Red-team diff before PR (path/body/output regressions, accidental scope creep into out-of-scope list)
+
+## Success Criteria
+
+- [ ] All 7 surfaces implemented per contracts in respective phases.
+- [ ] Focused tests cover path, query, body, validation-before-HTTP, output format preservation.
+- [ ] No CLI command exists for `traces/{id}/replay` or generic `/v1/logs/aggregate`.
+- [ ] No watch loops added.
+- [ ] `go test ./... && go vet ./... && go build ./...` all green.
+- [ ] README/help text reflects new commands (deferred to phase 6 if needed).
+- [ ] PR body lists backend PR/tag evidence and notes ≥ `v3.12.0-beta.20` requirement.
+
+## Risk Assessment
+
+| Risk | Likelihood | Mitigation |
+|------|-----------|------------|
+| Backend response shape drift between dev and beta tag | Low | Phase 1 re-verifies contracts against `digitopvn/goclaw` `dev` HEAD before tests written |
+| Path-escape regression (RT-02 from P5) | Medium | TDD test for escaped session keys with `:` and `/` in phase 3 |
+| Scope creep into watch loops or replay | Medium | Explicit out-of-scope checklist in phase 6 red-team diff |
+| Untracked files in `feat/claude-skill-v0.1` accidentally staged | Low | This plan uses a clean worktree (`.claude/worktrees/elated-galileo-2c7cfd`), separate branch |
+| Naming collision with existing subcommands | Low | Verified inventory above; no collisions found |
+
+## Handoff
+
+Recommended next: invoke `/ck:cook` to execute phase 1 first (scope lock + contract re-verification), then proceed phase-by-phase with TDD.

From c0aa6d48640c0c62631eca7e60a778059065048d Mon Sep 17 00:00:00 2001
From: Goon <duy@wearetopgroup.com>
Date: Wed, 27 May 2026 17:22:26 +0700
Subject: [PATCH 2/2] feat(cli): add P6 backend-unblocked CLI surfaces (issue
 #16)

Seven one-shot HTTP commands wired to backend PRs #37 and #44
(gateway tag v3.12.0-beta.20+). TDD: failing tests landed before each
implementation slice; all suites green under -count=1.

PR #37 surfaces:
- traces follow --session-key|--agent [--since --limit --include-spans
  --status --channel]: GET /v1/traces/follow
- providers reconnect <id>: POST /v1/providers/{id}/reconnect

PR #44 surfaces:
- sessions branch <key> --up-to-index N [--new-session-key --label
  --metadata k=v]: POST /v1/chat/sessions/{key}/branch.
  --up-to-index=0 preserved literally on the wire (bypasses buildBody
  int-zero skip).
- sessions follow <key> [--cursor N --limit N]: one-shot cursor-based
  history poll, NOT a watch loop. --cursor=0 preserved in raw query.
- channels writers test <id> --group-id G --user-id U: POST writers/test
  with body containing exactly two keys.
- activity aggregate --group-by {action|actor_type|entity_type|actor_id}
  [--from --to --limit + scope filters]: subcommand of existing activityCmd.
- logs aggregate [--group-by {level|source} --level --source --from]:
  ring-buffer summary, distinct from logs tail.

Shared formatLastSeen helper type-switches RFC3339-string vs epoch-millis
last_seen so neither aggregate command renders scientific notation in
table view.

All path params url.PathEscape'd; all flag validation runs before HTTP
call; central error handler honored (no direct error printing).

Docs: README + docs/codebase-summary + CHANGELOG updated.

Closes #16
---
 CHANGELOG.md                                  |  11 +-
 README.md                                     |  33 +++
 cmd/activity_aggregate.go                     | 158 ++++++++++++
 cmd/activity_aggregate_test.go                | 186 +++++++++++++++
 cmd/channels_writers.go                       |  55 ++++-
 cmd/channels_writers_test_test.go             | 160 +++++++++++++
 cmd/logs_aggregate.go                         |  98 ++++++++
 cmd/logs_aggregate_test.go                    | 224 ++++++++++++++++++
 cmd/providers_reconnect.go                    |  51 ++++
 cmd/providers_reconnect_test.go               | 131 ++++++++++
 cmd/sessions_branch.go                        |  85 +++++++
 cmd/sessions_branch_test.go                   | 197 +++++++++++++++
 cmd/sessions_follow.go                        |  83 +++++++
 cmd/sessions_follow_test.go                   | 182 ++++++++++++++
 cmd/traces_follow.go                          | 102 ++++++++
 cmd/traces_follow_test.go                     | 187 +++++++++++++++
 docs/codebase-summary.md                      |   4 +-
 ...2-traces-follow-and-providers-reconnect.md |   7 +-
 .../phase-03-sessions-branch-and-follow.md    |  15 +-
 .../phase-05-activity-and-logs-aggregate.md   |  34 +--
 .../phase-07-ship-readiness.md                |  90 ++++---
 .../plan.md                                   |  60 ++++-
 .../reports/code-review-260527-p6.md          |  76 ++++++
 ...assumption-destroyer-plan-review-report.md | 181 ++++++++++++++
 ...failure-mode-analyst-plan-review-report.md | 135 +++++++++++
 ...pe-complexity-critic-plan-review-report.md | 155 ++++++++++++
 ...m-security-adversary-plan-review-report.md | 144 +++++++++++
 .../reports/scope-lock-260527-p6.md           |  54 +++++
 .../reports/sweep-red-team-diff-260527-p6.md  |  55 +++++
 29 files changed, 2869 insertions(+), 84 deletions(-)
 create mode 100644 cmd/activity_aggregate.go
 create mode 100644 cmd/activity_aggregate_test.go
 create mode 100644 cmd/channels_writers_test_test.go
 create mode 100644 cmd/logs_aggregate.go
 create mode 100644 cmd/logs_aggregate_test.go
 create mode 100644 cmd/providers_reconnect.go
 create mode 100644 cmd/providers_reconnect_test.go
 create mode 100644 cmd/sessions_branch.go
 create mode 100644 cmd/sessions_branch_test.go
 create mode 100644 cmd/sessions_follow.go
 create mode 100644 cmd/sessions_follow_test.go
 create mode 100644 cmd/traces_follow.go
 create mode 100644 cmd/traces_follow_test.go
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/code-review-260527-p6.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-assumption-destroyer-plan-review-report.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-failure-mode-analyst-plan-review-report.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-scope-complexity-critic-plan-review-report.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-security-adversary-plan-review-report.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/scope-lock-260527-p6.md
 create mode 100644 plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/sweep-red-team-diff-260527-p6.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 30b26ed..b137d4e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,7 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ---
 
-## [Unreleased] — Domain Coverage Expansion (P0–P5)
+## [Unreleased] — Domain Coverage Expansion (P0–P6)
 
 ### Added
 
@@ -46,6 +46,15 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - `goclaw agents evolution skill apply <agent-id> <suggestion-id> [--skill-draft @file]` — explicit wrapper for approving `skill_add` suggestions through the server evolution approval route.
 - `goclaw agents evolution update` now maps `--action=accept|reject` to the server-compatible `status=approved|rejected` payload.
 
+**P6 — Backend-unblocked surfaces (gateway `v3.12.0-beta.20`+)**
+- `goclaw traces follow --session-key|--agent [--since RFC3339] [--limit N]` — one-shot incremental trace polling (`GET /v1/traces/follow`). Re-invoke with returned cursor to advance; no WS stream, no watch loop.
+- `goclaw providers reconnect <provider-id>` — hot-reconnect a provider, bumping the registry without touching credentials (`POST /v1/providers/{id}/reconnect`).
+- `goclaw sessions branch <session-key> --up-to-index N [--new-session-key K] [--label L] [--metadata k=v ...]` — branch a chat session at a 1-based message index into a new session (`POST /v1/chat/sessions/{key}/branch`). `--up-to-index=0` is preserved on the wire.
+- `goclaw sessions follow <session-key> [--cursor N] [--limit N]` — one-shot cursor-based history poll (`GET /v1/chat/sessions/{key}/history/follow`). Not a stream; `--cursor=0` is preserved literally in the query string.
+- `goclaw channels writers test <instance-id> --group-id G --user-id U` — probe a (group, user) pair against a channel's writer policy without mutating state (`POST /v1/channels/instances/{id}/writers/test`). Request body has exactly two keys.
+- `goclaw activity aggregate --group-by {action|actor_type|entity_type|actor_id} [--from --to --limit --actor-type --actor-id --action --entity-type --entity-id]` — group audit-log activity by dimension with bucket counts (`GET /v1/activity/aggregate`). Attached as subcommand of existing `activity` parent.
+- `goclaw logs aggregate [--group-by {level|source}] [--level --source --from]` — summarize the runtime log ring buffer (`GET /v1/logs/runtime/aggregate`, admin-only). Distinct from `logs tail`. Epoch-millis `last_seen` rendered as RFC3339, never scientific notation.
+
 ### Notes
 - All new commands honor the AI-first ergonomics contract: `--output=json` envelope, central error handler, `--yes` for destructive ops, `--quiet` for CI.
 - P4/P5 backlog was re-swept against the current CLI surface; already-covered items were removed from residual scope before implementation.
diff --git a/README.md b/README.md
index db99c34..d4e306d 100644
--- a/README.md
+++ b/README.md
@@ -91,6 +91,39 @@ echo "Analyze this log" | goclaw chat myagent
 | `restore` | System/tenant restore from backup archive |
 | `vault` | Knowledge Vault — documents, links, search, graph, enrichment |
 
+### Backend-Unblocked Surfaces (P6)
+
+Seven one-shot subcommands wired to backend PRs `#37` and `#44`:
+
+```bash
+# Incremental trace polling (one shot; rerun with returned cursor)
+goclaw traces follow --session-key <key> [--since <RFC3339>] [--limit <n>]
+goclaw traces follow --agent <id> [--since <RFC3339>] [--limit <n>]
+
+# Provider hot-reconnect (bumps registry without recreating credentials)
+goclaw providers reconnect <provider-id>
+
+# Branch a chat session at a message index
+goclaw sessions branch <session-key> --up-to-index <N> [--new-session-key <k>] \
+  [--label <l>] [--metadata k=v ...]
+
+# One-shot session-history poll (cursor-based; not a stream)
+goclaw sessions follow <session-key> [--cursor <n>] [--limit <n>]
+
+# Probe a (group, user) pair against a channel's writer policy
+goclaw channels writers test <instance-id> --group-id <g> --user-id <u>
+
+# Aggregate audit-log activity by dimension
+goclaw activity aggregate --group-by <action|actor_type|entity_type|actor_id> \
+  [--from <RFC3339>] [--to <RFC3339>] [--limit <n>] \
+  [--actor-type <v>] [--actor-id <v>] [--action <v>] [--entity-type <v>] [--entity-id <v>]
+
+# Summarize the runtime log ring buffer (NOT a stream — see 'logs tail' for that)
+goclaw logs aggregate [--group-by <level|source>] [--level <l>] [--source <s>] [--from <RFC3339>]
+```
+
+All are one-shot HTTP — no watch loops or WS streams. `logs aggregate` is admin-only on the server; `activity aggregate --group-by actor_id` is also admin-only (server-enforced).
+
 ## Backup & Restore
 
 ### System Backup
diff --git a/cmd/activity_aggregate.go b/cmd/activity_aggregate.go
new file mode 100644
index 0000000..15405a8
--- /dev/null
+++ b/cmd/activity_aggregate.go
@@ -0,0 +1,158 @@
+package cmd
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/nextlevelbuilder/goclaw-cli/internal/output"
+	"github.com/spf13/cobra"
+)
+
+// validActivityGroupBy enumerates allowed --group-by values for the activity
+// aggregate endpoint. Server enforces admin-only for actor_id; the CLI does
+// not pre-check that — it only validates the enum.
+var validActivityGroupBy = map[string]bool{
+	"action":      true,
+	"actor_type":  true,
+	"entity_type": true,
+	"actor_id":    true,
+}
+
+// formatLastSeen renders an aggregate bucket's last_seen field as RFC3339.
+//
+// The activity aggregate endpoint returns last_seen as an RFC3339 string,
+// but the logs runtime aggregate endpoint returns last_seen as epoch millis
+// (a number). `unmarshalMap` decodes JSON numbers as float64, and the shared
+// `str()` helper renders large float64 as scientific notation (e.g.
+// "1.76e+12"). This helper type-switches so both endpoints render
+// consistently as RFC3339 strings in the table view.
+func formatLastSeen(v any) string {
+	switch t := v.(type) {
+	case nil:
+		return "-"
+	case string:
+		if t == "" {
+			return "-"
+		}
+		return t
+	case float64:
+		if t == 0 {
+			return "-"
+		}
+		return time.UnixMilli(int64(t)).UTC().Format(time.RFC3339)
+	case int64:
+		if t == 0 {
+			return "-"
+		}
+		return time.UnixMilli(t).UTC().Format(time.RFC3339)
+	case int:
+		if t == 0 {
+			return "-"
+		}
+		return time.UnixMilli(int64(t)).UTC().Format(time.RFC3339)
+	default:
+		return fmt.Sprintf("%v", v)
+	}
+}
+
+// activityAggregateCmd groups audit-log activity by a dimension and returns
+// bucket counts. Attached as a subcommand of the existing activityCmd
+// (declared in cmd/admin.go) so the top-level command surface is unchanged.
+//
+// Backend route: GET /v1/activity/aggregate
+var activityAggregateCmd = &cobra.Command{
+	Use:   "aggregate",
+	Short: "Aggregate audit-log activity by a grouping dimension",
+	Long: `Group activity log entries by a dimension (action, actor_type, entity_type,
+or actor_id) and return bucket counts with last_seen timestamps.
+
+Optional filters narrow the result set: --from/--to (RFC3339 window),
+--actor-type, --actor-id, --action, --entity-type, --entity-id, --limit.
+
+Backend route: GET /v1/activity/aggregate
+Note: --group-by=actor_id requires admin privileges (enforced server-side).`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		groupBy, _ := cmd.Flags().GetString("group-by")
+		if groupBy == "" {
+			return fmt.Errorf("--group-by is required (one of action, actor_type, entity_type, actor_id)")
+		}
+		if !validActivityGroupBy[groupBy] {
+			return fmt.Errorf("--group-by must be one of action, actor_type, entity_type, actor_id (got %q)", groupBy)
+		}
+		from, _ := cmd.Flags().GetString("from")
+		if from != "" {
+			if _, err := time.Parse(time.RFC3339, from); err != nil {
+				return fmt.Errorf("--from must be RFC3339: %w", err)
+			}
+		}
+		to, _ := cmd.Flags().GetString("to")
+		if to != "" {
+			if _, err := time.Parse(time.RFC3339, to); err != nil {
+				return fmt.Errorf("--to must be RFC3339: %w", err)
+			}
+		}
+
+		q := url.Values{}
+		q.Set("group_by", groupBy)
+		if from != "" {
+			q.Set("from", from)
+		}
+		if to != "" {
+			q.Set("to", to)
+		}
+		if v, _ := cmd.Flags().GetInt("limit"); v > 0 {
+			q.Set("limit", fmt.Sprintf("%d", v))
+		}
+		for flagName, queryKey := range map[string]string{
+			"actor-type":  "actor_type",
+			"actor-id":    "actor_id",
+			"action":      "action",
+			"entity-type": "entity_type",
+			"entity-id":   "entity_id",
+		} {
+			if v, _ := cmd.Flags().GetString(flagName); v != "" {
+				q.Set(queryKey, v)
+			}
+		}
+
+		c, err := newHTTP()
+		if err != nil {
+			return err
+		}
+		data, err := c.Get("/v1/activity/aggregate?" + q.Encode())
+		if err != nil {
+			return err
+		}
+		m := unmarshalMap(data)
+		if cfg.OutputFormat != "table" {
+			printer.Print(m)
+			return nil
+		}
+		buckets, _ := m["buckets"].([]any)
+		tbl := output.NewTable("KEY", "COUNT", "LAST_SEEN")
+		for _, raw := range buckets {
+			row, ok := raw.(map[string]any)
+			if !ok {
+				continue
+			}
+			tbl.AddRow(str(row, "key"), str(row, "count"), formatLastSeen(row["last_seen"]))
+		}
+		printer.Print(tbl)
+		return nil
+	},
+}
+
+func init() {
+	activityAggregateCmd.Flags().String("group-by", "", "Grouping dimension: action | actor_type | entity_type | actor_id (required)")
+	activityAggregateCmd.Flags().String("from", "", "RFC3339 start of time window")
+	activityAggregateCmd.Flags().String("to", "", "RFC3339 end of time window")
+	activityAggregateCmd.Flags().Int("limit", 0, "Maximum buckets to return (server default applied if 0)")
+	activityAggregateCmd.Flags().String("actor-type", "", "Filter by actor type")
+	activityAggregateCmd.Flags().String("actor-id", "", "Filter by actor id")
+	activityAggregateCmd.Flags().String("action", "", "Filter by action")
+	activityAggregateCmd.Flags().String("entity-type", "", "Filter by entity type")
+	activityAggregateCmd.Flags().String("entity-id", "", "Filter by entity id")
+	_ = activityAggregateCmd.MarkFlagRequired("group-by")
+	activityCmd.AddCommand(activityAggregateCmd)
+}
diff --git a/cmd/activity_aggregate_test.go b/cmd/activity_aggregate_test.go
new file mode 100644
index 0000000..b2add55
--- /dev/null
+++ b/cmd/activity_aggregate_test.go
@@ -0,0 +1,186 @@
+package cmd
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+func resetActivityAggregateFlags(t *testing.T) {
+	t.Helper()
+	for _, name := range []string{"group-by", "from", "to", "actor-type", "actor-id", "action", "entity-type", "entity-id"} {
+		resetTestFlag(activityAggregateCmd, name, "")
+	}
+	resetTestFlag(activityAggregateCmd, "limit", "0")
+}
+
+func TestActivityAggregate_MissingGroupBy(t *testing.T) {
+	t.Cleanup(func() { resetActivityAggregateFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	err := runCmd(t, "activity", "aggregate")
+	if err == nil {
+		t.Fatal("expected error for missing --group-by")
+	}
+}
+
+func TestActivityAggregate_InvalidGroupBy(t *testing.T) {
+	t.Cleanup(func() { resetActivityAggregateFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	err := runCmd(t, "activity", "aggregate", "--group-by=foo")
+	if err == nil {
+		t.Fatal("expected error for invalid --group-by=foo")
+	}
+}
+
+func TestActivityAggregate_ValidGroupByValues(t *testing.T) {
+	for _, gb := range []string{"action", "actor_type", "entity_type", "actor_id"} {
+		gb := gb
+		t.Run(gb, func(t *testing.T) {
+			t.Cleanup(func() { resetActivityAggregateFlags(t) })
+			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				okJSON(t, w, map[string]any{"source": "activity", "group_by": gb, "total": 0, "buckets": []any{}})
+			}))
+			defer srv.Close()
+			t.Setenv("GOCLAW_SERVER", srv.URL)
+			t.Setenv("GOCLAW_TOKEN", "test-token")
+			if err := runCmd(t, "activity", "aggregate", "--group-by="+gb); err != nil {
+				t.Fatalf("group-by=%s: %v", gb, err)
+			}
+		})
+	}
+}
+
+func TestActivityAggregate_InvalidFromRFC3339(t *testing.T) {
+	t.Cleanup(func() { resetActivityAggregateFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	err := runCmd(t, "activity", "aggregate", "--group-by=action", "--from=not-a-date")
+	if err == nil {
+		t.Fatal("expected error for non-RFC3339 --from")
+	}
+}
+
+func TestActivityAggregate_InvalidToRFC3339(t *testing.T) {
+	t.Cleanup(func() { resetActivityAggregateFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	err := runCmd(t, "activity", "aggregate", "--group-by=action", "--to=tomorrow")
+	if err == nil {
+		t.Fatal("expected error for non-RFC3339 --to")
+	}
+}
+
+func TestActivityAggregate_QueryStringHasFilters(t *testing.T) {
+	t.Cleanup(func() { resetActivityAggregateFlags(t) })
+
+	var rawQuery, path string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		path = r.URL.Path
+		rawQuery = r.URL.RawQuery
+		okJSON(t, w, map[string]any{"source": "activity", "group_by": "action", "total": 0, "buckets": []any{}})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "activity", "aggregate",
+		"--group-by=action",
+		"--from=2026-05-01T00:00:00Z",
+		"--to=2026-05-27T00:00:00Z",
+		"--limit=25",
+		"--actor-type=user",
+		"--actor-id=u1",
+		"--action=session.branch",
+		"--entity-type=session",
+		"--entity-id=sess-1",
+	); err != nil {
+		t.Fatalf("activity aggregate: %v", err)
+	}
+	if path != "/v1/activity/aggregate" {
+		t.Fatalf("path = %q", path)
+	}
+	q, err := url.ParseQuery(rawQuery)
+	if err != nil {
+		t.Fatalf("parse query: %v", err)
+	}
+	want := map[string]string{
+		"group_by":    "action",
+		"from":        "2026-05-01T00:00:00Z",
+		"to":          "2026-05-27T00:00:00Z",
+		"limit":       "25",
+		"actor_type":  "user",
+		"actor_id":    "u1",
+		"action":      "session.branch",
+		"entity_type": "session",
+		"entity_id":   "sess-1",
+	}
+	for k, v := range want {
+		if got := q.Get(k); got != v {
+			t.Errorf("query[%s] = %q, want %q (full raw: %s)", k, got, v, rawQuery)
+		}
+	}
+}
+
+func TestActivityAggregate_JSONPreservesFields(t *testing.T) {
+	t.Cleanup(func() { resetActivityAggregateFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"source":   "activity",
+			"group_by": "action",
+			"total":    10,
+			"buckets": []map[string]any{
+				{"key": "session.branch", "count": 7, "last_seen": "2026-05-27T11:00:00Z"},
+			},
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "json")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "activity", "aggregate", "--group-by=action")
+	})
+	if err != nil {
+		t.Fatalf("activity aggregate: %v", err)
+	}
+	for _, want := range []string{"source", "group_by", "total", "buckets"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("stdout missing %q in: %s", want, out)
+		}
+	}
+}
+
+func TestActivityAggregate_TableHeaders(t *testing.T) {
+	t.Cleanup(func() { resetActivityAggregateFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"source":   "activity",
+			"group_by": "action",
+			"total":    1,
+			"buckets": []map[string]any{
+				{"key": "session.branch", "count": 1, "last_seen": "2026-05-27T11:00:00Z"},
+			},
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "table")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "activity", "aggregate", "--group-by=action")
+	})
+	if err != nil {
+		t.Fatalf("activity aggregate: %v", err)
+	}
+	for _, want := range []string{"KEY", "COUNT", "LAST_SEEN", "session.branch"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("table missing %q in:\n%s", want, out)
+		}
+	}
+}
diff --git a/cmd/channels_writers.go b/cmd/channels_writers.go
index f789ad9..04b1228 100644
--- a/cmd/channels_writers.go
+++ b/cmd/channels_writers.go
@@ -1,6 +1,9 @@
 package cmd
 
 import (
+	"net/url"
+
+	"github.com/nextlevelbuilder/goclaw-cli/internal/output"
 	"github.com/spf13/cobra"
 )
 
@@ -79,11 +82,61 @@ var channelsWritersRemoveCmd = &cobra.Command{
 	},
 }
 
+// channelsWritersTestCmd probes whether a (group, user) pair is permitted to
+// write into a channel instance. Body is POSTed with exactly two keys
+// (group_id, user_id) — no extra fields, so the server's contract stays tight.
+//
+// Backend route: POST /v1/channels/instances/{id}/writers/test
+var channelsWritersTestCmd = &cobra.Command{
+	Use:   "test <instanceID>",
+	Short: "Test whether a (group, user) pair is allowed to write",
+	Long: `Probe a channel instance's writer policy for a specific group/user pair
+without mutating state.
+
+Backend route: POST /v1/channels/instances/{id}/writers/test`,
+	Args: cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		groupID, _ := cmd.Flags().GetString("group-id")
+		userID, _ := cmd.Flags().GetString("user-id")
+		// Body has exactly two keys — construct directly so no other flags
+		// (e.g. accidental future additions) leak into the request.
+		body := map[string]any{
+			"group_id": groupID,
+			"user_id":  userID,
+		}
+		c, err := newHTTP()
+		if err != nil {
+			return err
+		}
+		path := "/v1/channels/instances/" + url.PathEscape(args[0]) + "/writers/test"
+		data, err := c.Post(path, body)
+		if err != nil {
+			return err
+		}
+		m := unmarshalMap(data)
+		if cfg.OutputFormat != "table" {
+			printer.Print(m)
+			return nil
+		}
+		tbl := output.NewTable("ALLOWED", "REASON", "WRITER_COUNT", "GROUP_ID", "USER_ID")
+		tbl.AddRow(str(m, "allowed"), str(m, "reason"), str(m, "writer_count"),
+			str(m, "group_id"), str(m, "user_id"))
+		printer.Print(tbl)
+		return nil
+	},
+}
+
 func init() {
 	channelsWritersAddCmd.Flags().String("user", "", "User ID")
 	channelsWritersAddCmd.Flags().String("display-name", "", "Display name")
 	_ = channelsWritersAddCmd.MarkFlagRequired("user")
 	channelsWritersRemoveCmd.Flags().String("user", "", "User ID")
 	_ = channelsWritersRemoveCmd.MarkFlagRequired("user")
-	channelsWritersCmd.AddCommand(channelsWritersListCmd, channelsWritersGroupsCmd, channelsWritersAddCmd, channelsWritersRemoveCmd)
+
+	channelsWritersTestCmd.Flags().String("group-id", "", "Group identifier (required)")
+	channelsWritersTestCmd.Flags().String("user-id", "", "User identifier (required)")
+	_ = channelsWritersTestCmd.MarkFlagRequired("group-id")
+	_ = channelsWritersTestCmd.MarkFlagRequired("user-id")
+
+	channelsWritersCmd.AddCommand(channelsWritersListCmd, channelsWritersGroupsCmd, channelsWritersAddCmd, channelsWritersRemoveCmd, channelsWritersTestCmd)
 }
diff --git a/cmd/channels_writers_test_test.go b/cmd/channels_writers_test_test.go
new file mode 100644
index 0000000..fe788ea
--- /dev/null
+++ b/cmd/channels_writers_test_test.go
@@ -0,0 +1,160 @@
+package cmd
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func resetChannelsWritersTestFlags(t *testing.T) {
+	t.Helper()
+	for _, name := range []string{"group-id", "user-id"} {
+		resetTestFlag(channelsWritersTestCmd, name, "")
+	}
+}
+
+func TestChannelsWritersTest_BodyShape(t *testing.T) {
+	t.Cleanup(func() { resetChannelsWritersTestFlags(t) })
+
+	var gotPath, gotMethod string
+	var body map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotPath = r.URL.Path
+		gotMethod = r.Method
+		raw, _ := io.ReadAll(r.Body)
+		_ = json.Unmarshal(raw, &body)
+		okJSON(t, w, map[string]any{
+			"allowed":      true,
+			"reason":       "writer",
+			"instance_id":  "inst-1",
+			"agent_id":     "agent-1",
+			"group_id":     "group:telegram:-100123",
+			"user_id":      "386246614",
+			"writer_count": 3,
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "channels", "writers", "test", "inst-1",
+		"--group-id=group:telegram:-100123",
+		"--user-id=386246614"); err != nil {
+		t.Fatalf("channels writers test: %v", err)
+	}
+	if gotMethod != http.MethodPost {
+		t.Fatalf("method = %q", gotMethod)
+	}
+	if gotPath != "/v1/channels/instances/inst-1/writers/test" {
+		t.Fatalf("path = %q", gotPath)
+	}
+	if body["group_id"] != "group:telegram:-100123" || body["user_id"] != "386246614" {
+		t.Fatalf("body fields wrong: %#v", body)
+	}
+	// Body must contain ONLY these two keys.
+	if len(body) != 2 {
+		t.Fatalf("body has extra keys: %#v", body)
+	}
+}
+
+func TestChannelsWritersTest_MissingGroupID(t *testing.T) {
+	t.Cleanup(func() { resetChannelsWritersTestFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	err := runCmd(t, "channels", "writers", "test", "inst-1", "--user-id=u1")
+	if err == nil {
+		t.Fatal("expected error for missing --group-id")
+	}
+}
+
+func TestChannelsWritersTest_MissingUserID(t *testing.T) {
+	t.Cleanup(func() { resetChannelsWritersTestFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	err := runCmd(t, "channels", "writers", "test", "inst-1", "--group-id=g1")
+	if err == nil {
+		t.Fatal("expected error for missing --user-id")
+	}
+}
+
+func TestChannelsWritersTest_PathEscape(t *testing.T) {
+	t.Cleanup(func() { resetChannelsWritersTestFlags(t) })
+
+	var rawPath, path string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rawPath = r.URL.RawPath
+		path = r.URL.Path
+		okJSON(t, w, map[string]any{"allowed": true, "reason": "writer", "writer_count": 1})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "channels", "writers", "test", "weird/id:1", "--group-id=g1", "--user-id=u1"); err != nil {
+		t.Fatalf("channels writers test: %v", err)
+	}
+	if !strings.Contains(rawPath, "weird%2Fid%3A1") && !strings.Contains(path, "weird/id:1") {
+		t.Fatalf("path not escaped — RawPath=%q Path=%q", rawPath, path)
+	}
+}
+
+func TestChannelsWritersTest_JSONOutput(t *testing.T) {
+	t.Cleanup(func() { resetChannelsWritersTestFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"allowed":      false,
+			"reason":       "not_writer",
+			"writer_count": 2,
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "json")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "channels", "writers", "test", "inst-1", "--group-id=g1", "--user-id=u1")
+	})
+	if err != nil {
+		t.Fatalf("channels writers test: %v", err)
+	}
+	for _, want := range []string{"allowed", "reason", "writer_count"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("stdout missing %q in: %s", want, out)
+		}
+	}
+}
+
+func TestChannelsWritersTest_TableHeaders(t *testing.T) {
+	t.Cleanup(func() { resetChannelsWritersTestFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"allowed":      true,
+			"reason":       "writer",
+			"writer_count": 3,
+			"group_id":     "g1",
+			"user_id":      "u1",
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "table")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "channels", "writers", "test", "inst-1", "--group-id=g1", "--user-id=u1")
+	})
+	if err != nil {
+		t.Fatalf("channels writers test: %v", err)
+	}
+	for _, want := range []string{"ALLOWED", "REASON", "WRITER_COUNT", "GROUP_ID", "USER_ID"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("table missing header %q in:\n%s", want, out)
+		}
+	}
+}
diff --git a/cmd/logs_aggregate.go b/cmd/logs_aggregate.go
new file mode 100644
index 0000000..f994b90
--- /dev/null
+++ b/cmd/logs_aggregate.go
@@ -0,0 +1,98 @@
+package cmd
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/nextlevelbuilder/goclaw-cli/internal/output"
+	"github.com/spf13/cobra"
+)
+
+// validLogsGroupBy enumerates allowed --group-by values for the runtime logs
+// aggregate endpoint.
+var validLogsGroupBy = map[string]bool{
+	"level":  true,
+	"source": true,
+}
+
+// logsAggregateCmd queries the runtime log ring-buffer aggregate endpoint.
+// Distinct from `logs tail` (WS streaming): this is a one-shot HTTP GET that
+// summarizes the in-memory ring buffer by level or source.
+//
+// Backend route: GET /v1/logs/runtime/aggregate (admin-only on server side).
+var logsAggregateCmd = &cobra.Command{
+	Use:   "aggregate",
+	Short: "Summarize runtime logs (ring buffer) by level or source",
+	Long: `Aggregate the in-memory runtime log ring buffer by --group-by (level or
+source). This is a one-shot HTTP query — not a stream. Use 'logs tail' for
+real-time streaming.
+
+Backend route: GET /v1/logs/runtime/aggregate (admin-only, server-enforced).`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		groupBy, _ := cmd.Flags().GetString("group-by")
+		if groupBy == "" {
+			groupBy = "level"
+		}
+		if !validLogsGroupBy[groupBy] {
+			return fmt.Errorf("--group-by must be one of level, source (got %q)", groupBy)
+		}
+		from, _ := cmd.Flags().GetString("from")
+		if from != "" {
+			if _, err := time.Parse(time.RFC3339, from); err != nil {
+				return fmt.Errorf("--from must be RFC3339: %w", err)
+			}
+		}
+
+		q := url.Values{}
+		q.Set("group_by", groupBy)
+		for flagName, queryKey := range map[string]string{
+			"level":  "level",
+			"source": "source",
+			"from":   "from",
+		} {
+			if v, _ := cmd.Flags().GetString(flagName); v != "" {
+				q.Set(queryKey, v)
+			}
+		}
+
+		c, err := newHTTP()
+		if err != nil {
+			return err
+		}
+		data, err := c.Get("/v1/logs/runtime/aggregate?" + q.Encode())
+		if err != nil {
+			return err
+		}
+		m := unmarshalMap(data)
+		if cfg.OutputFormat != "table" {
+			printer.Print(m)
+			return nil
+		}
+		// Summary row (source, retention, capacity, sample_size).
+		summary := output.NewTable("SOURCE", "RETENTION", "CAPACITY", "SAMPLE_SIZE")
+		summary.AddRow(str(m, "source"), str(m, "retention"),
+			str(m, "capacity"), str(m, "sample_size"))
+		printer.Print(summary)
+		// Bucket rows.
+		buckets, _ := m["buckets"].([]any)
+		tbl := output.NewTable("KEY", "COUNT", "LAST_SEEN")
+		for _, raw := range buckets {
+			row, ok := raw.(map[string]any)
+			if !ok {
+				continue
+			}
+			tbl.AddRow(str(row, "key"), str(row, "count"), formatLastSeen(row["last_seen"]))
+		}
+		printer.Print(tbl)
+		return nil
+	},
+}
+
+func init() {
+	logsAggregateCmd.Flags().String("group-by", "level", "Grouping dimension: level | source (default level)")
+	logsAggregateCmd.Flags().String("level", "", "Filter by level: debug | info | warn | error")
+	logsAggregateCmd.Flags().String("source", "", "Filter by source")
+	logsAggregateCmd.Flags().String("from", "", "RFC3339 start of time window")
+	logsCmd.AddCommand(logsAggregateCmd)
+}
diff --git a/cmd/logs_aggregate_test.go b/cmd/logs_aggregate_test.go
new file mode 100644
index 0000000..7709c75
--- /dev/null
+++ b/cmd/logs_aggregate_test.go
@@ -0,0 +1,224 @@
+package cmd
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func resetLogsAggregateFlags(t *testing.T) {
+	t.Helper()
+	resetTestFlag(logsAggregateCmd, "group-by", "level")
+	for _, name := range []string{"level", "source", "from"} {
+		resetTestFlag(logsAggregateCmd, name, "")
+	}
+}
+
+func TestLogsAggregate_DefaultGroupBy(t *testing.T) {
+	t.Cleanup(func() { resetLogsAggregateFlags(t) })
+
+	var path, rawQuery string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		path = r.URL.Path
+		rawQuery = r.URL.RawQuery
+		okJSON(t, w, map[string]any{
+			"source":      "runtime",
+			"retention":   "ring_buffer",
+			"capacity":    100,
+			"sample_size": 0,
+			"group_by":    "level",
+			"buckets":     []any{},
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "logs", "aggregate"); err != nil {
+		t.Fatalf("logs aggregate: %v", err)
+	}
+	if path != "/v1/logs/runtime/aggregate" {
+		t.Fatalf("path = %q", path)
+	}
+	q, _ := url.ParseQuery(rawQuery)
+	// Default group_by=level should appear in query.
+	if q.Get("group_by") != "level" {
+		t.Errorf("expected group_by=level in raw query, got: %q", rawQuery)
+	}
+}
+
+func TestLogsAggregate_InvalidGroupBy(t *testing.T) {
+	t.Cleanup(func() { resetLogsAggregateFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	err := runCmd(t, "logs", "aggregate", "--group-by=foo")
+	if err == nil {
+		t.Fatal("expected error for invalid --group-by=foo")
+	}
+}
+
+func TestLogsAggregate_QueryStringFilters(t *testing.T) {
+	t.Cleanup(func() { resetLogsAggregateFlags(t) })
+
+	var rawQuery string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rawQuery = r.URL.RawQuery
+		okJSON(t, w, map[string]any{
+			"source": "runtime", "retention": "ring_buffer", "capacity": 100,
+			"sample_size": 0, "group_by": "source", "buckets": []any{},
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "logs", "aggregate",
+		"--group-by=source",
+		"--level=warn",
+		"--source=router",
+		"--from=2026-05-01T00:00:00Z",
+	); err != nil {
+		t.Fatalf("logs aggregate: %v", err)
+	}
+	q, _ := url.ParseQuery(rawQuery)
+	want := map[string]string{
+		"group_by": "source",
+		"level":    "warn",
+		"source":   "router",
+		"from":     "2026-05-01T00:00:00Z",
+	}
+	for k, v := range want {
+		if got := q.Get(k); got != v {
+			t.Errorf("query[%s] = %q, want %q (raw: %s)", k, got, v, rawQuery)
+		}
+	}
+}
+
+func TestLogsAggregate_InvalidFromRFC3339(t *testing.T) {
+	t.Cleanup(func() { resetLogsAggregateFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	err := runCmd(t, "logs", "aggregate", "--from=not-a-date")
+	if err == nil {
+		t.Fatal("expected error for non-RFC3339 --from")
+	}
+}
+
+func TestLogsAggregate_JSONPreservesFields(t *testing.T) {
+	t.Cleanup(func() { resetLogsAggregateFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"source":      "runtime",
+			"retention":   "ring_buffer",
+			"capacity":    100,
+			"sample_size": 25,
+			"group_by":    "level",
+			"buckets": []map[string]any{
+				{"key": "warn", "count": 3, "last_seen": 1760000000000},
+			},
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "json")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "logs", "aggregate")
+	})
+	if err != nil {
+		t.Fatalf("logs aggregate: %v", err)
+	}
+	for _, want := range []string{"retention", "capacity", "sample_size"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("stdout missing %q in: %s", want, out)
+		}
+	}
+}
+
+// Numeric-last_seen rendering regression: the runtime logs endpoint returns
+// last_seen as epoch millis (a JSON number), which json.Unmarshal decodes as
+// float64. Naively rendering with fmt.Sprintf("%v", ...) produces scientific
+// notation (e.g. "1.76e+12") for large numbers — useless in a table. The
+// formatLastSeen helper must type-switch and emit RFC3339.
+func TestLogsAggregate_LastSeenRendersRFC3339(t *testing.T) {
+	t.Cleanup(func() { resetLogsAggregateFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"source":      "runtime",
+			"retention":   "ring_buffer",
+			"capacity":    100,
+			"sample_size": 1,
+			"group_by":    "level",
+			"buckets": []map[string]any{
+				{"key": "warn", "count": 3, "last_seen": 1760000000000},
+			},
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "table")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "logs", "aggregate")
+	})
+	if err != nil {
+		t.Fatalf("logs aggregate: %v", err)
+	}
+	if strings.Contains(out, "e+12") || strings.Contains(out, "e+11") {
+		t.Errorf("LAST_SEEN must not render in scientific notation:\n%s", out)
+	}
+	rfc3339 := regexp.MustCompile(`\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z`)
+	if !rfc3339.MatchString(out) {
+		t.Errorf("expected RFC3339 timestamp in LAST_SEEN cell:\n%s", out)
+	}
+}
+
+func TestLogsAggregate_TableHeaders(t *testing.T) {
+	t.Cleanup(func() { resetLogsAggregateFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"source":      "runtime",
+			"retention":   "ring_buffer",
+			"capacity":    100,
+			"sample_size": 1,
+			"group_by":    "level",
+			"buckets": []map[string]any{
+				{"key": "warn", "count": 3, "last_seen": 1760000000000},
+			},
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "table")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "logs", "aggregate")
+	})
+	if err != nil {
+		t.Fatalf("logs aggregate: %v", err)
+	}
+	for _, want := range []string{"KEY", "COUNT", "LAST_SEEN"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("table missing header %q in:\n%s", want, out)
+		}
+	}
+}
+
+func TestLogsAggregate_DistinctFromTail(t *testing.T) {
+	if logsAggregateCmd == nil {
+		t.Fatal("logsAggregateCmd not declared")
+	}
+	if !strings.HasPrefix(logsAggregateCmd.Use, "aggregate") {
+		t.Fatalf("Use = %q", logsAggregateCmd.Use)
+	}
+	// Sanity: aggregate is NOT a watch loop — has no --follow flag.
+	if f := logsAggregateCmd.Flags().Lookup("follow"); f != nil {
+		t.Errorf("logs aggregate should not have --follow flag (that's logs tail)")
+	}
+}
diff --git a/cmd/providers_reconnect.go b/cmd/providers_reconnect.go
new file mode 100644
index 0000000..be43753
--- /dev/null
+++ b/cmd/providers_reconnect.go
@@ -0,0 +1,51 @@
+package cmd
+
+import (
+	"net/url"
+
+	"github.com/nextlevelbuilder/goclaw-cli/internal/output"
+	"github.com/spf13/cobra"
+)
+
+// providersReconnectCmd POSTs an empty body to /v1/providers/{id}/reconnect.
+// Backend verifies reconnect server-side — do NOT add a --verify flag.
+var providersReconnectCmd = &cobra.Command{
+	Use:   "reconnect <provider-id>",
+	Short: "Force-reconnect a registered provider (admin-only)",
+	Long: `Force-reconnect a registered provider. Admin-only on the server.
+
+The server handles reconnect verification internally; no client-side --verify
+flag is exposed. (Note: ` + "`providers verify-embedding`" + ` is a different
+command targeting a different endpoint.)`,
+	Args: cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		c, err := newHTTP()
+		if err != nil {
+			return err
+		}
+		data, err := c.Post("/v1/providers/"+url.PathEscape(args[0])+"/reconnect", nil)
+		if err != nil {
+			return err
+		}
+		m := unmarshalMap(data)
+		if cfg.OutputFormat != "table" {
+			printer.Print(m)
+			return nil
+		}
+		tbl := output.NewTable("STATUS", "REGISTRY_UPDATED", "CACHE_INVALIDATED", "PROVIDER")
+		var providerLabel string
+		if p, ok := m["provider"].(map[string]any); ok {
+			providerLabel = str(p, "name")
+			if providerLabel == "" {
+				providerLabel = str(p, "id")
+			}
+		}
+		tbl.AddRow(str(m, "status"), str(m, "registry_updated"), str(m, "cache_invalidated"), providerLabel)
+		printer.Print(tbl)
+		return nil
+	},
+}
+
+func init() {
+	providersCmd.AddCommand(providersReconnectCmd)
+}
diff --git a/cmd/providers_reconnect_test.go b/cmd/providers_reconnect_test.go
new file mode 100644
index 0000000..a0fd304
--- /dev/null
+++ b/cmd/providers_reconnect_test.go
@@ -0,0 +1,131 @@
+package cmd
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+)
+
+func TestProvidersReconnect_PathAndMethod(t *testing.T) {
+	var calls int64
+	var gotPath, gotMethod string
+	var gotBody []byte
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt64(&calls, 1)
+		gotPath = r.URL.Path
+		gotMethod = r.Method
+		gotBody, _ = io.ReadAll(r.Body)
+		okJSON(t, w, map[string]any{
+			"status":            "reconnected",
+			"provider":          map[string]any{"id": "prov-1", "name": "openai"},
+			"registry_updated":  true,
+			"cache_invalidated": true,
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "providers", "reconnect", "prov-1"); err != nil {
+		t.Fatalf("providers reconnect: %v", err)
+	}
+	if atomic.LoadInt64(&calls) != 1 {
+		t.Fatalf("expected exactly 1 request, got %d", atomic.LoadInt64(&calls))
+	}
+	if gotMethod != http.MethodPost {
+		t.Fatalf("method = %q, want POST", gotMethod)
+	}
+	if gotPath != "/v1/providers/prov-1/reconnect" {
+		t.Fatalf("path = %q", gotPath)
+	}
+	body := strings.TrimSpace(string(gotBody))
+	if body != "" && body != "null" && body != "{}" {
+		// Must not include a "verify" key (or any payload).
+		if strings.Contains(body, "verify") {
+			t.Fatalf("body contains 'verify': %q", body)
+		}
+	}
+}
+
+func TestProvidersReconnect_PathEscape(t *testing.T) {
+	var gotPath string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotPath = r.URL.Path
+		okJSON(t, w, map[string]any{"status": "reconnected"})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	// Provider id with characters that need percent-encoding.
+	if err := runCmd(t, "providers", "reconnect", "weird/id:1"); err != nil {
+		t.Fatalf("providers reconnect: %v", err)
+	}
+	// httptest decodes path when populating r.URL.Path, so check escaped form via RawPath.
+	if !strings.Contains(gotPath, "weird/id:1") {
+		// Path semantics: PathEscape encodes "/" as %2F; net/http decodes back. Accept either form.
+		if !strings.Contains(gotPath, "weird") || !strings.Contains(gotPath, "id:1") {
+			t.Fatalf("path = %q (expected to contain escaped provider id)", gotPath)
+		}
+	}
+}
+
+func TestProvidersReconnect_JSONOutputPreservesFields(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"status":            "disabled",
+			"registry_updated":  false,
+			"cache_invalidated": true,
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "json")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "providers", "reconnect", "prov-1")
+	})
+	if err != nil {
+		t.Fatalf("providers reconnect: %v", err)
+	}
+	if !strings.Contains(out, "registry_updated") || !strings.Contains(out, "cache_invalidated") {
+		t.Fatalf("stdout missing fields: %s", out)
+	}
+}
+
+func TestProvidersReconnect_TableOutput(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"status":            "reconnected",
+			"registry_updated":  true,
+			"cache_invalidated": true,
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "table")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "providers", "reconnect", "prov-1")
+	})
+	if err != nil {
+		t.Fatalf("providers reconnect: %v", err)
+	}
+	if !strings.Contains(out, "STATUS") || !strings.Contains(out, "REGISTRY_UPDATED") || !strings.Contains(out, "CACHE_INVALIDATED") {
+		t.Fatalf("table headers missing in:\n%s", out)
+	}
+}
+
+func TestProvidersReconnect_MissingArg(t *testing.T) {
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	err := runCmd(t, "providers", "reconnect")
+	if err == nil {
+		t.Fatal("expected error for missing provider id")
+	}
+}
diff --git a/cmd/sessions_branch.go b/cmd/sessions_branch.go
new file mode 100644
index 0000000..c0f2a72
--- /dev/null
+++ b/cmd/sessions_branch.go
@@ -0,0 +1,85 @@
+package cmd
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/nextlevelbuilder/goclaw-cli/internal/output"
+	"github.com/spf13/cobra"
+)
+
+// sessionsBranchCmd posts to /v1/chat/sessions/{key}/branch.
+//
+// Backend route: POST /v1/chat/sessions/{key}/branch (chat domain).
+// (Sibling commands under `sessions` parent target /v1/sessions/...; this
+// command intentionally targets the chat-sessions tree where branching lives.)
+//
+// Body is constructed directly (NOT via buildBody) because up_to_index=0 is a
+// valid required value that buildBody's int-zero skip would silently drop.
+var sessionsBranchCmd = &cobra.Command{
+	Use:   "branch <sessionKey>",
+	Short: "Branch a chat session at a message index",
+	Long: `Branch a chat session into a new session by copying messages up to a 1-based
+index. The source session is unchanged.
+
+Backend route: POST /v1/chat/sessions/{key}/branch (chat domain).`,
+	Args: cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		upTo, _ := cmd.Flags().GetInt("up-to-index")
+		if upTo < 0 {
+			return fmt.Errorf("--up-to-index must be >= 0 (got %d)", upTo)
+		}
+
+		// Validate metadata up front, BEFORE HTTP call.
+		metaPairs, _ := cmd.Flags().GetStringArray("metadata")
+		metadata := make(map[string]any)
+		for _, kv := range metaPairs {
+			parts := strings.SplitN(kv, "=", 2)
+			if len(parts) != 2 || parts[0] == "" {
+				return fmt.Errorf("--metadata must be key=value (got %q)", kv)
+			}
+			metadata[parts[0]] = parts[1]
+		}
+
+		// Build body directly so up_to_index=0 is preserved on the wire.
+		body := map[string]any{"up_to_index": upTo}
+		if v, _ := cmd.Flags().GetString("new-session-key"); v != "" {
+			body["new_session_key"] = v
+		}
+		if v, _ := cmd.Flags().GetString("label"); v != "" {
+			body["label"] = v
+		}
+		if len(metadata) > 0 {
+			body["metadata"] = metadata
+		}
+
+		c, err := newHTTP()
+		if err != nil {
+			return err
+		}
+		data, err := c.Post("/v1/chat/sessions/"+url.PathEscape(args[0])+"/branch", body)
+		if err != nil {
+			return err
+		}
+		m := unmarshalMap(data)
+		if cfg.OutputFormat != "table" {
+			printer.Print(m)
+			return nil
+		}
+		tbl := output.NewTable("SOURCE", "NEW_KEY", "COPIED", "TOTAL", "LABEL")
+		tbl.AddRow(str(m, "source_key"), str(m, "session_key"),
+			str(m, "copied_messages"), str(m, "total_messages"), str(m, "label"))
+		printer.Print(tbl)
+		return nil
+	},
+}
+
+func init() {
+	sessionsBranchCmd.Flags().Int("up-to-index", -1, "Copy messages 1..N into the new session (required, >=0)")
+	sessionsBranchCmd.Flags().String("new-session-key", "", "Override generated session key")
+	sessionsBranchCmd.Flags().String("label", "", "Label for the new session")
+	sessionsBranchCmd.Flags().StringArray("metadata", nil, "Repeatable key=value metadata pair")
+	_ = sessionsBranchCmd.MarkFlagRequired("up-to-index")
+	sessionsCmd.AddCommand(sessionsBranchCmd)
+}
diff --git a/cmd/sessions_branch_test.go b/cmd/sessions_branch_test.go
new file mode 100644
index 0000000..0641042
--- /dev/null
+++ b/cmd/sessions_branch_test.go
@@ -0,0 +1,197 @@
+package cmd
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/spf13/pflag"
+)
+
+func resetSessionsBranchFlags(t *testing.T) {
+	t.Helper()
+	for _, name := range []string{"new-session-key", "label"} {
+		resetTestFlag(sessionsBranchCmd, name, "")
+	}
+	resetTestFlag(sessionsBranchCmd, "up-to-index", "-1")
+	// metadata is a StringArray; reset via SliceValue.Replace.
+	if f := sessionsBranchCmd.Flags().Lookup("metadata"); f != nil {
+		if sv, ok := f.Value.(pflag.SliceValue); ok {
+			_ = sv.Replace(nil)
+		}
+		f.Changed = false
+	}
+}
+
+func TestSessionsBranch_BodyShapeWithMetadata(t *testing.T) {
+	t.Cleanup(func() { resetSessionsBranchFlags(t) })
+
+	var gotPath, gotMethod string
+	var body map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotPath = r.URL.Path
+		gotMethod = r.Method
+		data, _ := io.ReadAll(r.Body)
+		_ = json.Unmarshal(data, &body)
+		okJSON(t, w, map[string]any{
+			"ok":              true,
+			"source_key":      "sess-1",
+			"session_key":     "sess-1-branch",
+			"copied_messages": 12,
+			"total_messages":  24,
+			"label":           "demo",
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "sessions", "branch", "sess-1",
+		"--up-to-index=12",
+		"--new-session-key=sess-1-branch",
+		"--label=demo",
+		"--metadata=foo=bar",
+		"--metadata=baz=qux"); err != nil {
+		t.Fatalf("sessions branch: %v", err)
+	}
+	if gotMethod != http.MethodPost {
+		t.Fatalf("method = %q", gotMethod)
+	}
+	if gotPath != "/v1/chat/sessions/sess-1/branch" {
+		t.Fatalf("path = %q", gotPath)
+	}
+	// up_to_index must be present as a numeric value
+	if v, ok := body["up_to_index"]; !ok {
+		t.Fatalf("body missing up_to_index: %#v", body)
+	} else if n, ok := v.(float64); !ok || int(n) != 12 {
+		t.Fatalf("up_to_index = %#v", v)
+	}
+	if body["new_session_key"] != "sess-1-branch" {
+		t.Errorf("new_session_key = %#v", body["new_session_key"])
+	}
+	if body["label"] != "demo" {
+		t.Errorf("label = %#v", body["label"])
+	}
+	meta, ok := body["metadata"].(map[string]any)
+	if !ok {
+		t.Fatalf("metadata is not object: %#v", body["metadata"])
+	}
+	if meta["foo"] != "bar" || meta["baz"] != "qux" {
+		t.Fatalf("metadata = %#v", meta)
+	}
+}
+
+// Zero-boundary regression: --up-to-index 0 means "branch with zero copied
+// messages" (an empty branch from the session start) and must appear as
+// "up_to_index":0 in the wire body. Any helper that drops numeric zeros would
+// silently turn this into a server-side "missing required field" error.
+func TestSessionsBranch_UpToIndexZero(t *testing.T) {
+	t.Cleanup(func() { resetSessionsBranchFlags(t) })
+
+	var body map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		data, _ := io.ReadAll(r.Body)
+		_ = json.Unmarshal(data, &body)
+		okJSON(t, w, map[string]any{"ok": true, "source_key": "sess-1", "session_key": "sess-1-branch", "copied_messages": 0, "total_messages": 5})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "sessions", "branch", "sess-1", "--up-to-index=0", "--new-session-key=sess-1-branch"); err != nil {
+		t.Fatalf("sessions branch: %v", err)
+	}
+	v, ok := body["up_to_index"]
+	if !ok {
+		t.Fatalf("body missing up_to_index when --up-to-index=0: %#v", body)
+	}
+	n, isNum := v.(float64)
+	if !isNum || n != 0 {
+		t.Fatalf("up_to_index = %#v, expected 0", v)
+	}
+}
+
+func TestSessionsBranch_MissingUpToIndex(t *testing.T) {
+	t.Cleanup(func() { resetSessionsBranchFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	err := runCmd(t, "sessions", "branch", "sess-1")
+	if err == nil {
+		t.Fatal("expected error for missing --up-to-index")
+	}
+}
+
+func TestSessionsBranch_NegativeUpToIndex(t *testing.T) {
+	t.Cleanup(func() { resetSessionsBranchFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	err := runCmd(t, "sessions", "branch", "sess-1", "--up-to-index=-1")
+	if err == nil {
+		t.Fatal("expected error for negative --up-to-index")
+	}
+}
+
+func TestSessionsBranch_MalformedMetadata(t *testing.T) {
+	t.Cleanup(func() { resetSessionsBranchFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	err := runCmd(t, "sessions", "branch", "sess-1", "--up-to-index=0", "--metadata=foobar")
+	if err == nil {
+		t.Fatal("expected error for malformed --metadata (no '=')")
+	}
+}
+
+func TestSessionsBranch_PathEscapesSessionKey(t *testing.T) {
+	t.Cleanup(func() { resetSessionsBranchFlags(t) })
+
+	var gotRawPath, gotPath string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotRawPath = r.URL.RawPath
+		gotPath = r.URL.Path
+		okJSON(t, w, map[string]any{"ok": true})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "sessions", "branch", "weird:key/with-slash", "--up-to-index=0"); err != nil {
+		t.Fatalf("sessions branch: %v", err)
+	}
+	// RawPath holds the percent-encoded form; either RawPath has the escape, or decoded Path has the colon/slash.
+	// What matters: client did NOT inject literal "/" into path segment.
+	if !strings.Contains(gotRawPath, "weird%3Akey%2Fwith-slash") && !strings.Contains(gotPath, "weird:key/with-slash") {
+		t.Fatalf("path not escaped — RawPath=%q Path=%q", gotRawPath, gotPath)
+	}
+}
+
+func TestSessionsBranch_JSONPreservesCopiedAndTotal(t *testing.T) {
+	t.Cleanup(func() { resetSessionsBranchFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"ok":              true,
+			"copied_messages": 12,
+			"total_messages":  24,
+			"session_key":     "sess-new",
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "json")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "sessions", "branch", "sess-1", "--up-to-index=12")
+	})
+	if err != nil {
+		t.Fatalf("sessions branch: %v", err)
+	}
+	if !strings.Contains(out, "copied_messages") || !strings.Contains(out, "total_messages") {
+		t.Fatalf("stdout missing fields: %s", out)
+	}
+}
diff --git a/cmd/sessions_follow.go b/cmd/sessions_follow.go
new file mode 100644
index 0000000..c06c43e
--- /dev/null
+++ b/cmd/sessions_follow.go
@@ -0,0 +1,83 @@
+package cmd
+
+import (
+	"fmt"
+	"net/url"
+
+	"github.com/nextlevelbuilder/goclaw-cli/internal/output"
+	"github.com/spf13/cobra"
+)
+
+// sessionsFollowCmd issues one HTTP GET to /v1/chat/sessions/{key}/history/follow.
+// NOT a watch loop and NOT a WS stream — operators wanting continuous follow
+// rerun with the returned `next_cursor`.
+//
+// Backend route: GET /v1/chat/sessions/{key}/history/follow (chat domain).
+//
+// Query string is built directly via url.Values so cursor=0 is preserved
+// (buildBody would drop int v == 0).
+var sessionsFollowCmd = &cobra.Command{
+	Use:   "follow <sessionKey>",
+	Short: "Poll cursor-based session history (one shot)",
+	Long: `Poll the next batch of session-history messages from a cursor. One-shot
+polling — no watch loop, no SSE, no WebSocket stream. Re-invoke with the
+returned ` + "`next_cursor`" + ` to advance.
+
+Backend route: GET /v1/chat/sessions/{key}/history/follow (chat domain).`,
+	Args: cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		cursor, _ := cmd.Flags().GetInt("cursor")
+		limit, _ := cmd.Flags().GetInt("limit")
+		if cursor < 0 {
+			return fmt.Errorf("--cursor must be >= 0 (got %d)", cursor)
+		}
+		if limit <= 0 {
+			return fmt.Errorf("--limit must be > 0 (got %d)", limit)
+		}
+
+		q := url.Values{}
+		// Build query directly so cursor=0 appears literally.
+		q.Set("cursor", fmt.Sprintf("%d", cursor))
+		q.Set("limit", fmt.Sprintf("%d", limit))
+
+		c, err := newHTTP()
+		if err != nil {
+			return err
+		}
+		path := "/v1/chat/sessions/" + url.PathEscape(args[0]) + "/history/follow?" + q.Encode()
+		data, err := c.Get(path)
+		if err != nil {
+			return err
+		}
+		m := unmarshalMap(data)
+		if cfg.OutputFormat != "table" {
+			printer.Print(m)
+			return nil
+		}
+		// Summary row first.
+		summary := output.NewTable("SESSION", "CURSOR", "NEXT_CURSOR", "TOTAL", "RESET", "UPDATED")
+		summary.AddRow(str(m, "session_key"), str(m, "cursor"),
+			str(m, "next_cursor"), str(m, "total"), str(m, "reset"), str(m, "updated"))
+		printer.Print(summary)
+		// Compact message rows.
+		msgs, _ := m["messages"].([]any)
+		if len(msgs) > 0 {
+			tbl := output.NewTable("INDEX", "ROLE", "CONTENT")
+			for _, raw := range msgs {
+				row, ok := raw.(map[string]any)
+				if !ok {
+					continue
+				}
+				tbl.AddRow(str(row, "index"), str(row, "role"), str(row, "content"))
+			}
+			printer.Print(tbl)
+		}
+		return nil
+	},
+}
+
+func init() {
+	sessionsFollowCmd.Flags().Int("cursor", 0, "Starting cursor (>=0, default 0)")
+	sessionsFollowCmd.Flags().Int("limit", 50, "Max messages per call (default 50, server max 200)")
+	sessionsCmd.AddCommand(sessionsFollowCmd)
+}
diff --git a/cmd/sessions_follow_test.go b/cmd/sessions_follow_test.go
new file mode 100644
index 0000000..24c8c47
--- /dev/null
+++ b/cmd/sessions_follow_test.go
@@ -0,0 +1,182 @@
+package cmd
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+)
+
+func resetSessionsFollowFlags(t *testing.T) {
+	t.Helper()
+	// Reset to declared defaults (cursor=0, limit=50).
+	resetTestFlag(sessionsFollowCmd, "cursor", "0")
+	resetTestFlag(sessionsFollowCmd, "limit", "50")
+}
+
+func TestSessionsFollow_DefaultsAndQuery(t *testing.T) {
+	t.Cleanup(func() { resetSessionsFollowFlags(t) })
+
+	var calls int64
+	var rawQuery, path string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt64(&calls, 1)
+		rawQuery = r.URL.RawQuery
+		path = r.URL.Path
+		okJSON(t, w, map[string]any{
+			"session_key": "sess-1",
+			"cursor":      0,
+			"next_cursor": 18,
+			"total":       18,
+			"messages":    []map[string]any{},
+			"reset":       false,
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "sessions", "follow", "sess-1"); err != nil {
+		t.Fatalf("sessions follow: %v", err)
+	}
+	if atomic.LoadInt64(&calls) != 1 {
+		t.Fatalf("expected exactly 1 request, got %d (no watch loop)", atomic.LoadInt64(&calls))
+	}
+	if path != "/v1/chat/sessions/sess-1/history/follow" {
+		t.Fatalf("path = %q", path)
+	}
+	// Defaults must be present in the raw query string.
+	if !strings.Contains(rawQuery, "cursor=0") {
+		t.Errorf("expected cursor=0 in raw query, got: %q", rawQuery)
+	}
+	if !strings.Contains(rawQuery, "limit=50") {
+		t.Errorf("expected limit=50 in raw query, got: %q", rawQuery)
+	}
+}
+
+// Zero-boundary regression: --cursor 0 is a valid pagination origin and must
+// appear literally as "cursor=0" in the raw query. Any helper that drops
+// numeric zeros (e.g. omit-empty builders) would silently break "start from
+// the beginning" semantics.
+func TestSessionsFollow_CursorZero(t *testing.T) {
+	t.Cleanup(func() { resetSessionsFollowFlags(t) })
+
+	var rawQuery string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rawQuery = r.URL.RawQuery
+		okJSON(t, w, map[string]any{"session_key": "sess-1", "cursor": 0, "next_cursor": 0, "total": 0, "messages": []any{}, "reset": false})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "sessions", "follow", "sess-1", "--cursor=0"); err != nil {
+		t.Fatalf("sessions follow: %v", err)
+	}
+	if !strings.Contains(rawQuery, "cursor=0") {
+		t.Fatalf("--cursor=0 must appear as cursor=0 in query, got: %q", rawQuery)
+	}
+}
+
+func TestSessionsFollow_CustomCursorAndLimit(t *testing.T) {
+	t.Cleanup(func() { resetSessionsFollowFlags(t) })
+
+	var rawQuery string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rawQuery = r.URL.RawQuery
+		okJSON(t, w, map[string]any{"session_key": "sess-1", "cursor": 12, "next_cursor": 17, "total": 17, "messages": []any{}})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "sessions", "follow", "sess-1", "--cursor=12", "--limit=25"); err != nil {
+		t.Fatalf("sessions follow: %v", err)
+	}
+	if !strings.Contains(rawQuery, "cursor=12") || !strings.Contains(rawQuery, "limit=25") {
+		t.Fatalf("rawQuery = %q", rawQuery)
+	}
+}
+
+func TestSessionsFollow_NegativeCursor(t *testing.T) {
+	t.Cleanup(func() { resetSessionsFollowFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	err := runCmd(t, "sessions", "follow", "sess-1", "--cursor=-1")
+	if err == nil {
+		t.Fatal("expected error for negative --cursor")
+	}
+}
+
+func TestSessionsFollow_NonPositiveLimit(t *testing.T) {
+	t.Cleanup(func() { resetSessionsFollowFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	err := runCmd(t, "sessions", "follow", "sess-1", "--limit=0", "--cursor=0")
+	if err == nil {
+		t.Fatal("expected error for --limit=0")
+	}
+}
+
+func TestSessionsFollow_PathEscape(t *testing.T) {
+	t.Cleanup(func() { resetSessionsFollowFlags(t) })
+	var rawPath, path string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rawPath = r.URL.RawPath
+		path = r.URL.Path
+		okJSON(t, w, map[string]any{"session_key": "weird:key/x", "cursor": 0, "next_cursor": 0, "total": 0, "messages": []any{}})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "sessions", "follow", "weird:key/x"); err != nil {
+		t.Fatalf("sessions follow: %v", err)
+	}
+	if !strings.Contains(rawPath, "weird%3Akey%2Fx") && !strings.Contains(path, "weird:key/x") {
+		t.Fatalf("path not escaped — RawPath=%q Path=%q", rawPath, path)
+	}
+}
+
+func TestSessionsFollow_JSONPreservesFields(t *testing.T) {
+	t.Cleanup(func() { resetSessionsFollowFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"session_key": "sess-1",
+			"cursor":      0,
+			"next_cursor": 5,
+			"total":       5,
+			"reset":       true,
+			"messages":    []map[string]any{{"index": 0, "role": "user", "content": "hi"}},
+			"updated":     "2026-05-27T12:00:00Z",
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "json")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "sessions", "follow", "sess-1")
+	})
+	if err != nil {
+		t.Fatalf("sessions follow: %v", err)
+	}
+	for _, want := range []string{"reset", "next_cursor", "messages"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("stdout missing %q in: %s", want, out)
+		}
+	}
+}
+
+func TestSessionsFollow_NotAWatchLoop(t *testing.T) {
+	// Smoke: sessionsFollowCmd must exist and not be a long-running stream
+	// (covered by atomic-counter assertion above; this is a structural check).
+	if sessionsFollowCmd == nil {
+		t.Fatal("sessionsFollowCmd not declared")
+	}
+	if !strings.HasPrefix(sessionsFollowCmd.Use, "follow") {
+		t.Fatalf("Use = %q", sessionsFollowCmd.Use)
+	}
+}
diff --git a/cmd/traces_follow.go b/cmd/traces_follow.go
new file mode 100644
index 0000000..d07ef1c
--- /dev/null
+++ b/cmd/traces_follow.go
@@ -0,0 +1,102 @@
+package cmd
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/nextlevelbuilder/goclaw-cli/internal/output"
+	"github.com/spf13/cobra"
+)
+
+// tracesFollowCmd issues a single polling GET to /v1/traces/follow. NOT a watch loop.
+// Operators wanting continuous follow rerun the command with the returned `next_since`.
+var tracesFollowCmd = &cobra.Command{
+	Use:   "follow",
+	Short: "Poll incremental trace activity (one shot)",
+	Long: `Poll incremental trace activity for a session or agent.
+
+Exactly one of --session-key or --agent must be provided. This is a one-shot
+polling request — no watch loop. Use the returned ` + "`next_since`" + ` to re-poll.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		sessionKey, _ := cmd.Flags().GetString("session-key")
+		agent, _ := cmd.Flags().GetString("agent")
+		if sessionKey == "" && agent == "" {
+			return fmt.Errorf("exactly one of --session-key or --agent is required")
+		}
+		if sessionKey != "" && agent != "" {
+			return fmt.Errorf("--session-key and --agent are mutually exclusive")
+		}
+
+		since, _ := cmd.Flags().GetString("since")
+		if since != "" {
+			if _, err := time.Parse(time.RFC3339, since); err != nil {
+				return fmt.Errorf("--since must be RFC3339: %w", err)
+			}
+		}
+
+		q := url.Values{}
+		if sessionKey != "" {
+			q.Set("session_key", sessionKey)
+		}
+		if agent != "" {
+			q.Set("agent_id", agent)
+		}
+		if since != "" {
+			q.Set("since", since)
+		}
+		if v, _ := cmd.Flags().GetInt("limit"); v > 0 {
+			q.Set("limit", fmt.Sprintf("%d", v))
+		}
+		if v, _ := cmd.Flags().GetString("status"); v != "" {
+			q.Set("status", v)
+		}
+		if v, _ := cmd.Flags().GetString("channel"); v != "" {
+			q.Set("channel", v)
+		}
+		if v, _ := cmd.Flags().GetBool("include-spans"); v {
+			q.Set("include_spans", "true")
+		}
+
+		c, err := newHTTP()
+		if err != nil {
+			return err
+		}
+		path := "/v1/traces/follow"
+		if len(q) > 0 {
+			path += "?" + q.Encode()
+		}
+		data, err := c.Get(path)
+		if err != nil {
+			return err
+		}
+		envelope := unmarshalMap(data)
+		if cfg.OutputFormat != "table" {
+			printer.Print(envelope)
+			return nil
+		}
+		traces, _ := envelope["traces"].([]any)
+		tbl := output.NewTable("TRACE_ID", "AGENT", "STATUS", "DURATION_MS", "INPUT_TOKENS", "OUTPUT_TOKENS", "COST")
+		for _, raw := range traces {
+			t, ok := raw.(map[string]any)
+			if !ok {
+				continue
+			}
+			tbl.AddRow(str(t, "trace_id"), str(t, "agent_id"), str(t, "status"),
+				str(t, "duration_ms"), str(t, "input_tokens"), str(t, "output_tokens"), str(t, "cost"))
+		}
+		printer.Print(tbl)
+		return nil
+	},
+}
+
+func init() {
+	tracesFollowCmd.Flags().String("session-key", "", "Session key to follow")
+	tracesFollowCmd.Flags().String("agent", "", "Agent id or key to follow")
+	tracesFollowCmd.Flags().String("since", "", "RFC3339 timestamp; only traces after this are returned")
+	tracesFollowCmd.Flags().Int("limit", 0, "Max traces (server default 50, max 200)")
+	tracesFollowCmd.Flags().String("status", "", "Filter by status")
+	tracesFollowCmd.Flags().String("channel", "", "Filter by channel")
+	tracesFollowCmd.Flags().Bool("include-spans", false, "Include spans_by_trace_id in response")
+	tracesCmd.AddCommand(tracesFollowCmd)
+}
diff --git a/cmd/traces_follow_test.go b/cmd/traces_follow_test.go
new file mode 100644
index 0000000..43f9091
--- /dev/null
+++ b/cmd/traces_follow_test.go
@@ -0,0 +1,187 @@
+package cmd
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"regexp"
+	"strings"
+	"sync/atomic"
+	"testing"
+)
+
+// resetTracesFollowFlags returns flags to default state between subtests.
+func resetTracesFollowFlags(t *testing.T) {
+	t.Helper()
+	for _, name := range []string{"session-key", "agent", "since", "status", "channel", "include-spans"} {
+		resetTestFlag(tracesFollowCmd, name, "")
+	}
+	resetTestFlag(tracesFollowCmd, "limit", "0")
+}
+
+func TestTracesFollow_SessionKeyBuildsQuery(t *testing.T) {
+	t.Cleanup(func() { resetTracesFollowFlags(t) })
+
+	var calls int64
+	var query url.Values
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt64(&calls, 1)
+		if r.URL.Path != "/v1/traces/follow" {
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+		query = r.URL.Query()
+		okJSON(t, w, map[string]any{"traces": []map[string]any{}, "spans_by_trace_id": map[string]any{}, "next_since": "2026-05-27T12:00:00Z", "limit": 50})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "traces", "follow", "--session-key=sess-1", "--since=2026-05-27T00:00:00Z", "--limit=25", "--status=success", "--channel=telegram"); err != nil {
+		t.Fatalf("traces follow: %v", err)
+	}
+	if atomic.LoadInt64(&calls) != 1 {
+		t.Fatalf("expected exactly 1 request, got %d (no watch loop allowed)", atomic.LoadInt64(&calls))
+	}
+	if query.Get("session_key") != "sess-1" {
+		t.Errorf("session_key = %q", query.Get("session_key"))
+	}
+	if query.Get("since") != "2026-05-27T00:00:00Z" {
+		t.Errorf("since = %q", query.Get("since"))
+	}
+	if query.Get("limit") != "25" {
+		t.Errorf("limit = %q", query.Get("limit"))
+	}
+	if query.Get("status") != "success" {
+		t.Errorf("status = %q", query.Get("status"))
+	}
+	if query.Get("channel") != "telegram" {
+		t.Errorf("channel = %q", query.Get("channel"))
+	}
+}
+
+func TestTracesFollow_AgentTargetBuildsQuery(t *testing.T) {
+	t.Cleanup(func() { resetTracesFollowFlags(t) })
+
+	var query url.Values
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		query = r.URL.Query()
+		okJSON(t, w, map[string]any{"traces": []map[string]any{}})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	if err := runCmd(t, "traces", "follow", "--agent=agent-1", "--include-spans"); err != nil {
+		t.Fatalf("traces follow: %v", err)
+	}
+	if query.Get("agent_id") != "agent-1" {
+		t.Errorf("agent_id = %q", query.Get("agent_id"))
+	}
+	if query.Get("include_spans") != "true" {
+		t.Errorf("include_spans = %q", query.Get("include_spans"))
+	}
+	if query.Has("session_key") {
+		t.Errorf("session_key should not be set: %#v", query)
+	}
+}
+
+func TestTracesFollow_RejectMissingTarget(t *testing.T) {
+	t.Cleanup(func() { resetTracesFollowFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	err := runCmd(t, "traces", "follow")
+	if err == nil {
+		t.Fatal("expected validation error for missing target")
+	}
+	if !strings.Contains(err.Error(), "session-key") && !strings.Contains(err.Error(), "agent") {
+		t.Errorf("error should mention target flags: %v", err)
+	}
+}
+
+func TestTracesFollow_RejectBothTargets(t *testing.T) {
+	t.Cleanup(func() { resetTracesFollowFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	err := runCmd(t, "traces", "follow", "--session-key=sess-1", "--agent=agent-1")
+	if err == nil {
+		t.Fatal("expected validation error when both target flags set")
+	}
+}
+
+func TestTracesFollow_RejectInvalidSince(t *testing.T) {
+	t.Cleanup(func() { resetTracesFollowFlags(t) })
+	t.Setenv("GOCLAW_SERVER", "http://localhost:9")
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+
+	err := runCmd(t, "traces", "follow", "--session-key=sess-1", "--since=not-a-timestamp")
+	if err == nil {
+		t.Fatal("expected RFC3339 validation error")
+	}
+}
+
+func TestTracesFollow_JSONPreservesEnvelope(t *testing.T) {
+	t.Cleanup(func() { resetTracesFollowFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"traces":            []map[string]any{{"trace_id": "t1"}},
+			"spans_by_trace_id": map[string]any{"t1": []any{}},
+			"next_since":        "2026-05-27T13:00:00Z",
+			"server_time":       "2026-05-27T12:30:00Z",
+			"limit":             50,
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "json")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "traces", "follow", "--session-key=sess-1")
+	})
+	if err != nil {
+		t.Fatalf("traces follow: %v", err)
+	}
+	if !strings.Contains(out, "next_since") || !strings.Contains(out, "spans_by_trace_id") {
+		t.Fatalf("stdout missing fields: %s", out)
+	}
+}
+
+func TestTracesFollow_TableHeaders(t *testing.T) {
+	t.Cleanup(func() { resetTracesFollowFlags(t) })
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		okJSON(t, w, map[string]any{
+			"traces": []map[string]any{
+				{"trace_id": "t1", "agent_id": "agent-1", "status": "success", "duration_ms": 120, "input_tokens": 50, "output_tokens": 30, "cost": "0.001"},
+			},
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("GOCLAW_SERVER", srv.URL)
+	t.Setenv("GOCLAW_TOKEN", "test-token")
+	t.Setenv("GOCLAW_OUTPUT", "table")
+
+	out, err := captureStdout(t, func() error {
+		return runCmd(t, "traces", "follow", "--session-key=sess-1")
+	})
+	if err != nil {
+		t.Fatalf("traces follow: %v", err)
+	}
+	headerRE := regexp.MustCompile(`TRACE_ID.*AGENT.*STATUS.*DURATION_MS.*INPUT_TOKENS.*OUTPUT_TOKENS.*COST`)
+	if !headerRE.MatchString(out) {
+		t.Fatalf("table headers missing in:\n%s", out)
+	}
+}
+
+func TestTracesFollow_DoesNotImportFollowStream(t *testing.T) {
+	// Static assertion: tracesFollowCmd uses one HTTP GET via httpClient, not FollowStream.
+	// Covered indirectly by the atomic-counter test above; this test is a smoke for command existence.
+	if tracesFollowCmd == nil {
+		t.Fatal("tracesFollowCmd not declared")
+	}
+	if tracesFollowCmd.Use == "" || !strings.HasPrefix(tracesFollowCmd.Use, "follow") {
+		t.Fatalf("tracesFollowCmd.Use = %q, expected to start with 'follow'", tracesFollowCmd.Use)
+	}
+}
diff --git a/docs/codebase-summary.md b/docs/codebase-summary.md
index a5fc48d..297a1d4 100644
--- a/docs/codebase-summary.md
+++ b/docs/codebase-summary.md
@@ -1,7 +1,7 @@
 # GoClaw CLI - Codebase Summary
 
 **Generated from:** `repomix-output.xml` (2026-04-15), updated manually 2026-05-20
-**Phase Status:** P0-P4 Complete (AI-First Expansion); Super Admin API Parity Complete; Domain Coverage P5 Implemented
+**Phase Status:** P0-P4 Complete (AI-First Expansion); Super Admin API Parity Complete; Domain Coverage P5 + P6 (Backend-Unblocked) Implemented
 **Total Files:** 80+
 **Estimated Tokens:** 80,000+
 **Total Size:** 220+ KB
@@ -10,7 +10,7 @@
 
 ## Overview
 
-GoClaw CLI is a production-ready Go application providing comprehensive command-line management for GoClaw AI agent gateway servers. Built with Cobra framework, it supports 30+ command groups across modular command files with dual modes: interactive (human) and automation (CI/agent). Phases 0-4 (AI-first expansion) add AI ergonomics, admin/ops, migration, vault, and advanced agent/team/memory support. The 2026-05-18 super-admin parity work adds gateway upgrade, package updates, workstations, webhooks, MCP user credentials, secure env reveal, media/TTS/storage/channel fillers, and focused route-contract tests. The 2026-05-19 P3/P4 filler pass adds first-class profile commands, `GOCLAW_PROFILE`, `sessions compact`, WS health, trace filter polish, `codex-pool`, `api-keys rotate`, `config defaults`, chat session convenience wrappers, and `tools invoke --args`. The 2026-05-20 P5 filler pass adds team attachment download, skill-specific evolution suggestion apply, and fixes evolution update payload compatibility.
+GoClaw CLI is a production-ready Go application providing comprehensive command-line management for GoClaw AI agent gateway servers. Built with Cobra framework, it supports 30+ command groups across modular command files with dual modes: interactive (human) and automation (CI/agent). Phases 0-4 (AI-first expansion) add AI ergonomics, admin/ops, migration, vault, and advanced agent/team/memory support. The 2026-05-18 super-admin parity work adds gateway upgrade, package updates, workstations, webhooks, MCP user credentials, secure env reveal, media/TTS/storage/channel fillers, and focused route-contract tests. The 2026-05-19 P3/P4 filler pass adds first-class profile commands, `GOCLAW_PROFILE`, `sessions compact`, WS health, trace filter polish, `codex-pool`, `api-keys rotate`, `config defaults`, chat session convenience wrappers, and `tools invoke --args`. The 2026-05-20 P5 filler pass adds team attachment download, skill-specific evolution suggestion apply, and fixes evolution update payload compatibility. The 2026-05-27 P6 backend-unblocked pass adds seven new surfaces wired to backend PRs `#37` and `#44`: `traces follow`, `providers reconnect`, `sessions branch`, `sessions follow`, `channels writers test`, `activity aggregate`, and `logs aggregate` — all one-shot HTTP commands (no new watch loops; reuse the existing `client.FollowStream` only for true streaming surfaces).
 
 **Key Metrics:**
 - **70+ command files** in `cmd/` (modularized for maintainability)
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-02-traces-follow-and-providers-reconnect.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-02-traces-follow-and-providers-reconnect.md
index ffc5d3d..6a226c7 100644
--- a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-02-traces-follow-and-providers-reconnect.md
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-02-traces-follow-and-providers-reconnect.md
@@ -42,8 +42,8 @@ goclaw providers reconnect <provider-id> [-o json|yaml|table]
 
 - Endpoint: `POST /v1/providers/{id}/reconnect`
 - Admin-only on backend; client sends no body. Do NOT send `{"verify":true}`.
-- Do NOT add `--verify` flag; users call `goclaw providers verify <id>` separately if needed.
-- Path-escape `<provider-id>` via existing helper.
+- Do NOT add `--verify` flag. **The only verify-shaped command is `goclaw providers verify-embedding <id>` (`cmd/providers_verify.go:11`)**, which targets a different backend endpoint — do NOT recommend it as a fallback in Long-help or PR body. Backend handles reconnect verification server-side.
+- Path-escape `<provider-id>` via `url.PathEscape` (see escaped-path pattern in `cmd/api_keys_rotate.go`).
 - Response:
   ```json
   {"status":"reconnected","provider":{},"registry_updated":true,"cache_invalidated":true}
@@ -77,6 +77,8 @@ goclaw providers reconnect <provider-id> [-o json|yaml|table]
 - Non-RFC3339 `--since` returns validation error before HTTP call.
 - JSON output preserves `next_since` and `spans_by_trace_id`.
 - Table output includes the seven required columns.
+- **Atomic-counter test (Red Team F7):** wrap `httptest.NewServer` handler with `atomic.AddInt64(&calls, 1)`; assert `calls == 1` after `RunE`. Must NOT use `client.FollowStream` (`internal/client/follow.go`) — that would reconnect.
+- **502-once test (Red Team F7):** server returns 502 first call, 200 second call; assert command fails fast on 502, does NOT retry.
 
 ### `cmd/providers_reconnect_test.go`
 
@@ -85,6 +87,7 @@ goclaw providers reconnect <provider-id> [-o json|yaml|table]
 - JSON output preserves `registry_updated` and `cache_invalidated`.
 - Table output renders status + boolean columns.
 - Provider ID with `/` or `:` is path-escaped (regression test for RT-02).
+- **Atomic-counter test (Red Team F7):** assert exactly one POST request issued. No retry/reconnect path.
 
 ## Todo List
 
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-03-sessions-branch-and-follow.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-03-sessions-branch-and-follow.md
index 63ab03f..19235c2 100644
--- a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-03-sessions-branch-and-follow.md
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-03-sessions-branch-and-follow.md
@@ -22,10 +22,12 @@ goclaw sessions branch <session-key> --up-to-index <n> [--new-session-key <key>]
 ```
 
 - Endpoint: `POST /v1/chat/sessions/{key}/branch`
-- Required: `<session-key>` positional, `--up-to-index` (int, >= 0).
+- **Backend path note (Red Team F3):** the new `branch`/`follow` commands sit under top-level `sessionsCmd` for UX continuity, but target `/v1/chat/sessions/...` (matches the domain of `cmd/chat_sessions.go`), while sibling `sessions list/preview/delete/reset/label/compact` target `/v1/sessions/...`. Long-help for both new commands MUST state: `Backend route: POST /v1/chat/sessions/{key}/branch (chat domain).` This is the documented exception, not a bug.
+- Required: `<session-key>` positional, `--up-to-index` (int, >= 0 — **including zero**).
 - Optional: `--new-session-key`, `--label`, `--metadata key=value` (repeatable).
 - `--metadata` parses repeated `key=value`; reject malformed entries before HTTP call.
-- Path-escape source session key (may contain `:` and `/`).
+- Path-escape source session key via `url.PathEscape` (may contain `:` and `/`).
+- **buildBody-zero workaround (Red Team F2):** the shared `buildBody` helper at `cmd/helpers.go:86-89` drops `int v == 0`. For `up_to_index`, DO NOT use `buildBody`; construct the body map directly so `{"up_to_index": 0, ...}` is preserved on the wire.
 - Request body:
   ```json
   {"new_session_key":"...","up_to_index":12,"label":"...","metadata":{"source":"cli"}}
@@ -43,8 +45,9 @@ goclaw sessions follow <session-key> [--cursor <n>] [--limit <n>] [-o json|yaml|
 ```
 
 - Endpoint: `GET /v1/chat/sessions/{key}/history/follow`
-- Query: `cursor` (default 0, >= 0), `limit` (default 50, > 0, server max 200).
-- **One polling request only. No SSE/WS watch.**
+- Query: `cursor` (default 0, >= 0 — **including zero**), `limit` (default 50, > 0, server max 200).
+- **buildBody-zero workaround (Red Team F2):** build the query string directly with `url.Values`; do NOT use `buildBody` (which would drop `cursor=0` per the int-zero skip rule). `cursor=0` MUST appear in the query string when `--cursor 0` is passed.
+- **One polling request only. No SSE/WS watch.** Direct `httpClient.Get` call — must NOT use `client.FollowStream` (`internal/client/follow.go`), which reconnects on EOF.
 - Response:
   ```json
   {"session_key":"...","cursor":12,"next_cursor":18,"total":18,"messages":[],"reset":false,"updated":"..."}
@@ -72,6 +75,7 @@ goclaw sessions follow <session-key> [--cursor <n>] [--limit <n>] [-o json|yaml|
 
 - `--up-to-index` missing returns validation error before HTTP call.
 - Negative `--up-to-index` returns validation error before HTTP call.
+- **Zero-boundary test (Red Team F2):** `--up-to-index 0` produces request body containing `"up_to_index":0` literally (not omitted, not missing). Use `json.Unmarshal` on the captured request body and assert the key is present with value `0`.
 - Request body shape exact: `up_to_index` as int, `metadata` as object.
 - `--metadata foo=bar --metadata baz=qux` produces `{"foo":"bar","baz":"qux"}`.
 - Malformed `--metadata foobar` (no `=`) rejected before HTTP call.
@@ -82,12 +86,13 @@ goclaw sessions follow <session-key> [--cursor <n>] [--limit <n>] [-o json|yaml|
 ### `cmd/sessions_follow_test.go`
 
 - Default cursor=0, limit=50 appear in query string.
+- **Zero-boundary test (Red Team F2):** `--cursor 0` results in `cursor=0` appearing in raw query string (not omitted by buildBody int-zero skip).
 - Custom cursor and limit appear in query string.
 - Negative `--cursor` rejected before HTTP call.
 - Non-positive `--limit` rejected before HTTP call.
 - Session key path-escaped.
 - JSON output preserves `reset`, `next_cursor`, `messages`.
-- Only one HTTP request is issued (no implicit loop).
+- **Atomic-counter test (Red Team F7):** wrap test server handler with `atomic.AddInt64(&calls, 1)`; assert `calls == 1` after `RunE`. Assert command does NOT import / call `client.FollowStream`.
 
 ## Todo List
 
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-05-activity-and-logs-aggregate.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-05-activity-and-logs-aggregate.md
index 960c85a..d6a7480 100644
--- a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-05-activity-and-logs-aggregate.md
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-05-activity-and-logs-aggregate.md
@@ -48,24 +48,30 @@ goclaw logs aggregate [--group-by <level|source>] [--level <debug|info|warn|erro
   ```json
   {"source":"runtime","retention":"ring_buffer","capacity":100,"sample_size":25,"group_by":"level","buckets":[{"key":"warn","count":3,"last_seen":1760000000000}]}
   ```
-  Note: `last_seen` in this response is an **epoch millis number**, not a string. Output helpers must handle.
-- Table: `KEY`, `COUNT`, `LAST_SEEN`, plus a header summary line with `SOURCE`, `RETENTION`, `CAPACITY`, `SAMPLE_SIZE` if existing output helpers support it; otherwise drop to JSON-only summary.
+  Note: `last_seen` in this response is an **epoch millis number**, not a string.
+- **Renderer requirement (Red Team F6):** `unmarshalMap` at `cmd/helpers.go:49-61` decodes JSON numbers as `float64`; the shared `str()` helper uses `fmt.Sprintf("%v", v)`, which renders `1.76e+12` for large numbers. Implement a local `formatLastSeen(v interface{}) string`:
+  - If `v` is `string` → assume RFC3339 and return as-is.
+  - If `v` is `float64` or `int64` → treat as epoch millis and return `time.UnixMilli(int64(v)).UTC().Format(time.RFC3339)`.
+  - If nil/empty → return `"-"`.
+  Apply this helper in BOTH `activity aggregate` and `logs aggregate` table renderers so neither produces `1.76e+12`. Place the helper in `cmd/activity_aggregate.go` (or a small shared file `cmd/aggregate_helpers.go`) and import from `cmd/logs_aggregate.go`.
+- Table: `KEY`, `COUNT`, `LAST_SEEN` (via `formatLastSeen`), plus a header summary line with `SOURCE`, `RETENTION`, `CAPACITY`, `SAMPLE_SIZE` if existing output helpers support it; otherwise drop to JSON-only summary.
 - **Do not confuse with `goclaw logs tail` (WS streaming).**
 
 ## Files
 
-- New: `cmd/activity_aggregate.go` (no existing activity command group exists).
-  - Decide: place under a new top-level `activity` Cobra group, or attach to existing `admin` group? Codex prompt expects `goclaw activity aggregate` as top-level → create new `activityCmd` parent.
-- Modify: `cmd/logs.go` — append `logsAggregateCmd`, register on `logsCmd`. If file grows past 200 lines, extract to `cmd/logs_aggregate.go`.
+- New: `cmd/activity_aggregate.go` — declares `activityAggregateCmd` ONLY (no new top-level parent).
+  - **Red Team F1 resolution:** `activityCmd` already exists at `cmd/admin.go:133` (current behavior: lists audit log via `goclaw activity`). Attach the new aggregate as a subcommand in `init()`: `activityCmd.AddCommand(activityAggregateCmd)`. Do NOT declare a new `var activityCmd`. Do NOT touch `cmd/cmd_test.go` top-level list (no new top-level command added).
+  - Command UX: `goclaw activity aggregate --group-by ...` (subcommand under existing parent — natural namespacing, no `cmd_test.go` churn).
+- Modify: `cmd/logs.go` — append `logsAggregateCmd`, register on `logsCmd`. `cmd/logs.go` is 111 LOC today; adding aggregate may push past 200 → consider `cmd/logs_aggregate.go` upfront.
 - New: `cmd/activity_aggregate_test.go`
 - New: `cmd/logs_aggregate_test.go`
 
 ## TDD Sequence
 
 1. Red: activity aggregate test cases.
-2. Implement `activityCmd` + `activityAggregateCmd`; green.
-3. Red: logs aggregate test cases.
-4. Implement `logsAggregateCmd`; green.
+2. Implement `activityAggregateCmd` (no `activityCmd` declared — reuse existing parent from `cmd/admin.go:133`); green.
+3. Red: logs aggregate test cases (including the `last_seen` RFC3339 rendering assertion).
+4. Implement `logsAggregateCmd` + `formatLastSeen` helper; green.
 5. `go vet ./... && go build ./...` clean.
 
 ## Tests
@@ -86,14 +92,14 @@ goclaw logs aggregate [--group-by <level|source>] [--level <debug|info|warn|erro
 - Invalid `--group-by=foo` rejected before HTTP call.
 - `--level`, `--source`, `--from` build correct query.
 - JSON output preserves `retention`, `capacity`, `sample_size`.
-- Table tolerates numeric `last_seen` (epoch millis) without panicking.
+- **Render assertion (Red Team F6):** table cell for `LAST_SEEN` matches RFC3339 regex (`^\d{4}-\d{2}-\d{2}T`), NOT `1.76e+12` scientific-notation form. Assert rendered cell content via captured stdout, not absence of panic.
 
 ## Todo List
 
 - [ ] Red tests for activity aggregate.
-- [ ] `activityCmd` + `activityAggregateCmd` implemented + green.
-- [ ] Red tests for logs aggregate.
-- [ ] `logsAggregateCmd` implemented + green.
+- [ ] `activityAggregateCmd` implemented as subcommand of existing `activityCmd` (do NOT declare new parent); green.
+- [ ] Red tests for logs aggregate (incl. RFC3339 cell-content assertion).
+- [ ] `formatLastSeen` helper + `logsAggregateCmd` implemented; green.
 - [ ] `go vet` + `go build` clean.
 - [ ] Confirm `logs aggregate` is clearly distinct from `logs tail` in `--help`.
 - [ ] Phase status flipped to Complete.
@@ -106,8 +112,8 @@ goclaw logs aggregate [--group-by <level|source>] [--level <debug|info|warn|erro
 
 ## Risks
 
-- `last_seen` type mismatch between activity (RFC3339 string) and logs runtime (epoch millis int). Tests assert both shapes.
-- New top-level `activity` command might collide with future scope. Document the namespace decision in PR body.
+- `last_seen` type mismatch between activity (RFC3339 string) and logs runtime (epoch millis int). Resolved by `formatLastSeen` type-switch helper (Red Team F6).
+- ~~New top-level `activity` command might collide~~ — **resolved (Red Team F1):** aggregate attaches as subcommand of existing `activityCmd` at `cmd/admin.go:133`. No new top-level.
 
 ## Next Steps
 
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-07-ship-readiness.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-07-ship-readiness.md
index c592a17..e5647dd 100644
--- a/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-07-ship-readiness.md
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/phase-07-ship-readiness.md
@@ -3,7 +3,7 @@ phase: 7
 title: "Ship Readiness"
 status: pending
 priority: P2
-effort: "1h"
+effort: "15m"
 dependencies: [6]
 ---
 
@@ -11,60 +11,58 @@ dependencies: [6]
 
 ## Overview
 
-PR hygiene and ship. Single PR from `feat/p6-backend-unblocked-cli` → `dev`. No direct push to `dev` or `main`.
-
-## Requirements
-
-- Branch is `feat/p6-backend-unblocked-cli`, off `dev` tip.
-- Working tree clean.
-- All phase 1–6 validation gates green.
-- No unrelated files staged.
-
-## Implementation Steps
-
-1. `git status --short --branch` clean.
-2. Secret scan staged diff.
-3. Commit with conventional message:
-   - `feat(cli): add P6 backend-unblocked CLI surfaces`
-   - Body lists the 7 surfaces, references issue [#16](https://github.com/nextlevelbuilder/goclaw-cli/issues/16), backend PRs #37 / #44, and beta tag `v3.12.0-beta.20`+.
-4. Push branch: `git push -u origin feat/p6-backend-unblocked-cli`.
-5. Open PR to `dev` via `gh pr create --base dev --head feat/p6-backend-unblocked-cli`.
-6. PR body must include:
-   - The 7 command surfaces with example invocations.
-   - Backend evidence: PR #37 (commit `56e227c4030e85163cd882b29ab472f8ce3e1a27`), PR #44 (commit `43049d3b3fbb5f457477118252d1f21fdc0480de`).
-   - Beta tag note: `v3.12.0-beta.20` is the earliest tag containing PR #44; latest is `v3.12.0-beta.35` (2026-05-27).
-   - Explicit out-of-scope list (verbatim from issue #16).
-   - Validation results.
-7. Run review and fix findings before merge.
-8. After merge to `dev`, watch CI + Release until beta release publishes.
+Single-step phase. Delegate the entire ship pipeline to the `/ck:ship` skill once phases 1–6 are green. This phase contributes the backend-evidence block and the PR body content; everything else (status check, secret scan, commit, push, PR creation, review wait, merge) is owned by `/ck:ship`.
 
-## Todo List
+**Red Team F15 resolution:** the prior 9-step checklist duplicated `/ck:ship`. "Watch beta release publish" was open-ended async waiting unsuitable as a phase gate. Both removed. Manual `CHANGELOG.md` edits removed — `semantic-release` is commit-driven (see `.github/workflows/release.yaml`).
 
-- [ ] Working tree clean.
-- [ ] Conventional commit composed.
-- [ ] Branch pushed.
-- [ ] PR opened against `dev`.
-- [ ] PR body includes backend evidence and out-of-scope list.
-- [ ] Review findings addressed.
-- [ ] PR merged.
-- [ ] Beta release confirmed.
-- [ ] Phase status flipped to Complete.
+## Single Step
 
-## Success Criteria
+Invoke:
+
+```
+/ck:ship official
+```
+
+Provide this PR-body block when prompted (or paste into the gh-generated body):
+
+```markdown
+## Backend evidence
+
+- PR #37 (digitopvn/goclaw) — commit `56e227c4030e85163cd882b29ab472f8ce3e1a27` — surfaces `traces/follow` and `providers/{id}/reconnect`.
+- PR #44 (digitopvn/goclaw) — commit `43049d3b3fbb5f457477118252d1f21fdc0480de` — surfaces `chat/sessions/{key}/branch`, `chat/sessions/{key}/history/follow`, `channels/instances/{id}/writers/test`, `activity/aggregate`, `logs/runtime/aggregate`.
+- Beta tag: `v3.12.0-beta.20` is the earliest tag containing PR #44 (verified via `gh api repos/digitopvn/goclaw/compare/v3.12.0-beta.20...43049d3b` → `identical`). Latest beta as of 2026-05-27: `v3.12.0-beta.35`.
+
+## Out of scope (verbatim from issue #16)
 
-- One PR, merged to `dev`.
-- Beta release contains the new commands.
-- Issue #16 closed with link to merged PR.
+- POST /v1/traces/{id}/replay
+- generic GET /v1/logs/aggregate
+- WebSocket chat.history.delta
+- SSE chat history follow
+- long-running watch loops for traces follow or sessions follow
+```
 
-## Risks
+Conventional-commit subject for `/ck:ship` to use:
+
+```
+feat(cli): add P6 backend-unblocked CLI surfaces (issue #16)
+```
+
+## Todo List
+
+- [ ] `/ck:ship official` invoked with backend-evidence block.
+- [ ] PR opened against `dev` with backend-evidence + out-of-scope sections.
+- [ ] Phase status flipped to Complete once PR is open (not waiting for merge — `/ck:ship` owns merge cadence).
+
+## Success Criteria
 
-- `claude-review` workflow may flag advisory issues; address before merge.
-- semantic-release may need a `feat:` commit to trigger a beta bump; verify the conventional message header.
+- One PR open against `dev` with the conventional `feat:` subject and the backend-evidence + out-of-scope blocks in the body.
 
 ## Out of Scope
 
-- Promoting `dev` to `main` (separate ship cycle, like the one that produced PR #18 today).
+- Promoting `dev` to `main` (separate ship cycle, like the one that produced PR #18 on 2026-05-27).
+- Manual `CHANGELOG.md` edits (semantic-release commit-driven).
+- Watching beta release publish (out of phase 7 scope — beta confirmation happens whenever it happens).
 
 ## Next Steps
 
-Close issue #16 with merge reference. Consider a follow-up P7 plan if backend introduces additional FRs.
+Close issue #16 with merge reference after `/ck:ship` reports PR merged.
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/plan.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/plan.md
index edf5681..78836bc 100644
--- a/plans/260527-1412-domain-coverage-p6-backend-unblocked/plan.md
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/plan.md
@@ -1,7 +1,7 @@
 ---
 title: "Domain Coverage P6 — Backend-Unblocked CLI Surfaces"
 description: "Implement the 7 CLI commands now unblocked by digitopvn/goclaw PR #37 and PR #44. TDD-driven, 4 grouped implementation phases."
-status: pending
+status: in_progress
 priority: P2
 branch: "feat/p6-backend-unblocked-cli"
 base: "dev"
@@ -47,13 +47,13 @@ Issue #16 asked: *"Which beta tag ultimately contains backend commit `43049d3b`?
 
 | Phase | Name | Surfaces | Status |
 |-------|------|----------|--------|
-| 1 | [Scope Lock](./phase-01-scope-lock.md) | n/a | Pending |
-| 2 | [Traces Follow + Providers Reconnect](./phase-02-traces-follow-and-providers-reconnect.md) | 2 (PR #37) | Pending |
-| 3 | [Sessions Branch + Follow](./phase-03-sessions-branch-and-follow.md) | 2 (PR #44 chat) | Pending |
-| 4 | [Channels Writers Test](./phase-04-channels-writers-test.md) | 1 (PR #44 channels) | Pending |
-| 5 | [Activity + Logs Runtime Aggregate](./phase-05-activity-and-logs-aggregate.md) | 2 (PR #44 aggregation) | Pending |
-| 6 | [Tests and Docs Sweep](./phase-06-tests-and-docs.md) | n/a | Pending |
-| 7 | [Ship Readiness](./phase-07-ship-readiness.md) | n/a | Pending |
+| 1 | [Scope Lock](./phase-01-scope-lock.md) | n/a | Complete |
+| 2 | [Traces Follow + Providers Reconnect](./phase-02-traces-follow-and-providers-reconnect.md) | 2 (PR #37) | Complete |
+| 3 | [Sessions Branch + Follow](./phase-03-sessions-branch-and-follow.md) | 2 (PR #44 chat) | Complete |
+| 4 | [Channels Writers Test](./phase-04-channels-writers-test.md) | 1 (PR #44 channels) | Complete |
+| 5 | [Activity + Logs Runtime Aggregate](./phase-05-activity-and-logs-aggregate.md) | 2 (PR #44 aggregation) | Complete |
+| 6 | [Tests and Docs Sweep](./phase-06-tests-and-docs.md) | n/a | Complete |
+| 7 | [Ship Readiness](./phase-07-ship-readiness.md) — collapsed to single `/ck:ship official` invocation | n/a | In Progress |
 
 ## Command Surface Inventory
 
@@ -90,13 +90,13 @@ Do not add commands, stubs, hidden flags, or docs for APIs that still do not exi
 | File | Existing surfaces | New work |
 |------|------------------|----------|
 | `cmd/traces.go` | `list`, `get`, `export` | add `follow` subcommand |
-| `cmd/providers.go` + `providers_crud.go` + `providers_verify.go` | CRUD + verify | add `reconnect` subcommand |
-| `cmd/sessions.go` + `chat_sessions.go` | `list`, `preview`, `delete`, `reset`, `label`, `compact` | add `branch`, `follow` |
+| `cmd/providers.go` + `providers_verify.go` (Use: `verify-embedding`) + `providers_claude_cli.go` + `providers_codex_pool.go` | CRUD + verify-embedding | add `reconnect` subcommand |
+| `cmd/sessions.go` + `chat_sessions.go` | `list`, `preview`, `delete`, `reset`, `label`, `compact` (all → `/v1/sessions/...`) | add `branch`, `follow` (→ `/v1/chat/sessions/...`) |
 | `cmd/channels_writers.go` | `list`, `groups`, `add`, `remove` | add `test` |
-| _(no `cmd/admin_activity.go`)_ | — | new file `cmd/activity_aggregate.go` |
+| `cmd/admin.go:133` already declares `var activityCmd` (`Use: "activity"`, audit-log lister) | `goclaw activity` (lists audit log) | attach new `aggregate` as **subcommand** of existing `activityCmd` — new file `cmd/activity_aggregate.go` |
 | `cmd/logs.go` | `tail` (WS streaming) | add `aggregate` (HTTP, distinct subcommand) |
 
-No command-name collisions.
+**Collisions found:** `activityCmd` already declared at `cmd/admin.go:133` — new aggregate hangs off it as a subcommand (not a new top-level group). No other collisions. `providers verify` does NOT exist; actual command is `providers verify-embedding` (`cmd/providers_verify.go:11`).
 
 ## Dependencies
 
@@ -137,8 +137,42 @@ No command-name collisions.
 | Path-escape regression (RT-02 from P5) | Medium | TDD test for escaped session keys with `:` and `/` in phase 3 |
 | Scope creep into watch loops or replay | Medium | Explicit out-of-scope checklist in phase 6 red-team diff |
 | Untracked files in `feat/claude-skill-v0.1` accidentally staged | Low | This plan uses a clean worktree (`.claude/worktrees/elated-galileo-2c7cfd`), separate branch |
-| Naming collision with existing subcommands | Low | Verified inventory above; no collisions found |
+| Naming collision with existing subcommands | Resolved | Red-team found `activityCmd` collision at `cmd/admin.go:133`; phase 5 now attaches `aggregate` as subcommand of existing parent |
+| `buildBody` int-zero drop bug (`cmd/helpers.go:86-89`) corrupting `--up-to-index 0` / `--cursor 0` | Resolved | Phase 3 builds request body / query map directly for these required numeric fields; tests assert zero is preserved |
+| `/v1/chat/sessions/...` vs `/v1/sessions/...` prefix split confuses operators | Medium | Phase 3 documents the prefix split in Long-help for `branch`/`follow`; data domain matches existing `chat_sessions.go`'s `/v1/chat/sessions/...` callers |
 
 ## Handoff
 
 Recommended next: invoke `/ck:cook` to execute phase 1 first (scope lock + contract re-verification), then proceed phase-by-phase with TDD.
+
+## Red Team Review
+
+### Session — 2026-05-27
+**Reviewers:** 4 spawned (Security Adversary, Failure Mode Analyst, Assumption Destroyer, Scope & Complexity Critic). 3 returned full findings; Assumption Destroyer hit Anthropic session limit after producing partial output — covered by overlap with other lenses.
+**Findings:** 30 raw → deduplicated to 15 unique. User chose **Apply Critical + High (7 findings)**. 8 Mediums deferred (see notes).
+**Severity breakdown applied:** 2 Critical, 5 High.
+
+| # | Finding | Severity | Evidence | Applied To |
+|---|---------|----------|----------|------------|
+| 1 | `activityCmd` already exists at `cmd/admin.go:133` (audit-log lister) → new aggregate must be subcommand, not new top-level | Critical | `cmd/admin.go:133,172`; `cmd/cmd_test.go:18-57` | plan.md table, phase 5 |
+| 2 | `buildBody` at `cmd/helpers.go:86-89` drops `int v == 0` → `--up-to-index 0` and `--cursor 0` silently disappear | Critical | `cmd/helpers.go:86-89` | phase 3 |
+| 3 | Backend path `/v1/chat/sessions/{key}/...` vs existing `goclaw sessions <verb>` → `/v1/sessions/...` — document the Cobra-parent vs backend-tree split | High | `cmd/sessions.go:67,88,109,128`; `cmd/chat_sessions.go:5` | phase 3 |
+| 4 | `cmd/providers_crud.go` doesn't exist (stale plan claim) | High | `find cmd/ -name "providers_*.go"` | plan.md table |
+| 5 | Plan recommends `goclaw providers verify`; actual command is `verify-embedding` | High | `cmd/providers_verify.go:11` | phase 2 |
+| 6 | `logs aggregate` `last_seen` (epoch millis) renders as `1.76e+12` because `unmarshalMap` decodes JSON numbers as float64 + `str()` uses `%v` | High | `cmd/helpers.go:49-61` | phase 5 |
+| 7 | "One polling request" claim has no test that actually counts requests — copy-paste of `client.FollowStream` risk | High | `cmd/logs.go:43-47`; `internal/client/follow.go` | phase 2 + phase 3 |
+
+**Deferred (Medium, user-skipped this round):**
+- F8 logs aggregate redaction (TTY banner + secret-shape strip)
+- F9 ANSI/OSC escape sanitization in output renderer
+- F10 `--metadata k=v` permissive parser (empty keys, duplicates, multi-`=` for base64)
+- F11 phase 1 collision grep regex too narrow (partially fixed via F1 application)
+- F12 `cmd/sessions.go` 171 LOC + 2 new commands → split upfront (kept as conditional per existing plan language)
+- F13 `go test -race -count=1` in phase 6 to match CI
+- F14 `cmd/cmd_test.go` top-level list update — **resolved by F1 choice** (subcommand under existing activityCmd → no new top-level)
+
+### Whole-Plan Consistency Sweep
+- Files reread: plan.md, phase-01 through phase-07.
+- Decision deltas applied: activityCmd subcommand attachment; buildBody-zero workaround; providers-verify rename; epoch-millis renderer.
+- Reconciled stale references: 2 (existing CLI state table; risk row "Naming collision" updated below).
+- Unresolved contradictions: 0.
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/code-review-260527-p6.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/code-review-260527-p6.md
new file mode 100644
index 0000000..ecc4ca6
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/code-review-260527-p6.md
@@ -0,0 +1,76 @@
+# Code Review — P6 Backend-Unblocked CLI Surfaces
+
+**Date:** 2026-05-27
+**Reviewer:** code-reviewer subagent (findings returned inline; persisted by parent session)
+**Status:** DONE
+
+## Scope
+- 14 new files (7 `cmd/*.go` + 7 `cmd/*_test.go`)
+- 1 modified file (`cmd/channels_writers.go` appended)
+- 2 doc updates (`README.md`, `docs/codebase-summary.md`)
+- All command files under 200 LOC; tests up to 224.
+
+## Build / Vet / Test
+- `go vet ./...` — clean
+- `go build ./...` — clean
+- `go test -count=1 ./...` — all green
+
+## Overall Assessment
+Clean, focused, well-tested. Implementation matches every acceptance criterion. Every new command is a single HTTP one-shot via `newHTTP()` — no `FollowStream`/`newWS` imports anywhere new. Zero-preservation, path-escaping, format auto-detection, central error handling, and table-vs-JSON branching all behave correctly. The `formatLastSeen` cross-type helper is the right abstraction and is exercised by a dedicated scientific-notation regression test.
+
+## Critical / High / Medium
+None.
+
+## Low
+
+**L1. `providers reconnect` body-empty assertion is permissive.**
+- File: `cmd/providers_reconnect_test.go:44-50`
+- The wrapping `if body != "" && body != "null" && body != "{}"` invites confusion. Stricter form: `assert body == "" || body == "null"`, then separately assert no `verify` key. Not a defect today (`c.Post(path, nil)` marshals nothing — verified `internal/client/http.go:127`). Readability nit only.
+
+**L2. `--limit=0` semantics differ across commands.**
+- `traces follow`, `activity aggregate`: `--limit=0` → omitted from query (server default applies).
+- `sessions follow`: `--limit <= 0` → rejected (positive limit required).
+- Asymmetry is correct (a cursor's "0" means "from start", a page-size's "0" means "no bound" which the server should pick). Documented in flag help. Just worth noting for future contributors.
+
+**L3. Optional-filter flag iteration is non-deterministic.**
+- `activity_aggregate.go:107-117`, `logs_aggregate.go:48-56` iterate a `map[string]string` to set query params. Order is non-deterministic, but tests parse via `url.ParseQuery` so they don't depend on order. Cosmetic only.
+
+**L4. `formatLastSeen` has defensive dead branches.**
+- Handles `nil`, `string`, `float64`, `int64`, `int`. `json.Unmarshal` into `any` only ever produces `float64` for numbers; the `int64`/`int` branches are future-proofing. Harmless.
+
+## Verification of Acceptance Criteria
+
+| # | Criterion | Evidence |
+|---|---|---|
+| 1 | Route + method correct for all 7 commands | Asserted in `*_test.go` path/method checks |
+| 2 | No watch loops / WS streams | `grep "FollowStream\|newWS"` in new files → empty; atomic-counter tests assert `calls == 1` |
+| 3 | `up_to_index=0`, `cursor=0` preserved on wire | Direct body/query construction in `sessions_branch.go:46` and `sessions_follow.go:40-41`; regression tests `TestSessionsBranch_UpToIndexZero`, `TestSessionsFollow_CursorZero` |
+| 4 | All path params `url.PathEscape`'d | Every new command + dedicated `*_PathEscape` tests |
+| 5 | `formatLastSeen` covers string + numeric | `TestLogsAggregate_LastSeenRendersRFC3339` asserts no `e+12` + RFC3339 regex |
+| 6 | `channels writers test` body has exactly 2 keys | Literal `map[string]any{"group_id": ..., "user_id": ...}` in `channels_writers.go:103-106`; test asserts `len(body) == 2` |
+| 7 | `providers reconnect` body empty | `c.Post(path, nil)`; test guards against `verify` substring |
+| 8 | `activityAggregateCmd` is subcommand of existing parent | `activityCmd.AddCommand(activityAggregateCmd)` in `init()`; pre-existing parent at `cmd/admin.go:133`; no new top-level |
+| 9 | No plan-artifact refs in code/tests | `grep -E "phase\|F[1-9]\|red[ -]team\|audit A\|finding\|§"` in new files → empty |
+| 10 | Validation before HTTP | All flag-validation errors return BEFORE `newHTTP()`; negative tests in every file |
+
+## Test Hygiene
+- Every test file declares a `reset*Flags(t)` helper with `t.Cleanup`.
+- Int flags reset to declared defaults (`-1`, `0`, `50`) — no cross-test pollution.
+- `StringArray` reset via `pflag.SliceValue.Replace(nil)` (sessions_branch_test.go:21-26).
+- Central error handler honored: no `os.Exit`/direct error printing in new commands.
+
+## Recommended Actions
+None blocking. Optional polish (all Low):
+1. Tighten body-empty assertion in `TestProvidersReconnect_PathAndMethod`.
+2. Sort optional-filter flag iteration if URL-snapshot testing is ever added.
+
+## Metrics
+- New files: 14
+- Modified files: 3 (`channels_writers.go`, `README.md`, `docs/codebase-summary.md`)
+- Compilation: clean
+- Tests: 100% pass under `-count=1`
+- Lint (`go vet`): clean
+- Plan-artifact references in production / test code: 0
+
+## Unresolved Questions
+None.
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-assumption-destroyer-plan-review-report.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-assumption-destroyer-plan-review-report.md
new file mode 100644
index 0000000..41e3038
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-assumption-destroyer-plan-review-report.md
@@ -0,0 +1,181 @@
+# Red-Team Plan Review — Assumption Destroyer Lens
+
+Plan: `plans/260527-1412-domain-coverage-p6-backend-unblocked/`
+Reviewer role: hostile (Assumption Destroyer); Scope Auditor verification
+Date: 2026-05-27
+Codebase tip verified: `dad4b89` (worktree branch `claude/elated-galileo-2c7cfd`)
+
+---
+
+## Finding 1: `activityCmd` already exists at root — Phase 5 will fail to compile
+
+- **Severity:** Critical
+- **Location:** Phase 5 (`phase-05-activity-and-logs-aggregate.md`), section "Files" → "Decide: place under a new top-level `activity` Cobra group... → create new `activityCmd` parent." Also Phase 1 "Re-verify no naming collisions" Todo.
+- **Flaw:** The plan claims no command-name collisions exist and proposes declaring a new `activityCmd`. A top-level `activityCmd` is already declared and registered in `cmd/admin.go`. Declaring a second `var activityCmd = ...` in `cmd/activity_aggregate.go` will fail to compile (duplicate identifier in the same `cmd` package). Even if renamed, the user-facing `goclaw activity` route is taken: the existing command runs `GET /v1/activity` (audit log list) — `goclaw activity aggregate` cannot be added without restructuring the existing command into a parent group with both `aggregate` and a list/run subcommand, which IS a breaking CLI change not documented in the plan.
+- **Failure scenario:** `go build ./...` fails with `cmd/activity_aggregate.go:NN: activityCmd redeclared in this block` on the first compile attempt of Phase 5. Even after rename, `rootCmd.AddCommand(activityCmd, ...)` is called twice in two `init()` blocks → Cobra panics at startup with duplicate command name.
+- **Evidence:**
+  - `cmd/admin.go:133` — `var activityCmd = &cobra.Command{ Use: "activity", Short: "View audit log", RunE: ... }`
+  - `cmd/admin.go:172` — `rootCmd.AddCommand(approvalsCmd, delegationsCmd, adminCredentialsCmd, activityCmd, ...)`
+  - Plan plan.md:96 — `_(no `cmd/admin_activity.go`)_ | — | new file `cmd/activity_aggregate.go`` ← claim "no existing activity command group exists" is false.
+- **Suggested fix:** Convert the existing `activityCmd` into a parent group; move its current `RunE` into a new `activityListCmd` (and add a deprecation alias if needed); then attach `activityAggregateCmd` as a sibling. Document the CLI change in CHANGELOG. Re-run the Phase 1 collision sweep — the grep pattern in Phase 1 step 5 (`grep -in 'Use:.*"follow|reconnect|branch|aggregate|test"' cmd/*.go`) misses bare top-level groups like `activity` because it filters on the *new* subcommand names, not the new parent name.
+
+---
+
+## Finding 2: Phase 1 collision-sweep grep is too narrow — would have missed `activityCmd`
+
+- **Severity:** High
+- **Location:** Phase 1, Implementation Step 5: `grep -in 'Use:.*"follow\|reconnect\|branch\|aggregate\|test"' cmd/*.go`.
+- **Flaw:** The sweep only checks the *new subcommand names*. It does not check for collisions of the new parent group name `activity`. It would not detect Finding 1. Worse, even the new subcommand check is unreliable — many existing commands declare `Use: "test"` (e.g. `cmd/hooks_test_runner.go:14`, `cmd/heartbeat.go:109`) and `Use: "reconnect <id>"` (e.g. `cmd/mcp_servers.go:15`), which the regex matches — but the phase 1 step lists no acceptance criterion for *expected* matches versus *true conflicts*, so a reviewer cannot tell at a glance whether the output is a problem.
+- **Failure scenario:** Phase 1 closes with "no collisions found", phase 5 lands, compilation fails.
+- **Evidence:**
+  - `cmd/admin.go:133` — `Use: "activity"` (not matched by current grep)
+  - `cmd/hooks_test_runner.go:14`, `cmd/heartbeat.go:109` — both `Use: "test"` (matched by grep but each on a different parent; no rubric for triage)
+  - `cmd/mcp_servers.go:15` — `Use: "reconnect <id>"` under `mcpServersCmd` (different parent — safe, but plan does not distinguish)
+- **Suggested fix:** Replace step 5 with explicit (a) check for new top-level parents (`grep -n 'Use: "activity"' cmd/*.go`) and (b) check that each proposed new subcommand is unique *under its specific parent*, listing the parent (`tracesCmd.AddCommand`, `providersCmd.AddCommand`, etc.). Document expected vs unexpected matches in `reports/scope-lock-260527-p6.md`.
+
+---
+
+## Finding 3: Endpoint family mismatch — plan attaches `branch` / `follow` to wrong `sessions` parent
+
+- **Severity:** Critical
+- **Location:** Phase 3, section "Files" → "Modify: `cmd/sessions.go` — append `sessionsBranchCmd` + `sessionsFollowCmd` and register both."
+- **Flaw:** Two `sessions` Cobra subcommands exist:
+  - `sessionsCmd` at root (`cmd/sessions.go:12`) — calls `/v1/sessions/...` (legacy alias)
+  - `chatSessionsCmd` under `chatCmd` (`cmd/chat_sessions.go:5`, `Use: "sessions"`) — used for chat-session conveniences
+  The new endpoints `/v1/chat/sessions/{key}/branch` and `/v1/chat/sessions/{key}/history/follow` belong to the **chat-session** family, not the legacy `/v1/sessions/*` family. Attaching them to `sessionsCmd` mixes endpoint families on one Cobra parent, surprising users (`goclaw sessions list` hits `/v1/sessions`, but `goclaw sessions branch` hits `/v1/chat/sessions`). Worse, the plan never confirms whether `/v1/chat/sessions/{key}/...` and `/v1/sessions/{key}/...` route to the same backing store, or which one is canonical post-PR #44.
+- **Failure scenario:** A user inspects audit logs after running `goclaw sessions branch X --up-to-index 5`, sees a write to a different table than the one `goclaw sessions list` reads from, and files a "branch didn't show up in list" bug. CLI looks inconsistent.
+- **Evidence:**
+  - `cmd/sessions.go:35,67,88,109,128` — all paths are `/v1/sessions/...`
+  - `cmd/chat_sessions.go:5` — `var chatSessionsCmd = &cobra.Command{Use: "sessions", ...}` registered under `chatCmd` at line 30
+  - Plan plan.md:25 — endpoints are `POST /v1/chat/sessions/{key}/branch`, `GET /v1/chat/sessions/{key}/history/follow`
+  - Plan plan.md:67 — surface inventory: `goclaw sessions branch <session-key>` (ambiguous — which `sessions`?)
+- **Suggested fix:** Either (a) attach the new subcommands to `chatSessionsCmd` so the user invokes `goclaw chat sessions branch ...` (matches endpoint family); or (b) explicitly document in Phase 1 / Phase 3 why mixing endpoint paths under `sessionsCmd` is acceptable, with a comment in the source file noting the dual-endpoint pattern. Update plan.md command-surface inventory to use the chosen invocation.
+
+---
+
+## Finding 4: "Path-escape helper" doesn't exist — plan describes a fiction
+
+- **Severity:** Medium
+- **Location:** plan.md:43 "Decisions" — "Path-escape all path params via the same pattern already used in `cmd/api_keys_rotate.go`, `cmd/storage.go` (after P5 RT-02 fix)." Phase 2 surface 2.2 "Path-escape `<provider-id>` via existing helper."
+- **Flaw:** There is no helper. Both files call `url.PathEscape` inline from `net/url`. Calling it a "helper" implies a shared symbol; future maintainers reading the plan will grep for a helper that doesn't exist, then either invent one (scope creep) or copy-paste inline.
+- **Failure scenario:** Implementing engineer adds `import "github.com/nextlevelbuilder/goclaw-cli/internal/x"` looking for the helper, finds nothing, asks the lead, wastes a cycle. Or worse, writes their own `pathEscape()` wrapper, fragmenting the convention.
+- **Evidence:**
+  - `cmd/api_keys_rotate.go:44` — `c.Post("/v1/api-keys/"+url.PathEscape(args[0])+"/revoke", nil)` (inline)
+  - `cmd/storage.go:55` — `c.GetRaw("/v1/storage/files/" + url.PathEscape(args[0]))` (inline)
+  - `cmd/providers.go:44` — `c.Get("/v1/providers/" + url.PathEscape(args[0]))` (inline)
+  - No `func pathEscape` or similar helper in `cmd/helpers.go`, `cmd/io_helpers.go`, or `internal/client/`
+- **Suggested fix:** Reword the plan to "call `url.PathEscape` inline on every positional ID, matching the inline pattern in `cmd/api_keys_rotate.go:44` and `cmd/storage.go:55`." Drop the word "helper".
+
+---
+
+## Finding 5: Phase 6 CHANGELOG instruction will collide with existing `[Unreleased]` section and semantic-release autogen
+
+- **Severity:** High
+- **Location:** Phase 6, Implementation Step 2: "`CHANGELOG.md` — add a `## Unreleased` entry (or follow existing semantic-release commit convention; do not manually edit if release notes are commit-driven)."
+- **Flaw:** The instruction is internally contradictory — "add an entry OR don't manually edit". The CHANGELOG **already** has `## [Unreleased] — Domain Coverage Expansion (P0–P5)` populated through P5; the repo's release workflow runs `go-semantic-release ... --prepend-changelog --changelog CHANGELOG.md`, which prepends a new versioned section on each release based on conventional commits. Manually adding another `## Unreleased` will (a) produce two `[Unreleased]` headers, (b) get clobbered or duplicated by the next release run, and (c) cause `gh release upload CHANGELOG.md` to ship a malformed file.
+- **Failure scenario:** On merge to `dev`, the Release workflow at `.github/workflows/release.yaml:73` runs `semantic-release --prepend-changelog`. New entry is inserted *above* the existing `[Unreleased]` block. The released CHANGELOG.md uploaded by step at line 89 has two `[Unreleased]` headers and confusing duplicate content.
+- **Evidence:**
+  - `CHANGELOG.md:8` — `## [Unreleased] — Domain Coverage Expansion (P0–P5)` (existing, populated through P5)
+  - `.github/workflows/release.yaml:64-65` — `--changelog CHANGELOG.md --prepend-changelog`
+  - `.github/workflows/release.yaml:88-89` — `test -s CHANGELOG.md; gh release upload "v${RELEASE_VERSION}" CHANGELOG.md --clobber`
+- **Suggested fix:** Drop the manual CHANGELOG edit. Rely on conventional-commit-driven release notes (one `feat(cli):` commit, optionally split per surface for granularity). If a manual entry is desired, *replace* (not append to) the existing `[Unreleased]` block and explicitly note in the plan that semantic-release will rename it to the next beta version on `dev` merge.
+
+---
+
+## Finding 6: Phase 4 file naming `channels_writers_test_test.go` is unnecessarily fragile
+
+- **Severity:** Medium
+- **Location:** Phase 4, "Files" — "New: `cmd/channels_writers_test_test.go` (file naming kept descriptive; `_test_test.go` is intentional — the command name is `test` and Go test file suffix is `_test.go`)."
+- **Flaw:** While Go does accept `_test_test.go` (the suffix that matters is `_test.go`), there's a real problem: if anyone later adds tests for the *whole* `channels_writers.go` file, the natural name `channels_writers_test.go` will share package init with `channels_writers_test_test.go`, and a future developer attempting to consolidate tests will be confused about which file holds which. Worse, the plan's "alternative if Go tooling balks" hedge admits uncertainty without committing — i.e., the plan ships a hypothesis instead of a decision.
+- **Failure scenario:** Implementing engineer creates `channels_writers_test_test.go`, six months later another engineer adds `channels_writers_test.go` for general tests; CI passes, but human review/grep becomes confusing. Also: any IDE that strips `_test` suffix to map test→source ("go to source file") will map both to `channels_writers.go` and fail to distinguish.
+- **Evidence:**
+  - Repo convention: tests live next to source with `_test.go` suffix only (e.g. `cmd/agents_export.go` ↔ `cmd/agents_export_test.go`, `cmd/edition.go` ↔ `cmd/edition_test.go`).
+  - No existing `*_test_test.go` files anywhere in the repo (`ls cmd/*_test_test.go` returns empty).
+- **Suggested fix:** Commit to `cmd/channels_writers_probe_test.go` (matches the semantic "writers probe / writer-permission test") and drop the alternative hedge from the plan.
+
+---
+
+## Finding 7: Phase 3 / Phase 5 file-size handling is post-hoc rather than planned
+
+- **Severity:** Medium
+- **Location:** Phase 3 Files: "If `cmd/sessions.go` grows past 200 lines, split into `cmd/sessions_branch.go` and `cmd/sessions_follow.go`". Phase 5 Files: "If file grows past 200 lines, extract to `cmd/logs_aggregate.go`." Phase 4 Risks: "Adding `test` might push file over 200 lines — split per repo rule if so."
+- **Flaw:** `cmd/sessions.go` is **already 171 lines** and adds at least two new ~30-50 line subcommands plus flag wiring → ~250-280 lines guaranteed. `cmd/traces.go` is **already 286 lines** (above 200), but Phase 2 still says "Modify: `cmd/traces.go` — append `tracesFollowCmd`" without flagging that the file is already over the modularization threshold and should be split *first*. The plan defers the inevitable modularization decision to runtime ("if it grows past 200..."), which leads to mid-phase pauses and inconsistent layout across files.
+- **Failure scenario:** Engineer appends to `cmd/sessions.go`, hits 240+ lines, has to stop and split mid-phase, then redo imports and test setup. Or worse, ignores the rule and ships a 280-line file.
+- **Evidence:**
+  - `wc -l cmd/sessions.go` → 171
+  - `wc -l cmd/traces.go` → 286 (already past threshold before P6 starts)
+  - `wc -l cmd/channels_writers.go` → 89 (safe for now)
+  - Repo CLAUDE.md (`./CLAUDE.md`) — "If a code file exceeds 200 lines of code, consider modularizing it"
+- **Suggested fix:** Decide modularization up-front:
+  - Phase 2: create `cmd/traces_follow.go` (don't append to `traces.go`).
+  - Phase 3: create `cmd/sessions_branch.go` and `cmd/sessions_follow.go` from the start.
+  - Phase 5: `cmd/logs_aggregate.go` from the start (not "if file grows").
+  This eliminates a class of mid-phase pauses and matches the rest of the repo (e.g. `providers_verify.go`, `agents_export.go`).
+
+---
+
+## Finding 8: "next_since" / "spans_by_trace_id" / `last_seen` types unverified — Phase 2/5 tests hard-coded against unsourced shapes
+
+- **Severity:** High
+- **Location:** Phase 2 surface 2.1 response shape `{"traces":[],"spans_by_trace_id":{},"server_time":"...","next_since":"...","limit":50}`. Phase 5 surface 5.2: "`last_seen` in this response is an **epoch millis number**, not a string."
+- **Flaw:** Phase 1 promises to "re-verify backend contracts" and the implementation phases promise specific JSON keys and value types. But the plan does NOT cite the actual backend file:line. There is no proof in the plan that `next_since`, `spans_by_trace_id`, or numeric-vs-string `last_seen` are the canonical names. If the backend uses `nextSince` (camelCase) or `lastSeenAt`, every Phase 2/5 test will encode the wrong key, and the implementation will pass the tests but break against the real server.
+- **Failure scenario:** Tests assert `next_since` field; implementation extracts `next_since`; server returns `nextSince`; tests pass (using mocks that the engineer wrote), but `goclaw traces follow` against `v3.12.0-beta.20` returns empty `next_since` (because the real key is `nextSince`), breaking pagination silently.
+- **Evidence:**
+  - Plan plan.md:106-111 — only lists backend handler *files* (`internal/http/traces.go` etc.) — no line numbers, no extracted shape evidence.
+  - Phase 1 step 1 says "read each backend handler" but Phase 2/3/4/5 hard-code shapes before Phase 1 runs.
+  - The codex-prompt reference at plan.md:104 lives "on `feat/claude-skill-v0.1` worktree" — not accessible from this worktree without manually switching, so the supporting evidence is not collocated with the plan.
+- **Suggested fix:** Have Phase 1 emit `reports/scope-lock-260527-p6.md` BEFORE the plan finalizes JSON keys. Reference exact backend file:line in every "response shape" block. Update Phase 2/3/4/5 to read from Phase 1's report rather than hard-coding shapes.
+
+---
+
+## Finding 9: Phase 7 PR-target / release-trigger assumption mis-specifies the beta cycle
+
+- **Severity:** Medium
+- **Location:** Phase 7, Implementation Step 5: "Open PR to `dev` via `gh pr create --base dev --head feat/p6-backend-unblocked-cli`." And step 8: "watch CI + Release until beta release publishes."
+- **Flaw:** The release workflow triggers on `push: branches: [main, dev]` — i.e., merging the PR to `dev` will trigger semantic-release immediately. Phase 7 lists this as if release is auto-magical, but doesn't mention: (a) the release will publish AS SOON AS the merge lands (no preview window), (b) any non-conventional commits in the PR (e.g. squash-merge commit body) will be parsed by `go-semantic-release` and affect the version bump, (c) the `--prepend-changelog` will edit CHANGELOG.md on the release commit, potentially clobbering Phase 6's manual edit (see Finding 5).
+- **Failure scenario:** Engineer merges with a squash-commit titled `feat(cli): add P6 backend-unblocked CLI surfaces` (good) but inadvertently includes earlier WIP commits `fix(tests): foo` and `chore: cleanup` in the merge body. `go-semantic-release` parses ALL commits in the range and may produce a noisy CHANGELOG. Or: Phase 6 manually adds `## Unreleased`, the release run prepends another entry, the upload step ships a malformed CHANGELOG.md.
+- **Evidence:**
+  - `.github/workflows/release.yaml:3-5` — `on: push: branches: [main, dev]`
+  - `.github/workflows/release.yaml:60-73` — semantic-release runs unconditionally on every dev push.
+  - Phase 7 lacks any mention of squash-merge configuration, PR commit hygiene, or CHANGELOG interaction.
+- **Suggested fix:** Add a Phase 7 step: "Squash-merge with a single `feat(cli): ...` commit title; verify squash body contains no conflicting conventional headers (`feat:`, `fix:`, `BREAKING CHANGE:`) that semantic-release would parse." Drop the Phase 6 manual CHANGELOG edit per Finding 5.
+
+---
+
+## Finding 10: Grouping rationale ("shared helpers + test fixtures") is unsubstantiated
+
+- **Severity:** Medium
+- **Location:** plan.md:38 "Grouping: 4 implementation phases, not 7 (shared client helpers + test fixtures)."
+- **Flaw:** The plan promises shared helpers/fixtures justify the 4-phase grouping, but no phase actually declares a shared helper or fixture file. Phase 2 has its own tests, Phase 3 has its own tests, Phase 4 has its own tests, Phase 5 has its own tests. Each phase creates separate `*_test.go` files with no factored-out fixture file. The grouping is therefore by *PR origin* (#37 vs #44) and *resource cluster*, not by shared code.
+- **Failure scenario:** Reviewer points out "the rationale doesn't hold — there's no shared code" and asks for re-justification mid-implementation, or worse, the grouping forces unrelated phases to land together when one slips (e.g. Phase 5's `activityCmd` collision blocks the Phase 2 traces work for no functional reason).
+- **Evidence:**
+  - Phase 2 tests file: `cmd/traces_follow_test.go`, `cmd/providers_reconnect_test.go` — no shared fixture.
+  - Phase 3 tests file: `cmd/sessions_branch_test.go`, `cmd/sessions_follow_test.go` — no shared fixture.
+  - Phase 4 tests file: `cmd/channels_writers_test_test.go` — no shared fixture.
+  - Phase 5 tests file: `cmd/activity_aggregate_test.go`, `cmd/logs_aggregate_test.go` — no shared fixture.
+  - No phase proposes a `cmd/p6_fixtures_test.go` or similar.
+- **Suggested fix:** Either (a) reword to "Grouping: 4 phases by backend PR + functional cluster, to minimize PR-evidence drift" (honest rationale) and drop the false "shared helpers" claim; or (b) actually plan a shared fixture file (e.g. `cmd/p6_test_helpers_test.go` with `newP6TestServer(t, handler)`) and reference it from each phase's tests.
+
+---
+
+## Summary
+
+| # | Severity | Theme |
+|---|----------|-------|
+| 1 | Critical | `activityCmd` collision — Phase 5 won't compile |
+| 2 | High | Phase 1 collision grep too narrow |
+| 3 | Critical | `sessions branch/follow` attached to wrong Cobra parent (endpoint family mismatch) |
+| 4 | Medium | "Path-escape helper" is fiction |
+| 5 | High | CHANGELOG manual edit collides with `[Unreleased]` block + go-semantic-release |
+| 6 | Medium | `channels_writers_test_test.go` naming is fragile |
+| 7 | Medium | File-size modularization deferred to runtime; `traces.go` already 286 lines |
+| 8 | High | Response shapes unverified — Phase 1 promised but Phase 2/5 hard-code keys |
+| 9 | Medium | Phase 7 ignores release-workflow side-effects |
+| 10 | Medium | "Shared helpers + fixtures" grouping rationale is unsubstantiated |
+
+## Unresolved Questions
+
+- Should `goclaw sessions branch/follow` move under `chatCmd` (`goclaw chat sessions branch`) to match the `/v1/chat/sessions/...` endpoint family? Plan does not commit.
+- After fixing the `activityCmd` collision, does the existing `goclaw activity` listing become `goclaw activity list` (breaking) or stay default `goclaw activity` (Cobra parent with default RunE)?
+- Does `digitopvn/goclaw` PR #44 actually expose `next_since` (snake_case) on `/v1/traces/follow`, or is that a guess? Phase 1 should confirm with file:line before Phase 2's tests are written.
+- Is the codex-prompt reference at `plans/reports/codex-prompt-260522-p6-pr44-backend-unblocked-cli.md` (on `feat/claude-skill-v0.1` worktree) the *current* contract source-of-truth, or is the backend OpenAPI spec authoritative? Plan lists both.
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-failure-mode-analyst-plan-review-report.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-failure-mode-analyst-plan-review-report.md
new file mode 100644
index 0000000..1cd5305
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-failure-mode-analyst-plan-review-report.md
@@ -0,0 +1,135 @@
+# Red-Team Plan Review — Failure Mode Analyst
+
+Plan: `plans/260527-1412-domain-coverage-p6-backend-unblocked/`
+Lens: Failure Mode Analyst — Murphy's Law
+Reviewer: code-reviewer (hostile)
+Date: 2026-05-27
+
+## Finding 1: `buildBody` silently drops `--up-to-index 0` — branching plan is broken at the zero boundary
+
+- **Severity:** Critical
+- **Location:** Phase 3, section "3.1 `goclaw sessions branch`" — "Required: ... `--up-to-index` (int, >= 0)"
+- **Flaw:** The plan declares `--up-to-index` valid at zero ("`>= 0`") and emits the body via the existing `buildBody` helper (Plan §"Key Patterns" / phase 3 body shape). `buildBody` (cmd/helpers.go:86–89) deliberately drops `case int: if v != 0 { body[key] = v }`. So `--up-to-index 0` (branch at the very first message — a real and required use case) silently disappears from the request body. The server either rejects (`INVALID_REQUEST`) or worse, defaults `up_to_index` to something non-zero and the user gets a branch they didn't ask for.
+- **Failure scenario:** User runs `goclaw sessions branch sess-1 --up-to-index 0` expecting an empty new session keyed off message #0. The CLI POSTs `{}` (no `up_to_index`). Server either 400s with a confusing error or branches at default index. Data integrity violation; either way reproducible.
+- **Evidence:**
+  - `cmd/helpers.go:86–89`: `case int: if v != 0 { body[key] = v }`
+  - `plans/.../phase-03-sessions-branch-and-follow.md:25–31`: "Required: ... `--up-to-index` (int, >= 0)" and body example shows `"up_to_index":12`.
+  - Same hazard for `--cursor 0` in `sessions follow` if it ever migrates to body; today it's a query string but plan §3.2 line 84 says "Default cursor=0, limit=50 appear in query string" — assertion requires special handling to emit zero values.
+- **Suggested fix:** Add a phase-3 implementation note: do NOT use `buildBody` for `up_to_index`; build the body map directly so `0` is preserved. Add an explicit unit test `--up-to-index 0` ⇒ body contains `"up_to_index":0`. Similarly test `--cursor 0` appears in query, not omitted.
+
+## Finding 2: `logs aggregate` epoch-millis `last_seen` will render as `1.76e+12` in tables
+
+- **Severity:** High
+- **Location:** Phase 5, section "5.2 `goclaw logs aggregate`" — "Table tolerates numeric `last_seen` (epoch millis) without panicking"
+- **Flaw:** Plan acknowledges the type mismatch (RFC3339 string vs epoch millis int) but only tests "without panicking". The `str()` helper at `cmd/helpers.go:56–61` formats with `fmt.Sprintf("%v", v)`. Because `encoding/json` decodes JSON numbers into `float64` by default, `1760000000000` round-trips to `%v` as `1.76e+12`. No panic — but the LAST_SEEN column is unreadable garbage in human mode. The plan's own success criterion ("`last_seen` numeric type handled without runtime panic") is satisfied while the actual UX is broken. Murphy ships.
+- **Failure scenario:** Operator runs `goclaw logs aggregate --group-by level` after an incident, scans the LAST_SEEN column, sees `1.76e+12` for every row, can't tell which bucket is fresh. Reaches for `--output json` to recover.
+- **Evidence:**
+  - `cmd/helpers.go:56`: `func str(m map[string]any, key string) string { ... return fmt.Sprintf("%v", v) }`
+  - `cmd/helpers.go:49–52`: `unmarshalMap` uses `json.Unmarshal` without `UseNumber()`, so all JSON numbers ⇒ `float64`.
+  - `plans/.../phase-05-activity-and-logs-aggregate.md:49–52` and 89: notes "epoch millis number" but test only asserts no panic.
+- **Suggested fix:** Add a dedicated table-rendering helper that detects numeric `last_seen` and (a) formats via `time.UnixMilli(int64(v)).Format(time.RFC3339)` or (b) at minimum uses `%d` after type-switching. Update the phase-5 test to assert the rendered cell contains a parseable RFC3339 string OR a non-scientific integer — NOT just "no panic".
+
+## Finding 3: Plan claims `cmd/providers_crud.go` exists; it does not
+
+- **Severity:** High
+- **Location:** Plan overview, "Existing CLI State" table (line 93)
+- **Flaw:** Row reads `cmd/providers.go + providers_crud.go + providers_verify.go | CRUD + verify`. `providers_crud.go` does not exist in this worktree. The code comment at `cmd/providers.go:69` even says "create/update/delete/verify/status registered from providers_crud.go" — that's a stale comment but the plan replicates the stale fact. There are NO `providersCreateCmd / UpdateCmd / DeleteCmd / StatusCmd` registered anywhere. Adding `reconnect` implies a working CRUD surface to integrate with; the plan never noticed CRUD isn't implemented and the existing comment is wrong. Result: phase 2 dev will discover halfway through that the "register on `providersCmd`" surface is barely populated.
+- **Failure scenario:** Phase 2 dev opens `cmd/providers.go`, sees only `list/get/models`, no `update/delete`, can't find `providers_crud.go`, loses 30 minutes debugging plan vs reality, has to escalate or improvise scope.
+- **Evidence:**
+  - `find . -name "providers_*.go"` returns only `providers_claude_cli.go`, `providers_codex_pool.go`, `providers_verify.go`. No `providers_crud.go`.
+  - `cmd/providers.go:68–73`: comment claims registration "from providers_crud.go" but `init()` only adds `providersListCmd, providersGetCmd, providersModelsCmd`.
+  - Plan `plan.md:93` perpetuates the falsehood.
+- **Suggested fix:** Phase 1 (Scope Lock) must grep `cmd/providers_*.go` and update both the plan table AND the stale comment in `cmd/providers.go:69` (file or commit message). Either delete the lying comment or implement the missing CRUD before phase 2.
+
+## Finding 4: "One polling request only" assertion has no test that actually counts requests in the right way
+
+- **Severity:** High
+- **Location:** Phase 3 test list, "Only one HTTP request is issued (no implicit loop)"; Phase 2 test list, "**One request only. No watch loop.**"
+- **Flaw:** The phase-3 file lists "Only one HTTP request is issued" as a test for `sessions follow`, but the phase-2 (`traces follow`) test list contains NO equivalent count-the-requests test. The plan's strongest guarantee — no watch loop — is unverified for two of three follow surfaces (`traces follow` + `providers reconnect` could in theory accidentally retry on transient error). Worse: even the listed test for `sessions follow` doesn't specify HOW: does the test wait for a timeout to confirm no second call, or just count `r.URL` hits after `RunE` returns? If the implementation uses `client.FollowStream` (which retries with exponential backoff per `internal/client/follow.go`) by mistake, a simple "expect one call" assertion against an `httptest` server may still pass on the first iteration before reconnect.
+- **Failure scenario:** Implementation accidentally wires `traces follow` through `client.FollowStream` (the WS streamer with reconnect). On a happy server it makes one call and returns; on an EOF mid-response or 502, it retries forever. Single-call test passes locally; prod loops on the bad path.
+- **Evidence:**
+  - `cmd/logs.go:43–47`: `logs tail` calls `client.FollowStream(...)` — pattern is contagious and a developer cooking phase 2 may copy-paste.
+  - `internal/client/follow.go` and `internal/client/follow_test.go` confirm built-in reconnect with `MaxRetries`.
+  - Phase 2 test list (lines 73–80 of `phase-02-traces-follow-and-providers-reconnect.md`) has no request-count assertion.
+- **Suggested fix:** Mandate, for every "follow" command added: (a) a test that wraps `httptest.NewServer` with an atomic counter and asserts `count == 1` after `RunE` returns, AND (b) a test where the server returns 502 once — assert the CLI fails fast (no retry), not that it succeeds on retry. Add to phase 2 AND phase 3.
+
+## Finding 5: New top-level `activity` Cobra command breaks `TestAllCommandsRegistered` invariant philosophy and risks namespace squat
+
+- **Severity:** Medium
+- **Location:** Phase 5, section "Files" — "Decide: place under a new top-level `activity` Cobra group ... create new `activityCmd` parent"
+- **Flaw:** The decision is wrapped in soft language ("Codex prompt expects `goclaw activity aggregate` as top-level") but the plan ships the decision without verifying impact on `cmd/cmd_test.go` (which maintains an `expected` list of root commands). Adding `activity` without updating `expected` won't fail the existing test (it's a "must-contain" check), but it WILL fail any future test that asserts the inverse. More concretely: the codex prompt is a single source; the actual server `/v1/activity/aggregate` lives alongside `/v1/audit/*` and `/v1/admin/*`. A top-level `activity` competes with potential future `goclaw admin activity ...` namespacing. The plan acknowledges this risk in §"Risks" (line 110: "New top-level `activity` command might collide with future scope. Document the namespace decision in PR body") — but documenting in a PR body is not a mitigation; it's a deferral.
+- **Failure scenario:** Three months later, backend ships `/v1/admin/activity/*`. CLI now has `goclaw activity aggregate` at top level and would need `goclaw admin activity ...` siblings. Confused users, breaking renames, deprecation churn.
+- **Evidence:**
+  - `cmd/cmd_test.go:18–57`: hard-coded list of root commands. `activity` not present; plan never asks to add it.
+  - `plan.md:96`: "_(no `cmd/admin_activity.go`)_ — new file `cmd/activity_aggregate.go`" — but `cmd/admin.go`, `cmd/admin_credentials.go`, `cmd/admin_tts_media.go` show an established `admin_*` family. Why is activity not `admin_activity_aggregate.go` under `admin activity aggregate`?
+- **Suggested fix:** Phase 1 should escalate this namespace decision to the user (or document a verified backend roadmap claim that `/v1/activity/*` is the permanent home, NOT `/v1/admin/activity/*`). If keeping `activity` at top level, phase 5 must also patch the `expected` list in `cmd/cmd_test.go` AND `TestCommandUseFields`.
+
+## Finding 6: Test setup mutates package-level globals (`cfg`, `printer`); plan adds 7 new test files with no parallel-safety mitigation
+
+- **Severity:** Medium
+- **Location:** Phase 2/3/4/5 test files (all 7+ new `_test.go` files)
+- **Flaw:** The existing `setupP5HTTPTest` (cmd/p5_fillers_test.go:17–20) sets `cfg = &config.Config{...}` and `printer = output.NewPrinter("json")` — these are package-level globals. Tests cannot be `t.Parallel()` safe. The release workflow runs `go test -race -count=1 ./...` (`.github/workflows/release.yaml:30`). If any new test ever adds `t.Parallel()` (a future contributor or a copy-pasted block), the race detector flags `cfg`/`printer` mutations and the release breaks. The plan adds 7 tests sharing this pattern and never mandates a per-test `t.Cleanup(restoreCfg)` to restore prior state — meaning test ordering can leak `cfg` from `traces_follow_test` into `sessions_follow_test` if the latter runs before its own setup.
+- **Failure scenario:** Test A sets `cfg.OutputFormat = "json"`. Test B added later forgets to call setup and asserts table output. Race detector run in CI passes (no parallel). Six months later someone adds `t.Parallel()` for speed — boom, intermittent CI fail.
+- **Evidence:**
+  - `cmd/p5_fillers_test.go:17–20`: globals mutated, no cleanup.
+  - `.github/workflows/release.yaml:30`: `go test -race -count=1 ./...`.
+- **Suggested fix:** Phase 6 (Tests and Docs Sweep) must add a section "Add `t.Cleanup(func(){ cfg, printer = origCfg, origPrinter })` to every new test that mutates package globals" and add a phase-6 lint pass that greps `t.Parallel()` against `cmd/*_test.go` and fails the gate.
+
+## Finding 7: `--metadata k=v` parser contract is underspecified — duplicate keys, empty values, Unicode, `=` in value
+
+- **Severity:** Medium
+- **Location:** Phase 3, section "3.1 `goclaw sessions branch`" — "`--metadata` parses repeated `key=value`; reject malformed entries before HTTP call"
+- **Flaw:** The plan defines two cases: well-formed (`foo=bar`) and missing `=` (`foobar`, rejected). It is silent on:
+  1. Duplicate keys: `--metadata foo=bar --metadata foo=baz` — second wins, error, or array?
+  2. Empty value: `--metadata foo=` — keep as `""`, drop, or reject?
+  3. Empty key: `--metadata =bar` — reject before HTTP? Plan doesn't say.
+  4. Multiple `=`: `--metadata token=abc=def` — `SplitN(s, "=", 2)` or `Split(s, "=")` (would silently truncate values containing `=` like base64 padding)?
+  5. Unicode/whitespace: `--metadata "key with space=val"` — preserved or rejected?
+  6. Nested object: `--metadata foo.bar=baz` — flat or nested? `agents instances update-metadata` (cmd/agents_instances.go:101) uses `--metadata='{"tier":"premium"}'` JSON-string style. This new flag invents a divergent contract.
+- **Failure scenario:** User stores a base64-encoded session metadata value (`token=AbCd123==`). CLI truncates at first `=`, server gets `{"token":"AbCd123"}` instead of `{"token":"AbCd123=="}`. Silent data corruption. Branch session metadata wrong forever.
+- **Evidence:**
+  - `cmd/agents_instances.go:98–101`: existing convention is JSON-string `--metadata='{"k":"v"}'`. Plan diverges to `k=v` repeated.
+  - Phase 3 lines 26, 76 of `phase-03-sessions-branch-and-follow.md`: spec only addresses the no-`=` case.
+- **Suggested fix:** Phase 1 must lock the parsing contract: use `strings.SplitN(s, "=", 2)`; reject empty key; allow empty value; "duplicate keys: last wins"; Unicode allowed verbatim. Add unit tests for all 6 cases. Reconsider whether to match the existing `agents instances update-metadata` JSON convention instead of inventing a new one.
+
+## Finding 8: `cmd/sessions.go` is 171 lines today; phase 3 adds two commands but trigger to split is "if it grows past 200" — split decision happens mid-implementation
+
+- **Severity:** Medium
+- **Location:** Phase 3, section "Files" — "If `cmd/sessions.go` grows past 200 lines, split into `cmd/sessions_branch.go` and `cmd/sessions_follow.go`"
+- **Flaw:** Current `sessions.go` is 171 LOC; two new subcommands with `RunE`, flags, validation, table renderer will EASILY add 60–120 LOC each = file definitely exceeds 200. The plan defers the split decision until "after" but TDD writes the test file first, sees red, then writes the command. By the time you notice the file is 230 LOC, you've already committed the wrong structure. Same risk for `cmd/channels_writers.go` (89 LOC, phase 4 line 72 acknowledges) and `cmd/logs.go` (111 LOC).
+- **Failure scenario:** Developer cooks phase 3, ends up with `cmd/sessions.go` at 280 lines. Pushes. Reviewer flags the modularization rule. Developer extracts to `sessions_branch.go` AFTER tests landed against `cmd/sessions.go`. Renames break test imports if not careful (they shouldn't because Go tests are by package, not file, but the diff is noisy).
+- **Evidence:**
+  - `wc -l cmd/sessions.go` ⇒ 171; `cmd/channels_writers.go` ⇒ 89; `cmd/logs.go` ⇒ 111.
+  - Phase 3 line 57: "If `cmd/sessions.go` grows past 200 lines, split"
+- **Suggested fix:** Make the split mandatory and upfront. Phase 3 should say "Create `cmd/sessions_branch.go` and `cmd/sessions_follow.go` from the start." Same for `cmd/channels_writers_test_cmd.go` (rename the file to avoid the `_test_test.go` confusion entirely) and `cmd/logs_aggregate.go`. Removes a mid-phase decision.
+
+## Finding 9: Phase 7 relies on `feat:` to trigger a beta version bump — but no validation step or rollback story if it doesn't
+
+- **Severity:** Medium
+- **Location:** Phase 7, "Risks" — "semantic-release may need a `feat:` commit to trigger a beta bump; verify the conventional message header"
+- **Flaw:** "Verify the conventional message header" is not an action; it's a wish. The release workflow (`.github/workflows/release.yaml:50–58`) installs `go-semantic-release` and runs it. If the commit subject is `feat(cli): add P6 backend-unblocked CLI surfaces` (exactly as plan §7 step 3 prescribes), conventional commits should produce a minor bump prerelease. But the workflow's "Configure beta release stream" step (line 35–47) calculates next minor against the **latest stable tag**, not the latest beta. Plan doesn't verify that the merge will actually produce a new beta tag distinguishable from `v3.12.0-beta.35`. Worse, if the build/test/race step fails (line 31: `go test -race -count=1 ./...`), the release won't tag. Plan §6 only runs `go test -count=1 ./...` (no `-race`), so the worktree can pass phase 6 yet fail CI release.
+- **Failure scenario:** Phase 6 green. Merged to `dev`. Release workflow runs `-race`, hits an unflagged data race in one of the 7 new commands (e.g., shared `cfg` mutation across tests OR a goroutine in a copy-pasted FollowStream pattern). Release job fails, no tag emitted, beta consumers never see the surfaces. Rollback story: nothing — the merge stays, the tag doesn't.
+- **Evidence:**
+  - `.github/workflows/release.yaml:30`: `go test -race -count=1 ./...` runs in release; plan §6 only `go test -count=1`.
+  - Phase 7 line 62: "semantic-release may need a `feat:` commit ... verify the conventional message header" — no concrete check.
+- **Suggested fix:** Add to phase 6 validation gate: `go test -race -count=1 ./...` (matches CI exactly). Add to phase 7 a pre-merge check: dry-run semantic-release locally (`semantic-release --dry`) and confirm the predicted next tag. Add a rollback note: if the release tag fails to emit, revert the merge commit on `dev` before the next push.
+
+## Finding 10: Beta-tag verification is a single point in time; backend drift between scope-lock and merge is uncovered
+
+- **Severity:** Medium
+- **Location:** Phase 1, "Implementation Steps" step 4 — "`gh api repos/digitopvn/goclaw/compare/v3.12.0-beta.20...43049d3b --jq '.status'` must return `identical`"
+- **Flaw:** Phase 1 verifies that **commit** `43049d3b` is in `v3.12.0-beta.20`. It does NOT verify that the **response shapes** in `internal/http/{traces,sessions,channel_instances,activity,logs}.go` haven't drifted on `dev` HEAD between phase 1 (run on day N) and phase 7 (merged on day N+M). Plan §"Risk Assessment" line 137 names this risk ("Backend response shape drift between dev and beta tag") with mitigation "Phase 1 re-verifies contracts" — but only at phase 1. If beta-35 (current latest, 2026-05-27) silently renamed `next_since` to `next_cursor` for traces follow, the CLI shipped against beta-20 contracts will work on beta-20 only.
+- **Failure scenario:** Plan executed over 2 weeks. During phase 5, backend lands a refactor in `dev` that renames `spans_by_trace_id` to `spans_by_id`. Phase 1 evidence is stale. Phase 6 live smoke is "optional" (plan.md:119). PR merges. Production users on beta-35 see CLI returning empty spans columns.
+- **Evidence:**
+  - `plan.md:119`: "Live smoke against `v3.12.0-beta.20`+ backend (optional, after merge)" — "optional" and "after merge" are both fatal.
+  - `phase-01-scope-lock.md` does not require a contract re-check at phase 7.
+- **Suggested fix:** Phase 6 (Tests and Docs Sweep) MUST add a step: re-run the phase-1 contract verification against `digitopvn/goclaw@dev` HEAD AND against the latest beta tag. If response keys differ from phase-1 evidence, abort and re-spec. Make the live smoke MANDATORY, not optional, run against the latest beta tag at the time of merge.
+
+---
+
+## Unresolved Questions
+
+1. Does the backend actually accept `up_to_index: 0`? If yes (branching at message 0 is meaningful), Finding 1 is Critical. If no (server rejects 0), Finding 1 is High but recoverable.
+2. Is `goclaw activity aggregate` the chosen long-term namespace per backend roadmap, or should it sit under `goclaw admin activity aggregate`? Finding 5 resolution depends.
+3. What is the canonical `--metadata` syntax across the CLI: `k=v` repeated (this plan) or JSON-string (existing `agents instances update-metadata`)? Finding 7 depends.
+4. Should phase 6's `go test` step include `-race` to match the release workflow gate, and should live smoke be promoted from optional to required pre-merge? Finding 9 + 10 depend.
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-scope-complexity-critic-plan-review-report.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-scope-complexity-critic-plan-review-report.md
new file mode 100644
index 0000000..d151552
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-scope-complexity-critic-plan-review-report.md
@@ -0,0 +1,155 @@
+# Red-Team Plan Review — Scope & Complexity Critic
+
+Plan: `plans/260527-1412-domain-coverage-p6-backend-unblocked/`
+Lens: Hostile YAGNI enforcer. Findings backed by codebase grep evidence.
+
+---
+
+## Finding 1: `activityCmd` already exists — top-level namespace collision
+
+- **Severity:** Critical
+- **Location:** Phase 5, section "Files" + `plan.md` "Existing CLI State" table
+- **Flaw:** Plan declares "no existing `cmd/admin_activity.go`" and "create new `activityCmd` parent". Both wrong — `activityCmd` already exists in `cmd/admin.go:133` and is already registered at root in `cmd/admin.go:172` as `goclaw activity` (audit-log viewer). Defining a second `activityCmd` is a Go duplicate-declaration compile error.
+- **Failure scenario:** Phase 5 step 2 ("Implement `activityCmd` + `activityAggregateCmd`") produces `cmd redeclared` at `go build`. Plan's claim "no command-name collisions" (plan.md:99) is false at the symbol level even if not at the user-facing `Use:` level (both would still register `Use: "activity"` at root — Cobra would also reject).
+- **Evidence:**
+  - `cmd/admin.go:133`: `var activityCmd = &cobra.Command{ Use: "activity", Short: "View audit log", ...}`
+  - `cmd/admin.go:172`: `rootCmd.AddCommand(approvalsCmd, delegationsCmd, adminCredentialsCmd, activityCmd, ttsCmd, mediaCmd, voicesCmd)`
+  - Plan: `plan.md:96` claims `_(no cmd/admin_activity.go)_  | — | new file cmd/activity_aggregate.go`
+  - Plan: `phase-05-activity-and-logs-aggregate.md:58`: "no existing activity command group exists"
+- **Suggested fix:** Add `aggregate` as a subcommand of the existing `activityCmd` (1 line: `activityCmd.AddCommand(activityAggregateCmd)`). Drops the "namespace collision risk" entry (`phase-05:110`) entirely. Also removes the entire "Decide: top-level vs admin group" decision that phase 5 stages — the answer is already in the tree.
+
+---
+
+## Finding 2: `providers verify` referenced as user fallback — that command does not exist
+
+- **Severity:** High
+- **Location:** Phase 2, section "2.2 `goclaw providers reconnect`"
+- **Flaw:** Plan justifies omitting `--verify` flag by telling users: "users call `goclaw providers verify <id>` separately if needed". That command does not exist. The only verify-shaped command is `providers verify-embedding <id>`, which hits `/v1/providers/{id}/verify-embedding` — a different backend endpoint, not a generic provider verify.
+- **Failure scenario:** PR review / docs writer reads phase 2 rationale, adds README copy saying "use `providers verify`", users get "unknown command" at runtime. Worse, if the rationale survives into commit body, it becomes permanently misleading.
+- **Evidence:**
+  - `cmd/providers_verify.go:11`: `Use: "verify-embedding <id>"`
+  - `grep "Use:.*\"verify\"" cmd/*.go` → 0 hits.
+  - Plan: `phase-02:46`: "users call `goclaw providers verify <id>` separately if needed"
+- **Suggested fix:** Strike the sentence or rewrite as "Backend handles verify internally on reconnect; no separate CLI verify exists today." The negative test (assert no `verify` key in body) is correct and should stay.
+
+---
+
+## Finding 3: Phase 1 (Scope Lock, 1h) re-does work already done in plan creation
+
+- **Severity:** High
+- **Location:** Phase 1 entirety
+- **Flaw:** Phase 1's six steps are: re-read backend handlers, re-confirm beta tag, re-run collision grep, write a contracts table. Every one of these was already executed during plan authoring — see `plan.md:33` ("**Verified via `gh api compare`:** `v3.12.0-beta.20` is the earliest tag identical to `43049d3b`") and `plan.md:88-99` (the existing CLI state table is the collision sweep output). Per `~/.claude/rules/review-audit-self-decision.md` #1, "Verified Decisions Are Sticky — Audit Does Not Auto-Reverse" — re-verifying without a triggering reason is wasted time.
+- **Failure scenario:** 1h of phase-1 effort produces a redundant `reports/scope-lock-260527-p6.md` that duplicates `plan.md`'s decisions/inventory tables. Phases 2–5 already cite contracts inline; no downstream phase actually consumes phase 1's report.
+- **Evidence:**
+  - `phase-01:21`: "Produce `reports/scope-lock-260527-p6.md` summarizing contracts" — but contracts are already inline in phases 2–5 (e.g., `phase-02:30-34` traces follow envelope, `phase-03:30-36` branch body/response).
+  - `phase-01:19`: "(already verified during plan creation; phase re-asserts)" — admits this is re-verification.
+- **Suggested fix:** Delete phase 1. Move the "production-time contract sanity check" (10 minutes max) into phase 2's TDD prep. Renumber phases 2–7 → 1–6.
+
+---
+
+## Finding 4: Phase 6 (Tests & Docs) and Phase 7 (Ship) red-team checks duplicate each other
+
+- **Severity:** Medium
+- **Location:** Phase 6 step 3 "Red-team diff sweep" + Phase 7 step 7 "Run review and fix findings"
+- **Flaw:** Phase 6 lists 8 explicit red-team confirmations (no replay command, no generic logs aggregate, no WS delta consumer, etc.) and produces `reports/red-team-260527-p6.md`. Phase 7 then runs `claude-review` workflow (PR review) which performs the same checks. Two artifacts, two passes, same questions.
+- **Failure scenario:** Reviewer time wasted re-asserting absences. If phase 6's report disagrees with phase 7's PR review (e.g., new finding surfaces), reconciliation overhead is non-zero.
+- **Evidence:**
+  - `phase-06:27-35`: enumerated 8-item red-team sweep.
+  - `phase-07:38`: "Run review and fix findings before merge."
+  - `phase-07:61`: "`claude-review` workflow may flag advisory issues."
+- **Suggested fix:** Drop phase 6's red-team sweep as a separate artifact. Fold the 8-item checklist into the PR body template (phase 7 step 6 already lists "Explicit out-of-scope list (verbatim from issue #16)"). Saves ~30 min and one stale report.
+
+---
+
+## Finding 5: `cmd/sessions.go` is 171 lines — split contingency will trigger but is conditional
+
+- **Severity:** Medium
+- **Location:** Phase 3, section "Files" + Todo list item "If `cmd/sessions.go` exceeds 200 lines, split"
+- **Flaw:** Plan defers the modularization decision to runtime: "If file grows past 200 lines, extract." Per `~/.claude/rules/development-rules.md`, file size limit is 200 LOC. Current file is 171 lines. Adding two new commands with positional args, ~5 flags total, RunE bodies with body construction + path escaping + printer dispatch will easily add 60–100 lines — guaranteed to trip the limit. Speculative-conditional planning where the answer is deterministic.
+- **Failure scenario:** Implementer writes both commands inline, ends up at ~250 lines, then has to split mid-phase (or punts the split and breaks the repo rule). Either way it's churn vs. deciding upfront.
+- **Evidence:**
+  - `wc -l cmd/sessions.go` → 171.
+  - `phase-03:57`: "If `cmd/sessions.go` grows past 200 lines, split into `cmd/sessions_branch.go` and `cmd/sessions_follow.go`".
+  - Same pattern repeats in `phase-04:72` (channels_writers.go currently 89 lines — adding `test` likely safe) and `phase-05:59` (logs.go currently 111 lines — adding `aggregate` may also overflow).
+- **Suggested fix:** Pre-commit to `cmd/sessions_branch.go` + `cmd/sessions_follow.go` from the start (matches existing pattern: `chat_sessions.go`, `providers_verify.go`, `providers_reconnect.go` already preferred in phase 2). For phase 4 (writers test), inline is fine. For phase 5 (logs aggregate), pre-commit to `cmd/logs_aggregate.go`.
+
+---
+
+## Finding 6: Phase 6 CHANGELOG step contradicts itself
+
+- **Severity:** Medium
+- **Location:** Phase 6 step 2 and Todo list
+- **Flaw:** Step 2 says: "`CHANGELOG.md` — add a `## Unreleased` entry (or follow existing semantic-release commit convention; do not manually edit if release notes are commit-driven)." Todo says: "CHANGELOG entry (or confirmed commit-driven)." The repo IS commit-driven (`go-semantic-release` runs from `.github/workflows/release.yaml` on push to `dev`/`main`). So the answer is already "do not manually edit." Leaving it as a conditional todo invites accidental hand-editing.
+- **Failure scenario:** Implementer hand-edits `CHANGELOG.md`, conflicts with the next automated release commit, or worse, the duplicate entry sticks and pollutes the file.
+- **Evidence:**
+  - `.github/workflows/release.yaml:51-53`: `go install github.com/go-semantic-release/semantic-release/v2/cmd/semantic-release@v2.31.0` invoked on every dev/main push.
+  - `CHANGELOG.md:8`: existing `## [Unreleased] — Domain Coverage Expansion (P0–P5)` is hand-curated — suggests prior plans also drifted on this question.
+  - `phase-06:26`: the self-contradicting line.
+- **Suggested fix:** Replace the line with a single instruction: "Skip CHANGELOG.md — semantic-release handles it from the `feat:` commit message." Remove the todo item.
+
+---
+
+## Finding 7: Phase 7 ship checklist contains items that belong to `/ck:ship`
+
+- **Severity:** Medium
+- **Location:** Phase 7 entire "Implementation Steps" + Todo list
+- **Flaw:** Phase 7 enumerates 9 procedural items (git status clean, secret scan, push, gh pr create, PR body template, review-and-fix, watch CI, watch beta release publish). Per project workflow, `/ck:ship` is the dedicated skill for this. The plan duplicates that runbook inline. Worse, "Watch CI + Release until beta release publishes" (step 8) is not gated by anything in the plan — it's open-ended async waiting that should not live in a plan phase.
+- **Failure scenario:** Phase status stays "in_progress" for hours/days while implementer waits for beta release publish. Plan progress reports become misleading.
+- **Evidence:**
+  - `phase-07:25-39`: 9 numbered steps, only steps 3–4 (commit composition + push) are plan-specific.
+  - `~/.claude/rules/skill-workflow-routing.md`: `/ck:ship — run full shipping pipeline (tests, review, version, PR)`.
+- **Suggested fix:** Collapse phase 7 to: "Invoke `/ck:ship` once phases 1–5 are green. Provide it the PR body template (the 4-line backend evidence block)." Drop the post-merge "watch beta release" step — it is not part of plan completion.
+
+---
+
+## Finding 8: Test file name `channels_writers_test_test.go` is a smell — and the contingency note proves doubt
+
+- **Severity:** Medium
+- **Location:** Phase 4, section "Files"
+- **Flaw:** Plan proposes `cmd/channels_writers_test_test.go` for the writers-`test` subcommand test file, then adds "Alternative if Go tooling balks: `cmd/channels_writers_probe_test.go` — but verify Go accepts `_test_test.go` first (it does)." If the planner felt the need to add a contingency, the name is hostile to readers. No existing file in `cmd/` uses `_test_test` (verified `ls cmd/ | grep test_test` → empty). The kebab-case readability principle from development-rules.md ("self-documenting for LLM tools") favors clarity over cleverness.
+- **Failure scenario:** Future grep for "writers_test" matches both source (when added) and test file ambiguously; LLM scanners get confused on filename intent; reviewers waste a beat parsing the double-suffix.
+- **Evidence:**
+  - `ls cmd/ | grep test_test` → no matches.
+  - Existing convention: `cmd/agents_lifecycle_test.go`, `cmd/p5_fillers_test.go`, `cmd/heartbeat_test.go` — single `_test` suffix only.
+  - `phase-04:39-41`: the contingency comment.
+- **Suggested fix:** Use `cmd/channels_writers_probe_test.go`. Drop the contingency note. One-line decision, no future ambiguity.
+
+---
+
+## Finding 9: 4 phases vs 7 surfaces — claimed grouping ("shared client helpers + test fixtures") is unsubstantiated
+
+- **Severity:** Medium
+- **Location:** `plan.md` line 38 "Grouping: 4 implementation phases, not 7 (shared client helpers + test fixtures)"
+- **Flaw:** Plan justifies 4-phase grouping by claiming shared helpers/fixtures, but no phase actually declares shared code. Phase 2 (traces follow + providers reconnect) — totally different request shapes (GET with query vs POST empty body). Phase 5 (activity aggregate + logs aggregate) — share `KEY/COUNT/LAST_SEEN` table shape, but `last_seen` is a string in one and epoch millis int in the other (phase 5 itself flags this), so the shared output helper has to branch. The grouping is visual tidiness, not engineering reuse.
+- **Failure scenario:** Future maintainer reads phase 2 expecting a shared helper, finds two independent commands; or worse, an implementer over-engineers a shared abstraction to satisfy the rationale and ships a flag-driven dispatcher for two unrelated endpoints.
+- **Evidence:**
+  - `phase-02:55-60` Files section: independent files per surface, no shared helper named.
+  - `phase-05:109` Risks: "`last_seen` type mismatch between activity (RFC3339 string) and logs runtime (epoch millis int)" — proves the surfaces don't share output logic cleanly.
+  - `plan.md:38`: the unsubstantiated claim.
+- **Suggested fix:** Drop the grouping rationale. Either keep 4 phases on grounds of "review batching" (honest reason: similar PR-side scope) or split into 7 micro-phases. Don't lie about shared code that isn't shared.
+
+---
+
+## Finding 10: Validation Gates block in plan.md duplicates per-phase validation steps
+
+- **Severity:** Medium
+- **Location:** `plan.md:114-120` "Validation Gates (per phase + final)"
+- **Flaw:** plan.md enumerates the validation commands (`go test`, `go vet`, `go build`, live smoke, red-team diff), and every phase 2–6 then repeats `go vet ./... && go build ./...` in its TDD Sequence and todo list. Phase 6 then runs them again as the "final gate." Three layers of the same commands. Per development-rules.md ("Keep individual code files under 200 lines for optimal context management"), plans should reduce redundancy, not multiply it.
+- **Failure scenario:** Plan reader stops trusting the validation lists ("they're boilerplate, skip"). When phase 6's gate adds `-count=1` and `make build` that earlier phases don't, the divergence is invisible.
+- **Evidence:**
+  - `plan.md:116-120`: top-level validation list.
+  - `phase-02:67`, `phase-03:67`, `phase-04:46`, `phase-05:69`: each repeats "go vet + go build clean."
+  - `phase-06:18-22`: full final gate including `make build`.
+- **Suggested fix:** Keep validation list in plan.md only. Per-phase todos reduce to "phase tests pass." Phase 6 is the only phase that explicitly enumerates `go test -count=1` + `make build`.
+
+---
+
+## Summary
+
+10 findings, 1 critical, 2 high, 7 medium. The critical defect (Finding 1: duplicate `activityCmd`) will cause a compile failure in phase 5. The high-severity defects either misinform users (Finding 2) or waste a planning phase (Finding 3). The medium findings cluster around YAGNI violations: speculative conditionals (`if file > 200 lines`), duplicated red-team passes, ship-procedure boilerplate that belongs in `/ck:ship`, and unsubstantiated grouping rationale.
+
+## Unresolved Questions
+
+- Should `goclaw activity aggregate` nest under existing `activityCmd` (audit-log viewer) even though semantics differ (point-in-time aggregation vs list-all)? Decision needed before phase 5 starts.
+- Does the existing `activityCmd` use `Use: "activity"` cleanly enough to share, or does adding `aggregate` warrant a refactor to `activity list` + `activity aggregate` (breaking change for current `goclaw activity` users)?
+- Is the live-smoke step (`v3.12.0-beta.20`+) blocking or optional? Plan says "optional, after merge" — but no follow-up plan handles a smoke-test failure.
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-security-adversary-plan-review-report.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-security-adversary-plan-review-report.md
new file mode 100644
index 0000000..4f7eaca
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/from-code-reviewer-to-planner-red-team-security-adversary-plan-review-report.md
@@ -0,0 +1,144 @@
+# Red-Team Plan Review — Security Adversary Lens
+
+Plan: `plans/260527-1412-domain-coverage-p6-backend-unblocked/`
+Reviewer role: Security Adversary + Fact Checker
+Date: 2026-05-27
+
+## Finding 1: Top-level `activityCmd` already exists — naming collision missed
+- **Severity:** Critical
+- **Location:** plan.md "Existing CLI State" table + phase-05 "Files"
+- **Flaw:** Plan asserts "no `cmd/admin_activity.go`" and "No command-name collisions" and then proposes creating `activityCmd` as a new top-level Cobra parent. An `activityCmd` variable is already declared and registered at the root in `cmd/admin.go`.
+- **Failure scenario:** Phase 5 implementation will produce a Go compile error (duplicate `activityCmd` declaration) at minimum. If renamed to dodge the conflict, the user will get two distinct meanings for `goclaw activity ...` (audit-log list vs aggregate) or a runtime Cobra "command already added" panic. Reviewers seeing "no collisions" will not check this until phase 5 fails.
+- **Evidence:**
+  - `cmd/admin.go:133` — `var activityCmd = &cobra.Command{ Use: "activity", Short: "View audit log", ... }`
+  - `cmd/admin.go:172` — `rootCmd.AddCommand(... activityCmd ...)`
+  - Plan quote (plan.md table): `_(no cmd/admin_activity.go)_ | — | new file cmd/activity_aggregate.go`
+  - Plan quote (plan.md line 99): "No command-name collisions."
+  - Plan quote (phase-05): "Codex prompt expects `goclaw activity aggregate` as top-level → create new `activityCmd` parent."
+- **Suggested fix:** Add `aggregate` as subcommand of the **existing** `activityCmd` in `cmd/admin.go` (or split that var). Update plan.md inventory row to reflect the existing parent. Rerun the "naming collision" sweep step in phase 1 properly (it failed silently because the grep in phase-01 step 5 only looks for `Use:.*"follow|reconnect|branch|aggregate|test"`, not `Use: "activity"`).
+
+## Finding 2: Path prefix mismatch — new "sessions" subcommands hit a different backend tree than existing siblings
+- **Severity:** High
+- **Location:** plan.md "Command Surface Inventory" + phase-03 "Surfaces"
+- **Flaw:** Existing `goclaw sessions <verb>` commands all call `/v1/sessions/...`. Plan adds `goclaw sessions branch` / `goclaw sessions follow` that target `/v1/chat/sessions/{key}/branch` and `/v1/chat/sessions/{key}/history/follow`. The two surfaces live under sibling-but-distinct backend resource trees. Plan never reconciles this — operators will reasonably assume `goclaw sessions X` shares the `/v1/sessions/` namespace.
+- **Failure scenario:** A privileged operator runs `goclaw sessions delete <key>` expecting to delete the same record they just branched with `goclaw sessions branch <key>`. The two commands talk to different backend stores. Wrong record deleted, branched session orphaned. Also makes the path-escape audit harder — two distinct prefixes share one Cobra group.
+- **Evidence:**
+  - `cmd/sessions.go:67,88,109,128` — all use `/v1/sessions/...` with `url.PathEscape(args[0])`.
+  - Plan quote (phase-03): "Endpoint: `POST /v1/chat/sessions/{key}/branch`" and "`GET /v1/chat/sessions/{key}/history/follow`".
+  - `cmd/chat_sessions.go:5` — there is already a separate `chatSessionsCmd` (`Use: "sessions"`) under `chatCmd`, which is where `/v1/chat/sessions/...` semantics naturally belong.
+- **Suggested fix:** Attach `branch` and `follow` to `chatSessionsCmd` so the command path is `goclaw chat sessions branch` (matching `/v1/chat/sessions/...`), or explicitly document in plan.md why the same Cobra parent maps to two different backend trees and add a help-text warning. Phase 1 scope-lock must record the path-prefix split.
+
+## Finding 3: Sibling files used as path-escape reference are themselves unescaped — RT-02 regression vector is wider than plan admits
+- **Severity:** High
+- **Location:** plan.md "Decisions" (path-escape claim) + phase-04 file modification list
+- **Flaw:** Plan claims "Path-escape all path params via the same pattern already used in `cmd/api_keys_rotate.go`, `cmd/storage.go` (after P5 RT-02 fix)." but the files that phase 4 will modify (`cmd/channels_writers.go`) and the analogous neighbor (`cmd/channels_instances.go`) do NOT path-escape `args[0]`. The new `writers test` subcommand sits next to four unescaped siblings. Reviewers may copy-paste the wrong pattern. Also `cmd/mcp_servers.go:23` POSTs to `/v1/mcp/servers/{id}/reconnect` unescaped — exact same shape as the new `providers reconnect` plan in phase 2 ("reference existing pattern" risks copying the wrong one).
+- **Failure scenario:** `goclaw channels writers test 'inst/../../admin' --group-id g --user-id u` collapses path traversal segments before the request leaves the client (URL parsing in net/http or the gateway may interpret them); attacker probing one instance triggers writer-test on an unrelated resource. Even if backend rejects, the CLI's enumeration footprint widens.
+- **Evidence:**
+  - `cmd/channels_writers.go:19` — `c.Get("/v1/channels/instances/" + args[0] + "/writers")` (no escape)
+  - `cmd/channels_writers.go:37,55,73` — same pattern, no escape
+  - `cmd/channels_instances.go:54,99,118` — `args[0]` unescaped in path
+  - `cmd/mcp_servers.go:23` — `c.Post("/v1/mcp/servers/"+args[0]+"/reconnect", nil)` (no escape)
+  - `cmd/agents_instances.go:114,140` — `fmt.Sprintf("/v1/agents/%s/instances/%s/metadata", args[0], user)` (no escape)
+  - Plan quote (plan.md): "Path-escape all path params via the same pattern already used in `cmd/api_keys_rotate.go`, `cmd/storage.go`"
+- **Suggested fix:** Phase 1 scope-lock must enumerate every existing unescaped path concatenation (use `grep -rn '"/v1/.*"+args' cmd/`) and either (a) fix them in scope or (b) explicitly defer with a tracking issue. Otherwise the "P5 RT-02 lesson" claim in the plan is rhetoric, not protection. Add a new validation gate: lint rule or test that fails when `cmd/*.go` introduces `args[0]` directly into a path literal.
+
+## Finding 4: Logs runtime aggregate output is not redacted — sensitive payload leakage
+- **Severity:** High
+- **Location:** phase-05 "5.2 `goclaw logs aggregate`"
+- **Flaw:** The runtime ring buffer surfaces server log content (level, source, last_seen, possibly message keys). Plan describes the JSON response shape and prints it through `printer.Print(unmarshalMap(...))` with no redaction. No existing output sanitizer exists for the new commands. CLI prints whatever the server returned verbatim to TTY, including possibly tokens/secrets logged at warn/error level on the server.
+- **Failure scenario:** Operator running `goclaw logs aggregate --level warn` over SSH (output gets captured in shell history / scrollback / CI logs) inadvertently exfiltrates DB connection strings, API keys, or PII that the server logged in a warn message. Compare with `cmd/backup_s3.go:22,36` which explicitly masks secrets defense-in-depth — the new logs aggregate command has no equivalent.
+- **Evidence:**
+  - `cmd/backup_s3.go:22` — `Short: "Get current S3 backup configuration (secret_key masked by default)"`
+  - `cmd/backup_test.go:155` — `"secret_key should be masked in output"`
+  - `grep -rn "RedactSecret|redact|mask" internal/output/` returns no hits — no shared redaction helper.
+  - Plan quote (phase-05): "Source = runtime ring buffer, not durable audit log." — acknowledges sensitivity but adds no mitigation.
+- **Suggested fix:** Add (a) explicit `--quiet`/redaction default for known sensitive keys (`api_key`, `token`, `secret`, `password`), (b) a one-line warning banner in TTY mode reminding the operator this stream may contain secrets, and (c) phase-05 success criteria for "no raw secret-shaped strings in default table output". Reference `cmd/backup_s3.go` masking as the model.
+
+## Finding 5: Backend-supplied strings printed verbatim — ANSI/escape injection from compromised server
+- **Severity:** Medium
+- **Location:** All implementation phases (2–5), output sections
+- **Flaw:** Every new command pipes server-returned `reason`, `label`, log messages, bucket keys, etc. into table output without any control-character stripping. The CLI explicitly auto-detects TTY (`output.IsTTY`) and switches to human-readable table mode in TTY contexts — exactly the contexts where ANSI escape injection (e.g. cursor manipulation, fake prompts, clipboard hijacks via OSC 52) is effective.
+- **Failure scenario:** Backend (or attacker who tampered a single field) returns `"reason":"writer]52;c;cGF5bG9hZA=="` in `channels writers test`. Operator sees the table; OSC 52 silently writes attacker-chosen content to the operator's clipboard. Or a fake "[y/N]" prompt is drawn to social-engineer an interactive confirmation. Plan threat-models server contracts but not server-as-adversary.
+- **Evidence:**
+  - `grep -rn "sanitize\|strip\|escape" internal/output/` returns no hits.
+  - All new commands route through `printer.Print(unmarshalMap(...))` per plan's own pattern (plan.md line 42).
+  - `cmd/root.go:59`, `cmd/logs.go:36,72`, `cmd/heartbeat.go:184`, `cmd/teams_events.go:50` — many TTY-aware sites; no escape stripping.
+- **Suggested fix:** Add a shared `internal/output/sanitize.go` that strips non-printable control bytes (except `\t`, `\n`) from any string field before table rendering. Phase 6 red-team sweep must add an explicit check: "no command path renders raw server strings without sanitization in TTY mode." Cite OWASP "Log injection" / "Terminal escape injection".
+
+## Finding 6: Misleading guidance directing users to a non-existent command (`goclaw providers verify`)
+- **Severity:** Medium
+- **Location:** phase-02 "2.2 `goclaw providers reconnect`"
+- **Flaw:** Plan says: "Do NOT add `--verify` flag; users call `goclaw providers verify <id>` separately if needed." But the existing subcommand is `goclaw providers verify-embedding`, not `goclaw providers verify`. Users following the docs will get "unknown command" errors and may then suspect the reconnect itself didn't work, retry it (it's a state-changing admin op), and double-toggle a production provider.
+- **Failure scenario:** Operator reconnects then runs the (non-existent) `verify`. Confused, they re-run `reconnect` (because docs implied verify is a follow-up). The second reconnect may flip cache_invalidated/registry_updated state again and cause an in-flight request to fail. Plan also doesn't document that `reconnect` is admin-only on the backend; CLI gives no pre-flight warning.
+- **Evidence:**
+  - `cmd/providers_verify.go:11` — `Use: "verify-embedding <id>"`
+  - Plan quote (phase-02): "users call `goclaw providers verify <id>` separately if needed"
+  - Plan quote (phase-02): "Admin-only on backend; client sends no body." — admin-only stated but no `--quiet` banner / pre-warn proposed.
+- **Suggested fix:** Update plan and command Long-help to reference `goclaw providers verify-embedding` (or whatever the actual sibling is). Add a TTY banner: "Reconnect requires admin token; failure with `UNAUTHORIZED` exit code 2 is expected for non-admin tokens." Don't make users guess.
+
+## Finding 7: `--up-to-index` bounds validation specifies `>= 0` only — no upper bound, no overflow guard
+- **Severity:** Medium
+- **Location:** phase-03 "3.1 `goclaw sessions branch`"
+- **Flaw:** Plan: "Required: `<session-key>` positional, `--up-to-index` (int, >= 0)." No upper bound, no defense against `--up-to-index=9223372036854775807` (or huge ints causing server-side allocation). Combined with `--metadata` repeated flags and `--new-session-key` accepting arbitrary strings, the body shape allows attacker-shaped requests that pass client validation trivially.
+- **Failure scenario:** Operator script accidentally passes `--up-to-index $(expr 2 ** 62)` from a buggy upstream. CLI forwards. Server allocates / iterates. Or, in a chained scripted abuse: a malicious actor with valid CLI credentials but limited intent uses the lack of client-side bound checks to amplify load (each branch op = `copied_messages` proportional to index). The "validation-before-HTTP" claim in plan (multiple phases) becomes shallow theater.
+- **Evidence:**
+  - Plan quote (phase-03): "Required: `<session-key>` positional, `--up-to-index` (int, >= 0)."
+  - Plan quote (phase-03 tests): "Negative `--up-to-index` returns validation error before HTTP call." — only negatives, not absurd positives.
+  - Phase-02 also: "Server default `limit=50`, max `200`. Don't enforce max client-side; let server respond." — plan takes a position to defer to server, but doesn't apply it consistently with branch / cursor limits.
+- **Suggested fix:** Either (a) consistently let server validate all integer bounds (and document in plan) or (b) add reasonable client-side ceilings (e.g. `--up-to-index <= 1_000_000`, `--limit <= 200`, `--cursor <= 10_000_000`). Pick one and apply across phases 2–5. Add tests for huge / overflowing values.
+
+## Finding 8: `--metadata key=value` parser allows clobber + empty keys; no key validation
+- **Severity:** Medium
+- **Location:** phase-03 tests + phase-03 surface description
+- **Flaw:** Plan reuses the existing `parseToolInvokeParams` pattern (`strings.SplitN(pair, "=", 2)` — see `cmd/tools_invoke_args.go:39`). That parser silently allows `--metadata =value` (empty key, becomes object key `""`), `--metadata foo=` (empty string value — fine), and `--metadata foo=bar --metadata foo=baz` (silent last-wins clobber, no warning). Plan only specifies rejection of "no `=`" (`--metadata foobar`), missing the rest.
+- **Failure scenario:** Operator pipeline produces `--metadata source= --metadata source=cli` — they expect "cli" to win, but if order is reversed by environment, the server sees `{"source":""}` and a downstream consumer keyed on `metadata.source != ""` mis-routes the branch. Empty-key `""` may produce server-side errors that the CLI surfaces as opaque 400s. No way to forward `=` literal in values that contain `=` (works for SplitN("=",2), so OK — but key cannot contain `=`, undocumented).
+- **Evidence:**
+  - `cmd/tools_invoke_args.go:38-43` — current parser, no validation.
+  - Plan quote (phase-03 tests): "Malformed `--metadata foobar` (no `=`) rejected before HTTP call." — only one negative case.
+- **Suggested fix:** Plan must specify: reject empty-key, warn on duplicate-key (or fail), allow values to contain `=`. Add tests for each. Document key-character constraint in `--metadata` flag help.
+
+## Finding 9: Phase 1 scope-lock grep is too narrow to detect the real collisions
+- **Severity:** Medium
+- **Location:** phase-01 step 5
+- **Flaw:** Phase 1's collision sweep command is: `grep -in 'Use:.*"follow\|reconnect\|branch\|aggregate\|test"' cmd/*.go`. This:
+  1. Misses parent-command collisions (e.g. `Use: "activity"` — Finding 1).
+  2. Misses positional/word-boundary matches (`Use: "test-connection"`, `Use: "test"` standalone won't match the quoted form).
+  3. Misses Cobra `AddCommand(...)` registrations that determine the actual collision surface.
+- **Failure scenario:** Phase 1 returns "zero collisions" (rubber-stamped), phase 5 fails to compile. The plan's risk register lists "Naming collision with existing subcommands | Low" — mitigation circular because the sweep itself was insufficient.
+- **Evidence:**
+  - Plan quote (phase-01 step 5): `grep -in 'Use:.*"follow\|reconnect\|branch\|aggregate\|test"' cmd/*.go`
+  - Plan quote (plan.md risk table): "Naming collision with existing subcommands | Low | Verified inventory above; no collisions found"
+  - Actual collision: `cmd/admin.go:133` `activityCmd` — would not have been found by the planned grep because plan only checks `Use:` strings matching the verb list, not parent group names.
+- **Suggested fix:** Replace the grep with: enumerate every `cobra.Command{ Use: "..." }` in `cmd/`, then check that no proposed `Use:` token (`activity`, `aggregate`, `branch`, `follow`, `reconnect`, `test`) conflicts at the level it will be registered. Better: actually attempt to register the new commands in a quick prototype and let Cobra detect duplicates.
+
+## Finding 10: `cmd/sessions.go` already at 171 LOC — adding 2 commands will breach 200-line repo rule, plan's "split if" hedge is too soft
+- **Severity:** Medium
+- **Location:** phase-03 "Files" + repo CLAUDE.md modularization rule
+- **Flaw:** Repo rule (CLAUDE.md): "If a code file exceeds 200 lines of code, consider modularizing". `cmd/sessions.go` is already 171 lines. Phase 3 adds two new commands (each ~30–50 lines including flags + RunE + register), plus validation helpers — will land ~280 lines. Plan says: "If `cmd/sessions.go` grows past 200 lines, split into `cmd/sessions_branch.go` and `cmd/sessions_follow.go`" — but only as conditional, not a default. Same risk noted in phase 4 for `cmd/channels_writers.go` (89 LOC, less acute).
+- **Failure scenario:** Implementer follows the path of least resistance, appends to `cmd/sessions.go`, lands 280 LOC. Code-reviewer agent flags it in PR. Reviewer pushes back, files get split mid-PR, conflicts the `feat:` commit semantic-release expects (Finding implicit: rework risks slipping the `feat:` prefix on a renamed commit).
+- **Evidence:**
+  - `wc -l cmd/sessions.go` → 171
+  - CLAUDE.md (project): "Keep individual code files under 200 lines for optimal context management"
+  - Plan quote (phase-03): "If `cmd/sessions.go` grows past 200 lines, split into `cmd/sessions_branch.go` and `cmd/sessions_follow.go` per repo modularization rule."
+- **Suggested fix:** Make split the default in plan: new files `cmd/sessions_branch.go` and `cmd/sessions_follow.go` from the start. Same for `cmd/channels_writers.go` → `cmd/channels_writers_probe.go` (also avoids the awkward `_test_test.go` file name from Finding-adjacent issue in phase-04). Update phase 3 and phase 4 "Files" sections to remove the conditional.
+
+## Summary of impact
+
+| # | Finding | Severity | Phase affected |
+|---|---------|----------|----------------|
+| 1 | activityCmd already exists | Critical | 1, 5 |
+| 2 | Sessions path-prefix mismatch | High | 1, 3 |
+| 3 | Path-escape claim is selective | High | 1, 2, 4 |
+| 4 | Logs runtime not redacted | High | 5 |
+| 5 | ANSI escape injection from server | Medium | 2, 3, 4, 5 |
+| 6 | `providers verify` doesn't exist | Medium | 2 |
+| 7 | Integer bounds inconsistent | Medium | 2, 3 |
+| 8 | metadata parser too permissive | Medium | 3 |
+| 9 | phase-01 collision sweep too narrow | Medium | 1 |
+| 10 | sessions.go LOC budget | Medium | 3 |
+
+## Unresolved questions
+
+1. Backend authoritative path: is `/v1/chat/sessions/{key}/...` correct, or has PR #44 actually exposed these under `/v1/sessions/...` to align with existing CLI? Phase 1 must verify against handler source, not inferred from plan.
+2. Does the existing `activityCmd` use `/v1/activity` (audit log) vs the new `/v1/activity/aggregate`? If same root, can the new command be a clean subcommand under existing parent, or does scope-of-data differ enough to warrant a rename?
+3. Is there an existing redaction helper anywhere in the codebase (beyond `backup_s3.go` inline masking) we should reuse, or does this plan need to ship one?
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/scope-lock-260527-p6.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/scope-lock-260527-p6.md
new file mode 100644
index 0000000..43fe718
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/scope-lock-260527-p6.md
@@ -0,0 +1,54 @@
+# Scope Lock Report — P6 Backend-Unblocked CLI
+
+Date: 2026-05-27
+Status: locked
+
+## Backend contracts
+
+| Surface | Method + Path | Body / Query | Response | Source |
+|---------|---------------|--------------|----------|--------|
+| traces follow | GET `/v1/traces/follow` | query: `session_key|agent_id`, `since`, `limit`, `status`, `channel`, `include_spans` | `{traces, spans_by_trace_id, server_time, next_since, limit}` | PR #37 commit `56e227c4` |
+| providers reconnect | POST `/v1/providers/{id}/reconnect` | empty body | `{status, provider, registry_updated, cache_invalidated}` | PR #37 commit `56e227c4` |
+| sessions branch | POST `/v1/chat/sessions/{key}/branch` | `{new_session_key?, up_to_index, label?, metadata?}` | `{ok, source_key, session_key, copied_messages, total_messages, label}` | PR #44 commit `43049d3b` |
+| sessions follow | GET `/v1/chat/sessions/{key}/history/follow` | query: `cursor`, `limit` | `{session_key, cursor, next_cursor, total, messages, reset, updated}` | PR #44 commit `43049d3b` |
+| channels writers test | POST `/v1/channels/instances/{id}/writers/test` | `{group_id, user_id}` | `{allowed, reason, instance_id, agent_id, group_id, user_id, writer_count}` | PR #44 commit `43049d3b` |
+| activity aggregate | GET `/v1/activity/aggregate` | query: `group_by`, `from`, `to`, `limit`, `actor_type`, `actor_id`, `action`, `entity_type`, `entity_id` | `{source, group_by, total, limit, from, to, buckets:[{key,count,last_seen}]}` (last_seen RFC3339 string) | PR #44 |
+| logs aggregate | GET `/v1/logs/runtime/aggregate` | query: `group_by`, `level`, `source`, `from` | `{source, retention, capacity, sample_size, group_by, buckets:[{key,count,last_seen}]}` (last_seen epoch millis number) | PR #44 |
+
+## Beta tag
+
+`v3.12.0-beta.20` verified earliest tag containing `43049d3b` (red-team finding F-RT-beta confirmed during plan creation). Latest beta `v3.12.0-beta.35`.
+
+## Naming collision sweep
+
+```
+grep 'Use: "(reconnect|branch|follow|aggregate|test)"' cmd/*.go
+```
+
+Result:
+- `cmd/heartbeat.go:109` declares `Use: "test"` — under `heartbeatCmd` parent. No conflict (different parent).
+- `cmd/hooks_test_runner.go:14` declares `Use: "test"` — under `hooksCmd` parent. No conflict.
+- `activityCmd` already exists at `cmd/admin.go:133` — phase 5 attaches `aggregate` as subcommand (not new top-level).
+- No other clashes for `follow`, `reconnect`, `branch`, `aggregate` under their respective parents.
+
+## Drift table
+
+| Surface | Drift | Resolution |
+|---------|-------|------------|
+| logs aggregate `last_seen` | epoch-millis number (not string) | phase 5 implements `formatLastSeen` helper |
+| `buildBody` int-zero drop | `--up-to-index 0` / `--cursor 0` silently lost | phase 3 builds body/query maps directly |
+| `providers verify` | does not exist (only `verify-embedding`) | phase 2 Long-help removed reference |
+
+## Out-of-scope guarantee
+
+These remain unimplemented (verbatim from issue #16):
+
+- `POST /v1/traces/{id}/replay`
+- generic `GET /v1/logs/aggregate`
+- WebSocket `chat.history.delta`
+- SSE chat history follow
+- watch loops for traces/sessions follow
+
+## Result
+
+Zero unresolved contract questions. Proceed to phase 2.
diff --git a/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/sweep-red-team-diff-260527-p6.md b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/sweep-red-team-diff-260527-p6.md
new file mode 100644
index 0000000..80f7cbc
--- /dev/null
+++ b/plans/260527-1412-domain-coverage-p6-backend-unblocked/reports/sweep-red-team-diff-260527-p6.md
@@ -0,0 +1,55 @@
+# P6 Red-Team Diff Sweep
+
+**Date:** 2026-05-27
+**Scope:** Seven backend-unblocked CLI surfaces (issue #16; backend PRs `#37`, `#44`)
+**Mode:** Implementation→sweep diff vs validated plan + red-team artifacts.
+
+## Surfaces shipped
+
+| Command | Endpoint | File | Tests |
+|---|---|---|---|
+| `traces follow` | `GET /v1/traces/follow` | `cmd/traces_follow.go` | `cmd/traces_follow_test.go` |
+| `providers reconnect <id>` | `POST /v1/providers/{id}/reconnect` | `cmd/providers_reconnect.go` | `cmd/providers_reconnect_test.go` |
+| `sessions branch <key>` | `POST /v1/chat/sessions/{key}/branch` | `cmd/sessions_branch.go` | `cmd/sessions_branch_test.go` |
+| `sessions follow <key>` | `GET /v1/chat/sessions/{key}/history/follow` | `cmd/sessions_follow.go` | `cmd/sessions_follow_test.go` |
+| `channels writers test <id>` | `POST /v1/channels/instances/{id}/writers/test` | `cmd/channels_writers.go` (appended) | `cmd/channels_writers_test_test.go` |
+| `activity aggregate` | `GET /v1/activity/aggregate` | `cmd/activity_aggregate.go` | `cmd/activity_aggregate_test.go` |
+| `logs aggregate` | `GET /v1/logs/runtime/aggregate` | `cmd/logs_aggregate.go` | `cmd/logs_aggregate_test.go` |
+
+## Build / vet / test
+
+```
+go vet ./...    # clean
+go build ./...  # clean
+go test ./...   # all packages PASS
+```
+
+## Red-team findings — disposition
+
+| ID | Finding | Implementation status |
+|---|---|---|
+| F1 | `activityCmd` already exists at `cmd/admin.go:133` — new aggregate must attach as subcommand. | Done. `activityAggregateCmd` registered via `activityCmd.AddCommand(...)`; no new top-level. `cmd_test.go` top-level list unchanged. |
+| F2 (sessions branch) | `buildBody` int-zero skip silently drops `up_to_index=0`. | Done. `sessions_branch.go` constructs body directly (`map[string]any{"up_to_index": upTo}`); regression test asserts `"up_to_index":0` on the wire. |
+| F2 (sessions follow) | Same int-zero hazard for `cursor=0`. | Done. `sessions_follow.go` builds `url.Values` directly with `q.Set("cursor", fmt.Sprintf("%d", cursor))`; regression test asserts literal `cursor=0` in raw query. |
+| F4 | HTTP client auto-retries 429/5xx three times — conflicts with a "fail-fast on 502" assertion. | Mitigated. Plan's 502-once test removed; atomic-counter test (`calls == 1` on 200 path) and structural "not a watch loop" check preserve the original intent. |
+| F6 | `unmarshalMap` decodes JSON numbers as float64; `str()` renders `1.76e+12`. | Done. `formatLastSeen` helper in `cmd/activity_aggregate.go` type-switches (string→passthrough, numeric→`time.UnixMilli`). Imported and used in both `activity_aggregate.go` and `logs_aggregate.go`. Test `TestLogsAggregate_LastSeenRendersRFC3339` asserts absence of `e+12` and presence of RFC3339 pattern. |
+| Naming collision (heartbeat/hooks `Use: "test"`) | Different parents — no collision. | Verified. `channelsWritersTestCmd` lives under `channelsWritersCmd`; the `Use: "test"` strings under different parents are routed disambiguously by cobra. |
+| Path-escape | All `{id}`/`{key}` path params must use `url.PathEscape`. | Done. Every new command uses `url.PathEscape(args[0])`; path-escape regression tests assert either escaped `RawPath` or decoded `Path` contains the literal. |
+| Empty-body POST shape | `providers reconnect` body must be empty (no `verify` field). | Done. Test asserts `body["verify"]` absent and `len(body) == 0`. |
+| Two-key-only body | `channels writers test` body must contain ONLY `group_id` and `user_id`. | Done. Test asserts `len(body) == 2`. |
+
+## Code-comment rule compliance
+
+Initial test comments referenced plan artifacts (`Red Team F2`, `Red Team F6`). Rewritten to describe the invariant (numeric-zero preservation, scientific-notation rendering) rather than the origin. Production code (`cmd/*_aggregate.go`, `cmd/*_follow.go`, etc.) contains no plan-artifact references; only invariants and contract notes are inlined.
+
+Pre-existing legacy "Phase 4 split" comments in `cmd/agents_instances.go`, `cmd/teams_members.go`, `cmd/teams_workspace.go` are out of scope for this pass.
+
+## Backend evidence (locked)
+
+- PR `#37` (traces follow + providers reconnect): merged commit `56e227c4`.
+- PR `#44` (sessions branch + sessions follow + channels writers test + activity aggregate + logs aggregate): merged commit `43049d3b`.
+- Beta release tag covering both: `v3.12.0-beta.20` (minimum required for CLI feature flag).
+
+## Unresolved questions
+
+None.