@securityreviewai/securityreview-kit 0.1.50 → 0.1.52

package/src/generators/rules/guardrails-selection/references/category-threat-map.md

@@ -0,0 +1,232 @@
+# Guardrail Selection Threat Map
+
+Use this file when deciding which guardrail categories apply to the current task and which threat families should influence the shortlist.
+
+The intent is not to produce a full threat model here. The intent is to make sure likely exploit paths influence which guardrails are fetched by id and enforced during implementation.
+
+## How to use this map
+
+1. Start from the feature or code change.
+2. Infer the categories involved in the implementation.
+3. Use the mappings below to identify likely threat families.
+4. Shortlist guardrails that directly or adjacently mitigate those threats.
+5. Fetch those guardrails with `get_guardrail_by_id`.
+
+## STRIDE-style mappings for guardrail selection
+
+### Spoofing
+
+Usually maps to authentication and session-related controls.
+
+Threat patterns to consider:
+
+- identity-related attacks
+- session and token attacks
+- business-logic attacks leading to authentication bypass
+- injection attacks leading to authentication bypass
+- serialization attacks leading to authentication bypass
+- cryptographic attacks leading to authentication bypass
+- lapses in logging leading to authentication bypass
+- client-side trust leading to authentication bypass
+
+Categories commonly shortlisted:
+
+- `authentication`
+- `session_management`
+- `cryptography`
+- `logging`
+- `client_side`
+- `business_logic`
+- `input_validation`
+- `deserialization`
+
+### Tampering
+
+Usually maps to authorization, integrity, and unsafe state change controls.
+
+Threat patterns to consider:
+
+- broken object level access control patterns
+- broken functional level access control patterns
+- injection-driven authorization bypass
+- serialization-driven authorization bypass
+- business-logic-driven authorization bypass
+- client-side trust leading to unauthorized state changes
+
+Categories commonly shortlisted:
+
+- `authorization`
+- `tenant_isolation`
+- `data_access`
+- `business_logic`
+- `logging`
+- `input_validation`
+- `deserialization`
+- `client_side`
+
+### Repudiation
+
+Usually appears when spoofing and tampering are possible but the system cannot prove what happened.
+
+Threat patterns to consider:
+
+- weak or missing audit trails for auth and authorization decisions
+- missing actor attribution on sensitive state changes
+- mutable or incomplete event records
+- inability to correlate session, actor, and resource changes
+
+Categories commonly shortlisted:
+
+- `logging`
+- `monitoring`
+- `authentication`
+- `authorization`
+- `admin_workflows`
+
+### Information Disclosure
+
+Usually maps to authorization, data exposure, logging, and unsafe client-side trust.
+
+Threat patterns to consider:
+
+- broken object level access control patterns
+- broken functional level access control patterns
+- injection-driven information disclosure
+- serialization-driven information disclosure
+- business-logic-driven information disclosure
+- lapses in logging leading to disclosure
+- client-side trust causing exposure of protected data
+
+Categories commonly shortlisted:
+
+- `authorization`
+- `tenant_isolation`
+- `data_access`
+- `logging`
+- `input_validation`
+- `deserialization`
+- `client_side`
+- `output_encoding`
+
+### Denial of Service
+
+Usually maps to workload protection, parsing safety, quota controls, and expensive query behavior.
+
+Threat patterns to consider:
+
+- broken access control patterns that expose heavy operations
+- injection or data-access paths that amplify resource consumption
+- serialization-driven memory or parser exhaustion
+- business-logic-driven abuse of expensive workflows
+- logging lapses that hide repeated abuse
+
+Categories commonly shortlisted:
+
+- `rate_limiting`
+- `input_validation`
+- `file_uploads`
+- `deserialization`
+- `data_access`
+- `network`
+- `monitoring`
+- `logging`
+- `business_logic`
+
+### Elevation of Privilege
+
+Usually maps to authorization, role boundaries, trust decisions, and privileged workflow controls.
+
+Threat patterns to consider:
+
+- access control bypasses from broken object or function level access
+- injection-based privilege escalation
+- client-side induced privilege escalation
+- serialization-induced privilege escalation
+- business-logic-triggered privilege escalation
+- logging lapses that conceal privilege abuse
+
+Categories commonly shortlisted:
+
+- `authorization`
+- `tenant_isolation`
+- `admin_workflows`
+- `business_logic`
+- `client_side`
+- `input_validation`
+- `deserialization`
+- `logging`
+
+## Fast examples
+
+### Add password reset flow
+
+Likely categories:
+
+- `authentication`
+- `session_management`
+- `cryptography`
+- `logging`
+- `rate_limiting`
+
+Likely threat families:
+
+- spoofing
+- repudiation
+- information disclosure
+
+### Add admin endpoint to change user role
+
+Likely categories:
+
+- `authorization`
+- `tenant_isolation`
+- `admin_workflows`
+- `logging`
+- `business_logic`
+
+Likely threat families:
+
+- tampering
+- repudiation
+- elevation of privilege
+- information disclosure
+
+### Add bulk import endpoint
+
+Likely categories:
+
+- `input_validation`
+- `file_uploads`
+- `deserialization`
+- `data_access`
+- `logging`
+- `rate_limiting`
+
+Likely threat families:
+
+- tampering
+- information disclosure
+- denial of service
+
+### Move entitlement checks to the frontend
+
+Likely categories:
+
+- `authorization`
+- `client_side`
+- `tenant_isolation`
+- `logging`
+
+Likely threat families:
+
+- tampering
+- information disclosure
+- elevation of privilege
+
+## Selection reminders
+
+- A feature can require guardrails from multiple categories.
+- Shortlist for exploit chains, not isolated weaknesses.
+- Logging often matters because poor auditability can turn spoofing, tampering, or privilege abuse into repudiation.
+- Client-side logic often needs server-side guardrails even if the visible change is in the UI.
+- If no existing guardrail covers a realistic recurring threat, create an `ide_generated` guardrail and carry it into the final VibeReview markdown sync.

package/src/generators/rules/guardrails_rule.md

@@ -0,0 +1,94 @@
+# Vibe Guardrails — Secure by Code
+
+**Enforce project-specific security guardrails during every code-generation task.**
+
+This rule complements the PWNISMS threat model ("secure by design") with concrete, project-level coding dos and don'ts ("secure by code"). Guardrails are maintained in SRAI and fetched via `security-review-mcp`.
+
+---
+
+## When this rule applies
+
+This rule is **active for every code-generation or code-modification task** — including:
+
+- Implementing new features or endpoints
+- Fixing bugs that touch security-relevant code
+- Refactoring code that handles auth, input, secrets, data storage, or network
+- Generating boilerplate, scaffolding, or templates that will run in production
+
+### When to skip
+
+Skip guardrail enforcement for tasks with **no code output** (documentation, Q&A, formatting, renaming).
+
+---
+
+## Required behavior
+
+### 1. Use the guardrails-selection skill at the start of every code task
+
+Before writing or modifying code, you must read and follow `{{GUARDRAILS_SELECTION_SKILL_DIR}}/SKILL.md`.
+
+That skill is mandatory because the IDE must not leave guardrail selection to chance. The required workflow is:
+
+- **Analyze the task first** — infer what the user is actually building, what components are touched, what categories are involved, and what threats might occur.
+- **Resolve the project** — use `find_project_by_name` with `name="<SRAI_PROJECT_NAME>"` to obtain `project_id`.
+- **Load the broad catalog** — call `get_guardrails` with `project_id`.
+- **Shortlist intentionally** — choose only the guardrails that mitigate the categories and likely threats for the current task.
+- **Hydrate the exact shortlist** — call `get_guardrail_by_id` for the shortlisted guardrail ids so implementation uses the exact selected guardrails, not a vague reading of the full catalog.
+- **Preserve the shortlist** — keep the selected existing guardrails in context so the final VibeReview markdown can include the same guardrails later without re-querying.
+
+The broad `get_guardrails` result is only the candidate catalog. The active implementation guardrails must come from the shortlisted `get_guardrail_by_id` result.
+
+Each guardrail used for implementation should preserve these fields:
+
+| Field | Description |
+|---|---|
+| `id` | Stable guardrail identifier used with `get_guardrail_by_id` |
+| `title` | Short name of the guardrail |
+| `rule_type` | `must` (mandatory) or `must_not` (prohibition) |
+| `category` | Grouping label (e.g. `authentication`, `input_validation`, `secrets`) or `null` |
+| `instruction` | The actionable coding directive |
+
+If `get_guardrails` returns additional metadata such as `source_ref`, use it as supporting context during selection.
+
+### 2. Apply guardrails during code generation
+
+- **`must` rules (DOs):** Treat as mandatory implementation requirements. Every line of generated code must satisfy all applicable `must` guardrails.
+- **`must_not` rules (DON'Ts):** Treat as hard prohibitions. Generated code must never violate a `must_not` guardrail.
+- If a guardrail conflicts with the user's explicit instruction, **flag the conflict** to the user and ask for confirmation before proceeding.
+- If no guardrails are returned (empty list), proceed normally using baseline PWNISMS controls.
+
+### 3. Cross-reference with PWNISMS
+
+Guardrails and PWNISMS are complementary:
+
+- Guardrails provide **project-specific, concrete rules** derived from prior threat reviews, compliance requirements, and team decisions.
+- PWNISMS provides **universal threat-category coverage** to catch gaps that guardrails may not yet cover.
+- When PWNISMS analysis reveals a gap not covered by any existing guardrail, **create a new guardrail on the fly** and apply it immediately (marked `source: "ide_generated"` in the VibeReview markdown).
+
+### 4. Report guardrail compliance
+
+After code generation, include a brief guardrails compliance summary:
+
+- List which guardrails were applied (by title), distinguishing existing vs IDE-generated.
+- Flag any guardrails that could not be fully satisfied and explain why.
+- Do not drop shortlisted existing guardrails from session context. The final VibeReview markdown must include the same shortlist, including any unsatisfied items with notes.
+
+---
+
+## Guardrail lifecycle — updates and new guardrails
+
+Guardrails are living artifacts. The IDE agent can create, apply, and update them:
+
+- **New guardrail**: When threat modeling or code review reveals a recurring security pattern not yet captured, the IDE agent creates and applies a new guardrail on the fly. These are reported to SRAI in the final VibeReview markdown with `source: "ide_generated"`.
+- **Edit suggestion**: When an existing guardrail is too broad, too narrow, or outdated, suggest an update to the user.
+- All guardrails — existing and IDE-generated — must be preserved in the VibeReview markdown under a single `Guardrails Applied` section that the server can normalize into `guardrails_applied`.
+
+---
+
+## Tool Reference
+
+| Tool | Purpose |
+|---|---|
+| `get_guardrails` | Fetch the broad project guardrails catalog (requires `project_id`) |
+| `get_guardrail_by_id` | Fetch the exact shortlisted guardrails that will govern implementation |
+| `find_project_by_name` | Resolve project by name to get `project_id` |

package/src/generators/rules/hooks.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "command": "printf '%s\\n' '{\"additional_context\":\"## MANDATORY SECURITY GATE (Session Policy)\\n\\nFor ANY user request that has security impact (auth, crypto, input handling, secrets, network, data storage, dependencies, new APIs/endpoints, or any code handling untrusted data):\\n\\n**Plan order:**\\n1. **Fetch Vibe Guardrails (first)** - Use .cursor/skills/guardrails-selection/SKILL.md. Analyze the task, call get_guardrails from security-review-mcp to load the broad catalog, shortlist the relevant guardrails, then call get_guardrail_by_id for the shortlist. These exact shortlisted guardrails are the hard constraints on generated code.\\n2. **PWNISMS threat modeling (second)** - Run threat modeling as a guide before writing code. Use .cursor/skills/threat-modelling/SKILL.md. Cross-reference guardrails with PWNISMS findings to identify gaps. Document findings to inform secure implementation.\\n3. **Implement secure code (third)** - Use the threat model findings AND shortlisted guardrails as guides to create secure code. Every must guardrail must be satisfied; no must_not guardrail may be violated.\\n4. **VibeReview sync (last)** - Read .cursor/skills/vibereview-sync/SKILL.md. The main agent must write a structured `.md` artifact under `vibereview/`, must not read sibling markdown files there just to infer format, must validate that all required metadata and sections are present, and must call `sync_ai_ide_markdown` directly after implementation is done. Include the exact shortlisted guardrails from earlier plus any IDE-generated guardrails in the markdown; do not query guardrails again during sync.\\n\\nNo blocking. No deferral. Guardrails enforce secure code; threat modeling guides the design; the main agent owns the final markdown sync to SRAI. Both sync and guardrail compliance are mandatory and should be part of your to-do.\"}'",
+        "timeout": 5
+      }
+    ]
+  }
+}

package/src/generators/rules/srai-profile.md

@@ -0,0 +1,32 @@
+---
+name: srai-profile
+description: Create and upload a SecurityReviewAI code profile using security-review-mcp
+---
+
+# SRAI Profile Uploader
+
+Create a code profile from the current request and upload it to SRAI using `security-review-mcp`.
+
+Configured SRAI project name: `<SRAI_PROJECT_NAME>`
+
+## Steps
+
+1. Determine scope from the user prompt.
+   - If the request is about a specific capability/module/endpoint, produce a **Feature Code Profile**.
+   - If the request is broad, exploratory, or architecture-level, produce a **Codebase Code Profile**.
+2. Build detailed profile content before any upload call.
+   - Include purpose, boundaries, entry points, sensitive data, trust boundaries, integrations, threats, controls, and open risks.
+3. Resolve the SRAI project.
+   - Use the configured project name by default; if it is missing or ambiguous, ask the user to confirm it.
+   - Call `find_project_by_name` with `name="<SRAI_PROJECT_NAME>"`.
+   - If missing, call `list_projects`; if still missing, call `create_project` with `name="<SRAI_PROJECT_NAME>"`.
+4. Upload generated markdown content with tool 11: `upload_document`.
+   - Use this for raw markdown/text generated in the chat.
+   - Use a clear document name such as `feature-code-profile-<feature>.md` or `codebase-code-profile-<repo>.md`.
+5. Upload files/diagrams with tool 10: `upload_document` when needed.
+   - Provide base64 file content and file name.
+   - Set `document_type` to `Component Diagram` for architecture diagrams.
+   - Set `document_type` to `Uploaded Knowledgebase doc` for other document uploads.
+6. Confirm the result.
+   - Report project name, upload tool used, document name, and that processing is asynchronous.
+   - If upload fails, return exact error details and next retry step.

package/src/generators/rules/vscode.js

@@ -0,0 +1,101 @@
+import { existsSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+    GUARDRAILS_SELECTION_SKILL_REL_DIR,
+    THREAT_MODELLING_SKILL_REL_DIR,
+    VIBEREVIEW_SYNC_SKILL_REL_DIR,
+} from '../../utils/constants.js';
+import { upsertSentinelBlock, writeText } from '../../utils/fs-helpers.js';
+import { getRuleContent, getThreatModellingSkillContent, getVibeReviewSyncSkillContent } from './content.js';
+
+function writeGeneratedText(filePath, content) {
+    const action = existsSync(filePath) ? 'updated' : 'created';
+    writeText(filePath, content);
+    return { filePath, action };
+}
+
+function removeGeneratedText(filePath) {
+    if (existsSync(filePath)) {
+        unlinkSync(filePath);
+        return { filePath, action: 'deleted' };
+    }
+    return null;
+}
+
+function getCopilotSessionHookContent() {
+    const additionalContext = [
+        '## MANDATORY SECURITY GATE (Session Policy)',
+        '',
+        'For any request with security impact (auth, authorization, crypto, input handling, secrets, network, data storage, dependencies, new APIs/endpoints, infrastructure, or code handling untrusted data), follow this order:',
+        '',
+        '1. Fetch Vibe Guardrails first using .github/skills/guardrails-selection/SKILL.md. Resolve the project, call get_guardrails, shortlist relevant guardrails, then call get_guardrail_by_id for the shortlist.',
+        '2. Run PWNISMS threat modelling using .github/skills/threat-modelling/SKILL.md. Explicitly walk Product, Workload, Network, IAM, Secrets, Monitoring, and Supply Chain.',
+        '3. Implement secure code using both the hydrated guardrails and PWNISMS findings.',
+        '4. Read .github/skills/vibereview-sync/SKILL.md. Write a structured .md artifact under vibereview/, do not read sibling markdown files there just to infer format, validate it, and call sync_ai_ide_markdown directly after threat modelling or guardrail enforcement. Reuse the exact guardrail shortlist; do not re-query guardrails during the final sync.',
+        '',
+        'Do not use project-profile exploration tools during normal coding tasks. No blocking and no deferral: guardrails first, PWNISMS second, implementation third, VibeReview sync last.',
+    ].join('\n');
+
+    const commandPayload = JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: 'SessionStart',
+            additionalContext,
+        },
+    });
+
+    return JSON.stringify(
+        {
+            hooks: {
+                SessionStart: [
+                    {
+                        type: 'command',
+                        command: `printf '%s\\n' '${commandPayload.replaceAll("'", "'\\''")}'`,
+                        timeout: 5,
+                    },
+                ],
+            },
+        },
+        null,
+        2,
+    ) + '\n';
+}
+
+/**
+ * Generate VS Code Copilot instructions — appends to .github/copilot-instructions.md
+ */
+export function generate(cwd, options = {}) {
+    const optionsWithSkillDirs = {
+        ...options,
+        guardrailsSelectionSkillDir: GUARDRAILS_SELECTION_SKILL_REL_DIR.vscode,
+        threatModellingSkillDir: THREAT_MODELLING_SKILL_REL_DIR.vscode,
+        vibereviewSyncSkillDir: VIBEREVIEW_SYNC_SKILL_REL_DIR.vscode,
+    };
+    const filePath = join(cwd, '.github', 'copilot-instructions.md');
+    const content = getRuleContent(optionsWithSkillDirs);
+    const action = upsertSentinelBlock(filePath, content);
+
+    const threatSkillPath = join(cwd, THREAT_MODELLING_SKILL_REL_DIR.vscode, 'SKILL.md');
+    const threatSkill = writeGeneratedText(
+        threatSkillPath,
+        getThreatModellingSkillContent(optionsWithSkillDirs),
+    );
+
+    const vibereviewSyncSkillPath = join(cwd, VIBEREVIEW_SYNC_SKILL_REL_DIR.vscode, 'SKILL.md');
+    const vibereviewSyncSkill = writeGeneratedText(
+        vibereviewSyncSkillPath,
+        getVibeReviewSyncSkillContent(optionsWithSkillDirs),
+    );
+
+    const deletedLegacyAgent = removeGeneratedText(join(cwd, '.github', 'agents', 'ctm_sync.agent.md'));
+
+    const hooksPath = join(cwd, '.github', 'hooks', 'srai-session-policy.json');
+    const hooks = writeGeneratedText(hooksPath, getCopilotSessionHookContent());
+
+    return [
+        { filePath, action, kind: 'rule' },
+        { ...threatSkill, kind: 'skill' },
+        { ...vibereviewSyncSkill, kind: 'skill' },
+        { ...hooks, kind: 'hooks' },
+        ...(deletedLegacyAgent ? [{ ...deletedLegacyAgent, kind: 'cleanup' }] : []),
+    ];
+}

package/src/generators/rules/vscode.test.js

@@ -0,0 +1,54 @@
+import { existsSync, mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { generate } from './vscode.js';
+
+test('VS Code Copilot generator writes instructions, skills, and hooks', () => {
+    const cwd = mkdtempSync(join(tmpdir(), 'securityreview-kit-vscode-'));
+
+    const results = generate(cwd, { projectName: 'SmokeProject' });
+
+    const expectedPaths = [
+        '.github/copilot-instructions.md',
+        '.github/skills/threat-modelling/SKILL.md',
+        '.github/skills/vibereview-sync/SKILL.md',
+        '.github/hooks/srai-session-policy.json',
+    ];
+
+    for (const relPath of expectedPaths) {
+        assert.equal(existsSync(join(cwd, relPath)), true, `${relPath} should exist`);
+    }
+
+    assert.deepEqual(results.map((entry) => entry.kind), ['rule', 'skill', 'skill', 'hooks']);
+
+    const instructions = readFileSync(join(cwd, '.github/copilot-instructions.md'), 'utf8');
+    assert.match(instructions, /\.github\/skills\/guardrails-selection\/SKILL\.md/);
+    assert.match(instructions, /\.github\/skills\/threat-modelling\/SKILL\.md/);
+    assert.match(instructions, /\.github\/skills\/vibereview-sync\/SKILL\.md/);
+    assert.match(instructions, /sync_ai_ide_markdown/);
+    assert.match(instructions, /vibereview\//);
+    assert.doesNotMatch(instructions, /\.cursor/);
+
+    const threatSkill = readFileSync(join(cwd, '.github/skills/threat-modelling/SKILL.md'), 'utf8');
+    for (const heading of ['Product', 'Workload', 'Network', 'IAM', 'Secrets', 'Monitoring', 'Supply Chain']) {
+        assert.match(threatSkill, new RegExp(heading));
+    }
+    assert.match(threatSkill, /sync_ai_ide_markdown/);
+    assert.match(threatSkill, /vibereview\//);
+    assert.doesNotMatch(threatSkill, /get_project_profile_description/);
+
+    const vibereviewSkill = readFileSync(join(cwd, '.github/skills/vibereview-sync/SKILL.md'), 'utf8');
+    assert.match(vibereviewSkill, /Do not read other/i);
+    assert.match(vibereviewSkill, /sync_ai_ide_markdown/);
+    assert.match(vibereviewSkill, /Guardrails Applied/);
+    assert.match(vibereviewSkill, /Practice 1/);
+    assert.match(vibereviewSkill, /practice_name:/);
+
+    const hooks = JSON.parse(readFileSync(join(cwd, '.github/hooks/srai-session-policy.json'), 'utf8'));
+    assert.equal(hooks.hooks.SessionStart[0].type, 'command');
+    assert.match(hooks.hooks.SessionStart[0].command, /vibereview/);
+    assert.match(hooks.hooks.SessionStart[0].command, /sync_ai_ide_markdown/);
+    assert.match(hooks.hooks.SessionStart[0].command, /vibereview-sync\/SKILL\.md/);
+});

package/src/generators/rules/windsurf.js

@@ -0,0 +1,13 @@
+import { join } from 'node:path';
+import { writeText } from '../../utils/fs-helpers.js';
+import { getRuleContent } from './content.js';
+
+/**
+ * Generate Windsurf workspace rule at .windsurf/rules/srai-security-review.md
+ */
+export function generate(cwd, options = {}) {
+    const filePath = join(cwd, '.windsurf', 'rules', 'srai-security-review.md');
+    const content = getRuleContent(options);
+    writeText(filePath, content + '\n');
+    return filePath;
+}

package/src/utils/constants.js

@@ -0,0 +1,95 @@
+// Shared constants for securityreview-kit
+
+export const MCP_SERVER_PACKAGE = '@securityreviewai/security-review-mcp';
+export const MCP_SERVER_NAME = 'security-review-mcp';
+
+export const ENV_VARS = {
+    apiUrl: 'SECURITY_REVIEW_API_URL',
+    apiToken: 'SECURITY_REVIEW_API_TOKEN',
+};
+
+export const TARGETS = {
+    cursor: {
+        name: 'Cursor',
+        mcpConfigPath: '.cursor/mcp.json',
+        rulePath: '.cursor/rules/srai-security-review.mdc',
+        detectDirs: ['.cursor'],
+    },
+    claude: {
+        name: 'Claude Code',
+        mcpConfigPath: '.mcp.json',
+        rulePath: '.claude/CLAUDE.md',
+        ruleMode: 'append',
+        detectDirs: ['.claude'],
+    },
+    vscode: {
+        name: 'VS Code Copilot',
+        mcpConfigPath: '.vscode/mcp.json',
+        rulePath: '.github/copilot-instructions.md',
+        ruleMode: 'append',
+        detectDirs: ['.vscode'],
+    },
+    windsurf: {
+        name: 'Windsurf',
+        mcpConfigPath: '.windsurf/mcp_config.json',
+        rulePath: '.windsurf/rules/srai-security-review.md',
+        detectDirs: ['.windsurf'],
+    },
+    codex: {
+        name: 'Codex',
+        mcpConfigPath: '.codex/config.toml',
+        rulePath: '.codex/AGENTS.md',
+        ruleMode: 'append',
+        detectDirs: ['.codex'],
+    },
+    gemini: {
+        name: 'Gemini CLI',
+        mcpConfigPath: '.gemini/settings.json',
+        rulePath: 'GEMINI.md',
+        ruleMode: 'append',
+        detectDirs: ['.gemini'],
+    },
+    antigravity: {
+        name: 'Antigravity',
+        mcpConfigPath: '.gemini/settings.json',
+        rulePath: '.agent/rules/srai-security-review.md',
+        detectDirs: ['.agent'],
+    },
+};
+
+export const TARGET_NAMES = Object.keys(TARGETS);
+
+/** Relative workspace dirs for the guardrails-profiler skill (per IDE / CLI). */
+export const GUARDRAILS_PROFILER_SKILL_REL_DIR = {
+    cursor: '.cursor/skills/guardrails-profiler',
+    claude: '.claude/skills/guardrails-profiler',
+    vscode: '.github/skills/guardrails-profiler',
+    codex: '.codex/skills/guardrails-profiler',
+};
+
+/** Relative workspace dirs for the guardrails-selection skill (per IDE / CLI). */
+export const GUARDRAILS_SELECTION_SKILL_REL_DIR = {
+    cursor: '.cursor/skills/guardrails-selection',
+    claude: '.claude/skills/guardrails-selection',
+    vscode: '.github/skills/guardrails-selection',
+    codex: '.codex/skills/guardrails-selection',
+};
+
+/** Relative workspace dirs for the PWNISMS threat-modelling skill (per IDE / CLI). */
+export const THREAT_MODELLING_SKILL_REL_DIR = {
+    cursor: '.cursor/skills/threat-modelling',
+    claude: '.claude/skills/threat-modelling',
+    vscode: '.github/skills/threat-modelling',
+    codex: '.codex/skills/threat-modelling',
+};
+
+/** Relative workspace dirs for the VibeReview markdown sync skill (per IDE / CLI). */
+export const VIBEREVIEW_SYNC_SKILL_REL_DIR = {
+    cursor: '.cursor/skills/vibereview-sync',
+    claude: '.claude/skills/vibereview-sync',
+    vscode: '.github/skills/vibereview-sync',
+    codex: '.codex/skills/vibereview-sync',
+};
+
+export const SENTINEL_START = '<!-- securityreview-kit:start -->';
+export const SENTINEL_END = '<!-- securityreview-kit:end -->';