Skip to main content
Glama

revise

Update an existing memory item by ID, keeping unmentioned fields unchanged and requiring a reason before any checked rule is weakened.

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, plus a dropped field or an unexplained weakening. Replies with the revised id and event sequence, or the refusal text.

Input Schema

TableJSON 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 that carries a check: clearing or changing the check, lowering or clearing severity, removing a binding (target, moment or Always), or narrowing scope from global to one project. 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 that could refuse a write lost its teeth. Blank or missing on one of those five is refused outright. Accepted and stored on any other revise too, but never required for one.
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.
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.
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.
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. 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)."
  2. 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"
      +  ]
      +}
  3. First observedv0.1.0

TDQS

A4.4/5.0
Behavior3/5

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the mutation profile is largely covered. The description does add real value beyond annotations: omit-keeps semantics, the harness-only empty-string defect, replica queueing, and the 'refuses with the exact reason' contract. However, it does not restate non-idempotency or explore reversibility/history-retention limits beyond the `because` note.

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?

Effectively one dense paragraph that is front-loaded with the core action and routing before the edge cases. Every sentence carries a rule, but the punctuation-heavy packing makes it harder to scan than it needs to be.

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 26-parameter mutation tool with no output schema, the description covers the return contract ('revised id and event sequence, or the refusal text'), the refusal grounds, and the write-gate behavior. Nothing an agent needs to invoke 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; the description elevates it by explaining the cross-cutting omit-keeps/empty-clears convention, the flag-plus-real-value refusal, and the check_* omit/clear/replace protocol at the call level rather than per-field. It does not enumerate every one of the 26 fields, but the conventions it states apply to all of them.

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?

States a specific verb and resource ('corrects an EXISTING item by id'), and explicitly positions itself against siblings remember ('prefer this... for an existing item that merely changed') and retract ('for one that is simply wrong'). An agent can distinguish it from every sibling without opening a 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?

Gives explicit when-to-use routing against two named alternatives (remember, retract) and states the deciding condition for each. Also discloses the prerequisite that weakening a checked rule requires a `because` sentence, and that replica calls queue rather than write.

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