A task record is now created only when the tool call has produced its
outcome, and the store is a pluggable async protocol:

- An input_required interim passes through un-augmented; only the leg
  that completes the call becomes a task, so a multi round-trip exchange
  yields exactly one task. An error (a raised MCPError, or ErrorData
  returned by a nested interceptor) propagates as the JSON-RPC error the
  client is waiting on instead of stranding a half-created task.
- tasks/cancel acknowledges without rewriting terminal status: the tool
  has always finished by the time a tasks/* request can arrive, and
  SEP-2663's cooperative cancellation permits an ack without effect.
- The missing-capability error uses mcp_types' -32021 constant via
  require_client_extension, replacing the stale -32003 numeral SEP-2663's
  prose still carries from before the error-code renumber.
- tasks/update is served as the SEP-required acknowledgement; unknown
  inputResponses keys are ignored, absent inputResponses is rejected.
- tasks/* bindings are version-scoped to the modern wire, so legacy
  clients get METHOD_NOT_FOUND instead of a capability error they could
  never satisfy on that wire.
- The default clock is a real UTC wallclock; clocks return datetimes and
  wire formatting lives in one place.
- TaskStore is an async protocol (Tasks(store=...)) with an in-memory
  default that enforces ttlMs (expired records drop on access and are
  swept on insert); stored results are copied at both boundaries; ttlMs
  stays on the wire when null (required-but-nullable in the extension
  schema); non-positive default_ttl_ms is rejected at construction.

The stdio leg now asserts graceful degradation (a legacy connection gets
a plain CallToolResult, never a task) instead of returning silently; the
stories index lists tasks as a current feature story; the migration note
reflects the -32021 capability error, the tasks/update acknowledgement,
and the pluggable store, and drops the taskSupport item (SEP-2663
defines no per-tool execution flag).

…sk lifecycle

- The wire models (Task, CreateTaskResult, request params, typed request
  wrappers, and a lenient GetTaskResult parser) move to mcp.shared.tasks
  so client code can import them without reaching into the server tier;
  mcp.server.tasks re-exports the public names.
- Tasks(augment=...) scopes augmentation per request (SEP-2663: the
  server decides at its own discretion); None keeps augment-everything.
- A JSON-RPC error under augmentation now records a task born "failed"
  (error inlined on tasks/get with no result key, statusMessage carrying
  the diagnostic) and returns CreateTaskResult(status="failed"). Errors
  on every non-augmented path propagate unchanged.
- require_client_extension moves to mcp.server.extension so the extension
  tier no longer reaches into the composition tier; mcp.server.mcpserver
  keeps re-exporting it.

…ders)

SEP-2663 mandates Mcp-Name: <taskId> on tasks/get, tasks/update, and
tasks/cancel Streamable HTTP POSTs. Adding the three methods to
NAME_BEARING_METHODS covers both ends at once: the client's modern
header stamp emits the header automatically and the server's validation
ladder rejects a mismatched or absent value. On a server without the
tasks extension a header-bearing tasks/* request still reaches -32601
method dispatch, while a headerless one fails the header rung first,
consistent with the SEP-2243 header rules; a test pins the ordering.

TasksExtension contributes a ResultClaim for resultType 'task': a
declaring Client admits CreateTaskResult on tools/call and resolves it
by polling tasks/get (honoring pollIntervalMs with a 1s fallback and
the caller's per-request read timeout) until terminal, returning the
inlined CallToolResult; failed, cancelled, and input_required tasks
surface as typed TaskFailedError, TaskCancelledError, and
TaskInputRequiredError. Manual driving stays available via
session.call_tool(..., allow_claimed=True) and the mcp.shared.tasks
wrappers. The tasks story's modern path is the plain typed call_tool,
with a compact manual leg over the shared wrappers.

The everything-server now opts into Tasks with an allowlist augment
predicate, so every pre-existing tool stays synchronous while the new
task fixture tools (slow_compute, failing_job, protocol_error_job,
confirm_delete, multi_input, test_tool_with_task) exercise augmentation,
failed-task recording, the required-capability error, and the
MRTR-then-task composition. Eight of the nine baselined tasks-* expected
failures now pass and are removed; tasks-mrtr-input stays baselined with
an accurate rationale (tasks are born terminal -- the in-task
input_required/tasks/update resume loop is a documented follow-up).
Verified locally against the pinned harness: all four server legs green
with zero unexpected failures and zero stale baselines.

Adds docs/advanced/tasks.md (sibling of the MCP Apps page) covering the
server opt-in with the augment/default_ttl_ms/clock knobs, the pluggable
TaskStore protocol and its per-process caveat, the inline execution
model (tasks born terminal; acks without effect), transparent client
polling with the typed task errors, manual driving over the
mcp.shared.tasks wrappers, and the per-wire error-code table. Three
compiled docs_src tutorials back the page, each behaviorally tested; the
page is registered in the mkdocs nav (which also feeds llms.txt). The
migration note and module docstring no longer list routing headers as
deferred -- Mcp-Name stamping and validation landed with the shared
header table.

Mcp-Name stamping and validation for tasks/* landed with the shared
header table; the module docstring's deferred list now matches the
migration note and docs page.

- The polling driver floors a server-supplied negative pollIntervalMs
  to zero instead of crashing (trio) or busy-looping (asyncio); tested.
- Client.call_tool documents TaskInputRequiredError alongside the other
  task errors, and the docs and story prose catch up: routing headers
  are no longer listed as deferred, failed tasks are named alongside
  completed ones in the store wording, and the migration guide's old
  removal note now points at the landed extension.
- The tasks story imports EXTENSION_ID from mcp.shared.tasks.

- Client.call_tool's per-call read_timeout_seconds now bounds each
  tasks/get poll as well as the initial call (per-request bound, not a
  whole-loop deadline); pinned by a recording test.
- The everything-server's confirm_delete keeps the file when an accepted
  elicitation answers confirm: false (conformance legs re-verified).
- The routing-header parentheticals attribute the requirement to
  SEP-2663 and the header family to SEP-2243.

The private driver module becomes the public mcp.client.tasks: get_task,
wait_task, update_task, and cancel_task are typed free functions over
ClientSession, so manually driving a task no longer means hand-building
wire requests. wait_task accepts a bare task id (the persist-and-resume
shape -- task ids are bearer capabilities that survive reconnects) or
the CreateTaskResult, which additionally seeds the poll-interval
fallback; the polling loop now exists once, shared with the
TasksExtension claim resolver. update_task and cancel_task hide the
empty acknowledgement and return None. The task errors gain a common
TaskError base (one except arm for any non-completion) and pickle
support, since they are public API. The manual-driving docs, story leg,
and tutorial are rewritten onto the functions.

…ucture

The restructured migration guide dropped the server extensions section this
branch used to edit, so the feature prose now lives in the extensions and
tasks pages. The migration guide's experimental Tasks section and the
whats-new removal list now say the extension ships as the built-in Tasks
extension instead of claiming it is unimplemented. The extensions page also
points at TasksExtension as the shipped behavioural example next to
advertise().

When a client abandons an augmented tools/call while the tool body is still
running, the cancellation propagates through the Tasks interceptor uncaught,
so no task record is written to the store. Pin that, and that the same
connection's later augmented calls still complete normally.

…berate

Reuse the shared _tasks_server fixture instead of hand-building an identical
server, and adopt the suite's task-group idiom for abandoning the in-flight
call. Record in the interceptor comment that catching only MCPError is
deliberate: cancellation must propagate so an abandoned call leaves no task
record.

…26-07-28 line

The 15-commit branch rebased onto latest main with four textual conflicts
(extension.py + mcpserver/server.py, the everything-server, client/__init__.py,
whats-new.md), all resolved to main's structure plus the branch's additions.
This commit carries the semantic adaptations that the merge could not surface:

- Gate task augmentation on the declared-capabilities fact, not clientInfo.
  Main made clientInfo optional on the 2026-07-28 wire (spec #3002) and split
  `session.client_capabilities` from `session.client_params`, so a conformant
  client can declare the extension while `client_params` is None. The
  interceptor's `_client_declared_tasks` now reads `client_capabilities`,
  matching main's rewritten `require_client_extension` (whose main body the
  relocated function carries). A pair-only declaring envelope is augmented.

- Interceptors now run at the handler layer (`compose_tool_call_handler`), so
  `call_next` returns the wrapped handler's domain result rather than a
  serialized dict, and every modern-era result envelope carries the
  `serverInfo` `_meta` identity stamp. The stored/inlined tool result stays
  the un-enveloped payload. Reword `_wire_payload` and the error-fold comment
  accordingly, and have the tests assert-and-strip the envelope stamp through
  strict helpers mirroring tests/_stamp.py instead of hard-coding it into
  every snapshot. A short-circuited `input_required` interim is now sieved to
  the core shape like any handler result, so its fixture is core-shaped.

- Declare `name_param = "taskId"` on GetTaskRequest/CancelTaskRequest/
  UpdateTaskRequest: main added `Request.name_param` as the per-request key a
  client mirrors into the `Mcp-Name` header, built expressly for the tasks
  verbs (its placeholder test models `tasks/get`). The server-side
  NAME_BEARING_METHODS rows remain the source of the spec-mandated validation.

- Follow main's spelling and toolchain moves: httpx -> httpx2 in the tasks
  server tests, `mcp.types` (not `mcp_types`) in docs/example imports with the
  matching `hl_lines` shift, and the GitHub form for SEP-2663 links.

- Refresh prose that the merge left stale: the migration guide's "Detached
  work" note now points at the extension for the fetch-later half, and the
  tasks story's docstring states the fixed-contract invariant rather than
  claiming identity with a task-less server's stamped result.