FetchSandbox

Working · 1.4 s

io.github.fetchsandbox/mcpv0.7.30

A deterministic verification engine for agents. Proves a fix: fails on the old code, passes on new.

Developer Tools

Source Website Registry entry

Maintain this server? Claim it

Try it

Call this server's tools from your browser. Nothing to install.

https://fetchsandbox.com/mcp/v1

Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.

Tool list from our last check. Connect live to refresh it.

coach Read-only

Conversational integration coach for FetchSandbox. Server-side orchestrator that walks the user through adding an API integration (payments / email / auth / etc.) — intake the goal, elicit domain-aware discovery questions from the spec's brain.yaml, route to the right workflow, prove the contract via FetchSandbox, surface compliance notes. Call this BEFORE any other FetchSandbox tool when the user has an open-ended 'help me add X', 'integrate X', 'test my X integration' ask. BEHAVIOR — strict, do exactly this each turn: If next_action=act_in_app, carry out next_actions with your platform's code, configuration and test tools, then return the results to the same validation session. Do not ask the human to choose routine fault tests, supply missing fixture data you can generate, or copy tool output. Ask only for genuine access, secret-entry constraints or ambiguous business rules. Never claim unsupported checks passed. (1) Say `message_for_user` to the user (verbatim or lightly paraphrased to fit your voice — but don't add new content). (2) If `next_action=wait_for_user` AND `options` is present + non-empty: USE YOUR CLIENT'S NATIVE QUESTION-PICKER TOOL (in Cursor / Claude Code this is `AskUserQuestion`) to render the lettered picker with the `question` text, the `options[].label` as rows, `default_option` as default, and an 'Other...' freeform row when `allow_freeform=true`. When the user picks or types, call coach again with `{session_id, user_response: <picked value or freeform text>}`. (3) If `next_action=wait_for_user` AND no `options`: just wait for free text. (4) If `next_action=call_tool`: invoke `tool_call.tool` with `tool_call.args`, then call coach again with the result in `context`. (5) If `next_action=done`: end the session. For a hosted app-builder request to build or test an integration, keep the user's simple goal intact and let the server route all named providers into one validation session. When FetchSandbox returns twin bindings, treat those as temporary TEST credentials: configure them server-side in the app-builder project, never ask the user for live Paddle/Resend keys, and never claim they were applied until the builder reports the change and the verifier observes app traffic. Infer app configuration details from the project when available; ask the user only for a fact the builder cannot discover. The deterministic verifier, not this conversation, owns the verdict. The state machine is server-side — DON'T try to predict the next step or skip ahead; let the server drive.

intentstring

User's free-form integration ask, on the FIRST call only. Pass through verbatim — the server's intent router benefits from the full phrasing.

contextobject

Optional context the LLM brings to the turn — e.g. a summary of the user's repo (if you ran an introspect step), or the result of a previously-instructed `tool_call`.

session_idstring

Returned by a previous coach call. Required on every call after the first.

user_responsestring

The user's reply to the previous coach turn's question. Required when the previous turn returned `next_action: wait_for_user`.

Try it

Call this server's tools from your browser. Nothing to install.

https://fetchsandbox.com/mcp/v1

Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.

Tool list from our last check. Connect live to refresh it.

coach Read-only

intentstring

User's free-form integration ask, on the FIRST call only. Pass through verbatim — the server's intent router benefits from the full phrasing.

contextobject

Optional context the LLM brings to the turn — e.g. a summary of the user's repo (if you ran an introspect step), or the result of a previously-instructed `tool_call`.

session_idstring

Returned by a previous coach call. Required on every call after the first.

user_responsestring

The user's reply to the previous coach turn's question. Required when the previous turn returned `next_action: wait_for_user`.

Tools (8)

coach

read-only

Argument	Type	Description
intent	string	User's free-form integration ask, on the FIRST call only. Pass through verbatim — the server's intent router benefits from the full phrasing.
context	object	Optional context the LLM brings to the turn — e.g. a summary of the user's repo (if you ran an introspect step), or the result of a previously-instructed `tool_call`.
session_id	string	Returned by a previous coach call. Required on every call after the first.
user_response	string	The user's reply to the previous coach turn's question. Required when the previous turn returned `next_action: wait_for_user`.

Input schema (JSON)

{
  "type": "object",
  "properties": {
    "intent": {
      "type": "string",
      "description": "User's free-form integration ask, on the FIRST call only. Pass through verbatim — the server's intent router benefits from the full phrasing."
    },
    "context": {
      "type": "object",
      "description": "Optional context the LLM brings to the turn — e.g. a summary of the user's repo (if you ran an introspect step), or the result of a previously-instructed `tool_call`."
    },
    "session_id": {
      "type": "string",
      "description": "Returned by a previous coach call. Required on every call after the first."
    },
    "user_response": {
      "type": "string",
      "description": "The user's reply to the previous coach turn's question. Required when the previous turn returned `next_action: wait_for_user`."
    }
  }
}

get_job

Retrieve the SAME running find_bugs, fix_bug, prove_fix, verify_behavior or validate_integration job (including requirements planning). Follow next_tool_call until status is done or error. Never restart the original tool to poll. A proposed plan is not execution proof; a running response is not proof. Only the completed measured verdict and receipt can establish a pass.

read-only

Argument	Type	Description
job_id*	string	Exact job_id returned by the original call.

Input schema (JSON)

{
  "type": "object",
  "required": [
    "job_id"
  ],
  "properties": {
    "job_id": {
      "type": "string",
      "description": "Exact job_id returned by the original call."
    }
  },
  "additionalProperties": false
}

guide

ROUTE a symptom to the provider behaviour that explains it. Use this when the user names a provider or a domain (payments, email, auth, SMS, subscriptions) and you need to know what that provider ACTUALLY does — not what its docs say, and not what can be inferred from reading the integration code. Reading the code tells you what your app does with a field. It cannot tell you what the field MEANS at the provider — whether a line item is a seat count, whether a 200 body carries ok:false, whether an event can arrive out of order. That is the class of bug this routes. Returns {spec, workflow, scenario, confidence, reasoning} plus `next_actions`: a typed list of what to call next, with arguments pre-filled. Follow it rather than improvising the next step.

read-only

Argument	Type	Description
hints	object	Optional caller-supplied overrides. Each field short-circuits the corresponding detection step.
intent*	string	The developer's free-form prompt as they typed it. Don't pre-process or shorten — the router benefits from the full phrasing (capture timing, geo cues, failure mode language).

Input schema (JSON)

{
  "type": "object",
  "required": [
    "intent"
  ],
  "properties": {
    "hints": {
      "type": "object",
      "properties": {
        "spec": {
          "type": "string",
          "description": "Force a specific spec slug."
        },
        "scenario": {
          "type": "string",
          "description": "Force a specific failure scenario name."
        },
        "workflow": {
          "type": "string",
          "description": "Force a specific workflow_id."
        }
      },
      "description": "Optional caller-supplied overrides. Each field short-circuits the corresponding detection step."
    },
    "intent": {
      "type": "string",
      "description": "The developer's free-form prompt as they typed it. Don't pre-process or shorten — the router benefits from the full phrasing (capture timing, geo cues, failure mode language)."
    }
  }
}

list_workflows

List the named, runnable workflows for a known provider slug or imported spec. Workflows are realistic multi-step API journeys (e.g. 'create customer → attach payment method → create subscription'). Known provider slugs need no import. Use this for exploration ("what can I do?", "show me the flows") OR before run_all_workflows when the user wants a SCOPED validation: list, filter by user intent ("checkout", "webhooks"), then pass the matching ids as `workflow_names` to run_all_workflows. Default results are summaries. Pass workflow_name with an exact returned id or name to inspect that workflow's full definition, including request bodies, assertions, outcomes and invariants; this does not execute it. Returns the workflows AND the failure scenarios this spec can simulate — each with a plain description and the exact call to run it. When cross_service_available is present, use each exact run_with invocation: cross-provider workflows use the returned namespace, not this provider's slug. These curated workflows exercise provider behavior; they do not verify the user's app. Choose relevant scenarios from the inspected workflow and user goal; ask only about ambiguous business requirements. Do not guess scenario names.

read-only

Argument	Type	Description
spec_id	string	The spec_id returned by import_spec.
spec_slug	string	A human name like 'resend' or 'stripe'. Use this when you do not have a spec_id — you do not need to look one up first.
workflow_name	string	Exact workflow id or name returned by this catalog. Returns its full definition, including steps and outcome rules, without executing it; omit for summaries.

Input schema (JSON)

quickrun

Run a curated reference workflow against a KNOWN, bundled spec (stripe, clerk, descope, resend, twilio, and 50+ others) in ONE call — it spins up the sandbox by slug, so you do NOT need import_spec or a sandbox_id first. Use this when exploring the bundled provider contract: call `guide` on their prompt, then call `quickrun` with the returned spec + workflow. To reproduce a failure, pass the `scenario` from guide's matched_bug_pattern.reproduce_with.scenario (e.g. webhook_retries, payment_declined). Returns sandbox_id + flow_run_id — pass BOTH to verify_behavior to inspect the reference behavior — plus a receipt URL. This does not execute or prove the caller's application. For a bug in their project, use find_bugs, fix_bug and prove_fix on that project; do not substitute this reference receipt for an own-code proof. Use run_workflow instead ONLY when you already hold a sandbox_id from import_spec of a custom/private spec.

Argument	Type	Description
scenario	string	OPTIONAL failure scenario to reproduce (e.g. webhook_retries, payment_declined). Take it from guide's matched_bug_pattern.reproduce_with.scenario. Omit for the happy path.
spec_slug*	string	The bundled spec slug from guide (e.g. 'stripe'). Lowercase.
workflow_name*	string	The workflow id from guide (e.g. 'accept_payment').

Input schema (JSON)

{
  "type": "object",
  "required": [
    "spec_slug",
    "workflow_name"
  ],
  "properties": {
    "scenario": {
      "type": "string",
      "description": "OPTIONAL failure scenario to reproduce (e.g. webhook_retries, payment_declined). Take it from guide's matched_bug_pattern.reproduce_with.scenario. Omit for the happy path."
    },
    "spec_slug": {
      "type": "string",
      "description": "The bundled spec slug from guide (e.g. 'stripe'). Lowercase."
    },
    "workflow_name": {
      "type": "string",
      "description": "The workflow id from guide (e.g. 'accept_payment')."
    }
  },
  "additionalProperties": false
}

run_workflow

Execute ONE specific workflow by name and return its step-by-step trace PLUS a `share_url` — a public, replayable proof URL that renders the full timeline (every request, response, webhook event) for this run. The share_url is the canonical 'here's what happened' artifact: surface it verbatim in any reply that needs evidence (PR comments, Slack threads, blog posts, X replies). Do NOT substitute a docs URL or any other link as the proof — the share_url is the only valid receipt. Use ONLY when the user explicitly names a single workflow to run (e.g., "run accept_payment", "just check the refund workflow"). For ANY validation-style request — "validate stripe", "check coverage", "run all workflows", "test this integration", or even "validate stripe checkout" (multiple workflows match "checkout") — use `run_all_workflows` instead. The batch tool collapses N approvals to 1 and supports a workflow_names filter for scope. Calling this in a loop is an anti-pattern.

Argument	Type	Description
scenario	string	OPTIONAL failure scenario to exercise (e.g. payment_declined, insufficient_funds, fraud_hold). Toggles the sandbox engine's scenario for the duration of the run, then restores. Use this for 'test with declined card' / 'simulate failure X' intents. Omit for the happy path.
sandbox_id*	string	The sandbox_id returned by import_spec.
workflow_name*	string	Workflow id or name from list_workflows. Case-insensitive; dashes and underscores are interchangeable.

Input schema (JSON)

{
  "type": "object",
  "required": [
    "sandbox_id",
    "workflow_name"
  ],
  "properties": {
    "scenario": {
      "type": "string",
      "description": "OPTIONAL failure scenario to exercise (e.g. payment_declined, insufficient_funds, fraud_hold). Toggles the sandbox engine's scenario for the duration of the run, then restores. Use this for 'test with declined card' / 'simulate failure X' intents. Omit for the happy path."
    },
    "sandbox_id": {
      "type": "string",
      "description": "The sandbox_id returned by import_spec."
    },
    "workflow_name": {
      "type": "string",
      "description": "Workflow id or name from list_workflows. Case-insensitive; dashes and underscores are interchangeable."
    }
  },
  "additionalProperties": false
}

validate_integration

Completion rule: a request to verify an app includes its applicable failure checks without another user prompt. When verification_continuation.required is true, continue in this agent: inspect pending_checks, preserve every declared check and its assertions, implement supported actions, and rerun a fresh attempt. Stop only with measured results or concrete blockers showing the missing capability and attempted evidence. Not run, not armed, and no observer yet are work to finish, not unsupported features. Do not clean up the session or present a final proof while actionable checks remain. Ask the owner only for genuinely missing business decisions, credentials or actions you cannot perform. For a local app, start the actual app and call manage_tunnel with its port; use the returned app_base_url. No ngrok install is needed. The managed relay origin deliberately rejects direct browser/curl requests with 404; after configuration and credential installation, test connectivity with validate_integration preflight instead. Do not interpret that private-origin 404 as an app failure or expose relay credentials. Hosted builders use their published origin. Start with providers (and optional app_base_url), then reuse the returned session_id for application_context, fixtures and attempts. Do not include application_context in the initial session call. Inspect how the actual app or workflow executes before choosing a verification path. If the builder can run that workflow locally, bind its real provider clients to every returned twin URL and the supplied test authentication. Use the returned provider operation contracts to implement those clients; a missing canned workflow does not mean the provider lacks an API operation. The existing arm/probe path does not require a published app or webhook: select a probe from the returned matrix, call arm with session_id, send its request_headers on EVERY provider request across the session, execute the actual workflow entry point, then call probe with the same session_id and returned run_id. Independently assert saved app state in the host and report that evidence separately. Provider traffic alone remains app_verified:false; it does not establish application execution or state. Do not substitute a standalone simulation, direct twin calls or a curated workflow for the user's implementation. A public origin is required when FetchSandbox must drive or observe an HTTP application suite; the hosted setup instructions below apply to that path. For hosted application_workflow_v1 apps, build and publish the disabled test adapter before requesting short-lived credentials. After installing the existing handoff and republishing, call preflight:true with session_id/run_id. A setup_blocked response is not a failed application test. Its next_tool_call is null: repair its exact host-side blocker first, then call resume_tool_call for the SAME run/preflight without rotating credentials. Do not poll an unchanged setup blocker. Execution has a separate deadline. Execution is already non-blocking: execute:true starts the existing backend job and returns running promptly. Use the SAME builder agent to follow status; no extra background helper or helper approval is needed. Never execute twice; retrieve status with session_id/run_id only. If the browser stops at a security challenge, immediately hand the owner the SAME run/order-verified original TEST checkout URL (livemode=false) while observation continues; never bypass the challenge, silently wait, create a replacement checkout or retry Pay. For an owner-assisted browser step, use ONE native question containing that verified URL, pause the builder for its answer while the backend job continues, and record that answer once. Do not keep working while asking for a plain chat reply that the host queues, or ask again after confirmation is recorded. Browser payments require an available browser or one explicit user action, and independently observed paid state; a click is not proof. After proof, remove only temporary settings, republish and verify disabled externally. When asked to reassess or recontract, set reassess=true and supply application_config.scope_review for every candidate check. Record outside-scope features separately, and keep relevant missing or failed behavior required. Scope is declared by the app-owning agent from its inspected code and requirements, not guessed from a provider name. For every app, inspect capabilities, coverage_policy and application_actions. Review every supplied coverage dimension against inspected app behavior without waiting for the user to enumerate failure tests. Supply application_config.coverage_review with relevance, reason and linked check IDs when the builder authors the plan. Missing dimensions stay unreviewed. A dimension review is not execution proof; never claim all possible invariants are known. Prepare missing test products, prices and related records before failures: author fixtures using documented provider operations, include a final GET with an exact identity assertion, then configure the app with returned fixture IDs. The server uses the existing twin workflow runner and independently checks read-back. Fixture readiness is not app proof. Unsupported application checks must be reported explicitly, not replaced by a separate script or quickrun. Use the returned fixture_authoring contract, not a web search for assertion syntax. Prepare fixtures before configuring any attempt. Fixture assertions are GET-only and contain select, equals (string), required:true, count:1. Use separate asserted GET steps for each additional value; do not use application all_of or where predicates in fixture assertions. Paddle selectors include the response envelope, e.g. data.id; Stripe uses id. Read the provided Paddle one-time-price example and adapt its product and amount to the app. If fixed receipt-suite transactions cannot match the app's product, price and pending order, do not execute them as app proof or a pointless rejection diagnostic. Report that compatibility gap, cancel any unexecuted mismatched attempt, then use application_workflow_v1 for supported checks while preserving untested receipt rules. After session creation, send session_id and application_context with the original goal and inspected workflow to obtain model-proposed rules, missing observations and fixture requirements. This planning action requires sign-in. Proposals are not executed checks. The app-owning agent authors the executable contract from inspected code and business scope. Server suggestions are advisory. Review every coverage dimension; declare relevant unsupported behavior explicitly and explain genuinely unrelated features as not_applicable. Omitted suggestions are retained separately and cannot add required checks. If server_requirements_model_available is false or planning returns requirements_model_unavailable, inspect the app and author the candidate contract with your own model; label it builder-proposed, not a FetchSandbox model result. Never wait for the human to write routine test requirements. For a Stripe app on a managed tunnel or published origin, use application_config.event_delivery=provider_lifecycle with the exact Stripe handler in event_destinations and require_verifier_token=true. Configuration creates a real subscription on this isolated Stripe twin via POST /v1/webhook_endpoints; the protected handoff supplies its returned signing secret. Select a returned catalog lifecycle profile with application_config.provider_lifecycle_workflows, e.g. {stripe:'create_and_send_invoice'} for invoice.sent or {stripe:'accept_payment'} for payment_intent.succeeded. The server freezes the workflow's subscription events, witness types and provider readback; missing delivery or mismatched provider state cannot pass. Drive that workflow through the inspected app's actual entry point. Do not manufacture a payment for an invoice or another non-payment workflow. Without a selection, the legacy payment/email witnesses remain unchanged. For the payment profile, confirm/capture the app's returned PaymentIntent and observe saved order plus email effects. Keep payment and duplicate replay in separate checks: first confirm payment and poll independently saved paid order and receipt state; then GET the actual received success-event ID from app state and bind replay_of to that GET response. Never assume the payment response contains event_id or use the PaymentIntent ID as an event ID. If the app cannot expose a received event identity, retain replay as unmeasured and explain the missing observation. Synthetic event type/payload actions are refused in this mode; exact replay of a delivered or explicitly withheld run-correlated generated event is supported. Event actions accept concurrency from 1 to 8 for real overlapping deliveries. Use the returned provider_control and fault.evidence contracts to drive recorded fault recovery. Use fault.evidence=accepted_response_retry when the app recovers a lost accepted response inside its HTTP request or a successful webhook callback. It requires an observed client disconnect before a matching provider retry and the same accepted effect ID; simultaneous sends and a slow response cannot pass. accepted_response_loss remains the failed-callback plus redelivery contract. For a declared client_lifecycle restart, follow client_checkpoint by restarting the real app process with the same durable storage and bindings, then retrieve the same run without another execute. Inspect webhook_subscriptions and recorded callback responses; missing delivery is inconclusive, never a pass. Resend lifecycle can be configured alongside Stripe using its exact existing handler in event_destinations. Configuration calls the isolated Resend POST /webhooks with endpoint/events and supplies the returned Svix signing secret through FETCHSANDBOX_RESEND_WEBHOOK_SECRET; map it to the inspected app setting. The real email send emits email.sent, email.delivered or the armed native email failure event. Inspect the signed callback acknowledgement and independently saved email state; a send ID or HTTP 200 alone does not prove application handling. Other providers remain explicit lifecycle gaps; existing hosted suites are unchanged. Local coding agents should call install_test_credentials after configuration to securely install temporary secrets using their MCP account key; do not call the browser receipt_secrets endpoint with an API key or print secret values. Hosted builders keep the existing owner browser handoff. For a normal HTTP app workflow with independently readable state, configure application_workflow_v1 and application_config. Declare a positive baseline first using ordinary HTTP app actions, no signed events, GET observations and required exact assertions. A pending order is a valid baseline; prove signed payment and access in a later check without removing those assertions. HTTP actions are {method,path,body?,expect_status?,concurrency?}. concurrency from 1 to 8 sends the same inspected app request concurrently against frozen prior bindings; all statuses are checked. For concurrency greater than 1, the response slot is {results:[...]} in request declaration order: bind each actual identity with {{step1.results.0.id}}, {{step1.results.1.id}}, then independently GET saved state. Same input does not imply the same logical operation; use the app business contract to distinguish independent purchases from duplicate submission. Every concurrent request consumes the existing check/run action budget; signed-event actions are ONLY {event:{provider,type,payload},expect_status?}, or {event:{provider,replay_of},expect_status?} for exact replay. Never combine event with method/path/body/headers or invent method EVENT. Webhook paths belong in event_destinations and MUST be the inspected app handler paths. Provider event names, resource envelopes, signing algorithm, raw request bytes and replay event identity must follow that provider. Do not invent a test webhook handler that replaces the real implementation; a protected setup/state adapter may expose isolated records but may not implement the behavior being tested. Managed relay URLs register verifier connectivity only, not a live-provider subscription. All action, before and observe paths must omit query strings and fragments, even run_id queries: use inspected protected path-segment routes and preserve run scoping. A configuration_rejected result identifies offending field paths; repair those fields in the SAME session before another configuration call. It is not an app test result and does not request credentials. Reuse applicable proposed rule IDs when useful; only app-declared checks are binding. Do not drop a relevant failed check to obtain green. Signed callback app_response contains a sanitized acknowledgement; response remains delivery metadata. Inspect response_capture_status when the body is missing, and independently read state for the verdict. Signed provider event actions use isolated secure-handoff signing secrets; bind payload identity to actual app responses and verify saved state. No browser, arbitrary auth-header or SQL execution is supported by this HTTP contract: record those gaps explicitly. Do not weaken signature or access checks to make a test pass. Start a validation session for the user's integration. quickrun and run_workflow execute OUR curated workflow against a twin — green there says the provider behaves as documented, and says nothing about whether their integration wired to it correctly. This instead hands back a FRESH twin per provider and asks the user to point their app at it, then reads external provider traffic. Direct agent calls also appear there; caller identity is not established. Use it when someone wants their integration verified before launch. Call once with `providers`, then follow the returned `next_action`. Inspect the app and supply a complete `receipt_config` before configuring the suite; the application suite drives its own purchases and webhooks, so do not ask the user to run a manual flow first. The matrix is returned before any traffic: pass `arm` with a probe ID before exercising the app. Send the returned request_headers on every provider request in that attempt, then pass `probe` and `run_id` to evaluate. Use `cancel: true` with `run_id` to abort or retry failed cleanup. Request logs alone do not prove application state or production readiness. For a supported payment-to-receipt integration, follow the structured `next_action`; call `next_tool_call` only when it is non-null and its arguments are complete. Never execute while host-side setup is pending. Do not substitute guide, quickrun, list_workflows, or reference probes for application verification. Use the widest suite the server recommends. receipt_recovery_v1 includes R1-R4 and adds checks R5-R8 for accepted-send response loss, concurrent redelivery, source/email transient failures and delayed redelivery. Pass suite plus receipt_config with the app's exact webhook URL, test recipients and observable purchase marker. FetchSandbox freezes all four receipt rules for both same-customer and different-customer purchases. You are responsible for completing this setup: treat the target as a disposable test app, not the user's live production service, until its declared suite passes. For a greenfield app, keep live billing disabled and publish a temporary test build first to obtain its stable public origin. Use the published webhook URL, not a private preview URL. Inspect the app and identify the exact webhook route before suite configuration. Before requesting or applying test secrets, send an unsigned POST to that exact URL from outside the workspace; a 400 signature rejection is expected, while a 307/login redirect is a blocker. Keep signature validation enabled. After the successful preflight, configure the suite with its complete receipt_config. Apply the returned twin URLs, X-Flow-Run-Id, and three temporary credentials only to this disposable app; execute only after the host-side setup actions are complete. The credentials are twin-only test values: PADDLE_API_KEY, RESEND_API_KEY, and PADDLE_WEBHOOK_SECRET. Use the platform's supported secret store or secret-writing tool and never use real provider credentials or enable live billing. After every required check is held, remove only the test secrets and twin config this run added, including from the disposable test app's published scope. Never modify a separate live production app or delete pre-existing, shared, or real-provider values. Confirm the temporary names are absent, then hand the app to its owner to configure separate development/staging credentials. If the suite is failing or inconclusive, retain test config for repair and a fresh run. The configure_app response contains public twin URLs/IDs and a secret_handoff_url, never the secret values themselves. If the host exposes no safe way for you to write test secrets, explain that specific limitation and show the human the link to open while signed in to the owning FetchSandbox account; they can copy the three values directly into the platform secret store. Do not ask the human to discover endpoints, call FetchSandbox manually, or paste secret values into chat, project files, or logs. Wait for confirmation only when the human must complete that secure-store action. Then call execute:true with its run_id. FetchSandbox drives signed events and independently observes accepted email records. Keep every check and the observation windows in your report. Restore any temporary host privacy setting after the test. On an inconclusive execute result, inspect and report its `execution_diagnostics` field directly; do not ask the human to infer a cause from the public receipt page, which intentionally omits private proof. If you cannot configure the app, report that blocker; reference tests cannot replace app execution. A verified receipt suite covers only its declared rules and windows, never all production behavior. A missing or untriggered recovery fault stays unmeasured. This application suite requires sign-in. Paddle checkout is a separate app-owned browser flow: if a transaction's `checkout.url` points to `fetchsandbox.com/checkout`, returns 404, or does not show a checkout page, do not imply FetchSandbox hosts the merchant's payment UI. Inspect the exact URL and the Paddle Sandbox default payment link or per-transaction override. Tell the builder to use a reachable app checkout page that loads Paddle.js and opens the `_ptxn` transaction, or a supported Paddle-hosted flow. Verify browser checkout/payment separately from twin API and webhook tests; transaction creation alone is not payment proof.

verify_behavior

Prove a known fix survives a bug — the 'prove' half of reproduce→prove. The backend spawns a buggy AND a fixed reference handler and fires the bug_pattern's probes at both, returning the side-by-side diff (e.g. the buggy handler double-charges on a duplicate webhook, the fixed handler dedupes). Call this AFTER run_workflow reproduces a failure, when the matched bug_pattern has a simulation block, to show the fix actually holds — not just that the failure reproduced. Pass sandbox_id + flow_run_id from the run so the diff is saved onto that run's receipt URL. bug_pattern_id comes from guide's matched_bug_pattern. The buggy/fixed handlers are FetchSandbox reference implementations, NOT the user's code. A confirmed reference result does not verify the user's app or show that it is ready to ship. Keep the returned provider and evidence scope with any reported result.

Argument	Type	Description
prompt	string	OPTIONAL. The user's own description of the symptom. For patterns that can originate in the handler OR the provider, this classifies which side to simulate. Omit to run both.
sandbox_id	string	OPTIONAL. The sandbox from the run. Pass with flow_run_id to save the diff onto that run's receipt. This binds the pattern to that sandbox's provider; provide it when verifying a provider integration.
flow_run_id	string	OPTIONAL. The flow_run_id returned by run_workflow. Pass with sandbox_id so the receipt URL renders the diff alongside the steps.
bug_pattern_id*	string	The bug_pattern to prove (e.g. webhook_duplicate_side_effect). Comes from guide's matched_bug_pattern.id or the spec's brain.

Input schema (JSON)

Argument

Type

Description

arm

string

Probe ID from the matrix to arm before running the app. Requires session_id.

probe

string

Probe ID from the matrix to evaluate after running the app. Requires session_id and run_id.

suite

string

Configure the declared application receipt suite on this session.

cancel

boolean

Abort the attempt or retry failed cleanup. Requires session_id and run_id; cannot combine with arm or probe.

run_id

string

Attempt ID returned by arm or suite configuration. Required with probe, cancel, execute or preflight; prevents stale calls from consuming a newer attempt.

execute

boolean

Drive the configured app and evaluate the frozen receipt suite. Requires session_id/run_id; configuration acknowledgment alone is not proof. Starts the existing backend job asynchronously and returns promptly; follow status in this agent without allocating a background helper.

inspect

object

Read fixture inputs through MCP using session_id. Prefer this MCP read to extracting a key for direct HTTP: the edge can reject a generic Python user agent even with valid ownership. This path keeps the existing MCP client authentication and headers. Do not ask for live provider keys. First resource=state returns collection counts; select collection to read real IDs and relationships with pagination. resource=operations lists provider contracts; specify both exact method and documented path to resolve one schema. Read-only, session-owned twins only, not application proof.

fixtures

object

Prepare session-owned twin data before app tests. Requires session_id. Stable id makes repeated calls replay-safe. Every step names spec, method and relative path. Use {{step1.id}} for dependencies. End with GET and an exact identity assertion. No live provider calls. An explicitly advertised /__fetchsandbox/fixtures/time step is an owner-only synthetic clock control, not a provider API; it is unavailable during active attempts and requires normal provider GET readback.

reassess

boolean

Set true when the user asks to reassess/recontract an app. Requires suite=application_workflow_v1 and application_config.scope_review for EVERY candidate check. Freeze a fresh contract scoped to inspected promised behavior. Outside-scope proposals are recorded separately; missing protection on relevant behavior remains a requirement. Never edit historical results or remove a failed requirement for the same app version.

preflight

boolean

Read-only public readiness check for a configured application_workflow_v1. Requires session_id/run_id. Checks frozen empty baseline and token enforcement without creating orders, injecting faults or rotating secrets. Retry same run after its exact setup blocker is repaired.

providers

array

Provider slugs the app integrates, e.g. ['stripe'] or ['paddle','resend']. For provider-free HTTP workflows, omit providers and pass app_base_url.

session_id

string

Returned by the first call. Pass it back after their app has run a flow to see what it did.

app_base_url

string

App origin when FetchSandbox must drive or observe a hosted HTTP suite. Optional for a provider-backed workflow executed by the builder through arm/probe; that path does not require a published app or webhook.

receipt_config

object

application_config

object

Frozen HTTP app drive/read-back contract: 1-30 checks, 1-20 actions per executable check, at most 300 declared actions in total, below 64 KiB. Preserve intermediate reads within these bounds; do not silently remove them. First check id=baseline must establish success. Checks require id, name, before {path,assertion}, ordinary HTTP actions [{method,path,body?,expect_status?}] or signed-event actions [{event:{provider,type,payload},expect_status?}], observe {path}, and assertion using select/equals/count/required or all_of. where and all_of must be lists of assertion objects, not field maps. equals accepts JSON strings, numbers, booleans and null; numeric/boolean literals preserve type, and null must be a present null field. Stripe event.payload is only the resource inside data.object, never a full event or a data.object wrapper: the server constructs and signs the envelope. Optional per-check observation_deadline_seconds (0-180, repeat=1 only) records bounded polling for eventual saved state; it does not drive a browser or turn a timeout into a pass. Every check first reads its declared starting-state precondition. Baseline requires count=0 on the same observed collection, with no where filter. Use {{run_id}} to scope fresh synthetic records. All paths are app-relative without query strings or fragments, including non-secret run_id queries; preserve run scoping through an inspected protected path-segment observer. Baseline permits only ordinary HTTP actions without signed events; prove signed purchase/access in later checks. Do not combine event actions with method/path/body/headers. {{step1.id}} binds a real action response to read-back. assertion.repeat (1-5) and stable_under_repeat support replay. Optional fault {provider,scenario} requires independently recorded provider refusal. For reassess/recontract include scope_review for every candidate check. Outside-scope feature proposals contain id,name,unsupported_reason only and move to separate scope_exclusions; they are not required tests. In-scope missing work uses id,name,blocker {category,reason,evidence,...}, never a free-text unsupported reason. engine_unsupported requires a capability confirmed by current backend capabilities; a missing app route or observer is not an engine gap. Unresolved policy remains unmeasured. Legacy untyped reasons remain unclassified, not engine unsupported. No user-supplied credentials, auth headers or live data. require_verifier_token=true generates an owner-only temporary Bearer token through secure handoff for protected test endpoints.

application_context

object

Bounded inspected app summary, not credentials or raw code. The existing requirements model proposes rules; it cannot issue a verdict. Requires sign-in and an existing session_id: start with providers first, then send this context in a separate call using the returned session. Separate from fixtures/execution.

{ "type": "object", "$defs": { "applicationAssertion": { "type": "object", "required": [], "properties": { "count": { "type": "integer", "minimum": 0 }, "where": { "type": "array", "items": { "$ref": "#/$defs/applicationAssertion" } }, "absent": { "type": "boolean" }, "all_of": { "type": "array", "items": { "$ref": "#/$defs/applicationAssertion" } }, "equals": { "type": [ "string", "number", "boolean", "null" ] }, "repeat": { "type": "integer", "maximum": 5, "minimum": 1 }, "select": { "type": "string" }, "contains": { "type": "string" }, "required": { "type": "boolean" }, "set_equals": { "type": "array", "items": { "type": "string" }, "uniqueItems": true }, "stable_under_repeat": { "type": "boolean" } }, "additionalProperties": false } }, "properties": { "arm": { "type": "string", "description": "Probe ID from the matrix to arm before running the app. Requires session_id." }, "probe": { "type": "string", "description": "Probe ID from the matrix to evaluate after running the app. Requires session_id and run_id." }, "suite": { "enum": [ "receipt_delivery_v1", "receipt_recovery_v1", "application_workflow_v1" ], "type": "string", "description": "Configure the declared application receipt suite on this session." }, "cancel": { "type": "boolean", "description": "Abort the attempt or retry failed cleanup. Requires session_id and run_id; cannot combine with arm or probe." }, "run_id": { "type": "string", "description": "Attempt ID returned by arm or suite configuration. Required with probe, cancel, execute or preflight; prevents stale calls from consuming a newer attempt." }, "execute": { "type": "boolean", "description": "Drive the configured app and evaluate the frozen receipt suite. Requires session_id/run_id; configuration acknowledgment alone is not proof. Starts the existing backend job asynchronously and returns promptly; follow status in this agent without allocating a background helper." }, "inspect": { "type": "object", "required": [ "provider", "resource" ], "properties": { "path": { "type": "string" }, "limit": { "type": "integer", "maximum": 100, "minimum": 1 }, "method": { "type": "string" }, "offset": { "type": "integer", "minimum": 0 }, "provider": { "type": "string" }, "resource": { "enum": [ "state", "operations" ], "type": "string" }, "collection": { "type": "string" } }, "description": "Read fixture inputs through MCP using session_id. Prefer this MCP read to extracting a key for direct HTTP: the edge can reject a generic Python user agent even with valid ownership. This path keeps the existing MCP client authentication and headers. Do not ask for live provider keys. First resource=state returns collection counts; select collection to read real IDs and relationships with pagination. resource=operations lists provider contracts; specify both exact method and documented path to resolve one schema. Read-only, session-owned twins only, not application proof.", "additionalProperties": false }, "fixtures": { "type": "object", "required": [ "id", "steps" ], "properties": { "id": { "type": "string", "maxLength": 100, "minLength": 1 }, "steps": { "type": "array", "items": { "type": "object", "required": [ "spec", "method", "path" ], "properties": { "body": { "type": "object" }, "name": { "type": "string" }, "path": { "type": "string" }, "spec": { "type": "string" }, "method": { "enum": [ "GET", "POST", "PUT", "PATCH", "DELETE" ], "type": "string" }, "assertion": { "type": "object", "required": [ "select", "equals", "required", "count" ], "properties": { "count": { "enum": [ 1 ], "type": "integer" }, "equals": { "type": "string" }, "select": { "type": "string" }, "required": { "enum": [ true ], "type": "boolean" } }, "description": "GET read-back only. Exactly four fields, e.g. {select: data.id, equals: '{{step2.id}}', required: true, count: 1} for Paddle. Use separate GET assertions for amount and currency; application all_of/where and JSON scalar predicates are not supported here.", "additionalProperties": false }, "query_params": { "type": "object" }, "expect_status": { "type": "integer", "maximum": 299, "minimum": 200 } }, "additionalProperties": false }, "maxItems": 40, "minItems": 1 } }, "description": "Prepare session-owned twin data before app tests. Requires session_id. Stable id makes repeated calls replay-safe. Every step names spec, method and relative path. Use {{step1.id}} for dependencies. End with GET and an exact identity assertion. No live provider calls. An explicitly advertised /__fetchsandbox/fixtures/time step is an owner-only synthetic clock control, not a provider API; it is unavailable during active attempts and requires normal provider GET readback.", "additionalProperties": false }, "reassess": { "type": "boolean", "description": "Set true when the user asks to reassess/recontract an app. Requires suite=application_workflow_v1 and application_config.scope_review for EVERY candidate check. Freeze a fresh contract scoped to inspected promised behavior. Outside-scope proposals are recorded separately; missing protection on relevant behavior remains a requirement. Never edit historical results or remove a failed requirement for the same app version." }, "preflight": { "type": "boolean", "description": "Read-only public readiness check for a configured application_workflow_v1. Requires session_id/run_id. Checks frozen empty baseline and token enforcement without creating orders, injecting faults or rotating secrets. Retry same run after its exact setup blocker is repaired." }, "providers": { "type": "array", "items": { "type": "string" }, "description": "Provider slugs the app integrates, e.g. ['stripe'] or ['paddle','resend']. For provider-free HTTP workflows, omit providers and pass app_base_url." }, "session_id": { "type": "string", "description": "Returned by the first call. Pass it back after their app has run a flow to see what it did." }, "app_base_url": { "type": "string", "description": "App origin when FetchSandbox must drive or observe a hosted HTTP suite. Optional for a provider-backed workflow executed by the builder through arm/probe; that path does not require a published app or webhook." }, "receipt_config": { "type": "object", "required": [ "webhook_url", "recipient_a", "recipient_b", "purchase_marker", "app_version", "source_lookup_required" ], "properties": { "app_version": { "type": "string", "description": "Declared application build identifier; not code attestation." }, "recipient_a": { "type": "string", "description": "Expected test recipient for purchase A, fixed before execution." }, "recipient_b": { "type": "string", "description": "Different test recipient for the different-customer case." }, "webhook_url": { "type": "string", "description": "Exact normal application webhook URL, including path." }, "purchase_marker": { "type": "object", "required": [ "field" ], "properties": { "field": { "enum": [ "html", "text", "subject", "tags" ], "type": "string" }, "tag_name": { "type": "string" } }, "description": "Where the normal receipt includes its Paddle transaction ID; same-record recipient/marker matching is required.", "additionalProperties": false }, "purchase_context": { "type": "object", "description": "Application routing custom_data, e.g. test workspace ID. Never credentials." }, "observation_seconds": { "type": "number", "maximum": 5, "minimum": 0.1, "description": "Observation window after each checkpoint; default 2 seconds. Verdict covers only measured windows." }, "source_lookup_required": { "type": "boolean", "description": "Whether the app reads the source provider during its normal webhook handler." } }, "additionalProperties": false }, "application_config": { "type": "object", "required": [ "app_version", "disposable_test_app", "checks" ], "properties": { "checks": { "type": "array", "items": { "oneOf": [ { "type": "object", "required": [ "id", "name", "blocker" ], "properties": { "id": { "type": "string", "maxLength": 100, "minLength": 1 }, "name": { "type": "string" }, "blocker": { "type": "object", "required": [ "category", "reason", "evidence" ], "properties": { "path": { "type": "string" }, "method": { "enum": [ "GET", "POST", "PUT", "PATCH", "DELETE" ], "type": "string" }, "reason": { "type": "string", "maxLength": 1000, "minLength": 1 }, "category": { "enum": [ "setup_missing", "observation_missing", "policy_unresolved", "engine_unsupported" ], "type": "string" }, "evidence": { "type": "array", "items": { "type": "string", "maxLength": 500, "minLength": 1 }, "maxItems": 10, "minItems": 1 }, "provider": { "type": "string" }, "capability": { "enum": [ "provider_lifecycle", "provider_operation", "independent_storage_attestation" ], "type": "string" } }, "additionalProperties": false } }, "additionalProperties": false }, { "type": "object", "required": [ "id", "name", "unsupported_reason" ], "properties": { "id": { "type": "string", "maxLength": 100, "minLength": 1 }, "name": { "type": "string" }, "unsupported_reason": { "type": "string", "minLength": 1 } }, "additionalProperties": false }, { "type": "object", "required": [ "id", "name", "actions", "before", "observe", "assertion" ], "properties": { "id": { "type": "string", "maxLength": 100, "minLength": 1 }, "name": { "type": "string" }, "fault": { "type": "object", "required": [ "provider", "scenario" ], "properties": { "evidence": { "enum": [ "refusal", "accepted_response_loss", "accepted_response_retry", "webhook_withheld" ], "type": "string" }, "provider": { "type": "string" }, "scenario": { "type": "string" }, "event_type": { "type": "string" } }, "additionalProperties": false }, "before": { "type": "object", "required": [ "path", "assertion" ], "properties": { "path": { "type": "string" }, "assertion": { "$ref": "#/$defs/applicationAssertion" } }, "additionalProperties": false }, "actions": { "type": "array", "items": { "oneOf": [ { "type": "object", "required": [ "provider_input" ], "properties": { "expect_status": { "enum": [ 200 ], "type": "integer" }, "provider_input": { "type": "object", "required": [ "provider", "method", "path", "body" ], "properties": { "body": { "type": "object" }, "path": { "type": "string" }, "actor": { "enum": [ "requester", "external_operator" ], "type": "string" }, "method": { "type": "string" }, "provider": { "type": "string" } }, "additionalProperties": false } }, "description": "Qualified external input, recorded separately from app execution. Requester is the default (Zendesk public reply). Explicit external_operator permits only configured twin operations, such as an independent refund or new subscription between app actions. It cannot replace app execution or count as an app effect.", "additionalProperties": false }, { "type": "object", "required": [ "method", "path" ], "properties": { "body": {}, "path": { "type": "string" }, "method": { "enum": [ "GET", "POST", "PUT", "PATCH", "DELETE" ], "type": "string" }, "concurrency": { "type": "integer", "maximum": 8, "minimum": 1 }, "expect_status": { "type": "integer", "maximum": 599, "minimum": 200 } }, "additionalProperties": false }, { "type": "object", "required": [ "event" ], "properties": { "event": { "oneOf": [ { "type": "object", "required": [ "provider", "type", "payload" ], "properties": { "type": { "type": "string" }, "payload": { "type": "object" }, "provider": { "type": "string" } }, "additionalProperties": false }, { "type": "object", "required": [ "provider", "replay_of" ], "properties": { "provider": { "type": "string" }, "replay_of": { "type": "string" } }, "additionalProperties": false } ] }, "concurrency": { "type": "integer", "maximum": 8, "minimum": 1 }, "expect_status": { "type": "integer", "maximum": 599, "minimum": 200 } }, "additionalProperties": false }, { "type": "object", "required": [ "delay_seconds" ], "properties": { "delay_seconds": { "type": "number", "maximum": 5, "exclusiveMinimum": 0 } }, "additionalProperties": false }, { "type": "object", "required": [ "provider_control" ], "properties": { "provider_control": { "type": "object", "required": [ "provider", "scenario" ], "properties": { "provider": { "type": "string" }, "scenario": { "enum": [ "default" ], "type": "string" } }, "additionalProperties": false } }, "additionalProperties": false }, { "type": "object", "required": [ "client_lifecycle" ], "properties": { "client_lifecycle": { "type": "object", "required": [ "operation", "observe_path", "identity_field", "timeout_seconds" ], "properties": { "operation": { "enum": [ "restart" ], "type": "string" }, "observe_path": { "type": "string" }, "identity_field": { "type": "string" }, "timeout_seconds": { "type": "number", "maximum": 180, "minimum": 1 } }, "additionalProperties": false } }, "additionalProperties": false } ] }, "maxItems": 20, "minItems": 1 }, "observe": { "type": "object", "required": [ "path" ], "properties": { "path": { "type": "string" } }, "additionalProperties": false }, "assertion": { "$ref": "#/$defs/applicationAssertion" }, "provider_assertions": { "type": "array", "items": { "type": "object", "required": [ "provider", "collection", "assertion" ], "properties": { "provider": { "type": "string" }, "assertion": { "type": "object" }, "collection": { "type": "string" } }, "additionalProperties": false }, "maxItems": 8, "description": "Additional independent state assertions against this session's provider twins. Select records[*] from a public collection; readbacks are recorded separately from app-reported state. This is simulated provider state, not live-provider delivery." }, "observation_deadline_seconds": { "type": "number", "maximum": 180, "minimum": 0 } }, "additionalProperties": false } ] }, "maxItems": 30, "minItems": 1 }, "app_version": { "type": "string" }, "scope_review": { "type": "array", "items": { "type": "object", "required": [ "check_id", "classification", "reason", "evidence" ], "properties": { "reason": { "type": "string", "maxLength": 1000, "minLength": 1 }, "check_id": { "type": "string" }, "evidence": { "type": "array", "items": { "type": "string", "maxLength": 500, "minLength": 1 }, "maxItems": 10, "minItems": 1 }, "classification": { "enum": [ "in_scope", "outside_app_scope", "unresolved" ], "type": "string" } }, "additionalProperties": false }, "maxItems": 30, "minItems": 1, "description": "Required when reassessing/recontracting app scope. Review EVERY candidate check from inspected app behavior. Outside-app-scope entries must be non-executable proposals with inspection references; the backend excludes them from required checks and records them separately. Keep missing protection on relevant behavior in scope. A reason is an app-agent declaration, not independent source attestation. coverage_review links must name retained required checks only. Preserve failed requirements for the same app version." }, "event_delivery": { "enum": [ "direct", "provider_lifecycle" ], "type": "string", "description": "provider_lifecycle registers provider-native subscriptions and requires actual app workflow actions. Optional provider_lifecycle_workflows selects catalog-owned witnesses/readback. Omitted selection preserves payment/email witnesses. direct uses verifier-signed events." }, "coverage_review": { "type": "array", "items": { "type": "object", "required": [ "dimension", "relevance", "reason", "rule_ids" ], "properties": { "reason": { "type": "string" }, "rule_ids": { "type": "array", "items": { "type": "string" } }, "dimension": { "type": "string" }, "relevance": { "enum": [ "relevant", "not_applicable", "unresolved" ], "type": "string" } }, "additionalProperties": false }, "maxItems": 17, "description": "Applicability review against the returned coverage_policy. Missing dimensions remain unreviewed. Link relevant dimensions to declared checks, including explicitly unsupported checks. This is a proposed review, not execution proof." }, "event_destinations": { "type": "object", "description": "Session-provider to same-origin webhook path without query/fragment. Requires require_verifier_token=true and the isolated FETCHSANDBOX_<PROVIDER>_WEBHOOK_SECRET from secure handoff. Complete signed action shape: {event:{provider,type,payload},expect_status:200}; exact replay: {event:{provider,replay_of:'{{step2.event_id}}'},expect_status:200}. No method/path/body/headers on signed actions. Baseline uses ordinary HTTP actions; signed events belong in later checks. Existing signature checks must remain enabled.", "additionalProperties": { "type": "string" } }, "disposable_test_app": { "enum": [ true ], "type": "boolean" }, "observation_seconds": { "type": "number", "maximum": 5, "minimum": 0.1 }, "require_verifier_token": { "type": "boolean" }, "provider_lifecycle_workflows": { "type": "object", "description": "Optional destination-provider to returned catalog workflow id, e.g. {stripe: create_and_send_invoice}. Only declared application_lifecycle profiles are accepted. The server freezes expected events and independently reads the event resource in the workflow terminal state. Do not invent event names or substitute provider traffic for app-state assertions.", "additionalProperties": { "type": "string" } } }, "description": "Frozen HTTP app drive/read-back contract: 1-30 checks, 1-20 actions per executable check, at most 300 declared actions in total, below 64 KiB. Preserve intermediate reads within these bounds; do not silently remove them. First check id=baseline must establish success. Checks require id, name, before {path,assertion}, ordinary HTTP actions [{method,path,body?,expect_status?}] or signed-event actions [{event:{provider,type,payload},expect_status?}], observe {path}, and assertion using select/equals/count/required or all_of. where and all_of must be lists of assertion objects, not field maps. equals accepts JSON strings, numbers, booleans and null; numeric/boolean literals preserve type, and null must be a present null field. Stripe event.payload is only the resource inside data.object, never a full event or a data.object wrapper: the server constructs and signs the envelope. Optional per-check observation_deadline_seconds (0-180, repeat=1 only) records bounded polling for eventual saved state; it does not drive a browser or turn a timeout into a pass. Every check first reads its declared starting-state precondition. Baseline requires count=0 on the same observed collection, with no where filter. Use {{run_id}} to scope fresh synthetic records. All paths are app-relative without query strings or fragments, including non-secret run_id queries; preserve run scoping through an inspected protected path-segment observer. Baseline permits only ordinary HTTP actions without signed events; prove signed purchase/access in later checks. Do not combine event actions with method/path/body/headers. {{step1.id}} binds a real action response to read-back. assertion.repeat (1-5) and stable_under_repeat support replay. Optional fault {provider,scenario} requires independently recorded provider refusal. For reassess/recontract include scope_review for every candidate check. Outside-scope feature proposals contain id,name,unsupported_reason only and move to separate scope_exclusions; they are not required tests. In-scope missing work uses id,name,blocker {category,reason,evidence,...}, never a free-text unsupported reason. engine_unsupported requires a capability confirmed by current backend capabilities; a missing app route or observer is not an engine gap. Unresolved policy remains unmeasured. Legacy untyped reasons remain unclassified, not engine unsupported. No user-supplied credentials, auth headers or live data. require_verifier_token=true generates an owner-only temporary Bearer token through secure handoff for protected test endpoints.", "additionalProperties": false }, "application_context": { "type": "object", "required": [ "goal" ], "properties": { "goal": { "type": "string" }, "workflow": { "type": "string" }, "app_version": { "type": "string" }, "state_store": { "type": "string" }, "entry_points": { "type": "array", "items": { "type": "string" } }, "fixture_requirements": { "type": "array", "items": { "type": "string" } } }, "description": "Bounded inspected app summary, not credentials or raw code. The existing requirements model proposes rules; it cannot issue a verdict. Requires sign-in and an existing session_id: start with providers first, then send this context in a separate call using the returned session. Separate from fixtures/execution.", "additionalProperties": false } }, "additionalProperties": false }