Skip to main content
Glama

revise

Correct an existing memory item by id without retyping it: unmentioned fields keep their values, and weakening a checked rule requires a one-sentence reason.

Instructions

Code lane: corrects an EXISTING item by id through the same write gate as remember; a field left unmentioned keeps its current value, and none may silently vanish - clear one with clear_severity/clear_project/clear_expires/clear_key/clear_falsifier/clear_check; an empty string on the field is the harness-only equivalent, and a flag plus a real value for that field is refused. Weakening a checked rule (its check, severity, a binding, or scope) needs because: one sentence, kept in history. On a replica this queues instead of writing ('queued for the main machine' is not an error). Prefer this over remember for an existing item that merely changed; retract, with its own reason, is for one that is simply wrong. Refuses, with the exact reason, on remember's grounds (a secret token newly written into the text or falsifier included), plus a dropped field or an unexplained weakening. A revise that changes its text, anchors, check, project or severity is tried again (a revise naming only the id tries a rule no trial has decided yet); one that changes only tags, falsifier, expires or key keeps its verdict. Replies with the revised id and event sequence, or the refusal text.

Input Schema

NameRequiredDescriptionDefault
idYesThe id of the existing item to correct.
keyNoOmit to keep the current key; pass "" to clear it (see `clear_key` below for the spelling that reaches this server from an assistant).
tagsNoReplaces the whole tag list. Omit to keep the current tags; pass an empty list to clear them on purpose - the same omit-keeps/empty-clears convention as severity/project/expires/key/falsifier, spelled with a list: omitted means unmentioned, an empty array means deliberately cleared, a real list replaces the whole set.
textNoNew text, replacing the whole body. Omit to keep the current text unchanged. For a SMALL correction to a long item, prefer `append` or `replace_from`/`replace_to` below - retyping a 290-character rule to fix one word is friction on exactly the maintenance this memory needs most, and it is the reason corrections get skipped.
alwaysNoReplaces whether this item is bound Always - see `moments`' own note.
appendNoAdd this to the END of the current text, with one space between. Refused together with `text` (say what the body is, or say what to add to it, never both). The result still goes through the whole gate, so a 300-character limit is enforced on what comes out, not on what you typed.
becauseNoRequired when this revise WEAKENS a Rule/Orientation: clearing or changing its check, lowering or clearing severity, removing a binding (a command, path or dir anchor on any rule; any binding on one that carries a check or is marked expensive), narrowing scope from global to one project, taking a fragment THOR builds teeth from (a backtick span, a quoted call, a flag or a path) out of its text, or moving it off the rule track. Say in one sentence why - it is written into this item's own history (see `history`), the same way retract's reason is, so the owner can read later why a rule lost its teeth. Blank or missing on one of those is refused outright. Accepted and stored on any other revise too, but never required for one - except that a revise naming legitimate_calls, may_change or accept_refusing always needs it: at least 20 characters saying why the span may change or the call is legitimate while the rule stays true.
expiresNoOmit to keep the current expiry; pass "" to clear it (see `clear_expires` below for the spelling that reaches this server from an assistant).
momentsNoReplaces the moment bindings. Give this, `targets`, and/or `always` TOGETHER to replace the WHOLE binding list in one call - when none of the three are given, the existing bindings are kept untouched. See RememberArgs' own note on which moments actually fire - a NEW answer/ claim_done binding is refused here too, though one the item already carried stays correctable.
projectNoOmit to keep the current project; pass "" to make it global (see `clear_project` below for the spelling that reaches this server from an assistant).
targetsNoReplaces the target bindings - see `moments`' own note on how the three binding fields combine.
severityNoOne of: irreversible, costly, house_style. Omit to keep the current value; pass "" to clear it (see `clear_severity` below for the spelling of a clear that actually reaches this server from an assistant).
clear_keyNoSet true to clear key - same fix and convention as `clear_severity` above. Refused, naming the conflict, if `key` is also given here as a real, non-empty value.
falsifierNoOmit to keep the current falsifier; pass "" to clear it (a Rule or Orientation left with none is refused, same as at creation - see `clear_falsifier` below for the spelling that reaches this server from an assistant).
check_kindNoOne of: path_exists, contains, absent, absent_all, forbidden, requires. Omit all four check_* fields to keep the current check untouched; pass check_kind as "" to clear it (refused if check_path/check_literal/check_literals is also given) - see `clear_check` below for the spelling that reaches this server from an assistant. Give check_kind plus whichever of check_path/check_literal/check_literals the kind takes, together, to replace the check wholesale - see RememberArgs' own check_kind note for what each kind needs and which to prefer.
check_pathNoSee check_kind's own note on the omit/clear/replace convention, and RememberArgs' own note on check_path for the directory shape contains/absent/absent_all also accept (every regular file DIRECTLY inside it, never a subdirectory). Refused outright if check_kind is "forbidden" - that kind carries no path at all.
may_changeNoONLY after a refusal said THOR derived a contains check from this rule's text and a file: the span you name as one that MAY CHANGE in that file - e.g. ["version"] for a rule that names the version line of package.json. It must be exactly the derived check's literal. Then the rule is stored as a note by dispute, which doctor lists for the owner. Needs `because`. Leave it out otherwise.
replace_toNoWhat `replace_from` becomes. Pass an empty string to delete the substring.
clear_checkNoSet true to clear the check - the same clear `check_kind: ""` above documents, same fix and convention as `clear_severity`'s own doc comment (see there for the defect and the evidence). Refused, naming the conflict, together with a non-empty check_kind, or with check_path/check_literal/check_literals - clearing takes none of the four; give a real check_kind (plus whatever it needs) to replace the check instead.
replace_fromNoReplace the FIRST occurrence of this substring in the current text with `replace_to`. Refused unless `replace_to` is given too, refused together with `text`, and refused when the substring is not actually in the current text - a silent no-op would report success while changing nothing.
check_literalNoSee check_kind's own note on the omit/clear/replace convention.
clear_expiresNoSet true to clear expires - same fix and convention as `clear_severity` above. Refused, naming the conflict, if `expires` is also given here as a real, non-empty value.
clear_projectNoSet true to clear project (make it global) - same fix and convention as `clear_severity` above. Refused, naming the conflict, if `project` is also given here as a real, non-empty value.
check_literalsNoThe set form of check_literal, for check_kind absent_all or forbidden - see RememberArgs' own note on why this is a repeatable field rather than a delimited string. Same omit/clear/replace convention as check_kind: an empty list here reads the same as omitting it, since a list has no separate way to say 'given, but deliberately empty'.
clear_severityNoSet true to clear severity - the same clear `severity: ""` above documents, run through the identical code path, never a second mechanism. THE DEFECT THIS FIXES, bitten twice (2026-09-09 and 2026-09-11): an assistant's tool-call layer drops an empty-string argument before it ever reaches this server (the field arrives as though it was never mentioned, or the call itself is rejected before that), and a literal '""' arrives as two quote characters, not an empty value - so the one documented way to clear a field was never actually reachable from an assistant. Both sessions gave up, retracted the rule and stored a fresh one with no check, silently losing its history. This flag is the one that works from an assistant; the empty string above still works for a caller that can send one (the JSON-RPC harness). Refused, naming the conflict, if `severity` is ALSO given here as a real, non-empty value - say one or the other, never both.
accept_refusingNoONLY after a refusal said your check would refuse most of the real calls it reaches: one of the calls it listed, named because refusing it IS the intent - e.g. ["git push origin main"] for a "never push this repository until the owner says so" ban. The rule stays on the rule track, and doctor lists every rule kept this way. Needs `because`. Otherwise narrow the check instead.
clear_falsifierNoSet true to clear falsifier - same fix and convention as `clear_severity` above (still refused outright on a Rule/Orientation, same as `falsifier: ""` above, by the same ground that guards creation). Refused, naming the conflict, if `falsifier` is also given here as a real, non-empty value.
legitimate_callsNoONLY after a refusal said THOR built a tooth from this rule's own text and it bites: a real, whole call you name as LEGITIMATE although that tooth refuses it - e.g. ["git push --force-with-lease origin main"] for a rule whose text names `--force`. It must reach the tooth's command, be refused by it, differ from the forbidden form THOR built itself, and carry something beyond the command and the literal. Then the rule is stored as a note by dispute, which doctor lists for the owner. Needs `because`. Leave it out otherwise.
new_collection_named_by_ownerNoTHE OWNER JUST NAMED A NEW COLLECTION - repeat that name here, exactly as he gave it. Same field, same rule and same one flow as on remember: only after nothing fitted, you showed him the refusal and he answered with a name. It must match the project (or key) this call files the item under.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed4 schema fields changedv2.6.0
    • addedInput schema / properties / accept_refusing
      Added value: +{
      +  "default": [],
      +  "description": "ONLY after a refusal said your check would refuse most of the real calls it reaches: one of\nthe calls it listed, named because refusing it IS the intent - e.g. [\"git push origin main\"]\nfor a \"never push this repository until the owner says so\" ban. The rule stays on the rule\ntrack, and doctor lists every rule kept this way. Needs `because`. Otherwise narrow the check instead.",
      +  "items": {
      +    "type": "string"
      +  },
      +  "type": "array"
      +}
    • changedInput schema / properties / because / description
      Previous value: -"Required when this revise WEAKENS a Rule/Orientation that carries a\ncheck: clearing or changing the check, lowering or clearing severity,\nremoving a binding (target, moment or Always), or narrowing scope\nfrom global to one project. Say in one sentence why - it is written\ninto this item's own history (see `history`), the same way retract's\nreason is, so the owner can read later why a rule that could refuse a\nwrite lost its teeth. Blank or missing on one of those five is\nrefused outright. Accepted and stored on any other revise too, but\nnever required for one."New value: +"Required when this revise WEAKENS a Rule/Orientation: clearing or\nchanging its check, lowering or clearing severity, removing a binding\n(a command, path or dir anchor on any rule; any binding on one that\ncarries a check or is marked expensive), narrowing scope from global\nto one project, taking a fragment THOR builds teeth from (a backtick\nspan, a quoted call, a flag or a path) out of its text, or moving it\noff the rule track. Say in one sentence why - it is written into this\nitem's own history (see `history`), the same way retract's reason is,\nso the owner can read later why a rule lost its teeth. Blank or\nmissing on one of those is refused outright. Accepted and stored on\nany other revise too, but never required for one - except that a revise\nnaming legitimate_calls, may_change or accept_refusing always needs it:\nat least 20 characters saying why the span may change or the call is\nlegitimate while the rule stays true."
    • addedInput schema / properties / legitimate_calls
      Added value: +{
      +  "default": [],
      +  "description": "ONLY after a refusal said THOR built a tooth from this rule's own text and it bites: a real,\nwhole call you name as LEGITIMATE although that tooth refuses it - e.g. [\"git push\n--force-with-lease origin main\"] for a rule whose text names `--force`. It must reach the\ntooth's command, be refused by it, differ from the forbidden form THOR built itself, and\ncarry something beyond the command and the literal. Then the rule is stored as a note by\ndispute, which doctor lists for the owner. Needs `because`. Leave it out otherwise.",
      +  "items": {
      +    "type": "string"
      +  },
      +  "type": "array"
      +}
    • addedInput schema / properties / may_change
      Added value: +{
      +  "default": [],
      +  "description": "ONLY after a refusal said THOR derived a contains check from this rule's text and a file: the\nspan you name as one that MAY CHANGE in that file - e.g. [\"version\"] for a rule that names\nthe version line of package.json. It must be exactly the derived check's literal. Then the\nrule is stored as a note by dispute, which doctor lists for the owner. Needs `because`. Leave it out otherwise.",
      +  "items": {
      +    "type": "string"
      +  },
      +  "type": "array"
      +}
  2. Changed12 schema fields changedv2.4.1
    • changedInput schema / properties / check_kind / description
      Previous value: -"One of: path_exists, contains, absent, absent_all, forbidden, requires. Omit all four\ncheck_* fields to keep the current check untouched; pass check_kind as \"\" to clear it\n(refused if check_path/check_literal/check_literals is also given). Give check_kind plus\nwhichever of check_path/check_literal/check_literals the kind takes, together, to replace\nthe check wholesale - see RememberArgs' own check_kind note for what each kind needs and\nwhich to prefer."New value: +"One of: path_exists, contains, absent, absent_all, forbidden, requires. Omit all four\ncheck_* fields to keep the current check untouched; pass check_kind as \"\" to clear it\n(refused if check_path/check_literal/check_literals is also given) - see `clear_check`\nbelow for the spelling that reaches this server from an assistant. Give check_kind plus\nwhichever of check_path/check_literal/check_literals the kind takes, together, to replace\nthe check wholesale - see RememberArgs' own check_kind note for what each kind needs and\nwhich to prefer."
    • addedInput schema / properties / clear_check
      Added value: +{
      +  "default": false,
      +  "description": "Set true to clear the check - the same clear `check_kind: \"\"` above\ndocuments, same fix and convention as `clear_severity`'s own doc\ncomment (see there for the defect and the evidence). Refused, naming\nthe conflict, together with a non-empty check_kind, or with\ncheck_path/check_literal/check_literals - clearing takes none of the\nfour; give a real check_kind (plus whatever it needs) to replace the\ncheck instead.",
      +  "type": "boolean"
      +}
    • addedInput schema / properties / clear_expires
      Added value: +{
      +  "default": false,
      +  "description": "Set true to clear expires - same fix and convention as\n`clear_severity` above. Refused, naming the conflict, if `expires` is\nalso given here as a real, non-empty value.",
      +  "type": "boolean"
      +}
    • addedInput schema / properties / clear_falsifier
      Added value: +{
      +  "default": false,
      +  "description": "Set true to clear falsifier - same fix and convention as\n`clear_severity` above (still refused outright on a Rule/Orientation,\nsame as `falsifier: \"\"` above, by the same ground that guards\ncreation). Refused, naming the conflict, if `falsifier` is also given\nhere as a real, non-empty value.",
      +  "type": "boolean"
      +}
    • addedInput schema / properties / clear_key
      Added value: +{
      +  "default": false,
      +  "description": "Set true to clear key - same fix and convention as `clear_severity`\nabove. Refused, naming the conflict, if `key` is also given here as a\nreal, non-empty value.",
      +  "type": "boolean"
      +}
    • addedInput schema / properties / clear_project
      Added value: +{
      +  "default": false,
      +  "description": "Set true to clear project (make it global) - same fix and convention\nas `clear_severity` above. Refused, naming the conflict, if `project`\nis also given here as a real, non-empty value.",
      +  "type": "boolean"
      +}
    • addedInput schema / properties / clear_severity
      Added value: +{
      +  "default": false,
      +  "description": "Set true to clear severity - the same clear `severity: \"\"` above\ndocuments, run through the identical code path, never a second\nmechanism. THE DEFECT THIS FIXES, bitten twice (2026-09-09 and\n2026-09-11): an assistant's tool-call layer drops an empty-string\nargument before it ever reaches this server (the field arrives as\nthough it was never mentioned, or the call itself is rejected before\nthat), and a literal '\"\"' arrives as two quote characters, not an\nempty value - so the one documented way to clear a field was never\nactually reachable from an assistant. Both sessions gave up,\nretracted the rule and stored a fresh one with no check, silently\nlosing its history. This flag is the one that works from an\nassistant; the empty string above still works for a caller that can\nsend one (the JSON-RPC harness). Refused, naming the conflict, if\n`severity` is ALSO given here as a real, non-empty value - say one or\nthe other, never both.",
      +  "type": "boolean"
      +}
    • changedInput schema / properties / expires / description
      Previous value: -"Omit to keep the current expiry; pass \"\" to clear it."New value: +"Omit to keep the current expiry; pass \"\" to clear it (see\n`clear_expires` below for the spelling that reaches this server from\nan assistant)."
    • changedInput schema / properties / falsifier / description
      Previous value: -"Omit to keep the current falsifier; pass \"\" to clear it (a Rule or\nOrientation left with none is refused, same as at creation)."New value: +"Omit to keep the current falsifier; pass \"\" to clear it (a Rule or\nOrientation left with none is refused, same as at creation - see\n`clear_falsifier` below for the spelling that reaches this server\nfrom an assistant)."
    • changedInput schema / properties / key / description
      Previous value: -"Omit to keep the current key; pass \"\" to clear it."New value: +"Omit to keep the current key; pass \"\" to clear it (see `clear_key`\nbelow for the spelling that reaches this server from an assistant)."
    • changedInput schema / properties / project / description
      Previous value: -"Omit to keep the current project; pass \"\" to make it global."New value: +"Omit to keep the current project; pass \"\" to make it global (see\n`clear_project` below for the spelling that reaches this server from\nan assistant)."
    • changedInput schema / properties / severity / description
      Previous value: -"One of: irreversible, costly, house_style. Omit to keep the current\nvalue; pass \"\" to clear it."New value: +"One of: irreversible, costly, house_style. Omit to keep the current\nvalue; pass \"\" to clear it (see `clear_severity` below for the\nspelling of a clear that actually reaches this server from an\nassistant)."
  3. Changed1 schema field changedv2.3.2
    • addedInput schema / properties / because
      Added value: +{
      +  "default": null,
      +  "description": "Required when this revise WEAKENS a Rule/Orientation that carries a\ncheck: clearing or changing the check, lowering or clearing severity,\nremoving a binding (target, moment or Always), or narrowing scope\nfrom global to one project. Say in one sentence why - it is written\ninto this item's own history (see `history`), the same way retract's\nreason is, so the owner can read later why a rule that could refuse a\nwrite lost its teeth. Blank or missing on one of those five is\nrefused outright. Accepted and stored on any other revise too, but\nnever required for one.",
      +  "type": [
      +    "string",
      +    "null"
      +  ]
      +}
  4. First observedv0.1.0

TDQS

A4.7/5.0
Behavior5/5

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

Annotations only give readOnly=false, destructive=false, idempotent=false. The description goes well beyond them: omit-keeps/empty-clears semantics, that 'none may silently vanish', the clear_* flag-plus-real-value conflict refusal, the because requirement for weakening a checked rule, and the non-idempotent retry behavior ('tried again' vs 'keeps its verdict'). Nothing here contradicts destructiveHint=false or idempotentHint=false.

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

Conciseness3/5

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

Purpose and the sibling routing are correctly front-loaded, but the body is a single dense run-on paragraph of semicolon-chained clauses covering clearing, refusals, replica behavior and retry semantics. It is information-rich yet hard to scan, and a few clauses (e.g. the append/replace retyping aside) restate schema notes.

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

Completeness5/5

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

For a 29-parameter mutation with no output schema, it covers the full lifecycle: what gets corrected, what is preserved when omitted, the refusal grounds (secrets, dropped fields, unexplained weakening), replica queueing, and the return shape ('the revised id and event sequence, or the refusal text'). Nothing needed to call it correctly is missing.

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 100%, so the baseline is 3, but the description adds cross-field meaning the schema only states per-field: the global omit/empty convention, that a flag plus a real value for the same field is refused, and that because: is mandatory specifically when a check, severity, binding or scope is weakened. It consolidates rules an agent would otherwise have to infer from 29 separate field notes.

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

Purpose5/5

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

Opens with a specific verb+resource+scope: 'corrects an EXISTING item by id through the same write gate as remember.' It immediately distinguishes itself from the two nearest siblings by name (remember for changed items, retract for wrong ones), so an agent can route without opening any schema.

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

Usage Guidelines5/5

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

Explicit when-to-use and when-not: 'Prefer this over remember for an existing item that merely changed; retract, with its own reason, is for one that is simply wrong.' It also states the replica fallback ('this queues instead of writing... is not an error') and the retry verdict rule, which are usage conditions rather than restated capability.

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