linxule/memex-plugin/recall

Recall: Retrieving Session Memory

Context

Project: !basename $(git remote get-url origin 2>/dev/null | sed 's/\.git$//' | xargs basename 2>/dev/null) 2>/dev/null || basename $(pwd) Vault: !sqlite3 "$(memex path --index 2>/dev/null)" "SELECT (SELECT COUNT(*) FROM fts_content) || ' documents indexed'" 2>/dev/null || echo "(index unavailable)"

Step 0: Classify the Query

Before doing anything, classify the user's question into one of four modes:

TEMPORAL — date-based browsing

Triggers: "yesterday", "last week", "today", "what did I do on Monday", "show me recent work", "last 3 days", "this week's sessions", any date reference without topic keywords.

Action: Go to → Temporal Recall

KEYWORD — topic/decision lookup

Triggers: "why did we...", "find the memo about...", "what was the decision on...", "remind me about the retry pattern", any question with specific technical terms or project names.

Action: Go to → Keyword Recall

DEEP — cross-project synthesis

Triggers: "what patterns do we use across...", "how has our approach to X evolved...", "compare how we handle X in different projects", questions spanning multiple sessions or projects, complex why/how questions needing synthesis.

Action: Go to → Deep Recall

LOAD — direct file retrieval

Triggers: "load the X topic", "pull up project Y", "show me the memo about Z", explicit topic or memo names, "what does the X topic say".

Action: Go to → Load Recall

If mixed (date + topic, e.g., "what auth work did I do last week"): Start with TEMPORAL to narrow the date range, then scan the results for the topic.

Temporal Recall

Run the temporal scanner to browse sessions and memos by date:

memex timeline "<date-expression>"

With project filter:

memex timeline "<date-expression>" --project=<name>

Filter by type:

memex timeline "<date-expression>" --type=memo

Supported date expressions

yesterday, today, 3 days ago, last 5 days, this week, last week, last monday, 7d, 2w, march 15, 2026-03-15

After getting results

1. Present the timeline clearly — group by project if multiple projects
2. If the user wants details on a specific session, read the full memo or transcript
3. Go to → One Thing Synthesis

Keyword Recall

Step 1: Generate 2-3 query variants

Before searching, proactively generate keyword variants to compensate for FTS's literal matching. This is not optional — always expand.

Process:

1. Extract exact technical terms from the question
2. Generate synonyms and alternative phrasings
3. Add related concepts that might appear in memos about this topic

Example expansions:

Step 2: Run searches in parallel

Run all variants simultaneously:

memex search "JWT OR authentication"
memex search "OAuth OR token OR auth"

Search reference

Modes:

• Hybrid (default): Best for most queries — combines keyword + semantic
• FTS (`--mode=fts`): Fastest. Best for exact terms, names, acronyms, error codes
• Vector (`--mode=vector`): Best for conceptual questions when exact wording is unknown

Filters:

memex search "query" --type=memo          # Filter by type
memex search "query" --project=myapp      # Filter by project
memex search "query" --limit=5            # Limit results
memex search "query" --scope=observations # Search extracted learnings/decisions
memex search "query" --since=7d           # Recent only
memex search "query" --before="last week" # Before cutoff
memex search "query" --between "2026-03-01" "2026-03-15"  # Date range

Query syntax: term1 OR term2 (either), "exact phrase" (literal), term1 term2 (both/AND)

Step 3: Merge and deduplicate

If the same document appears in multiple searches, keep the highest-scoring instance. Present the top 5-8 unique results.

Step 4: Check for trails

If the question is about how thinking on a topic evolved, check whether a trail exists:

grep -rl '^type: trail' $(memex path 2>/dev/null)/topics/ 2>/dev/null | xargs -I{} basename {} .md

If a relevant trail exists, read it directly — it captures the narrative arc better than memo search results. Present its phase structure as the answer.

Step 5: Present results

1. Summarize relevance — explain how results relate to the question
2. Quote key snippets — pull the most relevant sentences
3. Acknowledge gaps — if results don't fully answer, say so
4. Offer to read more — if a memo looks promising, offer to read the full content

If searches return nothing

1. Try broader terms: "JWT" → "auth OR token OR JWT"
2. Try vector mode for conceptual matching: --mode=vector
3. Remove project filter if you added one
4. Try temporal scan to find sessions from the right time period
5. Check spelling of technical terms

Go to → One Thing Synthesis

Deep Recall

For complex questions that require synthesizing across many sessions or projects.

Step 1: Check for compiled knowledge first

Before searching, check if a relevant topic already exists. Compiled topics are higher quality than search-assembled answers.

CONCEPT="trust-calibration"  # set to the main subject of the question
ls "$(memex path)/topics/" | grep -i "$CONCEPT" 2>/dev/null

If ls finds nothing, try a type-filtered search:

memex search "$CONCEPT" --type=concept --limit=3 2>/dev/null

If a matching topic exists, use it as a prior — not a gate:

1. Read it — check the frontmatter for updated: or last_extended: date
2. If fresh (updated within 60 days), non-stub (50+ lines), and covers the question → use the topic as the primary answer, supplemented by search only if gaps remain. If older than 30 days, mention: "Based on [[topic]] (last updated DATE). This may not reflect the most recent work."
3. Always fall through to search when: the topic is a stub (< 50 lines), freshness metadata is missing, multiple topics partially match, or the question spans concepts beyond what one topic covers.

Step 2: Deep retrieval via search

memex ask "<question>"

For thorough (semantic + keyword) retrieval:

memex ask "<question>" --depth=thorough

Also run an observation-specific search to surface atomic claims:

memex search "<keywords>" --scope=observations --limit=10

Observations are structured claims extracted from memos — they provide precision that document-level search misses.

Step 3: Synthesize and offer to save

After receiving results:

1. Read the content field of each result directly.
2. Check observations for atomic facts that answer the question.
3. Synthesize across results for agreements, contradictions, and evolution over time.
4. Cite source memo paths when making claims.
5. Note anything missing from query_info.gaps.
6. Offer to save valuable syntheses. If the synthesis spans 3+ projects or 5+ memos and produces a cross-cutting insight, offer: "This synthesis touches N projects — save as a trail or topic note?" Save trails to topics/trail-<concept>.md with type: trail. Save encyclopedic syntheses to topics/<concept>.md with type: concept.
7. Flag stale topics. If you used a topic but found it outdated by search results, note: "The [[topic]] page may need refreshing — recent memos contain newer information."

Go to → One Thing Synthesis

Load Recall

Direct retrieval of a specific topic, memo, or project context.

Step 1: Parse the argument

Determine what to load:

• Topic name → look in topics/<name>.md
• Project name → look in projects/<project>/_project.md + recent memos
• Memo reference → search projects/*/memos/ for matching filename

Step 2: Find and read

VAULT=$(memex path)
 
# For topics (fuzzy match)
ls "$VAULT/topics/" | grep -i "<query>" 2>/dev/null
 
# For projects
ls "$VAULT/projects/" | grep -i "<query>" 2>/dev/null
 
# For memos (search by filename)
find "$VAULT/projects" -path "*/memos/*" -name "*<query>*" 2>/dev/null | head -5

Read the matched file(s) with the Read tool.

Step 3: Present loaded content

1. Show the full content for single files
2. For projects: show _project.md overview + list of recent memos
3. Mention related backlinks if visible in the content
4. Offer to load related items

Go to → One Thing Synthesis

One Thing Synthesis

Every recall ends with ONE specific next action. Not "what would you like to do?" — a concrete recommendation.

After presenting results (any mode), synthesize the single highest-leverage next step based on:

1. Momentum — What's almost done? What was actively being worked on?

→ "Continue the auth middleware rewrite in alcor — the token refresh handler is the last piece"

1. Blockers — What's stuck or waiting on a decision?

→ "The rate limiter is blocked on the Redis config decision from last week — resolve that first"

1. Recency — What was just active and could benefit from a follow-up?

→ "You were working on the MCP server yesterday — pick up where you left off with tool registration"

Rules:

• Be specific: include the project name and concrete task
• Reference the evidence: "Based on the memo from March 15..."
• If nothing actionable emerges, say so honestly: "These sessions are complete — no open threads"
• If multiple threads are open, pick the one with the most momentum

When NOT to Search

1. Answer is already in context — current conversation already contains the information
2. Question is general knowledge — "What is a closure?" (not project-specific)
3. Question is purely future-oriented with no past context — "What's the best way to do X?"
4. User explicitly asks for fresh perspective — "Without looking at past decisions..."
5. Already searched this session — avoid redundant searches for the same topic