@raishin/vanguard-frontier-agentic 2.2.0 → 2.5.0

package/skills/salesforce/salesforce-soql-explorer-skill/references/safe-query-patterns.md

@@ -0,0 +1,317 @@
+<!-- Parent: salesforce-soql-explorer-skill/SKILL.md -->
+# Safe SOQL Query Patterns — SOQL Explorer Reference
+
+
+---
+
+## Non-Negotiable Query Rules
+
+These apply to every query executed by this skill. No exceptions.
+
+1. **Always include LIMIT.** Default: `LIMIT 200`. Maximum interactive: `LIMIT 2000`.
+2. **Never use SELECT *.** Enumerate every field explicitly.
+3. **Always use a selective WHERE clause** when querying objects with > 10,000 records.
+4. **Never include encrypted fields** (`encrypted: true` in describe output).
+5. **Never include DML keywords** (`INSERT`, `UPDATE`, `DELETE`, `MERGE`, `UPSERT`).
+6. **Use COUNT for aggregate counts** — do not load records just to count them.
+
+---
+
+## Indexed Fields — Use These in WHERE Clauses
+
+Salesforce automatically indexes these fields on all standard objects:
+
+| Field | API Name | Notes |
+|---|---|---|
+| Record ID | `Id` | Always selective; use for record lookup |
+| Record Name | `Name` | Case-insensitive; not always unique |
+| Owner | `OwnerId` | Indexed; filter by team or user scope |
+| Created Date | `CreatedDate` | Indexed; use date literals |
+| Last Modified Date | `LastModifiedDate` | Indexed |
+| External ID fields | varies | Custom external ID fields are indexed |
+| Lookup / master-detail fields | varies | Foreign key fields are indexed |
+| Standard indexed fields | `Email` on Contact/Lead, `RecordTypeId` | Varies by object |
+
+Non-indexed fields (formula fields, multi-select picklists, long text areas)
+in a WHERE clause without a companion indexed filter will trigger a full table
+scan. On objects > 50,000 records, non-selective queries will fail with
+`QUERY_TIMEOUT` or `NUMBER_OF_QUERY_ROWS_EXCEEDED`.
+
+---
+
+## Safe Pattern Library
+
+### Pattern 1 — Record lookup by ID
+
+Fastest possible query. Always selective.
+
+```soql
+SELECT Id, Name, BillingCity, Phone
+FROM Account
+WHERE Id = '001Xx000001ABCxxx'
+LIMIT 1
+```
+
+### Pattern 2 — Pipeline query by date range and stage
+
+Uses indexed `StageName` (picklist, standard indexed) and `CloseDate` (indexed).
+
+```soql
+SELECT Id, Name, StageName, Amount, CloseDate
+FROM Opportunity
+WHERE StageName NOT IN ('Closed Won', 'Closed Lost')
+  AND CloseDate >= THIS_QUARTER
+  AND CloseDate <= NEXT_QUARTER
+LIMIT 200
+```
+
+### Pattern 3 — Account by owner (team scope)
+
+```soql
+SELECT Id, Name, Industry, AnnualRevenue
+FROM Account
+WHERE OwnerId IN (
+  SELECT Id FROM User WHERE UserRole.Name = 'Account Executive'
+)
+LIMIT 200
+```
+
+### Pattern 4 — Contact by domain (email suffix)
+
+> **Note:** `LIKE` with a leading wildcard (`%@example.com`) defeats
+> indexes. Use only when the result set is bounded by an additional indexed
+> filter like `AccountId` or `CreatedDate`.
+
+```soql
+SELECT Id, FirstName, LastName, Email
+FROM Contact
+WHERE AccountId = '001Xx000001ABCxxx'
+  AND Email LIKE '%@example.com'
+LIMIT 200
+```
+
+### Pattern 5 — Count by category (aggregate — no record data)
+
+```soql
+SELECT Priority, COUNT(Id) cnt
+FROM Case
+WHERE IsClosed = false
+  AND CreatedDate = LAST_N_DAYS:30
+GROUP BY Priority
+```
+
+No record IDs or PII fields returned. Use this for "how many" questions.
+
+### Pattern 6 — Open cases without an assigned owner
+
+Uses boolean filter on indexed `OwnerId` combined with `IsClosed`.
+
+```soql
+SELECT Id, CaseNumber, Subject, CreatedDate
+FROM Case
+WHERE OwnerId = null
+  AND IsClosed = false
+LIMIT 200
+```
+
+### Pattern 7 — Child-to-parent relationship query
+
+Traverses one level. Keep relationship depth to one level unless the
+extra level is required.
+
+```soql
+SELECT Id, Name, Account.Name, Account.BillingCity
+FROM Contact
+WHERE Account.Industry = 'Technology'
+  AND CreatedDate = THIS_YEAR
+LIMIT 200
+```
+
+### Pattern 8 — Parent-to-child subquery
+
+Keep subquery result sets small. Subqueries are subject to 200-record
+inner-query limits
+.
+
+```soql
+SELECT Id, Name,
+  (SELECT Id, Subject, Status FROM Cases WHERE IsClosed = false LIMIT 5)
+FROM Account
+WHERE AnnualRevenue > 1000000
+LIMIT 50
+```
+
+### Pattern 9 — Opportunity pipeline aggregate by owner
+
+```soql
+SELECT OwnerId, StageName, COUNT(Id) cnt, SUM(Amount) total
+FROM Opportunity
+WHERE CloseDate >= THIS_QUARTER
+  AND IsClosed = false
+GROUP BY OwnerId, StageName
+ORDER BY total DESC
+LIMIT 200
+```
+
+> **Redaction reminder:** `OwnerId` in aggregate results must be replaced
+> with `<user_id_placeholder>` before emission.
+
+### Pattern 10 — Records modified in last N hours (incident triage)
+
+```soql
+SELECT Id, Name, LastModifiedById, LastModifiedDate
+FROM Account
+WHERE LastModifiedDate = LAST_N_HOURS:24
+LIMIT 200
+```
+
+> **Redaction reminder:** `LastModifiedById` must be replaced with
+> `<user_id_placeholder>`.
+
+---
+
+## OFFSET Usage
+
+OFFSET is supported but has a hard limit of 2,000 records
+. Use sparingly and only for
+small paginated result sets where ORDER BY is defined:
+
+```soql
+SELECT Id, Name FROM Account ORDER BY CreatedDate DESC LIMIT 50 OFFSET 50
+```
+
+Do not use OFFSET to paginate through large objects. Use `sf data export bulk`
+via `salesforce-bulk-data-ops-skill` for large-volume pagination.
+
+---
+
+## Date Literals Reference
+
+Salesforce date literals avoid timezone ambiguity and use server-side
+indexed date values:
+
+| Literal | Meaning |
+|---|---|
+| `TODAY` | Current day (midnight to midnight in org timezone) |
+| `THIS_WEEK` | Current week |
+| `THIS_MONTH` | Current calendar month |
+| `THIS_QUARTER` | Current fiscal or calendar quarter |
+| `THIS_YEAR` | Current year |
+| `LAST_N_DAYS:n` | Previous n days (e.g., `LAST_N_DAYS:30`) |
+| `LAST_N_HOURS:n` | Previous n hours |
+| `NEXT_N_DAYS:n` | Next n days |
+| `LAST_QUARTER` | Previous quarter |
+| `NEXT_QUARTER` | Following quarter |
+
+Date literals are always safe to use in WHERE clauses on date/datetime fields
+and will use the index.
+
+---
+
+## Bind Variables
+
+Bind variables (`:variableName`) are not supported in the `sf data query`
+CLI. Use literal values in WHERE clauses when executing from the CLI.
+
+```soql
+-- This works in Apex but NOT in sf CLI
+SELECT Id FROM Account WHERE Name = :accountName  ← not valid in CLI
+
+-- Use literal values in CLI
+SELECT Id FROM Account WHERE Name = 'Acme Corp'   ← valid
+```
+
+If a query requires dynamic values that would come from a variable, construct
+the literal string carefully and audit it for injection risk (a concern even
+in read-only contexts if the query is constructed from user input).
+
+---
+
+## Anti-Patterns — Do Not Use
+
+### Anti-pattern 1 — SELECT * equivalent (enumerating all fields without selection)
+
+```soql
+-- WRONG: querying every field without need
+SELECT Id, Name, Phone, Fax, Email, Website, BillingStreet, BillingCity,
+       BillingState, BillingPostalCode, BillingCountry, ShippingStreet, ...
+FROM Account LIMIT 200
+```
+
+Query only the fields the task actually requires.
+
+### Anti-pattern 2 — No LIMIT on a large object
+
+```soql
+-- WRONG: no LIMIT on a high-volume object
+SELECT Id, Name FROM Contact WHERE LastName = 'Smith'
+```
+
+Always include LIMIT. Use COUNT if the goal is a count, not records.
+
+### Anti-pattern 3 — Non-indexed WHERE without companion indexed filter
+
+```soql
+-- WRONG: formula field in WHERE with no indexed companion filter
+SELECT Id, Name FROM Account WHERE My_Formula_Field__c = 'Active'
+```
+
+Formula fields are not indexed. This causes a full table scan. Add an
+indexed field filter (e.g., `CreatedDate = THIS_YEAR`) as a companion.
+
+### Anti-pattern 4 — Leading wildcard LIKE on unfiltered large object
+
+```soql
+-- WRONG: leading wildcard defeats index on large object
+SELECT Id, Name FROM Contact WHERE Email LIKE '%@gmail.com'
+```
+
+Add a companion indexed filter (AccountId, OwnerId, CreatedDate) to bound
+the scan before using LIKE.
+
+### Anti-pattern 5 — OFFSET without ORDER BY
+
+```soql
+-- WRONG: OFFSET without ORDER BY produces non-deterministic pages
+SELECT Id FROM Account LIMIT 50 OFFSET 50
+```
+
+Always pair OFFSET with ORDER BY.
+
+### Anti-pattern 6 — Querying encrypted fields
+
+```soql
+-- WRONG: querying an encrypted field
+SELECT Id, Name, SSN__c FROM Contact LIMIT 10
+```
+
+If `SSN__c` has `encrypted: true` in the describe output, remove it.
+The Run As account does not have View Encrypted Data permission and the
+query will either fail or return masked values — either way the result
+is unusable and the attempt must be logged.
+
+### Anti-pattern 7 — DML in a query context (not applicable to CLI but listed for awareness)
+
+```soql
+-- NOT POSSIBLE in sf data query but refuse if attempted
+UPDATE Account SET Name = 'New Name' WHERE Id = '001...'  ← DML, not SOQL SELECT
+```
+
+The `sf data query` command only accepts SELECT statements. Any request
+to execute DML must be refused and routed to the human approval path.
+
+---
+
+## Governor Limit Awareness
+
+| Limit | Value | Notes |
+|---|---|---|
+| Synchronous query rows | 50,000 per transaction | Applies to interactive `sf data query` |
+| Aggregate query rows | 2,000 | GROUP BY result rows |
+| SOQL query depth (subqueries) | 1 level of child subquery | One subquery per query |
+| OFFSET maximum | 2,000 | Hard limit |
+| Bulk API batch size | 10,000 rows | Handled by bulk ops skill |
+
+
+If a query would approach the 50,000-row synchronous limit, add a tighter
+LIMIT or date range filter, or route to `salesforce-bulk-data-ops-skill`.

package/skills/salesforce/salesforce-soql-generator-skill/SKILL.md

@@ -0,0 +1,305 @@
+---
+name: salesforce-soql-generator-skill
+description: "Generates SOQL queries from natural-language requirements without executing them. T0 generation skill — emits ready-to-paste SOQL with selectivity analysis, governor-limit guidance, and a 100-point quality score. Pairs with salesforce-soql-explorer-skill for live execution. TRIGGER when: user describes a query in plain English, asks for SOQL syntax help, needs an aggregate or relationship query, wants a pipeline hygiene query, needs report-equivalent SOQL. Trigger phrases: \"write SOQL for\", \"how do I query\", \"give me a SOQL query\", \"find all opportunities where\", \"count contacts with\", \"pipeline by stage SOQL\", \"stale leads query\". DO NOT TRIGGER when: the query needs to be executed live (use salesforce-soql-explorer-skill); when DML is required (T3 — escalate); when the user wants permission-set diagnostic SOQL (specialized form — use salesforce-permission-model-review-skill)."
+license: MIT
+allowed-tools: Read Grep Glob
+metadata:
+  author: "github: Raishin"
+  version: 0.1.0
+  updated: 2026-05-21
+  category: generation
+  lifecycle: experimental
+  execution_tier: static-review
+  mcp_servers: []
+  oauth_scopes: []
+  run_as_permissions:
+---
+
+# salesforce-soql-generator-skill
+
+Pure generation skill — plain English to production-ready SOQL. This skill
+is a **translator**, not an executor. It produces ready-to-paste queries with
+selectivity analysis and governor-limit guidance, then hands off to
+`salesforce-soql-explorer-skill` for live execution.
+
+## When This Skill Owns the Task
+
+Use `salesforce-soql-generator-skill` when the work requires **query authoring**
+from a description, not live data retrieval:
+
+- "Write SOQL to find all opportunities closing this quarter with no next step"
+- "Give me a query to count contacts by account with no email"
+- "How do I query stale leads not modified in 90 days?"
+- "I need aggregate SOQL for pipeline by stage and owner"
+- "Generate the SOQL equivalent of this report"
+
+**Delegate elsewhere when:**
+
+| Situation | Skill to use |
+|---|---|
+| Query must be executed against a live org | `salesforce-soql-explorer-skill` |
+| User needs permission-set or profile diagnostic SOQL | `salesforce-permission-model-review-skill` |
+| Query result will drive DML or automation | Review with `salesforce-metadata-review-skill` first |
+| Apex selector pattern needed (not raw SOQL) | `querying-soql` (sf-skills) |
+| Report or dashboard conversion | Assess whether SOQL truly maps to Report; flag gap |
+
+---
+
+## Required Context to Gather First
+
+Before generating any query, confirm or infer:
+
+1. **Target sObject** — API name (e.g., `Opportunity`, `Lead`, `Contact`,
+   `My_Custom_Object__c`). Is this a single-object or multi-level relationship
+   query?
+2. **Fields needed** — enumerate explicitly, or accept 'minimal' and choose
+   the fewest informative fields.
+3. **Filter criteria** — WHERE conditions, date literals, owner scope, record
+   type, status values.
+4. **Sort and pagination** — ORDER BY field, ASC/DESC, LIMIT, OFFSET if needed.
+5. **Intended use** — display in UI, CSV export, automation trigger, Apex
+   selector, or report equivalent. Affects LIMIT choice and field set.
+6. **Expected result volume** — rough estimate. Affects selectivity guidance.
+7. **Relationship depth** — parent lookup traversal, child subquery, or
+   polymorphic relationship?
+
+If any of these are ambiguous, make a conservative assumption, state it
+explicitly, and offer an alternative.
+
+---
+
+## Recommended Workflow
+
+### Step 1 — Confirm target sObject and primary purpose
+
+Identify the root sObject and clarify whether the query is for:
+- Record retrieval (display, export)
+- Aggregate analysis (GROUP BY, COUNT, SUM)
+- Relationship traversal (parent fields from child, child subquery from parent)
+- Anti-join / semi-join (NOT IN, EXISTS equivalent)
+
+State the confirmed interpretation before generating.
+
+### Step 2 — Generate the simplest correct query
+
+Apply these constraints from the start:
+- Only enumerate required fields — no `SELECT *`
+- Use the most selective WHERE clause available (indexed fields first)
+- Apply LIMIT appropriate to the use case (default 200 for display, omit for
+  aggregates that return few rows, use 50000-ceiling awareness for exports)
+- Traverse relationships only as deep as necessary
+
+Produce one canonical query first, then offer variants.
+
+### Step 3 — Score selectivity
+
+Evaluate the generated query against the selectivity rubric:
+
+- Does the WHERE clause use at least one **indexed field**? (Id, Name, OwnerId,
+  ExternalId__c, CreatedDate, standard lookup fields, custom external IDs)
+- Is a LIMIT present (where appropriate)?
+- Is the field count ≤ 10?
+- Are date literals used correctly (TODAY, THIS_WEEK, LAST_N_DAYS:n)?
+- Are formula fields or non-indexed fields used in WHERE without a companion
+  indexed filter?
+
+Document the selectivity assessment inline.
+
+### Step 4 — Add governor-limit guidance
+
+For every generated query, provide:
+- Estimated row return range and relationship to the 50,000-row limit
+- Whether a LIMIT is essential or advisory
+- Whether the query is safe to embed in a transaction (≤ 100 SOQL queries per
+  transaction ceiling awareness)
+- Whether `USING SCOPE` or `FOR REFERENCE` / `FOR VIEW` / `FOR UPDATE` locking
+  hints apply
+
+### Step 5 — Provide variant queries
+
+Emit at least two variants beyond the canonical query:
+- **Filtered variant** — narrower scope (add date filter, status filter, or
+  owner scope)
+- **Aggregate variant** — GROUP BY with COUNT / SUM where applicable
+- **Paginated variant** — with LIMIT + OFFSET or a keyset-pagination pattern
+  using WHERE Id > :lastId when the result set could exceed one page
+
+### Step 6 — Output ready-to-paste SOQL and handoff recommendation
+
+Emit the structured output (see Output Format). Always include a
+`handoff_recommendation` pointing to `salesforce-soql-explorer-skill` for
+live execution, or to the appropriate review skill if the query surfaces a
+governance concern.
+
+---
+
+## Quality Scoring Rubric (100-point)
+
+Score every generated query before emitting. Threshold: 80+ acceptable for
+paste-ready output; 60–79 emit with caveat; below 60 revise before emitting.
+
+| Dimension | Points | What earns full marks |
+|---|---|---|
+| **Selectivity** | 30 | WHERE uses at least one indexed field; no full-table-scan pattern on objects likely > 10k records |
+| **Field minimality** | 20 | Only required fields; no `SELECT *`; field count ≤ 10 for display queries |
+| **LIMIT present** | 15 | LIMIT applied where result set could be unbounded; aggregate queries exempt when GROUP BY guarantees few rows |
+| **Syntax correctness** | 20 | Valid SOQL syntax; correct relationship traversal notation; correct date literal usage; no reserved word conflicts |
+| **Governor-limit safety** | 15 | Row return estimate well below 50k ceiling; embeddable in transaction; no query-in-loop anti-pattern implied |
+
+**Scoring penalties:**
+- No WHERE clause on a high-volume object (> 50k records likely): −20
+- `SELECT *` pattern: −15
+- Missing LIMIT on unbounded query: −15
+- Formula field in WHERE without indexed companion: −10
+- Incorrect date literal syntax: −10
+
+---
+
+## Output Format
+
+```yaml
+generated_query: |
+  SELECT <fields>
+  FROM <SObject>
+  WHERE <filter>
+  ORDER BY <field> <ASC|DESC>
+  LIMIT <n>
+
+interpretation: "<what was understood from the natural-language request>"
+
+alternate_queries:
+  filtered: |
+    SELECT <fields>
+    FROM <SObject>
+    WHERE <narrower filter>
+    LIMIT <n>
+  aggregate: |
+    SELECT <grouping_field>, COUNT(Id) record_count
+    FROM <SObject>
+    WHERE <filter>
+    GROUP BY <grouping_field>
+  paginated: |
+    SELECT <fields>
+    FROM <SObject>
+    WHERE Id > :lastId AND <filter>
+    ORDER BY Id ASC
+    LIMIT 200
+
+selectivity_analysis:
+  indexed_filters_used: ["<field1>", "<field2>"]
+  non_indexed_filters: ["<field>"]
+  full_table_scan_risk: "low | medium | high"
+  notes: "<explanation>"
+
+governor_limit_notes:
+  estimated_row_range: "<low estimate> – <high estimate>"
+  limit_advisory: "<why this LIMIT was chosen>"
+  transaction_safe: true | false
+  notes: "<any ceiling-proximity warnings>"
+
+suggested_index:
+  - field: "<FieldApiName>"
+    reason: "<why an index on this field would help>"
+
+score: <0-100>
+score_breakdown:
+  selectivity: <0-30>
+  field_minimality: <0-20>
+  limit_present: <0-15>
+  syntax_correctness: <0-20>
+  governor_limit_safety: <0-15>
+score_notes: "<what drove the score; any penalties applied>"
+
+handoff_recommendation:
+  execute_live: "salesforce-soql-explorer-skill"
+  governance_review: "<skill if a concern surfaced, else 'none'>"
+  notes: "<when to execute, any pre-execution checks>"
+
+assumptions:
+  - "<explicit list of assumptions made where input was ambiguous>"
+```
+
+---
+
+## Handoff Rules
+
+| Situation | Hand off to |
+|---|---|
+| User wants to execute the generated query against a live org | `salesforce-soql-explorer-skill` |
+| Query reveals a governance or access concern | `salesforce-permission-model-review-skill` |
+| Query is a Report-equivalent but a Report likely meets the need | Note the gap; suggest the Report builder as an alternative |
+| Permission diagnostic SOQL needed | `salesforce-permission-model-review-skill` |
+| Apex selector pattern needed | `querying-soql` (sf-skills reference) |
+
+---
+
+## Common Pitfalls
+
+These are the most frequent errors in generated SOQL. Check each before
+emitting the final query.
+
+### SELECT * pattern
+
+SOQL does not support `SELECT *`. Always enumerate fields. When fields are
+unknown, use a minimal set (`Id`, `Name`, one or two distinguishing fields)
+and note that the user should expand once the schema is confirmed.
+
+### Missing LIMIT
+
+Any query on a high-volume object without a LIMIT risks hitting the 50,000-row
+governor ceiling or causing a query timeout. Always include LIMIT unless:
+- The query is a COUNT aggregate with GROUP BY that produces few groups
+- The user has explicitly confirmed they need all records and the object has
+  low cardinality
+
+### Non-indexed filters
+
+Filtering on formula fields, long-text-area fields, or custom fields without
+an explicit custom index is a common performance trap. Always flag these in
+`selectivity_analysis.non_indexed_filters` and recommend that the user check
+with their Salesforce admin whether a custom index exists or is needed.
+
+### Date literals
+
+Use Salesforce date literal syntax precisely:
+- `TODAY`, `YESTERDAY`, `TOMORROW`
+- `THIS_WEEK`, `LAST_WEEK`, `NEXT_WEEK`
+- `THIS_MONTH`, `LAST_MONTH`, `NEXT_MONTH`
+- `THIS_QUARTER`, `LAST_QUARTER`, `NEXT_QUARTER`
+- `THIS_YEAR`, `LAST_YEAR`, `NEXT_YEAR`
+- `LAST_N_DAYS:n`, `NEXT_N_DAYS:n`
+- `LAST_N_WEEKS:n`, `NEXT_N_WEEKS:n`
+- `LAST_N_MONTHS:n`, `NEXT_N_MONTHS:n`
+
+Do not mix date literals with datetime comparisons without explicit timezone
+handling. Salesforce date literals respect the running user's timezone.
+
+### Formula fields in WHERE
+
+Formula fields are not indexed and cannot use standard indexes. Including a
+formula field in a WHERE clause without a companion indexed filter forces a
+full table scan. Flag this in `selectivity_analysis` and suggest an
+alternative (e.g., use the underlying source fields instead of the formula).
+
+### Polymorphic relationships
+
+Querying the `Who` or `What` fields on `Task` / `Event`, or the `Owner`
+field when it can be a User or Queue, requires a `TYPEOF` expression or a
+`Type` filter. Incorrect assumptions produce incomplete results. Always
+clarify whether the relationship is polymorphic and use `TYPEOF` where needed.
+
+### Deep relationship traversal
+
+SOQL allows up to 5 levels of parent traversal and up to 1 level of child
+subquery nesting (for relationship queries). Beyond these limits, the query
+will fail at runtime. Flag any traversal depth that approaches the limit.
+
+---
+
+## Reference File Index
+
+| File | When to read |
+|---|---|
+| `references/soql-syntax-quickref.md` | Syntax reference for SELECT, WHERE, GROUP BY, HAVING, ORDER BY, LIMIT, FOR clauses |
+| `references/common-patterns.md` | Pre-built patterns for pipeline, stale records, ownership audit, junction objects |
+| `references/governor-limits.md` | Row limits, query count limits, LDV considerations, index guidance |

package/skills/salesforce/salesforce-soql-generator-skill/metadata.json

@@ -0,0 +1,25 @@
+{
+  "id": "salesforce-soql-generator-skill",
+  "name": "Salesforce SOQL Generator Skill",
+  "type": "skill",
+  "provider": "salesforce",
+  "harnesses": ["claude-code", "codex", "cursor", "gemini", "kiro", "other"],
+  "summary": "Generates SOQL queries from plain-English requirements without executing them. T0 static-review skill — emits ready-to-paste SOQL with selectivity analysis, governor-limit guidance, and a 100-point quality score. Pairs with salesforce-soql-explorer-skill for live execution. No org connection required.",
+  "source_type": "original",
+  "category": "generation",
+  "execution_tier": "static-review",
+  "oauth_scopes": [],
+  "mcp_servers": [],
+  "run_as_permissions": {},
+  "official_docs": [
+    "https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql.htm",
+    "https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_select.htm",
+    "https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_select_conditionexpression.htm",
+    "https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/langCon_apex_SOQL_govlimits.htm"
+  ],
+  "security_notes": "T0 static-review only. No org connection, no OAuth, no MCP calls. Purely generative — emits query text for human review before any live execution. No secrets, credentials, or org data handled. Handoff to salesforce-soql-explorer-skill for live execution under T1 least-privilege scope.",
+  "last_verified": "2026-05-21",
+  "path": "skills/salesforce/salesforce-soql-generator-skill",
+  "author": "github: Raishin",
+  "version": "0.1.0"
+}