Skip to main content
Glama

Resolve Platform Policy Conflict

resolve_platform_policy_conflict

Resolve a platform-policy dead-end with a structured plan decision.

``decision`` is one of ``reuse_existing_evidence``, ``split_task``,
``raise_project_cap``, ``remove_scenario``, or
``correct_evidence_selector``. ``raise_project_cap`` also requires
``project_cap`` (6..32). The decision becomes a new task-plan section; the
same task lineage is requeued before the escalation resolves.

``correct_evidence_selector`` (web_app tasks, active workspace owner only;
a workspace key or a non-owner gets ``owner_decision_required``) fixes a
frozen ``ready_selector`` no scenario can prove, such as an interaction
criterion frozen with the selector its static sibling proves at route
load. ``selector_corrections`` maps each acceptance-criterion id (the
``criterion_id`` of a list_escalations ``evidence_selector_cells`` entry)
to ``{"expected_ready_selector": <the frozen value>, "ready_selector":
<replacement>}`` (at most 10). Only those selectors change; a stale
expected value, an invalid selector, a cell left with two selectors, or an
interaction criterion that would still share a static sibling's selector
changes nothing. The old and new specs are audited.

On a project that runs the ui-review evidence lifecycle (``ui-review.json``
is a retained evidence catalog), ``raise_project_cap`` changes the
per-run capture budget -- how many scenarios one capture run holds -- not
catalog capacity: the catalog has no scenario limit, so no decision is
needed to make room in it.

On a ``web_app`` task, ``reuse_existing_evidence`` also repairs a frozen
theme-only collision in the same transaction: criteria whose evidence specs
differ only by a light/dark variant token (for example
``setup-timeline-light`` and ``setup-timeline-dark``) are refrozen to one
shared cell that lists the required ``themes``, the old and new specs are
audited, and the plan tells the worker to cover that cell with one
scenario. Criteria on one route, state and variant that name different
ready selectors are likewise refrozen to one selector. Every criterion
keeps its row and alias; unrelated specs are not changed.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
decisionYes
decision_mdYes
project_capNo
escalation_idYes
selector_correctionsNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changed
    • addedInput schema / properties / selector_corrections
      Added value: +{
      +  "anyOf": [
      +    {
      +      "additionalProperties": {
      +        "additionalProperties": {
      +          "type": "string"
      +        },
      +        "type": "object"
      +      },
      +      "type": "object"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Selector Corrections"
      +}
  2. Added

TDQS

A4.2/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Far exceeds what the annotations declare (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false). It discloses that the decision becomes a new plan section, that lineage is requeued before resolution, the owner_decision_required error token, the audit of old/new specs, precise no-op conditions, and the explicit non-destructive guarantee that unrelated specs and criterion rows are untouched.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the decision enum and then sections behavior by decision value, which fits the tool's complexity, and most sentences carry required semantics. A few clauses are overly nested (the static-sibling selector case), pushing length beyond what a caller needs on first read.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a destructive-capable, multi-branch mutation tool with an output schema (so returns need no explanation), the description covers decision effects, prerequisites, error paths, and transactional guarantees thoroughly. The only gap is the semantics of escalation_id and decision_md, which the agent must guess.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage the description must carry the load, and it does for the three complex parameters: it enumerates every decision value, constrains project_cap to 6..32, and fully specifies the selector_corrections nested shape and 10-entry limit. escalation_id and decision_md remain unexplained, so it is not fully complete.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (resolve) and resource (platform-policy conflict) and frames the outcome as a structured plan decision, which is more than a restatement of the name. It never explicitly distinguishes itself from the sibling resolve_escalation, so an agent must infer the boundary from the domain jargon.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives clear conditional context for each decision value (when project_cap is required, which tasks/paths apply to correct_evidence_selector, owner-only prerequisites) and describes side effects. It stops short of stating when to pick this tool over resolve_escalation or requeue_for_review, leaving the primary routing question unanswered.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.