memory-journal-mcp 7.1.0 → 7.3.0

package/skills/gitlab/scripts/gitlab-client.ts

@@ -0,0 +1,125 @@
+import { Gitlab } from '@gitbeaker/rest'
+import * as dotenv from 'dotenv'
+import { join } from 'path'
+import * as fs from 'fs'
+
+// Try loading from .claude/.env as per specific requirements, fallback to regular .env
+const homeDir = process.env.USERPROFILE || process.env.HOME || ''
+const claudeEnvPath = join(homeDir, '.claude', '.env')
+
+if (fs.existsSync(claudeEnvPath)) {
+    dotenv.config({ path: claudeEnvPath })
+} else {
+    dotenv.config()
+}
+
+/**
+ * Core GitLab Client wrapping the @gitbeaker/rest API.
+ */
+export class GitLabClient {
+    public api: InstanceType<typeof Gitlab>
+
+    constructor() {
+        const token = process.env.GITLAB_API_TOKEN
+        if (!token) {
+            throw new Error('GITLAB_API_TOKEN is missing in environment or ~/.claude/.env')
+        }
+
+        const host = process.env.GITLAB_URL || 'https://gitlab.com'
+
+        this.api = new Gitlab({
+            host,
+            token,
+            // Default to rejectUnauthorized = false equivalent via custom fetch if required,
+            // but gitbeaker handles standard HTTPS well.
+        })
+    }
+
+    async getCurrentUser() {
+        return await this.api.Users.current()
+    }
+
+    async getProjects(
+        options: {
+            search?: string
+            owned?: boolean
+            membership?: boolean
+            starred?: boolean
+            perPage?: number
+        } = {}
+    ) {
+        return await this.api.Projects.all(options)
+    }
+
+    async getProject(projectId: string | number) {
+        return await this.api.Projects.show(projectId)
+    }
+
+    async getBranches(projectId: string | number, search?: string) {
+        return await this.api.Branches.all(projectId, { search })
+    }
+
+    async getTags(projectId: string | number, search?: string) {
+        return await this.api.Tags.all(projectId, { search })
+    }
+
+    async getCommits(
+        projectId: string | number,
+        refName?: string,
+        options: { since?: string; until?: string } = {}
+    ) {
+        return await this.api.Commits.all(projectId, { refName, ...options })
+    }
+
+    async getFile(projectId: string | number, filePath: string, ref: string) {
+        return await this.api.RepositoryFiles.show(projectId, filePath, ref)
+    }
+
+    async getTree(
+        projectId: string | number,
+        options: { path?: string; ref?: string; recursive?: boolean } = {}
+    ) {
+        return await this.api.Repositories.tree(projectId, options)
+    }
+
+    async getMergeRequests(
+        projectId: string | number,
+        options: { state?: string; scope?: string } = {}
+    ) {
+        return await this.api.MergeRequests.all({ projectId, ...options })
+    }
+
+    async getMergeRequest(projectId: string | number, mrIid: number) {
+        return await this.api.MergeRequests.show(projectId, mrIid)
+    }
+
+    async getMergeRequestChanges(projectId: string | number, mrIid: number) {
+        return await this.api.MergeRequests.changes(projectId, mrIid)
+    }
+
+    async getIssues(projectId: string | number, options: { state?: string; labels?: string } = {}) {
+        return await this.api.Issues.all({ projectId, ...options })
+    }
+
+    async getPipelines(
+        projectId: string | number,
+        options: { status?: string; ref?: string } = {}
+    ) {
+        return await this.api.Pipelines.all(projectId, options)
+    }
+
+    async getPipelineJobs(projectId: string | number, pipelineId: number) {
+        return await this.api.Jobs.all(projectId, { pipelineId })
+    }
+
+    async getJobLog(projectId: string | number, jobId: number) {
+        return await this.api.Jobs.showLog(projectId, jobId)
+    }
+
+    async search(query: string, scope: string, projectId?: string | number) {
+        if (projectId) {
+            return await this.api.Search.all(scope, query, { projectId })
+        }
+        return await this.api.Search.all(scope, query)
+    }
+}

package/skills/gitlab/scripts/gitlab-helper.ts

@@ -0,0 +1,80 @@
+import { GitLabClient } from './gitlab-client.js'
+
+/**
+ * High-level repository operations utilizing GitLabClient.
+ */
+export class GitLabHelper {
+    private client: GitLabClient
+
+    constructor() {
+        this.client = new GitLabClient()
+    }
+
+    async connect() {
+        // Current user request will throw if authentication fails
+        return await this.client.getCurrentUser()
+    }
+
+    async listProjects(
+        options: { search?: string; owned?: boolean; membership?: boolean; starred?: boolean } = {}
+    ) {
+        return await this.client.getProjects(options)
+    }
+
+    async getProject(projectPath: string) {
+        return await this.client.getProject(projectPath)
+    }
+
+    async getFileContent(project: string, path: string, ref: string = 'main') {
+        const file = await this.client.getFile(project, path, ref)
+        if (!file || !file.content) return null
+        return Buffer.from(file.content, 'base64').toString('utf-8')
+    }
+
+    async listFiles(project: string, path?: string, ref?: string, recursive: boolean = false) {
+        return await this.client.getTree(project, { path, ref, recursive })
+    }
+
+    async getCommits(project: string, branch: string = 'main', limit: number = 10) {
+        const commits = await this.client.getCommits(project, branch)
+        return Array.isArray(commits) ? commits.slice(0, limit) : []
+    }
+
+    async listMergeRequests(projectPath: string, state: string = 'opened') {
+        return await this.client.getMergeRequests(projectPath, { state })
+    }
+
+    async getMyMergeRequests() {
+        const user = await this.client.getCurrentUser()
+        // Scope 'created_by_me' requires different endpoint parameters, but using standard API
+        return await this.client.api.MergeRequests.all({ authorId: user.id, state: 'opened' })
+    }
+
+    async getAssignedMergeRequests() {
+        const user = await this.client.getCurrentUser()
+        return await this.client.api.MergeRequests.all({ assigneeId: user.id, state: 'opened' })
+    }
+
+    async listPipelines(project: string, status?: string, ref?: string) {
+        return await this.client.getPipelines(project, { status, ref })
+    }
+
+    async getPipelineJobs(project: string, pipelineId: number) {
+        return await this.client.getPipelineJobs(project, pipelineId)
+    }
+
+    async getJobLog(project: string, jobId: number) {
+        return await this.client.getJobLog(project, jobId)
+    }
+
+    async getLatestPipeline(project: string, ref: string = 'main') {
+        const pipelines = await this.client.getPipelines(project, { ref })
+        if (!pipelines || pipelines.length === 0) return null
+        // Pipelines are generally sorted by id desc
+        return pipelines[0]
+    }
+
+    async searchCode(query: string, project?: string) {
+        return await this.client.search(query, 'blobs', project)
+    }
+}

package/skills/golang/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: golang
+description: |
+  Master Go development using production-grade best practices merged from the Google and Uber style guides. Use whenever writing Go code, designing APIs, handling errors, managing goroutines, or configuring linters.
+---
+
+# Golang Engineering Standards
+
+This skill synthesizes the absolute best practices from the ecosystem (Uber Guide, Google Guide, and community consensus) to ensure written Go code is idiomatic, performant, and safe.
+
+## 1. Interface & API Design
+
+- **Accept Interfaces, Return Structs**: Define interfaces where they are consumed (by the caller), not where they are implemented. Return concrete structs from constructors so callers can use all methods or mock as needed.
+- **Context is King**: `context.Context` must **always** be the first parameter of any function doing I/O or asynchronous work.
+- **Never Store Context**: Do not store `context.Context` inside structs. It is meant to flow entirely through the function stack.
+- **No Dependency Injection via Context**: Only use `context.WithValue` for request-scoped data (like trace IDs, user claims). Never use it to pass databases, loggers, or configuration.
+
+## 2. Error Handling
+
+- **Wrapping Options**: Use `fmt.Errorf("doing operation: %w", err)` to preserve the underlying error for `errors.Is` or `errors.As`. Use `%v` only if you explicitly want to hide the underlying error's identity.
+- **Never Log AND Return**: Pick one. If you log an error, handle it there. If you return it, let the caller log it. Doing both creates duplicate noise in APM systems.
+- **Sentinel Errors**: Define top-level exported errors for standard package failure modes (`var ErrNotFound = errors.New(...)`). Use `errors.Is(err, ErrNotFound)` rather than string comparisons.
+
+## 3. Concurrency & Goroutines
+
+- **Know When To Stop**: Never start a goroutine without knowing exactly how and when it will terminate. Unbounded or untracked goroutines cause devastating memory leaks.
+- **Coordination**: Use `sync.WaitGroup` to wait for a pool of workers.
+- **Channels vs Mutexes**:
+  - Use `chan` to pass ownership of data between concurrent routines.
+  - Use `sync.Mutex` to protect shared state accessed from multiple routines.
+- **Lock Discipline**: Keep the critical section of a lock as short as physically possible. **Never** perform I/O while holding a mutex.
+
+## 4. Naming Conventions (No Stuttering)
+
+- **Getters**: Go does not use `Get` prefixes for getters. If a struct has an `Owner` field, the getter is `Owner()`, not `GetOwner()`. The setter would be `SetOwner()`.
+- **Stuttering**: Avoid package/type name redundancy.
+  - _Bad_: `user.UserConfig`, `log.Logger`.
+  - _Good_: `user.Config`, `log.Entry`.
+- **Interfaces**: Single-method interfaces should end in `-er` (`Reader`, `Writer`, `Formatter`).
+- **Short Variable Names**: Idiomatic Go uses very short variables for scope-limited entities (`idx` instead of `index`, `b` instead of `buffer`, `r` instead of `reader`).
+
+## 5. Performance & Data Structures
+
+- **Capacity Pre-allocation**: Always use `make([]T, 0, capacity)` or `make(map[K]V, capacity)` when the target size is known. This dramatically reduces heap allocations during append loops.
+- **Nil vs Empty**: A `nil` slice (`var names []string`) is idiomatically correct, functionally identical to a zero-length slice, and requires zero allocations. Use it over `names := []string{}` unless JSON formatting explicitly demands an empty array `[]` instead of `null`.
+
+## 6. Testing
+
+- **Table-Driven Tests**: Always utilize `[]struct{ name string ... }` iterated via `t.Run()` for clear, modular test cases.
+- **t.Helper()**: Ensure any custom assertion or setup function immediately calls `t.Helper()` so test runner output points to the actual failure site, not the inside of the utility function.
+
+## 7. Tooling & Enforcement
+
+- The agent should prioritize running `go fmt ./...` and `golangci-lint run` (if available) before confirming code completion.

package/skills/mysql/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: mysql
+description: Enterprise MySQL & MariaDB production rules — query safety, connection pooling, and strict schema configurations.
+---
+
+# MySQL / MariaDB Production Standards
+
+MySQL and MariaDB are powerful relationship-driven databases, but AI agents MUST adhere to these strict behavioral boundaries when executing queries, utilizing the `mysql-mcp` server, or generating application code.
+
+## 1. Query Safety & Execution Rules
+
+- **Absolute Parameterization**: You MUST ALWAYS use parameterized queries (`?`). Under zero circumstances are you permitted to string-interpolate or concatenate variables into a raw SQL string. This is to enforce strict SQL-injection prevention.
+- **Guarded Reads**: Every top-level `SELECT` statement MUST contain a `LIMIT` clause unless explicitly overridden by the user. Do not execute unbounded `SELECT * FROM table;` queries.
+- **Safe Destructive Ops**: `DELETE` and `UPDATE` queries MUST include a `WHERE` clause. Never execute these operations without a targeted identifier.
+- **Action Scoping**: Limit operations to single-statements. Do not stack multiple statements (`query1; query2;`) in a single payload unless executing a batch migration.
+
+## 2. Connections & Transactions
+
+- **Connection Pooling**: Always assume and design for connection pooling. Code evaluating database connections should handle acquiring from and releasing to a pool, avoiding connection leaks.
+- **Data Mutability Scopes**: Whenever executing writes spanning across multiple tables (e.g., inserts requiring foreign key links), they MUST be wrapped in a transaction block: `START TRANSACTION; ... COMMIT;` with robust `ROLLBACK` logic in the `catch` block.
+
+## 3. Strict Schema Configurations
+
+- **Mode Enforcement**: Ensure `sql_mode` includes `STRICT_TRANS_TABLES` and `ONLY_FULL_GROUP_BY`. AI agents must not disable these modes to bypass errors; you must rewrite your `GROUP BY` logic to be strictly compliant.
+- **Foreign Keys**: Explicitly define `FOREIGN KEY` constraints during `CREATE TABLE` unless specifically orchestrating a Vitess/PlanetScale sharded environment where declarative FKs are explicitly forbidden by the user context.
+
+## 4. Ecosystem & Diagnostics
+
+- **Error Handling**: When intercepting connection drops or authentication failures (e.g., ER_ACCESS_DENIED_ERROR), instruct the user to verify their `.env` configurations (`MYSQL_URL`, `MYSQL_HOST`, etc.). Do not hallucinate database names.
+- **Using MCP**: If the `mysql-mcp` server is attached, prefer utilizing its formal 227+ structured tools over executing raw Bash CLI scripts (`mysql -h ...`) to guarantee payload optimizations and schema intelligence.

package/skills/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "neverinfamous-agent-skills",
+    "version": "1.0.8",
+    "description": "Foundational AI agent metacognitive skills and workflows for the Adamic ecosystem.",
+    "type": "module",
+    "main": "README.md",
+    "bin": {
+        "agent-skills": "bin/sync.js"
+    },
+    "files": [
+        "bin/",
+        "README.md",
+        "autonomous-dev/",
+        "bun/",
+        "github-commander/",
+        "gitlab/",
+        "golang/",
+        "mysql/",
+        "playwright-standard/",
+        "postgres/",
+        "react-best-practices/",
+        "rust/",
+        "shadcn-ui/",
+        "skill-builder/",
+        "sqlite/",
+        "typescript/",
+        "vitest-standard/"
+    ],
+    "scripts": {
+        "sync": "node bin/sync.js"
+    },
+    "keywords": [
+        "agent",
+        "skills",
+        "mcp",
+        "llm",
+        "github-commander"
+    ],
+    "author": "Adamic.tech",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/neverinfamous/memory-journal-mcp.git"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/skills/playwright-standard/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: playwright-standard
+description: |
+  Comprehensive, opinionated guidance for Playwright test development. Use when
+  writing E2E, API, component, or visual tests, debugging failures, implementing
+  Page Object Model, or configuring CI/CD. Includes "Golden Rules" for resilient
+  tests and provides on-demand reference for specialized scenarios (Electron,
+  WebSockets, mobile, security audits).
+---
+
+# Playwright Standard
+
+This skill combines battle-tested coding standards with industrial-scale infrastructure guidance. It is designed to keep agents on the "Golden Path" of modern Playwright development while providing deep reference for niche environments.
+
+## Golden Rules (Mandatory)
+
+1.  **`getByRole()` over CSS/XPath** — Resilient to markup changes, mirrors how users see the page.
+2.  **Never `page.waitForTimeout()`** — Use `expect(locator).toBeVisible()` or `page.waitForURL()`.
+3.  **Web-first assertions** — `expect(locator)` auto-retries; `expect(await locator.textContent())` does not.
+4.  **Isolate every test** — Every test must run independently in any order (no shared state).
+5.  **Fixtures over globals** — Share state via `test.extend()`, not module-level variables.
+6.  **`baseURL` in config** — ZERO hardcoded URLs in test files.
+7.  **Auth: Reuse storage state** — Use `browserContext.storageState` to avoid UI login in every test.
+8.  **Network: Mock third-party only** — Never mock your own app; mock external APIs, gateways, and emails.
+9.  **Traces: `'on-first-retry'`** — High-fidelity debugging without CI performance penalties.
+10. **One behavior per test** — Avoid "mega-tests": keep focus narrow and assertions meaningful.
+
+## Quality Standards
+
+### Locators Priority
+
+1.  **Role**: `page.getByRole('button', { name: 'Submit' })`
+2.  **Label**: `page.getByLabel('User Name')`
+3.  **Placeholder**: `page.getByPlaceholder('Search...')`
+4.  **Text**: `page.getByText('Success')`
+5.  **TestID**: `page.getByTestId('submit-btn')` (Last resort)
+
+### Synchronization
+
+- **Do**: `await expect(locator).toBeVisible()`
+- **Avoid**: `await page.waitForSelector('.btn')`
+- **Avoid**: `await page.waitForLoadState('networkidle')` (Flaky on high-latency networks)
+
+---
+
+## Specialized References (Load On-Demand)
+
+For infrastructure, scale, or niche environments, read the relevant reference file:
+
+| Scenario                         | Reference File                                            |
+| :------------------------------- | :-------------------------------------------------------- |
+| **CI/CD, Sharding, Docker**      | [infrastructure.md](references/infrastructure.md)         |
+| **Electron, WebSockets, Canvas** | [advanced-scenarios.md](references/advanced-scenarios.md) |
+| **Visual, Accessibility, API**   | [advanced-scenarios.md](references/advanced-scenarios.md) |
+
+## Example: Fixture-based Isolation
+
+See [fixtures.ts](examples/fixtures.ts) for the recommended pattern for sharing state without global variables.

package/skills/playwright-standard/examples/fixtures.ts

@@ -0,0 +1,66 @@
+import { test as base, Page, Browser, BrowserContext } from '@playwright/test'
+
+// 1. Define the fixture type
+type MyFixtures = {
+    todoPage: TodoPage
+    authenticatedUser: User
+}
+
+// 2. Extend the base test with your fixture
+export const test = base.extend<MyFixtures>({
+    todoPage: async ({ page }: { page: Page }, use: (r: TodoPage) => Promise<void>) => {
+        // Setup (Isolation over globals)
+        const todoPage = new TodoPage(page)
+        await todoPage.goto()
+
+        // Pass the fixture to the test
+        await use(todoPage)
+
+        // Teardown (optional)
+        await todoPage.removeAll()
+    },
+
+    authenticatedUser: async (
+        { browser }: { browser: Browser },
+        use: (r: User) => Promise<void>
+    ) => {
+        // Shared state (StorageState over login-in-each-test)
+        const context = await browser.newContext({ storageState: 'auth.json' })
+        const user = new User(context)
+        await use(user)
+        await context.close()
+    },
+})
+
+export { expect } from '@playwright/test'
+
+// 3. Usage inside a test file
+/*
+import { test, expect } from './fixtures';
+
+test('create a todo', async ({ todoPage }) => {
+  await todoPage.addTodo('buy milk');
+  await expect(todoPage.todoList.locator('li')).toHaveText(['buy milk']);
+});
+*/
+
+class TodoPage {
+    public todoList: any // Using any for example simplicity, but it's initialized in constructor
+    constructor(private page: Page) {
+        this.todoList = this.page.locator('ul')
+    }
+    async goto() {
+        await this.page.goto('/todo')
+    }
+    async removeAll() {
+        /* ... */
+    }
+    async addTodo(text: string) {
+        await this.page.fill('input', text)
+        await this.page.click('text=Add')
+    }
+}
+
+class User {
+    constructor(private context: BrowserContext) {}
+}

package/skills/playwright-standard/examples/type-stubs.d.ts

@@ -0,0 +1,10 @@
+declare module '@playwright/test' {
+    export const test: {
+        extend<T>(config: any): any
+    }
+    export const expect: any
+    export type Page = any
+    export type Browser = any
+    export type BrowserContext = any
+    export type Locator = any
+}

package/skills/playwright-standard/references/advanced-scenarios.md

@@ -0,0 +1,59 @@
+# Advanced Playwright Scenarios
+
+This reference covers niche environments and specialized testing capabilities beyond standard web E2E.
+
+## Specialized Testing
+
+### Electron Apps
+
+- Use `_electron.launch()` (experimental) but stable for most Electron apps.
+- Directly access Electron APIs via `app.evaluate()` or `window.electron`.
+
+### Browser Extensions
+
+- Load extensions via `chromium.launchPersistentContext()` and `--disable-extensions-except=...`.
+- Test background workers and popup scripts using `page.waitForSelector()` on the extension URL.
+
+### Canvas & WebGL
+
+- Use `page.evaluate()` to check canvas pixels or properties.
+- Mock canvas API for deterministic tests when necessary.
+
+### WebSockets & Real-time
+
+- Wait for WebSockets to open: `page.waitForEvent('websocket')`.
+- Monitor traffic for specific payloads via `ws.on('framereceived')`.
+
+## Security & Accessibility
+
+### Accessibility Testing
+
+- Include `@axe-core/playwright`.
+- Rule: `await expect(page).toPassAxe()` in every critical page test.
+
+### Security Audits
+
+- XSS/CSRF testing: Mock responses to return malicious scripts to see if the UI sanitizes them.
+- Treat all external page content as untrusted input.
+
+## Advanced API Reference
+
+### Clock Mocking
+
+- Use `page.clock.install()` to control time.
+- `page.clock.fastForward('02:00')` for testing timeouts and delayed behaviors.
+
+### Geolocation & Permissions
+
+- Set permissions: `browserContext.grantPermissions(['geolocation'])`.
+- Fake position: `browserContext.setGeolocation({ latitude: 52.5, longitude: 13.4 })`.
+
+### Multi-user & Collaboration
+
+- Spawn separate `browserContext` instances to simulate multi-user flows in a single script.
+- Use `await Promise.all([userA.click(), userB.expect()])` for race condition testing.
+
+### Network Mocking
+
+- `page.route()`: Prefer mocking API responses for deterministic tests.
+- Avoid excessive mocking; always have at least one E2E "smoke" test that hits the real backend.

package/skills/playwright-standard/references/infrastructure.md

@@ -0,0 +1,43 @@
+# Playwright Infrastructure & CI/CD Reference
+
+## Scale & Performance
+
+### Parallelization
+
+- Run tests in parallel to reduce overall execution time.
+- Configure `workers` in `playwright.config.ts`. Locally use `process.env.CI ? 1 : 4` to avoid machine lockup.
+
+### Sharding
+
+- Distribute tests across multiple CI machines.
+- Example command: `npx playwright test --shard=1/3`.
+- Combine blob reports for a unified HTML report.
+
+## CI Configuration
+
+### Trace & Video
+
+- Tracing: `'on-first-retry'` (Best balance of debug info vs storage).
+- Video: `'on-first-retry'` (High fidelity failure evidence).
+
+### Secret Management
+
+- Use environment variables for secrets: `process.env.PASSWORD`.
+- Never commit `.env` or hardcoded keys.
+
+## Docker & Containerization
+
+### SLSA Compliance
+
+- Pin images using SHA-256 digests: `mcr.microsoft.com/playwright:v1.59.1-focal@sha256:xxxx`.
+- Avoid floating tags like `:latest` or `:v1` to ensure reproducible builds.
+
+### Execution Policy
+
+- Run as a non-root user when possible.
+- Mount the host machine's UI/X11 socket if running headed mode inside Docker.
+
+## Reporting & Analytics
+
+- Use **Currents.dev** for enterprise-grade reporting, flakiness detection, and parallelization analytics.
+- Integrate via the `@currents/playwright` reporter plugin.

package/skills/postgres/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: postgres
+description: Enterprise PostgreSQL production rules — advanced querying, indexing, JSONB data, and strict optimization patterns.
+---
+
+# PostgreSQL Production Standards
+
+PostgreSQL is a deeply capable object-relational database. Because of its advanced feature set, AI agents and orchestrated deployment workflows MUST adhere to strict operational boundaries to avoid common pitfalls like index bloating, inefficient JSONB parsing, and locking regressions.
+
+## 1. Advanced Querying & Safety
+
+- **Strict Parameterization**: Just like MySQL, executing parameterized queries (`$1, $2, ...`) is a non-negotiable hard mandate. String interpolation is globally prohibited.
+- **Explicit Columns**: NEVER use `SELECT *` in production code. You must specifically query required columns. This minimizes data transfer latency and prevents application crashes if schema columns mutate.
+- **N+1 Avoidance**: Agents scaffolding code must implement batch loading architectures (e.g., `DataLoader`) or advanced `JOIN` logic when building APIs. Do not execute identical iterative queries inside loops.
+- **Guarded Modifications**: Any `UPDATE` or `DELETE` MUST contain a deterministic `WHERE` block.
+
+## 2. Advanced Indexing Patterns
+
+- **Targeted Strategies**: Do not blindly index every column. Optimize based on frequency.
+- **Partial Indexes**: If you routinely query states like `WHERE active = true`, you must use a Partial Index (`CREATE INDEX idx_active_users ON users(email) WHERE active = true;`) instead of indexing the entire column.
+- **Composite Layout**: For standard queries targeting multiple identifiers, employ Composite Indexes with the most selective columns first.
+
+## 3. Operations & Migrations
+
+- **Transaction Safety**: Wrap multi-step mutations in `BEGIN; ... COMMIT;`. Standardize transactions to stay small and fast to prevent lock contentions.
+- **Analytical Overviews**: Use `EXPLAIN ANALYZE` locally when debugging slow queries to analyze sequential sweeps relative to index scans.
+- **Schema Extensibility**: Add constraints and columns dynamically (e.g., `ALTER TABLE users ADD CONSTRAINT unique_email UNIQUE (email);`). Always apply sane `DEFAULT` properties to avoid backfilling issues on massive tables.
+
+## 4. Modern PostGres Functionality
+
+- **JSONB Arrays/Objects**: Use `JSONB`, never `JSON`. JSONB is stored in a decomposed binary format, allowing fast, native index checking (via `@>` or `?` operators) instead of full parsing upon retrieval.
+- **Row-Level Security (RLS)**: Emphasize defining default-deny security protocols using `ENABLE ROW LEVEL SECURITY`.
+- **Ecosystem Integration**: Whenever available, prefer using structured `postgres-mcp` tools for safe schema interpretation over native Bash `psql` piping.