Skip to main content
Glama

Append to memory note

append_journal

Add a Markdown entry under a heading in an existing vault note to extend a topic without duplication. Atomic write with content-addressed history and human approval.

Instructions

Use this when new information extends a topic that already has a note, instead of creating a duplicate. Append a Markdown entry under a heading in an existing memory note; the entry goes after the heading's own content, before its first subsection. This is a write operation: it is confined to DATACRON_WRITE_PATHS, stores content-addressed history, writes atomically, and relies on the MCP client's tool approval for human-in-the-loop review.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
entryYes
headingYes
rel_pathYes
request_idNo
expected_hashNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
indexedYes
appendedNo
rel_pathNo
replayedNo
committedNo
content_hashYes
operation_idNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed9 schema fields changedv0.1.5
    • addedInput schema / properties / request_id
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Request Id"
      +}
    • removedOutput schema / properties / appended / $ref
      Removed value: -"#/$defs/AppendedNoteOutput"
    • addedOutput schema / properties / appended / anyOf
      Added value: +[
      +  {
      +    "$ref": "#/$defs/AppendedNoteOutput"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • addedOutput schema / properties / appended / default
      Added value: +null
    • addedOutput schema / properties / committed
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "boolean"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Committed"
      +}
    • addedOutput schema / properties / operation_id
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Operation Id"
      +}
    • addedOutput schema / properties / rel_path
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Rel Path"
      +}
    • addedOutput schema / properties / replayed
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "boolean"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Replayed"
      +}
    • changedOutput schema / required
      Previous value: -[
      -  "appended",
      -  "content_hash",
      -  "indexed"
      -]New value: +[
      +  "content_hash",
      +  "indexed"
      +]
  2. First observedv0.1.0

TDQS

A4.4/5.0
Behavior5/5

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

Annotations only set boolean hints to false, so the description carries the behavioral disclosure burden. It fully delivers: labels the operation a write, confines it to DATACRON_WRITE_PATHS, mentions content-addressed history, atomic writes, and reliance on MCP client approval for human-in-the-loop review. No contradiction with annotations.

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?

Three sentences with no filler: the first states usage, the second specifies exact placement, the third covers safety and execution details. Critical information is front-loaded and every sentence earns its place.

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?

The description covers purpose, usage, write behavior, path confinement, atomicity, and review flow, which is strong for a write operation. It omits explanation of the optional concurrency/request parameters, but an output schema exists for return values and the core invocation path is well covered.

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

Parameters3/5

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for rel_path (confined to DATACRON_WRITE_PATHS), heading, and entry (Markdown, placement). However, it does not explain the optional request_id or expected_hash parameters, which are opaque without schema descriptions.

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: append a Markdown entry under a heading in an existing memory note. The description also distinguishes the tool from creating a duplicate and gives precise placement semantics (after heading content, before first subsection), leaving no ambiguity about what it does.

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 an explicit condition for use: 'when new information extends a topic that already has a note, instead of creating a duplicate.' This clearly identifies the scenario and the alternative (duplicate creation), though it could have explicitly named sibling create_note_ai or noted when not to use it.

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