/forgetful-context-gather
Gather deep context before planning or implementing — one pass that turns a task description into a cited context pack: relevant decisions, patterns, constraints, code pointers, procedures, and explicit gaps. Runs recall from several angles, explores the graph around the
$ npx -y skills add ScottRBK/forgetful --skill forgetful-context-gather --agent claude-codeHow it fires
How this skill gets triggered: by you, by Claude, or both.
- Fires itselfAuto-invocation. Claude auto-loads it when your prompt matches the work.Auto-invocation is when the right skill fires by itself at the right moment, driven by a FLOW.md router and a hook, instead of you invoking it by name. It is the difference between a skill being installed and a skill actually getting used.Read the full definition →
- You can call itInvoke it directly when you want it.
- Slash command
/forgetful-context-gather
Context preview
The summary Claude sees to decide when to auto-load this skill.
Gather deep context before planning or implementing — one pass that turns a task description into a cited context pack: relevant decisions, patterns, constraints, code pointers, procedures, and explicit gaps. Runs recall from several angles, explores the graph around the
SKILL.md
forgetful-context-gather.SKILL.mdname: forgetful-context-gather
description: >-
Gather deep context before planning or implementing — one pass that turns a task
description into a cited context pack: relevant decisions, patterns, constraints, code
pointers, procedures, and explicit gaps. Runs recall from several angles, explores the
graph around the strongest hits, and opens the linked material.
license: MIT
disable-model-invocation: true
tags: [context, retrieval, workflow, pre-work]
allowed-tools:
- mcp__forgetful__discover_forgetful_tools
- mcp__forgetful__how_to_use_forgetful_tool
- mcp__forgetful__execute_forgetful_tool
- Bash(forgetful:*)
Gathering context before work
A single query answers a question; a context gather prepares a task. The output is a pack the work can lean on, with every claim cited by memory ID and every dry angle stated — silence is never ambiguous.
Invoking operations
Operations are named by registry name (`query_memory`, `get_document`, ...). Invoke via whichever surface this agent has:
- **MCP**: `execute_forgetful_tool(tool_name="query_memory", arguments={...})`
- **CLI**: `forgetful call query_memory --args '{"query": "..."}' --json`
Get any operation's schema at runtime: `how_to_use_forgetful_tool` (MCP) or `forgetful tools info <operation>` (CLI) — schemas are deliberately not repeated here.
Delegating this workflow to a subagent: hand it the CLI flavor — `Bash` travels into subagents, MCP tool access does not. Run MCP-flavored gathers in the main conversation.
Step 1 — Derive the query angles
From the task description, write 3–5 distinct angles: the feature area, the technology or library, exact error text or identifiers, the architectural layer, adjacent domains that share patterns. One angle is a spot-check; several are coverage.
Done when: the angles are listed before any query runs.
Step 2 — Recall per angle
`query_memory` per angle — `query` and `query_context` are both required, and `query_context` should carry the task's intent (per `forgetful-recall`: reads cross-project by default, identifiers verbatim, `truncated` handled). Skills referenced by name in this skill resolve via `search_skills` → `export_skill` when not already available. Track which angles hit and which came up dry.
Done when: every angle has run and its outcome is recorded.
Step 3 — Explore around the strongest hits
Where hits reference entities or cluster into a topic, walk the graph (per `forgetful-explore`, medium depth): expand the memories, discover the entities, harvest what is attached to them.
Done when: the strongest hits have their neighbourhood mapped, not just their own text.
Step 4 — Open the linked material
Hits point outward — follow the pointers: `get_document` for linked documents, `get_code_artifact` for reusable code, `search_skills` + `get_skill` for procedures that already do the task, `get_skill_links` for what those procedures bundle.
Done when: load-bearing linked material is read, not just listed.
Step 5 — Sweep for unlinked material
Link-following only surfaces what a hit already points to — a document or code artifact that no surfaced memory links to stays invisible to that flow. Close the gap: `list_documents` and `list_code_artifacts`, scoped with `project_id` when the task is project-bound, then scan titles for relevance. `search_skills` already searches skills directly, so no separate sweep is needed there.
Done when: documents and code artifacts have been swept by title, not just reached by link.
Step 6 — Synthesize the pack
Assemble, in order of usefulness to the task:
- **Decisions** that constrain the work (cited by memory ID)
- **Patterns and preferences** that shape how it should be done
- **Constraints** — things ruled out, with the reason
- **Code pointers** — artifacts and source references worth opening
- **Procedures** — stored skills that cover part of the task
- **Gaps** — every angle that came up dry, stated as "no existing knowledge about X"
Done when: the pack cites its sources, states its gaps, and the task could start from it without re-querying.
Read more
name: forgetful-context-gather description: >- Gather deep context before planning or implementing — one pass that turns a task description into a cited context pack: relevant decisions, patterns, constraints, code pointers, procedures, and explicit gaps. Runs recall from several angles, explores the graph around the strongest hits, and opens the linked material. license: MIT disable-model-invocation: true tags: [context, retrieval, workflow, pre-work] allowed-tools: - mcp__forgetful__discover_forgetful_tools - mcp__forgetful__how_to_use_forgetful_tool - mcp__forgetful__execute_forgetful_tool - Bash(forgetful:*)
Gathering context before work
A single query answers a question; a context gather prepares a task. The output is a pack the work can lean on, with every claim cited by memory ID and every dry angle stated — silence is never ambiguous.
Invoking operations
Operations are named by registry name (`query_memory`, `get_document`, ...). Invoke via whichever surface this agent has:
- **MCP**: `execute_forgetful_tool(tool_name="query_memory", arguments={...})`
- **CLI**: `forgetful call query_memory --args '{"query": "..."}' --json`
Get any operation's schema at runtime: `how_to_use_forgetful_tool` (MCP) or `forgetful tools info <operation>` (CLI) — schemas are deliberately not repeated here.
Delegating this workflow to a subagent: hand it the CLI flavor — `Bash` travels into subagents, MCP tool access does not. Run MCP-flavored gathers in the main conversation.
Step 1 — Derive the query angles
From the task description, write 3–5 distinct angles: the feature area, the technology or library, exact error text or identifiers, the architectural layer, adjacent domains that share patterns. One angle is a spot-check; several are coverage.
Done when: the angles are listed before any query runs.
Step 2 — Recall per angle
`query_memory` per angle — `query` and `query_context` are both required, and `query_context` should carry the task's intent (per `forgetful-recall`: reads cross-project by default, identifiers verbatim, `truncated` handled). Skills referenced by name in this skill resolve via `search_skills` → `export_skill` when not already available. Track which angles hit and which came up dry.
Done when: every angle has run and its outcome is recorded.
Step 3 — Explore around the strongest hits
Where hits reference entities or cluster into a topic, walk the graph (per `forgetful-explore`, medium depth): expand the memories, discover the entities, harvest what is attached to them.
Done when: the strongest hits have their neighbourhood mapped, not just their own text.
Step 4 — Open the linked material
Hits point outward — follow the pointers: `get_document` for linked documents, `get_code_artifact` for reusable code, `search_skills` + `get_skill` for procedures that already do the task, `get_skill_links` for what those procedures bundle.
Done when: load-bearing linked material is read, not just listed.
Step 5 — Sweep for unlinked material
Link-following only surfaces what a hit already points to — a document or code artifact that no surfaced memory links to stays invisible to that flow. Close the gap: `list_documents` and `list_code_artifacts`, scoped with `project_id` when the task is project-bound, then scan titles for relevance. `search_skills` already searches skills directly, so no separate sweep is needed there.
Done when: documents and code artifacts have been swept by title, not just reached by link.
Step 6 — Synthesize the pack
Assemble, in order of usefulness to the task:
- **Decisions** that constrain the work (cited by memory ID)
- **Patterns and preferences** that shape how it should be done
- **Constraints** — things ruled out, with the reason
- **Code pointers** — artifacts and source references worth opening
- **Procedures** — stored skills that cover part of the task
- **Gaps** — every angle that came up dry, stated as "no existing knowledge about X"
Done when: the pack cites its sources, states its gaps, and the task could start from it without re-querying.
Forgetful is a storage and retrieval tool for AI Agents. Designed as a Model Context Protocol (MCP) server built using the FastMCP framework.
Repo: ScottRBK/forgetful
Other skills on forgetful.
- /forgetful-cli-setup
Set up the Forgetful CLI and connect from a terminal — install, local or remote mode, auth, and verification. Use when connecting a human or headless agent via shell, wiring CI with token auth, or operating a local server (serve, database selection, feature flags, re-embedding).
Open skill - /forgetful-encode-repo
Encode a repository into the Forgetful knowledge base — bootstrap the project, its entities, memories, and documents from the codebase itself. Use when bringing a new repo under Forgetful or refreshing a stale encoding. Re-encoding is an update pass: query-before-create makes it
Open skill - /forgetful-entities
Model the things knowledge attaches to — people, organisations, devices, products, system components. Use when a new thing surfaces that memories will reference, when relationships between things need recording (owns, depends on, part of), or when another skill routes a
Open skill - /forgetful-explore
Explore the Forgetful knowledge graph when flat search isn't enough — cross-project investigations, "what do we know about X", entity-centred questions, tracing how decisions connect. Use when recall returns fragments that reference entities or trail across domains. Walks
Open skill - /forgetful-files
File binary content into the knowledge base — screenshots, PDFs, diagrams, fonts, assets. Use when a binary artifact is worth keeping alongside knowledge, or when a stored procedure needs a bundled asset. The description is the entire search surface: say what the file shows and
Open skill - /forgetful-mcp-setup
Set up an MCP client for Forgetful — wire Claude Code, Cursor, Copilot, Codex, Gemini, or OpenCode to the server and verify the connection behaves. Covers stdio vs HTTP transport, auth and scopes, the three meta-tools every client sees, and delegation to subagents.
Open skill