Skip to main content
Glama

ddflow_rule

Manage project rules for AI coding agents: add, search, edit, remove, sync, and show scoped rules to enforce coding standards and recover context.

Instructions

Project rules. Set action; required arguments in brackets: add(id,title), list, search(query), edit(id), remove(id), sync, show(id).

Input Schema

NameRequiredDescriptionDefault
idNoRule id, e.g. r-naming.
newNoDedup answer: a different record.
tagNoFilter results by this tag.
jsonNo
tagsNoComma-separated tags.
checkNoDry run: list duplicates only.
exactNoExact phrase.
globsNoComma-separated globs it governs.
limitNoMaximum results to return (default 10).
queryNoSearch query (keywords or regex).
regexNoQuery is a regex.
scopeNoproject (default) | phase | task | global.
titleNoOne-line rule statement.
actionYesWhat to do; see the tool description for each action's arguments.
reasonNo
contentNoRule text (may be empty for check_only).
extendsNoDedup answer: extends record ID.
relatedNoDedup answer: related to ID.
as_agentNoSubagent name, this call only.
priorityNoPriority 0-100 (default 50).
enforcementNoadvisory | warn | block: how hard the rule binds (default advisory).
duplicate_ofNoDedup answer: same as record ID.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv0.2.9

TDQS

B3.4/5.0
Behavior2/5

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

No annotations are provided, so the description carries the full burden. It enumerates actions but says nothing about what 'remove' destroys, whether edits are reversible, permission/auth needs, or what each action returns — significant gaps for a mutation tool with add/edit/remove.

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

Conciseness5/5

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

Extremely dense and front-loaded: two sentences pack the resource scope, the controlling action parameter, and a per-action required-argument map. No wasted words.

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

Completeness3/5

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

For a 7-action, 22-parameter tool with no output schema and no annotations, the description is thin. It covers required args per action but omits what 'sync' does, what fields 'edit' can change, and what any action returns, leaving real ambiguity for a complex tool.

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?

Schema coverage is 91%, so the schema already documents parameters well. The description adds genuine value by mapping each action to its required arguments (add(id,title), search(query), etc.), which the schema only gestures at with 'see the tool description'. It still doesn't clarify the many optional params (duplicate_of, extends, check, scope) beyond schema.

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?

Opens with the resource ('Project rules') and enumerates the seven supported actions, so the agent knows this is a rule-management CRUD tool. It distinguishes from siblings like ddflow_memory/ddflow_task by scope, though the core verb is only implied through the action list rather than stated.

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

Usage Guidelines3/5

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

The per-action bracket notation makes clear which arguments each action requires, which aids invocation. However, it never tells the agent when to use this tool versus siblings (memory, task) or when not to, and 'sync'/'edit' usage conditions are left entirely implicit.

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