gc

A command for cleaning up old or weak mnemonic memories, with options to preview, archive, delete, or compress them.

In plain words
What is it for?
Use it to find expired memories, preview cleanup, archive records, remove them when allowed, or compress large old entries.
Why use it?
It prevents stored memories from growing indefinitely and makes outdated information easier to manage.

Command

Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

agentmods
npx agentmods add commands/modeled-information-format/mnemonic/gc
Clone the repo
git clone --depth 1 https://github.com/modeled-information-format/mnemonic
Per session 7 Only the description is in the session, so the agent can decide to use it. The body loads when it is invoked.
When invoked 2,982 The whole file, excluding the scripts and references it only reads on demand.
Security scan B 1 finding. Scan, not verified.
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5 $0.00007 $0.02982
Opus 5 $0.00003 $0.01491
Sonnet 5 $0.00001 $0.00596
Haiku 4.5 $0.00001 $0.00298

Measured 2d ago against content hash b0223f8ba1f2, method: parsed. Prices are Anthropic first-party input rates as of 2026-08-30, from the pricing page.

Security

Grade B, and why

gc scanned grade B with 1 finding against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 2d ago.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Reads agent configuration directoriesmediumAgent snooping

.claude/, .codex/, .gemini/ hold keys, settings and other credentials a mod has no legitimate need for.

OLD_FILES=$(find "$HOME/.claude/mnemonic/$ORG" "./.claude/mnemonic" -name "*.memory.md" -mtime +$MAX_AGE 2>/dev/null)
commands/gc.md · 359 lines

How it starts

The opening of the file, as written. The whole thing — 359 lines — stays where its author put it; the contents beside it link to each section on GitHub.

Memory

Search first: /mnemonic:search {relevant_keywords} Capture after: /mnemonic:capture {namespace} "{title}"

Run /mnemonic:list --namespaces to see available namespaces from loaded ontologies.

/mnemonic:gc

Garbage collect expired memories based on TTL and decay, with optional compression.

Arguments

  • --dry-run - Show what would be removed without removing
  • --archive - Move to archive instead of deleting
  • --force - Skip confirmation prompts
  • --min-strength - Minimum strength threshold (default: 0.1)
  • --max-age - Maximum age in days (default: 365)
  • --compress - Compress large old memories before archiving
  • --compress-only - Only compress, don't archive/delete
  • --compress-threshold - Minimum lines for compression (default: 100)

Procedure

Step 1: Parse Arguments

DRY_RUN="${DRY_RUN:-false}"
ARCHIVE="${ARCHIVE:-true}"
FORCE="${FORCE:-false}"
MIN_STRENGTH="${MIN_STRENGTH:-0.1}"
MAX_AGE="${MAX_AGE:-365}"

ORG=$(git remote get-url origin 2>/dev/null | sed -E 's|.*[:/]([^/]+)/[^/]+\.git$|\1|' | sed 's|\.git$||')
[ -z "$ORG" ] && ORG="default"

ARCHIVE_DIR="$HOME/.claude/mnemonic/.archive/$(date +%Y-%m)"

Step 2: Find Candidates

By Age
echo "=== Finding GC Candidates ==="
echo ""

echo "Old memories (> $MAX_AGE days):"
OLD_FILES=$(find "$HOME/.claude/mnemonic/$ORG" "./.claude/mnemonic" -name "*.memory.md" -mtime +$MAX_AGE 2>/dev/null)
OLD_COUNT=$(echo "$OLD_FILES" | grep -c . 2>/dev/null || echo 0)
echo "  Found: $OLD_COUNT"
By TTL Expiry
echo ""
echo "Expired TTL:"
NOW=$(date +%s)
TTL_EXPIRED=""

for f in $(find "$HOME/.claude/mnemonic/$ORG" "./.claude/mnemonic" -name "*.memory.md" 2>/dev/null); do
    TTL=$(grep "^  ttl:" "$f" 2>/dev/null | sed 's/.*ttl: //')
    CREATED=$(grep "^created:" "$f" 2>/dev/null | sed 's/created: //')

    if [ -n "$TTL" ] && [ -n "$CREATED" ]; then
        # Parse TTL (simplified - handles P{N}D format)
        TTL_DAYS=$(echo "$TTL" | sed 's/P\([0-9]*\)D/\1/')
        if [ -n "$TTL_DAYS" ]; then
            # Calculate if expired (simplified check via file mtime)
            FILE_AGE=$(( ( NOW - $(stat -f %m "$f" 2>/dev/null || stat -c %Y "$f" 2>/dev/null) ) / 86400 ))
            if [ "$FILE_AGE" -gt "$TTL_DAYS" ]; then
                TTL_EXPIRED="$TTL_EXPIRED $f"
                echo "  $f (TTL: ${TTL_DAYS}d, Age: ${FILE_AGE}d)"
            fi
        fi
    fi
done

TTL_COUNT=$(echo "$TTL_EXPIRED" | wc -w | tr -d ' ')
echo "  Total: $TTL_COUNT"

Read the full file on GitHub · 359 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. 2d ago First seen · 359 lines · 7 tokens per session scan B b0223f8ba1f2

Subscribe to this mod's changes

gc is a command published in the GitHub repository modeled-information-format/mnemonic (22 stars, last pushed 1mo ago), licensed MIT. It adds 7 tokens to every session and 2,982 once invoked, about $0.0000 per session on Opus 5. A static security scan graded it B with 1 finding (reads agent configuration directories). No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-30.