Maintain one durable shared task and its role-bound checklist.

To create, send action="create", expected_revision=0, a unique operation_id, and plan; omit work_id. The plan must have one final integration step that depends directly or transitively on every other step, including investigations. For later mutations, get the card first and use its current revision as expected_revision. Use a new operation_id for a new or corrected request; reuse an ID only for an exact retry. list/get/history need no operation_id. Plan agreement, worker submission and independent acceptance are separate. Progress defaults to a bounded summary. Follow returned section/cursor pointers for omitted material; choose plan/step/full only when needed. Waiting observes committed changes, not permission to start an agent. Give after_revision the revision you last read: a card already past it returns at once instead of waiting for the next change. It is an observation baseline, never expected_revision, a claim, or permission to replay work. Autonomous grants and uncertain-attempt reconciliation are operator CLI actions.

Inspect the immutable project boundary and available computation profile defaults.

Separate launch folders have separate data even with one user-wide MCP registration. Additional client-granted directories permit working there, not reading their MCP history. This is data isolation, not an OS filesystem sandbox. execution_profiles describes defaults, not effective/actual settings after overrides; deep means more time, not higher thinking.

Page omitted product data from this task's immutable pinned snapshot.

Follow capsule pointers rather than repeatedly loading the whole product. This does not select another context, read files, or grant execution rights. Independent review uses its pinned review reader instead.

Explicitly ask Jev about gaps in a completed task's reported evidence.

preview=true shows the exact bounded export without a key, network call or reservation. Sending requires operator opt-in and an OpenRouter key. expected_input_sha256 refuses changed input before sending. The request includes selected criteria, goal, report prose and check descriptions. No source files, commands, task context, artifact bodies or history are read for export; report prose itself may still contain sensitive information. Advice is not verification, acceptance, a finding or permission to act. Ordinary results and waiting never call Jev. Exact repeated pages reuse the saved attempt, including failures; changed/overlapping pages may incur cost. No automatic retry after a timeout, cancellation or unresolved attempt.

Start a task with exactly one of prompt or structured contract. Returns immediately.

Base constraints/owned files stay fixed; each follow-up has a new goal and criteria. project_context_id pins product rules/decisions. Only the coordinator sets question timeout. Think: collaboration; analyze: read/search; work: edits/shell, NOT sandboxed. Use preflight=true to inspect admission without launching a worker. Structured requirements declare exact entry/boundary paths and shell/write needs; verification declares the agreed check ladder, never permission to execute it.

Start a NEW current goal after completion; supply exactly one of prompt or turn contract.

History/base policy/mode/cwd persist, but old goals/acceptance do not. The product snapshot stays pinned unless explicitly changed to another revision of the same project. Question timeout is inherited unless explicitly set here. For waiting_input use tandem_reply. continuation=fresh requires an explicit handoff and starts a new context without replaying native history or transferring claims/grants. The source remains intact. Use preflight=true to inspect the same admission without a model or worker.

Get the actual answer, work outcome and next_action. Questions return immediately.

wait_seconds: 0..1200, served in full by the server. A client may stop holding the call in the foreground first, and what it does then differs by client: if it answers that it moved the request to a background task, read that result instead of retrying; one measured Claude Code run handed off at 120 seconds and delivered every result. wait_mode="auto" also returns as soon as event delivery covers this task; "bounded" waits for the task itself, which costs one call instead of many when the client cannot use the waiting time. Either way the wait is finite and cancellable, and expiry is reported in wait, never as a task state. completed is turn completion, not proof of success. answer holds the requested text; summary only describes the work. When answer_truncated, read answer_artifact_id. details=true includes the full answer/report/contract/diagnostics.

Answer exactly the pending clarification, resuming the same worker. Expired/stale IDs fail.

Duplicate identical answers are idempotent; different second answers are rejected.

Stop a task, including while it waits for clarification. Does not undo edits.

List recent task/conversation IDs, statuses, outcomes and next actions without large bodies.

Publish immutable shared context; each same-name publication creates a new version.

Return artifact_id to the partner in a follow-up or contract.artifact_ids. Content max 4MiB UTF8. Logical names are not filesystem paths; no file is read or modified by this tool.

Read an immutable artifact version shared by the coordinator and OMP; page using next_offset.

Offsets count Unicode characters; limit 1..50000. IDs never resolve arbitrary local files.

Wait for ANY selected task to finish or ask a question, not for each in turn.

wait_seconds: 0..1200, served in full by the server; a client may stop holding the call in the foreground first; if it says it moved the request to a background task, read that result. wait_mode works as in tandem_result: "auto" also returns once event delivery covers every pending task, "bounded" waits for one of them to become ready. Returns ready IDs/questions, not full answers. Read ready terminal results with tandem_result and remove them from later wait sets; reply directly to a returned question. Does not acknowledge terminal events or rerun work. Await events only with a live independent watchdog.

Coordinator-only product knowledge: source-backed rules, examples and settled decisions.

publish creates an immutable snapshot; updating a project requires its current expected_revision. get uses an exact context_id; list optionally filters project_id. Pass context_id to tandem_start/continue explicitly. Publishing never changes active tasks. Workers may propose changes in their answer but do not get this publishing tool. Do not approve invented rules.

Explicitly offer this project's selected rules and referenced evidence to one recipient.

Use only when the user intends cross-project sharing. No tasks/history are shared. The returned transfer_id is a private capability, not a public link. The recipient must separately call tandem_import_context in its own coordinator session. This grants no permissions.

Explicitly accept a product snapshot offered to this launch project.

Only recipient-bound exports can be imported; no foreign database is browsed. Creates fresh local context/evidence IDs, preserving source provenance, not granting approval. Existing product revisions require expected_revision. Retrying one transfer is idempotent.

Manage optional Claude Code Channels push delivery; ordinary polling always remains available.

probe sends a receipt challenge only through the channel; ack with its probe_token confirms delivery. watchdog_token acknowledges an actual independent hook wake, never a tool-response assertion. ack with event_id acknowledges a webhook. pending lists unacknowledged events (include_previous explicitly includes earlier sessions). recover replays one event_id or a completed task_id; never changes task outcomes or reruns work. Token-file contents are secret.

Capture or read an immutable review bundle, or compare it with current selected files.

request.source selects base-to-worktree (default) or base-to-staged Git index material. Staged captures exclude unstaged/untracked content; source also governs applicability checks. Capture includes requirements, supplied checks and boundaries without executing tests. Bind review_id to a think task for snapshot-only review. Author rationale is withheld unless explicitly revealed in a comparison turn. Read pages by next_offset, not the live working directory. assess reports applicability at observation time, not whole-system correctness. prepare classifies the same request without saving anything: it reports every repairable selection conflict at once and proposes the corrected paths, which the caller decides whether to apply. It reserves nothing, so capture classifies the files again and a repaired request is a new request, not a retry.

Run one read-only review scenario without manually coordinating its native turns.

start: supply ReviewRequest and a stable request_key for this logical request. Reusing the key returns the same run; a different payload conflicts. Code captures the snapshot, runs independent think review, then at most one comparison if author material was supplied and the independent report succeeded. Total budget defaults to 600 seconds, including startup, both stages and questions. It never edits files or runs supplied test commands. status/reply/cancel: use the returned run_id, never start again to wait. Replies require the current question_id. Full stage answers, findings, applicability and peer-only usage are assembled by code. Claims are not automatically accepted or applied. Missing context needs an explicit new capture (context_paths), not hidden live reads.

Track version-bound review findings without rewriting their history.

Validity and resolution are separate. A claimed fix is not verified; verify_fixed needs evidence and a completed verification task for its snapshot. Update requires the current expected_revision. Get by stable finding_id or conversation_id plus human number. pin fixes the membership of a correction set for review_id once, so closure can be answered later; a live list cannot, because closing a finding removes it from the list. project reads what became of every pinned member of set_id, optionally against a target review. It records dispositions and decides nothing: a claimed fix is still unverified, and an accounted-for member is not a fix that holds.

Diagnose this client session's project, OMP execution, actual model and delivery.

live=true starts one short provider request and may incur a charge: use only for a user-requested live check. Default checks local state without contacting a provider. If still running, inspect the returned task_id instead of starting another check. A separate CLI process cannot certify this session's push receipt.

Gate result processing separately from reading/acknowledging notification events.

Claim before applying a terminal result; only an authorized fresh claim may proceed. Complete with its token after handling. Duplicate reads do not authorize repeated effects. A stranded claim is uncertain, never automatically released: reconcile external state. Claims grant no filesystem/external permissions. External effects still need their own idempotency/transaction boundary.