fpf:query
Search the FPF knowledge base and display hypothesis details with assurance information
Best use case
fpf:query is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Search the FPF knowledge base and display hypothesis details with assurance information
Teams using fpf:query should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/query/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How fpf:query Compares
| Feature / Agent | fpf:query | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Search the FPF knowledge base and display hypothesis details with assurance information
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Query Knowledge Search the FPF knowledge base and display hypothesis details with assurance information. ## Action (Run-Time) 1. **Search** `.fpf/knowledge/` and `.fpf/decisions/` by user query. 2. **For each found hypothesis**, display: - Basic info: title, layer (L0/L1/L2), kind, scope - If layer >= L1: read audit section for R_eff - If has dependencies: show dependency graph - Evidence summary if exists 3. **Present results** in table format. ## Search Locations | Location | Contents | |----------|----------| | `.fpf/knowledge/L0/` | Proposed hypotheses | | `.fpf/knowledge/L1/` | Verified hypotheses | | `.fpf/knowledge/L2/` | Validated hypotheses | | `.fpf/knowledge/invalid/` | Rejected hypotheses | | `.fpf/decisions/` | Design Rationale Records | | `.fpf/evidence/` | Evidence and audit files | ## Output Format ```markdown ## Search Results for "<query>" ### Hypotheses Found | Hypothesis | Layer | Kind | R_eff | |------------|-------|------|-------| | redis-caching | L2 | system | 0.85 | | cdn-edge | L2 | system | 0.72 | ### redis-caching (L2) **Title**: Use Redis for Caching **Kind**: system **Scope**: High-load systems, Linux only **R_eff**: 0.85 **Weakest Link**: internal test (0.85) **Dependencies**: ``` [redis-caching R:0.85] └── (no dependencies) ``` **Evidence**: - ev-benchmark-redis-caching-2025-01-15 (internal, PASS) ### cdn-edge (L2) **Title**: Use CDN Edge Cache **Kind**: system **Scope**: Static content delivery **R_eff**: 0.72 **Weakest Link**: external docs (CL1 penalty) **Evidence**: - ev-research-cdn-2025-01-10 (external, PASS) ``` ## Search Methods ### By Keyword Search file contents for matching text: ``` /fpf:query caching -> Finds all hypotheses with "caching" in title or content ``` ### By Specific ID Look up a specific hypothesis: ``` /fpf:query redis-caching -> Shows full details for redis-caching -> Displays dependency tree -> Shows R_eff breakdown ``` ### By Layer Filter by knowledge layer: ``` /fpf:query L2 -> Lists all L2 hypotheses with R_eff scores ``` ### By Decision Search decision records: ``` /fpf:query DRR -> Lists all Design Rationale Records -> Shows what each DRR selected/rejected ``` ## R_eff Display For L1+ hypotheses, read the audit section and display: ```markdown **R_eff Breakdown**: - Self Score: 1.00 - Weakest Link: ev-research-redis (0.90) - Dependency Penalty: none - **Final R_eff**: 0.85 ``` ## Dependency Tree Display If hypothesis has `depends_on`, show the tree: ``` [api-gateway R:0.80] └──(CL:3)── [auth-module R:0.85] └──(CL:2)── [rate-limiter R:0.90] ``` Legend: - `R:X.XX` = R_eff score - `CL:N` = Congruence Level (1-3) ## Examples **Search by keyword:** ``` User: /fpf:query caching Results: | Hypothesis | Layer | R_eff | |------------|-------|-------| | redis-caching | L2 | 0.85 | | cdn-edge-cache | L2 | 0.72 | | lru-cache | invalid | N/A | ``` **Query specific hypothesis:** ``` User: /fpf:query redis-caching # redis-caching (L2) Title: Use Redis for Caching Kind: system Scope: High-load systems R_eff: 0.85 Evidence: 2 files ``` **Query decisions:** ``` User: /fpf:query DRR # Design Rationale Records | DRR | Date | Winner | Rejected | |-----|------|--------|----------| | DRR-2025-01-15-caching | 2025-01-15 | redis-caching | cdn-edge | ```
Related Skills
tech-stack:add-typescript-best-practices
Setup TypeScript best practices and code style rules in CLAUDE.md
tdd:write-tests
Systematically add test coverage for all local code changes using specialized review and development agents. Add tests for uncommitted changes (including untracked files), or if everything is commited, then will cover latest commit.
tdd:test-driven-development
Use when implementing any feature or bugfix, before writing implementation code - write the test first, watch it fail, write minimal code to pass; ensures tests actually verify behavior by requiring failure first
tdd:fix-tests
Systematically fix all failing tests after business logic changes or refactoring
sdd:plan
Refine, parallelize, and verify a draft task specification into a fully planned implementation-ready task
sdd:implement
Implement a task with automated LLM-as-Judge verification for critical steps
sdd:create-ideas
Generate ideas in one shot using creative sampling
sdd:brainstorm
Use when creating or developing, before writing code or implementation plans - refines rough ideas into fully-formed designs through collaborative questioning, alternative exploration, and incremental validation. Don't use during clear 'mechanical' processes
sdd:add-task
creates draft task file in .specs/tasks/draft/ with original user intent
sadd:tree-of-thoughts
Execute tasks through systematic exploration, pruning, and expansion using Tree of Thoughts methodology with meta-judge evaluation specifications and multi-agent evaluation
sadd:subagent-driven-development
Use when executing implementation plans with independent tasks in the current session or facing 3+ independent issues that can be investigated without shared state or dependencies - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates
sadd:multi-agent-patterns
Design multi-agent architectures for complex tasks. Use when single-agent context limits are exceeded, when tasks decompose naturally into subtasks, or when specializing agents improves quality.