loadout-ai 0.8.0 → 0.9.0

package/docs/decisions/002-local-daemon-authentication.md

@@ -0,0 +1,32 @@
+# ADR 002: Loopback-only authenticated coordination daemon
+
+- Status: accepted
+- Date: 2026-09-03
+
+## Context
+
+A localhost HTTP service is still reachable by browser pages, local malware,
+and other users on an incorrectly configured machine. Coordination events can
+contain private repository structure and can influence paid provider turns.
+
+## Decision
+
+Bind the daemon only to `127.0.0.1`. Generate a random 32-byte project token in
+`.handoff/daemon.token` with mode `0600`. REST and SSE require a bearer header;
+query-string tokens are rejected. Validate loopback Host headers and allow only
+same-origin browser requests.
+
+The CLI passes the token to the dashboard in a URL fragment. The dashboard
+moves it into session storage immediately and removes the fragment from browser
+history. Human-readable status does not expose the project root. Request bodies,
+routes, cursors, agent names, and typed event payloads are bounded and validated.
+
+## Consequences
+
+- The dashboard opens conveniently without putting credentials in HTTP request
+  URLs or referrers.
+- API clients must explicitly read the local token and set `Authorization`.
+- The daemon is observability and local transport only; it is not supported as
+  a LAN or internet-facing service.
+- Activating the project kill switch fails closed across storage, daemon,
+  compaction, MCP/CLI writes, and provider-driven turns.

package/docs/decisions/003-bounded-agent-discussions.md

@@ -0,0 +1,91 @@
+# ADR 003: Bounded sequential agent discussions
+
+## Status
+
+Accepted
+
+## Date
+
+2026-09-04
+
+## Context
+
+The coordination bridge can deliver structured events to Claude Code and Codex,
+but it does not make the agents deliberate. Users who want both models to weigh
+the same feature must manually relay responses, and an unconstrained automatic
+relay could consume quota indefinitely, spread prompt injection, or let two
+agents edit the same files concurrently.
+
+Provider interfaces can start or resume turns, but neither supported interface
+offers a shared hidden context or reliable mid-turn steering. Provider output
+is also untrusted data and may be empty, malformed, oversized, or contain
+instructions unrelated to the user's question.
+
+## Decision
+
+Implement an opt-in, two-participant design room as a sequential protocol:
+
+- one proposer and one reviewer alternate for 1-8 rounds;
+- each response is explicitly public, redacted, bounded, persisted, and linked
+  to the prior event by thread and reply IDs;
+- each round costs two provider turns and final synthesis costs one, so the
+  exact required budget is known before any provider session starts;
+- prompts prohibit file edits, commands, tools, and disclosure of private
+  reasoning;
+- the proposer returns a strict final JSON decision, rationale, alternatives,
+  and unresolved disagreements;
+- Loadout emits a normal decision event and a terminal discussion event;
+- provider rejection, invalid output, and empty output close the discussion as
+  failed without silent retries;
+- the existing project kill switch is checked before every provider turn;
+- provider turns default to 120 seconds and are explicitly bounded to a
+  user-selectable 10-600 seconds.
+
+Fresh sessions start lazily with their first discussion prompt so setup does not
+spend a hidden extra turn. Existing provider session IDs are attached without a
+turn and then resumed on the first discussion response. The project bridge
+lease prevents a background bridge and a design room from controlling the same
+sessions concurrently.
+
+## Alternatives considered
+
+### Let both agents edit the same feature during the discussion
+
+Rejected. The purpose of the design room is to settle an approach before file
+ownership and implementation. Concurrent edits make the outcome harder to
+review and reintroduce the conflicts the ownership protocol prevents.
+
+### Forward full provider transcripts automatically
+
+Rejected. It would expose unrelated context, increase prompt-injection risk,
+and make storage and quota use unpredictable. Only responses requested for the
+public discussion are shared.
+
+### Run both agents concurrently and ask a third model to judge
+
+Rejected for the first release. Parallel first proposals do not support genuine
+back-and-forth critique, and a third model adds provider, billing, and tie-break
+semantics without evidence that it improves decisions.
+
+### Continue until the agents agree
+
+Rejected. Agreement is not guaranteed, and an unbounded loop is unsafe. The
+final result preserves unresolved disagreement rather than claiming consensus.
+
+### Host a remote coordination bus
+
+Rejected for this release. Authentication, tenant isolation, encryption,
+availability, and remote conflict semantics require a separate design. The
+current protocol remains local to one repository and machine.
+
+## Consequences
+
+- Users get a real Claude↔Codex critique loop with a predictable maximum cost.
+- The transcript is inspectable with `coord discuss show` and the normal replay.
+- The discussion cannot steer a provider mid-turn; a kill switch takes effect
+  before the next turn.
+- Strict final JSON may fail when a provider ignores the requested format. That
+  failure is visible and auditable instead of being misrepresented as a valid
+  decision.
+- More than two agents, voting, hosted rooms, and automatic implementation are
+  intentionally out of scope.

package/docs/specs/BOUNDED_AGENT_DISCUSSIONS.md

@@ -0,0 +1,169 @@
+# Spec: Bounded agent discussions
+
+## Objective
+
+Add an opt-in design room in which Claude Code and Codex can discuss one
+technical question, challenge each other's proposals, and record a final
+decision. The user chooses the topic, participants, round count, and provider
+turn budget. Success means the exchange is genuinely bidirectional, bounded,
+auditable, resumable from the coordination log, and unable to edit files merely
+because a discussion was started.
+
+The initial release targets two participants. One is the proposer and one is
+the reviewer. A round gives each participant one turn; after the configured
+rounds, the proposer receives one synthesis turn and Loadout records the final
+decision and considered alternative.
+
+## Assumptions approved by the user
+
+1. `loadout coord discuss start` is explicitly opt-in and may spend paid
+   provider turns.
+2. A discussion shares only responses produced for the public design room. It
+   does not expose hidden reasoning, unrelated chat history, or provider state.
+3. Discussion prompts forbid code edits and command execution. Implementation
+   begins only after the discussion completes and the user acts on the result.
+4. Exactly Claude Code and Codex are supported in the first release, using
+   either fresh sessions (`--agents`) or explicit existing sessions
+   (`--sessions`).
+5. A discussion has 1-8 rounds and a hard turn budget. The expected budget is
+   `rounds * 2 + 1`; invalid or insufficient budgets fail before any paid turn.
+6. Provider output is untrusted, redacted at the existing persistence boundary,
+   length-bounded, and stored only as explicit discussion events.
+
+## Tech stack
+
+- TypeScript 5.7, ESM, Node.js 20+
+- Commander 12 for the public CLI
+- Zod 4 for boundary validation
+- Vitest 4 for unit, integration, and CLI tests
+- Existing Claude Code CLI and official Codex SDK adapters
+- Existing project-local `.handoff/coordination.jsonl` protocol
+
+## Commands
+
+```bash
+# Build and static checks
+npm run build
+npm run typecheck
+npm run lint
+npm run format:check
+
+# Focused tests
+npx vitest run tests/coordination-discussion.test.ts
+npx vitest run tests/coordination-session-commands.test.ts
+
+# Full release gate
+npm run verify:full
+
+# Start fresh provider sessions
+loadout coord discuss start "REST or GraphQL for checkout?" \
+  --agents claude-code,codex --rounds 4 --max-turns 9
+
+# Reuse existing provider sessions
+loadout coord discuss start "REST or GraphQL for checkout?" \
+  --sessions claude-code:<session-id> codex:<thread-id> \
+  --rounds 4 --max-turns 9
+
+# Inspect a discussion without spending provider turns
+loadout coord discuss show <thread-id>
+loadout coord discuss list
+```
+
+## Project structure
+
+- `src/core/coordination/discussion.ts`: pure discussion state, prompts,
+  orchestration, result formatting, and bounded public transcript.
+- `src/core/coordination/events.ts`: additive discussion payload schema.
+- `src/commands/coordination-discussions.ts`: CLI registration and provider
+  session composition.
+- `src/commands/coordinate.ts`: registers the discussion command group.
+- `tests/coordination-discussion.test.ts`: protocol and orchestrator behavior.
+- `tests/coordination-session-commands.test.ts`: public argument parsing.
+- `docs/decisions/003-bounded-agent-discussions.md`: architecture rationale.
+- `docs/LIVE_COLLABORATION.md`, `docs/USER_TEST_GUIDE.md`, `README.md`: user
+  workflow and safety language.
+
+## Public contract and code style
+
+Discussion events extend the existing protocol without changing old events:
+
+```ts
+type DiscussionPayload = {
+  threadId: string;
+  kind: "started" | "proposal" | "critique" | "revision" | "summary" | "closed";
+  round: number;
+  role: "system" | "proposer" | "reviewer";
+  content: string;
+  participants?: [string, string];
+  replyTo?: string;
+  alternatives?: string[];
+  unresolved?: string[];
+  outcome?: "decided" | "failed";
+};
+```
+
+Names use current camelCase TypeScript conventions. Inputs and outputs are
+separate interfaces. Boundary schemas are strict and descriptive. Existing
+event error semantics and redaction are reused.
+
+## Testing strategy
+
+- Unit-test schemas, state reconstruction, prompt safety text, reply chains,
+  round limits, turn-budget validation, provider failure, and kill-switch
+  behavior with real coordination storage and fake participants.
+- Integration-test a complete alternating discussion and assert the persisted
+  event order and final decision.
+- CLI-test parsing for `--agents`, `--sessions`, rounds, and mutually exclusive
+  modes without invoking a paid provider.
+- Extend replay/adapter formatting tests so discussion events are legible.
+- Run all coordination suites, then `npm run verify:full`.
+- Manually run one real Claude Code/Codex discussion before publishing 0.9.0.
+
+## Boundaries
+
+### Always
+
+- Validate all CLI and persisted discussion input.
+- Check the kill switch before every provider turn and persisted event.
+- Emit a stable thread ID and reply ID for every public statement.
+- Keep turns sequential so each agent sees the previous public response.
+- Redact and bound shared responses through the canonical event store.
+- Print the exact paid-turn count before starting fresh or resumed sessions.
+
+### Ask first
+
+- Adding a third provider or more than two participants.
+- Allowing discussion prompts to edit files or execute commands.
+- Adding remote/networked coordination or a hosted message broker.
+- Persisting private provider transcripts or hidden reasoning.
+
+### Never
+
+- Start paid turns when validation or budget checks fail.
+- Route a discussion output as an instruction outside its thread.
+- Run an unbounded loop or retry provider turns silently.
+- Continue after the kill switch, missing response, or provider rejection.
+- Claim consensus when the synthesis records unresolved disagreement.
+
+## Success criteria
+
+- `coord discuss start` alternates Claude Code and Codex for exactly the
+  requested number of rounds and runs at most the declared turn budget.
+- Every response is a validated `discussion` event with `threadId`, `kind`,
+  `round`, `role`, and an explicit reply chain.
+- A successful discussion ends in `summary`, `decision`, and `closed` events;
+  a failed discussion ends in a bounded error/closed state without extra turns.
+- `list` and `show` reconstruct bounded discussion state from the JSONL log.
+- Both fresh sessions and explicit existing sessions are supported, but cannot
+  be selected together.
+- The kill switch halts the exchange before the next provider turn.
+- Each provider turn defaults to a 120-second timeout and accepts a validated
+  10-600 second override.
+- Existing coordination consumers continue to parse and operate unchanged.
+- Focused tests, all coordination tests, build, lint, formatting, package smoke,
+  and the complete release gate pass.
+
+## Open questions
+
+- None for the two-agent MVP. Multi-agent voting, remote machines, and automatic
+  implementation are intentionally deferred.

package/docs/superpowers/plans/2026-09-03-coordination-hardening.md

@@ -0,0 +1,231 @@
+# Coordination Hardening Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make Loadout coordination safe under concurrent processes, secure on localhost, correctly packaged over MCP, truthful about provider capabilities, and releasable behind an explicit beta contract.
+
+**Architecture:** Keep the human-readable JSONL audit log, but serialize every state-changing operation through one project-local lock and one canonical validated/redacted write path. Treat the HTTP daemon and stdio MCP server as authenticated/validated adapters over that core. Provider adapters may submit a new turn to a resumable session; they must never claim to inject into an active turn unless the host exposes that capability.
+
+**Tech Stack:** Node.js 20+, TypeScript, Zod, Vitest, `@modelcontextprotocol/sdk` v1, `@openai/codex-sdk`.
+
+## Global Constraints
+
+- Preserve existing `loadout handoff` behavior and `.handoff/messages.jsonl` compatibility.
+- Persist coordination events before notifying watchers or SSE subscribers.
+- Every persisted event has a unique, strictly increasing sequence number across concurrent processes.
+- Bind HTTP only to loopback and require a project-scoped bearer token for every API/SSE request.
+- Never persist raw secrets through any CLI, HTTP, or MCP write path.
+- Keep destructive actions, publishing, deployment, and permission expansion under user control.
+- Mark provider-driven live turns beta until both installed-host integration tests pass.
+
+---
+
+### Task 1: Restore the quality gate
+
+**Files:**
+
+- Modify: `src/core/coordination/adapters/codex.ts`
+- Modify: `src/core/coordination/daemon.ts`
+- Modify: `src/core/coordination/retention.ts`
+- Modify: `tests/coordination-concurrency.test.ts`
+- Modify: `tests/coordination-crash-recovery.test.ts`
+- Modify: `tests/coordination-interrupt-policy.test.ts`
+
+**Interfaces:**
+
+- Produces: a zero-error `npm run lint` baseline without weakening ESLint rules.
+
+- [ ] Remove imports that have no runtime or type use.
+- [ ] Rename or omit unused parameters rather than disabling lint rules.
+- [ ] Run `npm run lint`; expect exit 0.
+- [ ] Run `npm run typecheck`; expect exit 0.
+- [ ] Commit as `chore: restore coordination quality gate`.
+
+### Task 2: Serialize the coordination log and enforce invariants
+
+**Files:**
+
+- Create: `src/core/coordination/lock.ts`
+- Modify: `src/core/coordination/coordinator.ts`
+- Modify: `src/core/coordination/events.ts`
+- Modify: `src/commands/coordinate.ts`
+- Modify: `tests/coordination-concurrency.test.ts`
+- Create: `tests/fixtures/coordination-writer.mjs`
+
+**Interfaces:**
+
+- Produces: `withCoordinationLock<T>(projectRoot, operation): Promise<T>`.
+- Produces: `claimOwnership(projectRoot, input): Promise<CoordinationEvent>`.
+- Produces: atomic `publishContract` revision allocation and validated `ack` watermarks.
+
+- [ ] Add a failing multi-process test that starts independent Node writers and asserts 100 unique sequence numbers equal `0..99`.
+- [ ] Add failing tests for overlapping ownership (`src/api` vs `src/api/user.ts`), future acknowledgements, concurrent contract revisions, stale-lock recovery, and permission errors from an existing unreadable log.
+- [ ] Run `npx vitest run tests/coordination-concurrency.test.ts`; confirm failures describe duplicate sequences and missing validation.
+- [ ] Implement an exclusive lock file using `open(path, "wx", 0o600)`, bounded jittered retries, owner metadata, stale-owner recovery, and `finally` cleanup.
+- [ ] Move append, sequence allocation, contract revision allocation, ownership check/claim, and acknowledgement validation inside the lock.
+- [ ] Normalize project-relative paths and detect equal, parent, and child overlap.
+- [ ] Catch only `ENOENT` as an empty coordination log; propagate other I/O errors.
+- [ ] Cap IDs/agent names at 128 characters, descriptions at 8 KiB, context at 64 KiB, path counts at 256, and paths at 1 KiB.
+- [ ] Run the focused test until green, then run all coordination tests.
+- [ ] Commit as `fix: make coordination state atomic across processes`.
+
+### Task 3: Make redaction canonical
+
+**Files:**
+
+- Modify: `src/core/coordination/redaction.ts`
+- Modify: `src/core/coordination/coordinator.ts`
+- Modify: `src/core/coordination/daemon.ts`
+- Modify: `tests/coordination-redaction.test.ts`
+- Modify: `tests/coordination.test.ts`
+
+**Interfaces:**
+
+- Produces: `sanitizeEmitOptions(options): EmitOptions` used by the sole append path.
+
+- [ ] Add failing tests that emit secrets through direct core calls, CLI-equivalent calls, nested payloads, and daemon calls.
+- [ ] Confirm direct writes currently persist the sample secret.
+- [ ] Apply redaction inside the canonical locked writer before schema validation and persistence.
+- [ ] Remove adapter-specific duplicate redaction.
+- [ ] Verify all paths persist `[REDACTED]` and preserve non-sensitive fields.
+- [ ] Commit as `fix: redact every coordination write path`.
+
+### Task 4: Secure the localhost daemon and stabilize its API
+
+**Files:**
+
+- Create: `src/core/coordination/auth.ts`
+- Create: `src/core/coordination/http-api.ts`
+- Modify: `src/core/coordination/daemon.ts`
+- Modify: `src/commands/coordinate.ts`
+- Modify: `tests/coordination-daemon.test.ts`
+- Create: `tests/coordination-daemon-security.test.ts`
+
+**Interfaces:**
+
+- Produces: `ensureDaemonToken(projectRoot): Promise<string>` with a mode-0600 token file.
+- Produces: one structured error shape `{ error: { code, message } }`.
+- Consumes: atomic coordinator operations from Task 2.
+
+- [ ] Add failing tests for missing/wrong bearer token, malicious `Origin`, forged `Host`, unauthenticated SSE, oversized bodies, malformed JSON, and project-root leakage.
+- [ ] Confirm authenticated loopback requests remain possible.
+- [ ] Generate a 32-byte random token, store it under `.handoff` with mode `0600`, and compare tokens using `timingSafeEqual`.
+- [ ] Require `Authorization: Bearer <token>` for API requests; allow a query token only for the initial dashboard document and immediately move it to session storage/history-free state.
+- [ ] Replace wildcard CORS with same-origin behavior and reject non-loopback Host headers.
+- [ ] Return 400 for malformed JSON, 401 for missing authentication, 403 for origin/host rejection, 409 for ownership/revision conflict, and 413 for oversized bodies.
+- [ ] Stop returning absolute project paths from browser-visible status payloads.
+- [ ] Split the 700-line daemon into HTTP policy/route and lifecycle modules.
+- [ ] Run daemon security, daemon behavior, and full coordination tests.
+- [ ] Commit as `fix: authenticate and isolate the coordination daemon`.
+
+### Task 5: Ship a real MCP server
+
+**Files:**
+
+- Modify: `package.json`
+- Modify: `package-lock.json`
+- Modify: `tsconfig.json`
+- Modify: `src/core/coordination/mcp-server.ts`
+- Create: `tests/coordination-mcp.test.ts`
+- Modify: `scripts/package-smoke.mjs`
+
+**Interfaces:**
+
+- Produces: packaged `dist/src/core/coordination/mcp-server.js`.
+- Produces: stdio tools backed only by validated coordinator operations.
+
+- [ ] Add `@modelcontextprotocol/sdk` v1 as a runtime dependency and remove the TypeScript exclusion.
+- [ ] Add a failing package test asserting that `mcp-server.js` exists in the tarball.
+- [ ] Add an MCP client smoke test that initializes the server, lists tools, emits an event, and reads a snapshot in a temporary project.
+- [ ] Update handlers to use the SDK v1 API and convert validation/conflict failures into MCP tool errors.
+- [ ] Verify stdout contains only protocol messages and diagnostics go to stderr.
+- [ ] Run MCP tests and `npm pack --dry-run --json`.
+- [ ] Commit as `fix: compile and package the coordination MCP server`.
+
+### Task 6: Replace fictional provider commands with supported adapters
+
+**Files:**
+
+- Modify: `package.json`
+- Modify: `package-lock.json`
+- Modify: `src/core/coordination/adapters/types.ts`
+- Modify: `src/core/coordination/adapters/codex.ts`
+- Modify: `src/core/coordination/adapters/claude-code.ts`
+- Modify: `src/core/coordination/session-manager.ts`
+- Create: `tests/coordination-adapter-codex.test.ts`
+- Create: `tests/coordination-adapter-claude.test.ts`
+- Create: `tests/coordination-session-manager.test.ts`
+
+**Interfaces:**
+
+- Produces: capability `canSubmitTurn`, distinct from unsupported mid-turn injection.
+- Produces: Codex `start`, `resume`, and `submitTurn` through `@openai/codex-sdk`.
+- Produces: Claude `start`, `resume`, and `submitTurn` through documented positional CLI prompts.
+
+- [ ] Write adapter contract tests around injected process/SDK drivers so exact command arguments and session IDs are observable.
+- [ ] Assert Codex never uses `--quiet` and Claude never uses `--message` or `sessions list`.
+- [ ] Add `@openai/codex-sdk` as a runtime dependency and implement start/resume/turn using `startThread()`, `resumeThread(id)`, and `run()`.
+- [ ] Implement Claude print-mode turns as `claude -p --output-format json [--resume id] <prompt>` and parse `session_id` from validated output.
+- [ ] Track sessions Loadout itself creates instead of claiming to enumerate every host session.
+- [ ] Queue relevant events until an adapter is idle; do not interrupt active work unless a future host capability explicitly supports steering.
+- [ ] Run adapter and session-manager tests with fake drivers, followed by opt-in smoke checks against the locally installed CLIs.
+- [ ] Commit as `fix: use supported Codex and Claude session APIs`.
+
+### Task 7: Reconcile retention, recovery, and observability
+
+**Files:**
+
+- Modify: `src/core/coordination/retention.ts`
+- Modify: `src/core/coordination/crash-recovery.ts`
+- Modify: `src/core/coordination/replay.ts`
+- Modify: `src/core/coordination/watcher.ts`
+- Modify: `tests/coordination-retention.test.ts`
+- Modify: `tests/coordination-crash-recovery.test.ts`
+- Modify: `tests/coordination-replay.test.ts`
+
+**Interfaces:**
+
+- Consumes: the same lock from Task 2 for compaction and recovery.
+- Produces: explicit health data without filesystem secrets.
+
+- [ ] Add failing tests for append-during-compaction, truncated final lines, duplicate legacy sequences, reconnect after compaction, and backup restoration.
+- [ ] Make compaction and recovery use the same exclusive lock as append.
+- [ ] Preserve corrupt-line evidence rather than silently discarding it.
+- [ ] Bound replay and snapshot queries by event count and serialized byte size.
+- [ ] Add counters for connected clients, high watermark, corrupt records, rejected writes, and last compaction time.
+- [ ] Run focused recovery/retention/replay tests.
+- [ ] Commit as `fix: harden coordination recovery and retention`.
+
+### Task 8: Make the product contract truthful and test the release artifact
+
+**Files:**
+
+- Create: `docs/decisions/001-coordination-jsonl-locking.md`
+- Create: `docs/decisions/002-local-daemon-authentication.md`
+- Modify: `README.md`
+- Modify: `MASTERPLAN.md`
+- Modify: `docs/LIVE_COLLABORATION.md`
+- Modify: `docs/USER_TEST_GUIDE.md`
+- Modify: `CHANGELOG.md`
+- Modify: `scripts/readme-product-flow.mjs`
+- Modify: `scripts/cli-product-flow.mjs`
+
+**Interfaces:**
+
+- Produces: one user-facing distinction between durable handoff, live coordination, and provider-driven beta turns.
+
+- [ ] Document the locking and authentication decisions, rejected alternatives, limitations, and recovery behavior.
+- [ ] Remove contradictory phase/status claims and document exact supported commands.
+- [ ] Add a two-agent walkthrough: backend contract publish, frontend acknowledgement, revision diff, ownership conflict, reconnect, and kill switch.
+- [ ] Add CLI/product-flow coverage for the walkthrough without invoking paid model turns.
+- [ ] Run `npm run verify:full` from the clean branch.
+- [ ] Run `npm pack --dry-run --json`, install the tarball in a temporary directory, and execute `loadout --version`, `loadout coordinate --help`, daemon authentication, and MCP initialization.
+- [ ] Run opt-in real-host smoke tests with installed Codex and Claude CLIs; do not make destructive project changes.
+- [ ] Review `git diff` for secrets and unrelated changes.
+- [ ] Commit as `docs: define the live coordination beta contract`.
+
+## Self-review
+
+- Spec coverage: concurrency, authentication, MCP packaging, real provider APIs, validation, redaction, ownership overlap, acknowledgements, retention, recovery, documentation, clean-room packaging, and launch gates are each assigned to a task.
+- Placeholder scan: no deferred implementation placeholders are used; provider mid-turn interruption is explicitly excluded until supported by a host API.
+- Type consistency: all external adapters converge on `canSubmitTurn` and canonical coordinator operations; HTTP and MCP do not own state logic.