just-vibe 0.7.0

package/plugins/just-vibe/skills/data-profile/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: data-profile
+description: "Summarize distributions, missingness, duplicates, and suspicious values Use for descriptive data inspection; data-quality evaluates declared rules."
+---
+
+# data-profile
+
+Summarize distributions, missingness, duplicates, and suspicious values
+
+## Choose this workflow
+
+Use for descriptive data inspection; data-quality evaluates declared rules.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Data engineering methods](../../references/packs/data.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; dataset/snapshot, columns, sampling limit, and task context.
+
+data source/version, schema/semantics, transformation code, permitted sampling scope, and storage/compute budget. Prefer aggregates and redacted samples; never upload datasets to external services implicitly. Record time zones and snapshot identity for reproducibility.
+
+Declared evidence requirements: `data.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Distributions, missingness, uniqueness, duplicates, ranges, and suspicious values.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Validate schema, select a representative bounded sample or authorized aggregate scan, compute summaries, and flag anomalies relative to declared semantics.
+- Inspect schema and volume before scanning, distinguish nulls from sentinels and sample across relevant time/group strata with stated selection limits.
+
+## Decision branches
+
+- **When the sample is convenience-based or filtered:** Label its population and avoid extrapolating exact counts or representativeness.
+
+## Deliver and verify
+
+- Profile with sample/full-scan distinction, counts, caveats, and follow-up checks.
+- Snapshot/sample identity, summaries, anomaly examples and coverage limits.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Missing and sentinel values are separated; sample statistics are not presented as exact full-population counts.
+
+## Stop and recover
+
+- Unknown volume triggers size inspection before scanning. Do not print sensitive row-level data unnecessarily.
+
+## Example requests
+
+- **Normal (inspect):** Profile missingness and duplicates in this bounded dataset sample.
+- **edge (inspect):** Profile a time-partitioned dataset with sentinel zeros and missing recent partitions.
+- **blocked (inspect):** Inspect metadata only when row access is unavailable; do not fabricate distributions.

package/plugins/just-vibe/skills/data-quality/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: data-quality
+description: "Check freshness, completeness, validity, and consistency Use to evaluate an identified snapshot against declared rules; data-profile discovers descriptive anomalies."
+---
+
+# data-quality
+
+Check freshness, completeness, validity, and consistency
+
+## Choose this workflow
+
+Use to evaluate an identified snapshot against declared rules; data-profile discovers descriptive anomalies.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Data engineering methods](../../references/packs/data.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; dataset, quality contract, thresholds, time window, and bounded execution access.
+
+data source/version, schema/semantics, transformation code, permitted sampling scope, and storage/compute budget. Prefer aggregates and redacted samples; never upload datasets to external services implicitly. Record time zones and snapshot identity for reproducibility.
+
+Declared evidence requirements: `data.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Freshness, completeness, validity, uniqueness, and cross-field consistency.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Resolve applicable rules, evaluate against the identified snapshot, separate warnings from failures, compare history where available, and identify likely upstream causes.
+- Freeze applicable thresholds before observing results, evaluate completeness/freshness/validity separately and count excluded or unreadable records.
+
+## Decision branches
+
+- **When required rule evidence is missing:** Mark the rule unknown and preserve the failed/unknown result rather than changing thresholds to pass.
+
+## Deliver and verify
+
+- Rule-by-rule results, affected counts, severity, and repair/monitoring proposals.
+- Rule/version/snapshot/result matrix with counts and likely upstream causes.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Stale but complete data fails freshness; missing rule evidence is unknown rather than passing.
+
+## Stop and recover
+
+- Installing monitors or repairing records is separate. Do not redefine thresholds after seeing results to force a pass.
+
+## Example requests
+
+- **Normal (inspect):** Check these records against the supplied freshness and validity rules.
+- **edge (inspect):** Evaluate fresh-but-incomplete and complete-but-stale partitions separately.
+- **blocked (inspect):** Assess known rules without data access; do not install monitors or invent pass rates.

package/plugins/just-vibe/skills/data-reconcile/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: data-reconcile
+description: "Compare source and destination records and explain discrepancies Use to compare corresponding datasets; db-integrity checks database invariants."
+---
+
+# data-reconcile
+
+Compare source and destination records and explain discrepancies
+
+## Choose this workflow
+
+Use to compare corresponding datasets; db-integrity checks database invariants.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Data engineering methods](../../references/packs/data.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; source/destination snapshots, keys, transformations, tolerances, and comparison budget.
+
+data source/version, schema/semantics, transformation code, permitted sampling scope, and storage/compute budget. Prefer aggregates and redacted samples; never upload datasets to external services implicitly. Record time zones and snapshot identity for reproducibility.
+
+Declared evidence requirements: `data.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Missing, duplicated, changed, or aggregated discrepancies; no automatic repair.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Align snapshots/time windows, compare counts and keyed values, normalize only documented transformations, sample discrepancies safely, and explain likely causes.
+- Align snapshot/window and key grain, compare membership before values and normalize only explicitly documented transformations.
+
+## Decision branches
+
+- **When counts match but keys or values differ:** Quantify each mismatch class and retain redacted examples rather than declaring parity.
+
+## Deliver and verify
+
+- Reconciliation report, discrepancy categories, evidence, and repair candidates.
+- Snapshot pair, keyed mismatch categories, denominators and evidence limits.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Equal row counts do not hide different records; allowed rounding/timing differences are distinguished from loss.
+
+## Stop and recover
+
+- Misaligned snapshots prevent a definitive mismatch claim. No row-level data exposure beyond necessary authorized evidence.
+
+## Example requests
+
+- **Normal (inspect):** Compare these aligned snapshots by key, not just row counts.
+- **edge (inspect):** Reconcile exports with equal row counts but missing and duplicated IDs.
+- **blocked (inspect):** Compare misaligned snapshots without calling timing differences data loss.

package/plugins/just-vibe/skills/db-access/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: db-access
+description: "Audit roles, tenant filtering, and row-level policies where supported Use for grants, connection roles and row policies; backend-permissions checks application enforcement."
+---
+
+# db-access
+
+Audit roles, tenant filtering, and row-level policies where supported
+
+## Choose this workflow
+
+Use for grants, connection roles and row policies; backend-permissions checks application enforcement.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Databases methods](../../references/packs/database.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; roles, tenant model, policies, engine, and representative access matrix.
+
+actual engine/version, schema/migrations, query workload, and explicitly identified environment. Prefer supplied plans, metadata, and isolated fixtures. Even a SELECT can lock, call mutating functions, or overload a database; inspect semantics before execution. Executing an analyzed query is distinct from reading its plan.
+
+Declared evidence requirements: `database.context`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Database privileges, tenant predicates, row-level policies, and bypass paths.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Inspect grants and execution identities, trace connection-role behavior, evaluate policies including writes, and design or run authorized isolated access checks.
+- Trace the actual runtime role and ownership/bypass privileges; inspect read and write predicates with positive and cross-tenant negative cases.
+
+## Decision branches
+
+- **When tests run as an elevated owner/service role:** Do not infer ordinary-user isolation from those results; test the intended execution identity.
+
+## Deliver and verify
+
+- Access findings, policy coverage, and remediation/test proposals.
+- Role/resource/action matrix, policy paths and verified/unknown isolation checks.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A tenant cannot read/update another tenant's rows; privileged service roles are recognized as potential policy bypasses.
+
+## Stop and recover
+
+- No grant/policy changes or real tenant-data probing by default. Unknown execution roles block confident isolation claims.
+
+## Example requests
+
+- **Normal (inspect):** Audit tenant policies and service-role bypass paths from supplied metadata.
+- **edge (inspect):** Review row policies where reads are scoped but inserts permit another tenant ID.
+- **blocked (inspect):** Inspect policy definitions without probing real tenant data or changing grants.

package/plugins/just-vibe/skills/db-explain/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: db-explain
+description: "Interpret query plans and identify expensive operations Use to interpret an existing or authorized execution plan; db-index proposes an index from workload evidence."
+---
+
+# db-explain
+
+Interpret query plans and identify expensive operations
+
+## Choose this workflow
+
+Use to interpret an existing or authorized execution plan; db-index proposes an index from workload evidence.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Databases methods](../../references/packs/database.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; query, engine/version, saved execution plan, and workload context.
+
+actual engine/version, schema/migrations, query workload, and explicitly identified environment. Prefer supplied plans, metadata, and isolated fixtures. Even a SELECT can lock, call mutating functions, or overload a database; inspect semantics before execution. Executing an analyzed query is distinct from reading its plan.
+
+Declared evidence requirements: `database.context`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Plan interpretation, estimates, scans, joins, sorting, and evidence-supported bottlenecks.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Read operators and row estimates, compare actuals when supplied, identify cardinality errors and costly stages, and propose discriminating measurements.
+- Read estimated versus actual rows, loop counts, filters, joins, sorting/spilling and buffers using engine-specific meaning; locate the first large estimation divergence.
+
+## Decision branches
+
+- **When only an estimated plan is supplied:** Discuss cost/shape hypotheses without converting cost units into milliseconds or inventing execution statistics.
+
+## Deliver and verify
+
+- Annotated plan, likely causes, and targeted query/index/statistics options.
+- Operator evidence, likely bottleneck, discriminating measurement and risk of running it.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Estimated costs are not mislabeled as milliseconds; a row-estimate error is distinguished from a missing index.
+
+## Stop and recover
+
+- EXPLAIN ANALYZE or equivalents execute work and require appropriate authorization. No mutation hidden inside profiling.
+
+## Example requests
+
+- **Normal (inspect):** Interpret this saved query plan without executing EXPLAIN ANALYZE.
+- **edge (inspect):** Explain a plan whose nested loop multiplies work through a row-estimate error.
+- **blocked (inspect):** Analyze EXPLAIN output without executing EXPLAIN ANALYZE or mutating functions.

package/plugins/just-vibe/skills/db-index/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: db-index
+description: "Recommend indexes based on queries, write costs, and measurements Use for workload-specific index design; db-schema handles broader constraints and data shape."
+---
+
+# db-index
+
+Recommend indexes based on queries, write costs, and measurements
+
+## Choose this workflow
+
+Use for workload-specific index design; db-schema handles broader constraints and data shape.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Databases methods](../../references/packs/database.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; actual queries/plans, schema/indexes, write workload, engine, and storage constraints.
+
+actual engine/version, schema/migrations, query workload, and explicitly identified environment. Prefer supplied plans, metadata, and isolated fixtures. Even a SELECT can lock, call mutating functions, or overload a database; inspect semantics before execution. Executing an analyzed query is distinct from reading its plan.
+
+Declared evidence requirements: `database.context`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Evidence-based index design, redundancy, and rollout; no automatic production DDL.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Analyze predicates/order/selectivity, compare existing indexes, estimate write/storage costs from evidence, and design before/after measurement and online-creation strategy where supported.
+- Match equality/range/order predicates and selectivity to existing indexes, account for write/storage cost and compare the exact workload before/after.
+
+## Decision branches
+
+- **When an existing index shares the proposed name:** Inspect definition and validity before reuse; an IF NOT EXISTS notice is not a compatibility check.
+
+## Deliver and verify
+
+- Index recommendations or authorized migration with measured validation.
+- Candidate definition, supported workload, redundant overlap and rollout/measurement plan.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Target query improves under comparable conditions; added write cost and redundant indexes are considered.
+
+## Stop and recover
+
+- Do not recommend indexes from column names alone. Unsupported online operations or lock risks must be addressed before execution.
+
+## Example requests
+
+- **Normal (plan):** Recommend indexes from these query plans, including write and storage costs.
+- **edge (plan):** Design an index for a tenant-filtered timeline with a stable secondary sort key.
+- **blocked (inspect):** Assess indexing from schema without plans or workload counts; label performance estimates unknown.

package/plugins/just-vibe/skills/db-integrity/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: db-integrity
+description: "Find orphaned records, invalid relationships, and missing constraints Use to check declared invariants in existing data; db-access checks permission policy."
+---
+
+# db-integrity
+
+Find orphaned records, invalid relationships, and missing constraints
+
+## Choose this workflow
+
+Use to check declared invariants in existing data; db-access checks permission policy.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Databases methods](../../references/packs/database.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; invariants, schema, data scope, and bounded read permission.
+
+actual engine/version, schema/migrations, query workload, and explicitly identified environment. Prefer supplied plans, metadata, and isolated fixtures. Even a SELECT can lock, call mutating functions, or overload a database; inspect semantics before execution. Executing an analyzed query is distinct from reading its plan.
+
+Declared evidence requirements: `database.context`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Orphans, duplicates, invalid relationships, and constraint gaps; no automatic deletion or repair.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Translate each explicit business invariant into its row, relationship and transaction boundary. Distinguish nullability and historical exceptions from actual corruption; ambiguous policy remains a question, not a deletion rule.
+- Choose bounded counts and redacted examples against an identified snapshot. Assess scan/lock impact before live queries; use supplied artifacts when they are sufficient and do not infer current production state from stale samples.
+- For preventive changes, separate input validation from shared storage constraints and atomic multi-row checks. Verify type/range, ownership, uniqueness, referential rules and overflow where relevant to the invariant.
+- Propose repair with a selection predicate, expected count, restart behavior and recovery boundary. Implement only within the requested scope; detection does not authorize a live cleanup or schema change.
+
+## Decision branches
+
+- **When data violates an ambiguous business rule:** Report the evidence and policy question before proposing deletion or repair.
+
+## Deliver and verify
+
+- Invariant and snapshot, bounded check/count/example evidence, prevention or scoped repair proposal, and uncertainty from missing policy or live data.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Checks detect an actual violating example and accept legitimate null/historical cases. Preventive writes cannot leave partial multi-row state on interruption; repair claims name the snapshot and rows actually verified.
+
+## Stop and recover
+
+- Ambiguous business rules prevent destructive recommendations. Large scans need a budget and appropriate execution environment.
+
+## Example requests
+
+- **Normal (inspect):** Audit orphaned invoice records with bounded read-only checks.
+- **edge (inspect):** Check duplicate business keys while retaining legitimate archived duplicates.
+- **blocked (inspect):** Plan integrity checks on a large table without scan authorization or production row dumps.

package/plugins/just-vibe/skills/db-locks/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: db-locks
+description: "Investigate blocking, deadlocks, long transactions, and contention Use for transaction blocking/deadlock diagnosis; backend-concurrency designs application consistency."
+---
+
+# db-locks
+
+Investigate blocking, deadlocks, long transactions, and contention
+
+## Choose this workflow
+
+Use for transaction blocking/deadlock diagnosis; backend-concurrency designs application consistency.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Databases methods](../../references/packs/database.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; engine, time window, affected workload, and lock/session metadata.
+
+actual engine/version, schema/migrations, query workload, and explicitly identified environment. Prefer supplied plans, metadata, and isolated fixtures. Even a SELECT can lock, call mutating functions, or overload a database; inspect semantics before execution. Executing an analyzed query is distinct from reading its plan.
+
+Declared evidence requirements: `database.context`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Blocking chains, deadlocks, transaction duration, and contention causes.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Correlate blocked/blocking sessions and queries, inspect transaction boundaries, distinguish transient waits from persistent contention, and propose targeted remedies.
+- Correlate wait and blocker snapshots with transaction age, query identity and application transaction boundaries; follow the root blocker rather than the noisiest victim.
+
+## Decision branches
+
+- **When the reported deadlock already resolved:** Separate historical deadlock analysis from current blocking and avoid terminating unrelated live sessions.
+
+## Deliver and verify
+
+- Blocking graph/timeline, likely cause, and safe operational/code options.
+- Blocking chain, snapshot time, transaction boundary and targeted remedy.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- The root blocker is distinguished from downstream victims; a completed deadlock is not confused with current blocking.
+
+## Stop and recover
+
+- No session termination, transaction cancellation, or timeout changes implicitly. Redact sensitive query parameters and acknowledge snapshot limitations.
+
+## Example requests
+
+- **Normal (inspect):** Explain the blocking chain from these session and lock snapshots.
+- **edge (inspect):** Diagnose an idle transaction blocking several otherwise fast updates.
+- **blocked (inspect):** Analyze a saved lock snapshot without cancelling sessions or changing timeouts.

package/plugins/just-vibe/skills/db-migrate/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: db-migrate
+description: "Create migrations with compatibility and rollback considerations Use for schema/data transition mechanics; db-schema designs the target model."
+---
+
+# db-migrate
+
+Create migrations with compatibility and rollback considerations
+
+## Choose this workflow
+
+Use for schema/data transition mechanics; db-schema designs the target model.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Databases methods](../../references/packs/database.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; schema/data change, engine/version, deployment sequence, data volume, and recovery requirements.
+
+actual engine/version, schema/migrations, query workload, and explicitly identified environment. Prefer supplied plans, metadata, and isolated fixtures. Even a SELECT can lock, call mutating functions, or overload a database; inspect semantics before execution. Executing an analyzed query is distinct from reading its plan.
+
+Declared evidence requirements: `database.context`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Migration design/files when requested; live execution needs the exact environment/action authorization.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Inspect engine/version, migration runner transaction behavior, data shape and old/new application contracts. Record which versions read and write each field during rollout.
+- Separate expansion, restartable backfill, validation and contraction. Define lock/downtime bounds, batch identity/checkpoint and interruption handling; estimate impact from evidence rather than row count alone.
+- Exercise migration and restart on isolated representative data, including duplicates, nulls and old writers. Verify indexes/constraints are actually valid and semantically match the intended definition; name existence alone is insufficient.
+- Define recovery per phase: code rollback, forward repair, and restoration of lost information are different operations. Delay destructive contraction until old readers/writers are retired and the agreed evidence establishes compatibility.
+- Use the matching bundled evidence collector when available; read its result and limitations rather than treating exit zero as readiness. Revalidate identity before a dependent action.
+
+## Read when relevant
+
+- Resolving check, deployment or migration identity: [Delivery evidence](../../references/scenarios/delivery-evidence.md).
+
+## Decision branches
+
+- **When a PostgreSQL concurrent index is required:** Use the runner's supported nontransactional path, check invalid indexes after interruption, and never treat name existence alone as proof of a valid matching index.
+
+## Deliver and verify
+
+- Migration plan or files, compatibility evidence, execution conditions, and rollback/forward-recovery limits.
+- Phase/SQL-or-runner-step/lock-risk/check/recovery table and compatibility evidence.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Older app versions survive the intended overlap; interruption can resume without duplicated conversion.
+
+## Stop and recover
+
+- Never promise rollback for irreversible data loss. Missing backup/recovery evidence blocks destructive execution.
+
+## Example requests
+
+- **Normal (plan):** Plan splitting full_name while preserving old-version compatibility and source values.
+- **edge (plan):** Plan a restartable migration after a concurrent index build left an invalid index.
+- **blocked (inspect):** Review a destructive migration with no verified recovery evidence; do not execute it.

package/plugins/just-vibe/skills/db-query/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: db-query
+description: "Write or repair queries against the actual schema Use for correct query semantics; db-explain analyzes the execution plan afterward."
+---
+
+# db-query
+
+Write or repair queries against the actual schema
+
+## Choose this workflow
+
+Use for correct query semantics; db-explain analyzes the execution plan afterward.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Databases methods](../../references/packs/database.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; desired result, schema, engine, parameters, and scale. Explicit query execution selects the authorized mode/environment.
+
+actual engine/version, schema/migrations, query workload, and explicitly identified environment. Prefer supplied plans, metadata, and isolated fixtures. Even a SELECT can lock, call mutating functions, or overload a database; inspect semantics before execution. Executing an analyzed query is distinct from reading its plan.
+
+Declared evidence requirements: `database.context`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Correct SQL/query construction and relevant performance; no broad data repair.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Resolve join cardinality and null semantics, parameterize inputs, inspect result shape, and validate with representative fixtures or bounded authorized reads.
+- Define expected result grain and cardinality, test one-to-many joins and nullable predicates, and compare hand-computed small-fixture results before optimization.
+
+## Decision branches
+
+- **When joins multiply rows before aggregation:** Preaggregate or change the join while preserving semantics; DISTINCT is not a universal repair.
+
+## Deliver and verify
+
+- Query, assumptions, expected results, and verification evidence.
+- Parameterized query, expected row grain and empty/null/duplicate-boundary checks.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- One-to-many joins do not silently inflate aggregates; empty/null inputs yield the intended behavior.
+
+## Stop and recover
+
+- Writes need explicit scope and affected-row checks. Do not run unbounded expensive queries against production for convenience.
+
+## Example requests
+
+- **Normal (plan):** Write a query for invoice totals without multiplying values through one-to-many joins.
+- **edge (plan):** Fix revenue totals doubled by joining two child collections.
+- **blocked (inspect):** Review a query without database access; provide a fixture-based expectation rather than claimed live rows.

package/plugins/just-vibe/skills/db-schema/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: db-schema
+description: "Design or review tables, relationships, constraints, and types Use for relational modeling and constraints; db-migrate plans transition of existing data."
+---
+
+# db-schema
+
+Design or review tables, relationships, constraints, and types
+
+## Choose this workflow
+
+Use for relational modeling and constraints; db-migrate plans transition of existing data.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Databases methods](../../references/packs/database.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; entities, invariants, access patterns, engine, and existing schema.
+
+actual engine/version, schema/migrations, query workload, and explicitly identified environment. Prefer supplied plans, metadata, and isolated fixtures. Even a SELECT can lock, call mutating functions, or overload a database; inspect semantics before execution. Executing an analyzed query is distinct from reading its plan.
+
+Resolve any task-specific tools, target identity and evidence before dependent actions. No external connection is assumed.
+
+## Scope
+
+Tables, relationships, types, constraints, and lifecycle; no live DDL by default.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Model ownership/cardinality, encode enforceable invariants, compare access paths, assess nullability/deletion behavior, and plan compatibility with existing data.
+- Derive keys/cardinality and deletion rules from explicit invariants, then check null semantics, uniqueness and access paths for the selected engine.
+
+## Decision branches
+
+- **When an optional relationship must still be tenant-consistent:** Consider composite ownership constraints or equivalent enforceable checks rather than trusting a single foreign key.
+
+## Deliver and verify
+
+- Schema proposal, rationale, migration considerations, and representative queries.
+- Entity/key/constraint table, deletion semantics and valid/invalid row examples.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Invalid relationships are constrained; expected deletion behavior does not orphan required data.
+
+## Stop and recover
+
+- Do not invent business cardinality or assume another database's semantics. Data ambiguities become explicit decisions.
+
+## Example requests
+
+- **Normal (plan):** Design invoice relationships and deletion behavior against our actual database engine.
+- **edge (plan):** Model optional memberships that cannot reference another tenant's organization.
+- **blocked (inspect):** Design from requirements without a live database or inventing business cardinality.