pi-skill-search 0.1.0

package/skills/semantic-compression/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: semantic-compression
+description: Aggressively remove grammatical scaffolding LLMs reconstruct while preserving meaning-carrying content. Output may be fragments. Use when compressing text for prompts, reducing token count, preparing context for LLM input, or making documentation more token-efficient. Applies LLM-aware compression rules that delete predictable grammar while preserving semantics.
+---
+
+# Semantic Compression
+
+LLMs reconstruct grammar from content words. Remove predictable glue; keep semantic payload. Prefer fragments over sentences.
+
+## Aggressive Stance
+
+- Output can be noun/verb stacks, list fragments, or label:value phrases.
+- Default to deletion; keep function words only when loss changes meaning.
+- Prefer base verb forms; drop tense/aspect unless timeline is critical.
+
+## Deletion Tiers
+
+**Tier 1 — Always delete (even if fragments):**
+- Articles: a, an, the
+- Copulas: is, are, was, were, am, be, been, being
+- Expletive subjects: "There is/are...", "It is..."
+- Complementizer: that (as clause marker)
+- Pure intensifiers: very, quite, rather, really, extremely, somewhat
+- Filler phrases: "in order to" → to, "due to the fact that" → because, "in terms of" → delete
+- Infinitive "to" before verbs (unless it prevents noun/verb confusion)
+- Conjunctions when list/contrast obvious: and, or, but
+
+**Tier 2 — Delete unless meaning changes:**
+- Auxiliary verbs: have/has/had, do/does/did, will/would (keep if tense/aspect matters)
+- Modal verbs: can/could/may/might/should (keep when obligation/permission/possibility is critical; always keep must/must not)
+
+## Always Preserve
+
+- Nouns, main verbs, meaning-bearing adjectives/adverbs
+- Numbers, quantifiers: "at least 5", "approximately", "more than"
+- Uncertainty markers: "appears", "seems", "reportedly", "what sounded like"
+- Negation: not, no, never, without, none
+- Temporal markers: dates, frequencies, durations
+- Causality and conditionals: because, therefore, despite, although, if, unless
+- Requirements/permissions: must, required, prohibited, allowed
+- Proper nouns, titles, technical terms
+- Prepositions encoding relationships: from/to (direction), with/without (inclusion), between/among/within (relation), after/before (temporal), by (agent if passive)
+
+## Structural Compression
+
+- Passive → active when agent known: "was eaten by dog" → "dog ate"
+- Nominalization → verb: "made a decision" → "decided"
+- Drop implied subject when context allows: "System should log errors" → "Log errors"
+- Redundant pairs → single: "each and every" → "every"
+- Clause → modifier: "anomaly that was reported" → "reported anomaly"
+
+## Examples
+
+| Original | Compressed |
+|----------|------------|
+| The system was designed to efficiently process incoming data from multiple sources | System design: efficient process incoming data, multiple sources |
+| There were at least 20 people who appeared to be waiting | At least 20 people apparent waiting |
+| It is important to note that the medication should not be taken without food | Medication: should not take without food |
+| The researcher made a decision to investigate the anomaly that was reported | Researcher decided: investigate reported anomaly |
+
+
+

package/skills/setup/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: setup
+description: Use first for install/update routing — sends setup, doctor, or MCP requests to the correct OMC setup flow
+---
+
+# Setup
+
+Use `setup` as the unified setup/configuration entrypoint.
+
+## Usage
+
+```bash
+setup                # full setup wizard
+setup doctor         # installation diagnostics
+setup mcp            # MCP server configuration
+setup wizard --local # explicit wizard path
+```
+
+## Routing
+
+Process the request by the **first argument only** so install/setup questions land on the right flow immediately:
+
+- No argument, `wizard`, `local`, `global`, or `--force` -> route to `omc-setup` with the same remaining args
+- `doctor` -> route to `omc-doctor` with everything after the `doctor` token
+- `mcp` -> route to `mcp-setup` with everything after the `mcp` token
+
+Examples:
+
+```bash
+setup --local          # => omc-setup --local
+setup doctor --json    # => omc-doctor --json
+setup mcp github       # => mcp-setup github
+```
+
+## Notes
+
+- `omc-setup`, `omc-doctor`, and `mcp-setup` remain valid compatibility entrypoints.
+- Prefer `setup` in new documentation and user guidance.
+
+Task: {{ARGUMENTS}}
+
+

package/skills/shap/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: shap
+description: Model interpretability and explainability using SHAP (SHapley Additive exPlanations). Use this skill when explaining machine learning model predictions, computing feature importance, generating SHAP plots (waterfall, beeswarm, bar, scatter, force, heatmap), debugging models, analyzing model bias or fairness, comparing models, or implementing explainable AI. Works with tree-based models (XGBoost, LightGBM, Random Forest), deep learning (TensorFlow, PyTorch), linear models, and any black-box model.
+---
+
+# SHAP (SHapley Additive exPlanations)
+
+## Overview
+
+SHAP is a unified approach to explain machine learning model outputs using Shapley values from cooperative game theory. This skill provides comprehensive guidance for:
+
+- Computing SHAP values for any model type
+- Creating visualizations to understand feature importance
+- Debugging and validating model behavior
+- Analyzing fairness and bias
+- Implementing explainable AI in production
+
+SHAP works with all model types: tree-based models (XGBoost, LightGBM, CatBoost, Random Forest), deep learning models (TensorFlow, PyTorch, Keras), linear models, and black-box models.
+
+## When to Use This Skill
+
+**Trigger this skill when users ask about**:
+- "Explain which features are most important in my model"
+- "Generate SHAP plots" (waterfall, beeswarm, bar, scatter, force, heatmap, etc.)
+- "Why did my model make this prediction?"
+- "Calculate SHAP values for my model"
+- "Visualize feature importance using SHAP"
+- "Debug my model's behavior" or "validate my model"
+- "Check my model for bias" or "analyze fairness"
+- "Compare feature importance across models"
+- "Implement explainable AI" or "add explanations to my model"
+- "Understand feature interactions"
+- "Create model interpretation dashboard"
+
+## Quick Start Guide
+
+### Step 1: Select the Right Explainer
+
+**Decision Tree**:
+
+1. **Tree-based model?** (XGBoost, LightGBM, CatBoost, Random Forest, Gradient Boosting)
+   - Use `shap.TreeExplainer` (fast, exact)
+
+2. **Deep neural network?** (TensorFlow, PyTorch, Keras, CNNs, RNNs, Transformers)
+   - Use `shap.DeepExplainer` or `shap.GradientExplainer`
+
+3. **Linear model?** (Linear/Logistic Regression, GLMs)
+   - Use `shap.LinearExplainer` (extremely fast)
+
+4. **Any other model?** (SVMs, custom functions, black-box models)
+   - Use `shap.KernelExplainer` (model-agnostic but slower)
+
+### Step 2: Compute SHAP Values
+
+```python
+import shap
+
+# Example with tree-based model (XGBoost)
+import xgboost as xgb
+
+# Train model
+model = xgb.XGBClassifier().fit(X_train, y_train)
+
+# Create explainer
+explainer = shap.TreeExplainer(model)
+
+# Compute SHAP values
+shap_values = explainer(X_test)
+
+# The shap_values object contains:
+# - values: SHAP values (feature attributions)
+# - base_values: Expected model output (baseline)
+# - data: Original feature values
+```
+
+### Step 3: Visualize Results
+
+**For Global Understanding** (entire dataset):
+```python
+# Beeswarm plot - shows feature importance with value distributions
+shap.plots.beeswarm(shap_values, max_display=15)
+
+# Bar plot - clean summary of feature importance
+shap.plots.bar(shap_values)
+```
+
+**For Individual Predictions**:
+```python
+# Waterfall plot - detailed breakdown of single prediction
+shap.plots.waterfall(shap_values[0])
+
+# Force plot - additive force visualization
+shap.plots.force(shap_values[0])
+```
+
+**For Feature Relationships**:
+```python
+# Scatter plot - feature-prediction relationship
+shap.plots.scatter(shap_values[:, "Feature_Name"])
+
+# Colored by another feature to show interactions
+shap.plots.scatter(shap_values[:, "Age"], color=shap_values[:, "Education"])
+```

package/skills/simpy/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: simpy
+description: Process-based discrete-event simulation framework in Python. Use this skill when building simulations of systems with processes, queues, resources, and time-based events such as manufacturing systems, service operations, network traffic, logistics, or any system where entities interact with shared resources over time.
+---
+
+# SimPy - Discrete-Event Simulation
+
+## Overview
+
+SimPy is a process-based discrete-event simulation framework based on standard Python. Use SimPy to model systems where entities (customers, vehicles, packets, etc.) interact with each other and compete for shared resources (servers, machines, bandwidth, etc.) over time.
+
+**Core capabilities:**
+- Process modeling using Python generator functions
+- Shared resource management (servers, containers, stores)
+- Event-driven scheduling and synchronization
+- Real-time simulations synchronized with wall-clock time
+- Comprehensive monitoring and data collection
+
+## When to Use This Skill
+
+Use the SimPy skill when:
+
+1. **Modeling discrete-event systems** - Systems where events occur at irregular intervals
+2. **Resource contention** - Entities compete for limited resources (servers, machines, staff)
+3. **Queue analysis** - Studying waiting lines, service times, and throughput
+4. **Process optimization** - Analyzing manufacturing, logistics, or service processes
+5. **Network simulation** - Packet routing, bandwidth allocation, latency analysis
+6. **Capacity planning** - Determining optimal resource levels for desired performance
+7. **System validation** - Testing system behavior before implementation
+
+**Not suitable for:**
+- Continuous simulations with fixed time steps (consider SciPy ODE solvers)
+- Independent processes without resource sharing
+- Pure mathematical optimization (consider SciPy optimize)
+
+## Quick Start
+
+### Basic Simulation Structure
+
+```python
+import simpy
+
+def process(env, name):
+    """A simple process that waits and prints."""
+    print(f'{name} starting at {env.now}')
+    yield env.timeout(5)
+    print(f'{name} finishing at {env.now}')
+
+# Create environment
+env = simpy.Environment()
+
+# Start processes
+env.process(process(env, 'Process 1'))
+env.process(process(env, 'Process 2'))
+
+# Run simulation
+env.run(until=10)
+```
+
+### Resource Usage Pattern
+
+```python
+import simpy
+
+def customer(env, name, resource):
+    """Customer requests resource, uses it, then releases."""
+    with resource.request() as req:
+        yield req  # Wait for resource
+        print(f'{name} got resource at {env.now}')
+        yield env.timeout(3)  # Use resource
+        print(f'{name} released resource at {env.now}')
+
+env = simpy.Environment()
+server = simpy.Resource(env, capacity=1)
+
+## Core Concepts
+
+### 1. Environment
+
+The simulation environment manages time and schedules events.
+
+```python
+import simpy
+
+# Standard environment (runs as fast as possible)
+env = simpy.Environment(initial_time=0)
+
+# Real-time environment (synchronized with wall-clock)
+import simpy.rt
+env_rt = simpy.rt.RealtimeEnvironment(factor=1.0)
+
+# Run simulation
+env.run(until=100)  # Run until time 100
+env.run()  # Run until no events remain
+```
+
+### 2. Processes
+
+Processes are defined using Python generator functions (functions with `yield` statements).
+
+```python
+def my_process(env, param1, param2):
+    """Process that yields events to pause execution."""
+    print(f'Starting at {env.now}')
+
+    # Wait for time to pass
+    yield env.timeout(5)
+
+    print(f'Resumed at {env.now}')
+
+    # Wait for another event
+
+# Start the process
+env.process(my_process(env, 'value1', 'value2'))
+
+

package/skills/skill/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: skill
+description: Manage local skills - list, add, remove, search, edit, setup wizard
+---
+
+# Skill Management CLI
+
+Meta-skill for managing oh-my-claudecode skills via CLI-like commands.
+
+## Subcommands
+
+### /skill list
+
+Show all available skills organized by scope.
+
+**Behavior:**
+1. Scan bundled built-in skills in the plugin `skills/` directory (read-only)
+2. Scan user skills at `${CLAUDE_CONFIG_DIR:-~/.claude}/skills/omc-learned/`
+3. Scan project skills at `.omc/skills/`
+4. Parse YAML frontmatter for metadata
+5. Display in organized table format:
+
+```
+BUILT-IN SKILLS (bundled with oh-my-claudecode):
+| Name              | Description                    | Scope    |
+|-------------------|--------------------------------|----------|
+
+### /skill add [name]
+
+Interactive wizard for creating a new skill.
+
+**Behavior:**
+1. **Ask for skill name** (if not provided in command)
+   - Validate: lowercase, hyphens only, no spaces
+2. **Ask for description**
+   - Clear, concise one-liner
+3. **Ask for triggers** (comma-separated keywords)
+   - Example: "error, fix, debug"
+4. **Ask for argument hint** (optional)
+   - Example: "<file> [options]"
+5. **Ask for scope:**
+   - `user` → `${CLAUDE_CONFIG_DIR:-~/.claude}/skills/omc-learned//SKILL.md`
+
+#  Skill
+
+## Purpose
+
+[Describe what this skill does]
+
+## When to Activate
+
+[Describe triggers and conditions]
+
+## Workflow
+
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+## Examples
+
+```
+/oh-my-claudecode: example-arg
+```
+
+## Notes
+
+[Additional context, edge cases, gotchas]
+```
+
+7. **Report success** with file path
+8. **Suggest:** "Edit `/skill edit ` to customize content"
+
+**Example:**
+```
+User: /skill add custom-logger
+Assistant: Creating new skill 'custom-logger'...
+
+Description: Enhanced logging with structured output
+Triggers (comma-separated): log, logger, logging
+
+### /skill remove 
+
+Remove a skill by name.
+
+**Behavior:**
+1. **Search for skill** in both scopes:
+   - `${CLAUDE_CONFIG_DIR:-~/.claude}/skills/omc-learned//SKILL.md`
+   - `.omc/skills//SKILL.md`
+2. **If found:**
+   - Display skill info (name, description, scope)
+   - **Ask for confirmation:** "Delete '' skill from <scope>? (yes/no)"
+3. **If confirmed:**
+   - Delete entire skill directory (e.g., `${CLAUDE_CONFIG_DIR:-~/.claude}/skills/omc-learned//`)
+   - Report: "✓ Removed skill '' from <scope>"
+4. **If not found:**
+
+### /skill edit 
+
+Edit an existing skill interactively.
+
+**Behavior:**
+1. **Find skill** by name (search both scopes)
+2. **Read current content** via Read tool
+3. **Display current values:**
+   ```
+   Current skill 'custom-logger':
+   - Description: Enhanced logging with structured output
+   - Triggers: log, logger, logging
+   - Argument hint: <level> [message]
+   - Scope: user
+
+### /skill search <query>
+
+Search skills by content, triggers, name, or description.
+
+

package/skills/skill-search/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: skill-search
+description: On-demand skill discovery tool. Use when you need to find relevant skills for a task instead of scanning all available skills manually. Replaces full skill injection with search-by-keyword.
+---
+# skill-search
+
+Use this skill when you need to **find** the right skill for a task from a large collection.
+
+## When to use
+
+- You see `## Available Skill Domains` in your system prompt — this means `pi-skill-search` is active and skills are indexed.
+- You need a skill for a specific task but don't know its exact name.
+- A user mentions a domain (chemistry, ML, plotting, databases…) and you want matching skills.
+- You're about to work on a task that could benefit from specialized instructions.
+
+## How to use
+
+### 1. Search for skills
+
+Call the `skill-search` tool with a keyword query:
+
+```
+skill-search({ query: "molecular docking", limit: 5 })
+```
+
+- `query` (required): 1–500 characters. Use **domain keywords**, tool names, or task descriptions.
+- `limit` (optional): 1–20 results, default 5.
+
+### 2. Read the full skill
+
+Search results return `name`, `description`, and `path`. **Always** use the `read` tool to load the full SKILL.md from the returned path before following its instructions:
+
+```
+read({ path: "/path/to/skill/SKILL.md" })
+```
+
+When a skill file references relative paths, resolve them against the skill's parent directory.
+
+### 3. Follow the skill's instructions
+
+After loading SKILL.md, follow its guidance for the current task. Each skill contains domain-specific rules, anti-patterns, and code conventions.
+
+## Query tips
+
+| Strategy | Example query | When |
+|---|---|---|
+| Domain keyword | `"plotting"`, `"database"`, `"genomics"` | Broad exploration |
+| Tool/library name | `"rdkit"`, `"scanpy"`, `"spark"` | You know the tool |
+| Task description | `"train machine learning model"` | Describe what you want |
+| Category hint | `"chemistry"`, `"visualization"` | Browse a domain |
+
+The search engine applies **synonym expansion** automatically (e.g., "ml" → "machine learning", "plot" → "plotting visualization chart graph"). You don't need to guess exact keywords.
+
+## How it works
+
+1. **At session start**, the extension strips the full `<available_skills>` block and replaces it with a compact category summary (~250 tokens instead of ~23,500 for 137 skills).
+2. **On search**, it scores skills using tokenized query matching against name, description, and category keywords.
+3. **Results** include name, description, score, and file path.
+
+## Anti-patterns
+
+- **Don't** call `skill-search` on every turn "just in case" — call it when you actually need a skill for the current task.
+- **Don't** skip reading the SKILL.md — the search result description is a summary, not the full instructions.
+- **Don't** assume the category summary lists every skill — it shows domain names and a few examples. Search for specifics.
+- **Don't** use overly specific queries like exact error messages — use domain keywords instead.
+
+

package/skills/skillify/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: skillify
+description: Turn a repeatable workflow from the current session into a reusable OMC skill draft
+---
+
+# Skillify
+
+Use this skill when the current session uncovered a repeatable workflow that should become a reusable OMC skill.
+
+> Compatibility: `learner` is a deprecated alias for this skill. Prefer `skillify` in docs, prompts, and new workflows. Internal implementation modules may still use the learner name.
+
+## Goal
+Capture a successful multi-step workflow as a concrete skill draft instead of rediscovering it later.
+
+## Quality Gate
+Before extracting a skill, all three should be true:
+- "Could someone Google this in 5 minutes?" → No.
+- "Is this specific to this codebase, project, or workflow?" → Yes.
+- "Did this take real debugging, design, or operational effort to discover?" → Yes.
+
+Prefer skills that encode decision-making heuristics, constraints, pitfalls, and verification steps. Avoid generic snippets, boilerplate, or library usage examples that belong in normal documentation.
+
+## Workflow
+1. Identify the repeatable task the session accomplished.
+2. Extract:
+   - inputs
+   - ordered steps
+   - success criteria
+   - constraints / pitfalls
+   - verification evidence
+   - best target location for the skill
+3. Decide whether the workflow belongs as:
+   - a repo built-in skill
+   - a user/project learned skill
+   - documentation only
+4. When drafting a learned skill file, output a complete skill file that starts with YAML frontmatter.
+   - Never emit plain markdown-only skill files.
+
+## Rules
+- Only capture workflows that are actually repeatable.
+- Keep the skill practical and scoped.
+- Prefer explicit success criteria over vague prose.
+- If the workflow still has unresolved branching decisions, note them before drafting.
+- Keep `omc-learned` as the storage directory name for compatibility; do not present it as the public invocation name.
+
+

package/skills/smart-explore/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: smart-explore
+description: Token-optimized structural code search using tree-sitter AST parsing. Use instead of reading full files when you need to understand code structure, find functions, or explore a codebase efficiently.
+---
+
+# Smart Explore
+
+Structural code exploration using AST parsing. **This skill overrides your default exploration behavior.** While this skill is active, use smart_search/smart_outline/smart_unfold as your primary tools instead of Read, Grep, and Glob.
+
+**Core principle:** Index first, fetch on demand. Give yourself a map of the code before loading implementation details. The question before every file read should be: "do I need to see all of this, or can I get a structural overview first?" The answer is almost always: get the map.
+
+## Your Next Tool Call
+
+This skill only loads instructions. You must call the MCP tools yourself. Your next action should be one of:
+
+```
+smart_search(query="<topic>", path="./src")    -- discover files + symbols across a directory
+smart_outline(file_path="<file>")              -- structural skeleton of one file
+smart_unfold(file_path="<file>", symbol_name="")  -- full source of one symbol
+```
+
+Do NOT run Grep, Glob, Read, or find to discover files first. `smart_search` walks directories, parses all code files, and returns ranked symbols in one call. It replaces the Glob → Grep → Read discovery cycle.
+
+## 3-Layer Workflow
+
+### Step 1: Search -- Discover Files and Symbols
+
+```
+smart_search(query="shutdown", path="./src", max_results=15)
+```
+
+**Returns:** Ranked symbols with signatures, line numbers, match reasons, plus folded file views (~2-6k tokens)
+
+```
+-- Matching Symbols --
+  function performGracefulShutdown (services/infrastructure/GracefulShutdown.ts:56)
+  function httpShutdown (services/infrastructure/HealthMonitor.ts:92)
+  method WorkerService.shutdown (services/worker-service.ts:846)
+
+-- Folded File Views --
+
+### Step 2: Outline -- Get File Structure
+
+```
+smart_outline(file_path="services/worker-service.ts")
+```
+
+**Returns:** Complete structural skeleton -- all functions, classes, methods, properties, imports (~1-2k tokens per file)
+
+**Skip this step** when Step 1's folded file views already provide enough structure. Most useful for files not covered by the search results.
+
+**Parameters:**
+
+- `file_path` (string, required) -- Path to the file
+
+### Step 3: Unfold -- See Implementation
+
+Review symbols from Steps 1-2. Pick the ones you need. Unfold only those:
+
+```
+smart_unfold(file_path="services/worker-service.ts", symbol_name="shutdown")
+```
+
+**Returns:** Full source code of the specified symbol including JSDoc, decorators, and complete implementation (~400-2,100 tokens depending on symbol size). AST node boundaries guarantee completeness regardless of symbol size — unlike Read + agent summarization, which may truncate long methods.
+
+**Parameters:**
+
+- `file_path` (string, required) -- Path to the file (as returned by search/outline)
+- `symbol_name` (string, required) -- Name of the function/class/method to expand
+
+## When to Use Standard Tools Instead
+
+Use these only when smart_* tools are the wrong fit:
+
+- **Grep:** Exact string/regex search ("find all TODO comments", "where is `ensureWorkerStarted` defined?")
+- **Read:** Small files under ~100 lines, non-code files (JSON, markdown, config)
+- **Glob:** File path patterns ("find all test files")
+- **Explore agent:** When you need synthesized understanding across 6+ files, architecture narratives, or answers to open-ended questions like "how does this entire system work end-to-end?" Smart-explore is a scalpel — it answers "where is this?" and "show me that." It doesn't synthesize cross-file data flows, design decisions, or edge cases across an entire feature.
+
+For code files over ~100 lines, prefer smart_outline + smart_unfold over Read.
+
+## Workflow Examples
+
+**Discover how a feature works (cross-cutting):**
+
+```
+1. smart_search(query="shutdown", path="./src")
+   -> 14 symbols across 7 files, full picture in one call
+2. smart_unfold(file_path="services/infrastructure/GracefulShutdown.ts", symbol_name="performGracefulShutdown")
+   -> See the core implementation
+```
+
+**Navigate a large file:**
+```

package/skills/sqlite-pandas/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: sqlite-pandas
+description: Relational database querying and tabular data manipulation. Use when reading/writing SQLite databases with pandas, performing SQL joins, aggregations, window functions, or converting between DataFrames and SQL tables. Trigger on imports of sqlite3, pandas.read_sql, or mentions of database query, SQL, table join, data aggregation.
+---
+# sqlite-pandas
+
+Use this skill for database operations with pandas DataFrames.
+
+## Core patterns
+
+- **Connect**: `conn = sqlite3.connect('data.db')`.
+- **Read**: `pd.read_sql_query("SELECT * FROM table WHERE col > ?", conn, params=[val])`.
+- **Write**: `df.to_sql('table', conn, if_exists='append', index=False)`.
+- **Join**: SQL `JOIN` for multi-table queries; `pd.merge()` for in-memory joins.
+- **Aggregation**: SQL `GROUP BY` + `HAVING` for server-side; `df.groupby().agg()` for client-side.
+
+## Rules
+
+- Always use parameterized queries (`?` placeholders) — never f-string SQL.
+- Close connections: use `with sqlite3.connect() as conn:` or `conn.close()`.
+- For large tables, use `chunksize` parameter in `pd.read_sql_query()`.
+- Index columns used in WHERE/JOIN: `CREATE INDEX idx_col ON table(col)`.
+
+## Anti-patterns
+
+- Don't load entire database into memory — filter in SQL first.
+- Don't use `pd.read_sql_query()` without `params` for user input — SQL injection risk.
+- Don't mix datetime formats — SQLite stores dates as text; parse with `parse_dates` parameter.
+
+