@securityreviewai/securityreview-kit 0.1.35 → 0.1.36

package/README.md

@@ -29,7 +29,7 @@ npx @securityreviewai/securityreview-kit init --switch-project
 |---|---|---|---|
 | Cursor | `cursor` | `.cursor/mcp.json` | `.cursor/rules/srai-security-review.mdc`, `.cursor/rules/ctm_sync_rule.mdc`, `.cursor/commands/ctm_sync.md`, `.cursor/agents/ctm_sync.md`, `.cursor/commands/create-ide-workflow.md`, `.cursor/commands/srai-profile.md`, `.cursor/skills/threat-modelling/SKILL.md` |
 | Claude Code | `claude` | `.claude/settings.json` | `CLAUDE.md` |
-| VS Code Copilot | `vscode` | `.vscode/mcp.json` | `.github/copilot-instructions.md`, `.github/skills/guardrails-profiler/SKILL.md`, `.github/skills/guardrails-selection/SKILL.md` |
+| VS Code Copilot | `vscode` | `.vscode/mcp.json` | `.github/copilot-instructions.md`, `.github/skills/threat-modelling/SKILL.md`, `.github/skills/guardrails-profiler/SKILL.md`, `.github/skills/guardrails-selection/SKILL.md`, `.github/agents/ctm_sync.agent.md`, `.github/hooks/srai-session-policy.json` |
 | Windsurf | `windsurf` | `.windsurf/mcp_config.json` | `.windsurf/rules/srai-security-review.md` |
 | Codex | `codex` | `.codex/config.toml` | `AGENTS.md` |
 | Gemini CLI | `gemini` | `.gemini/settings.json` | `GEMINI.md` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@securityreviewai/securityreview-kit",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "description": "Bootstrap security-review-mcp for AI IDEs and CLI tools",
   "author": "Debarshi Das <debarshi.das@we45.com>",
   "license": "UNLICENSED",
@@ -17,7 +17,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "test": "node --test src/**/*.test.js",
+    "test": "node --test",
     "start": "node bin/securityreview-kit.js"
   },
   "keywords": [

package/src/generators/rules/content.js

@@ -44,6 +44,18 @@ function readTemplate(templateFileName, options = {}) {
         '.cursor/skills/guardrails-selection',
         options.guardrailsSelectionSkillDir,
     );
+    out = injectPathPlaceholder(
+        out,
+        '{{THREAT_MODELLING_SKILL_DIR}}',
+        '.cursor/skills/threat-modelling',
+        options.threatModellingSkillDir,
+    );
+    out = injectPathPlaceholder(
+        out,
+        '{{CTM_SYNC_AGENT_PATH}}',
+        '.cursor/agents/ctm_sync.md',
+        options.ctmSyncAgentPath,
+    );
 
     return out;
 }

package/src/generators/rules/content.md

@@ -1,126 +1,54 @@
-# Security-First Code Generation with PWNISMS Threat Modeling
-
-**THIS RULE IS NON-NEGOTIABLE AND TRIGGERED BEFORE YOU EVEN START THINKING.** You MUST think security-first and perform on-the-go threat modeling using the PWNISMS framework BEFORE and DURING every task whether it's TODO or PLAN or codegen. This is not optional. This is not deferred to a later review. Every line of code you write must be informed by threat awareness.
-
-> **Skill Reference:** Read and apply `.cursor/skills/threat-modelling/SKILL.md` for the full PWNISMS framework — the 7 threat categories, code generation rules, and post-generation checklist. You MUST walk through all 7 categories for every code task that seems security relevant.
->
-> **Guardrail Selection Skill:** In IDEs that support workspace skills, read and apply `{{GUARDRAILS_SELECTION_SKILL_DIR}}/SKILL.md` when fetching guardrails. In other IDEs, follow that same workflow explicitly: analyze the task, shortlist relevant guardrails, and hydrate the exact shortlist with `get_guardrail_by_id`.
-
-### When NOT to apply
-
-Skip PWNISMS, guardrails, and the MCP flow entirely for tasks that have **no security surface**:
-
-- Documentation-only changes (README, comments, changelogs)
-- Code formatting, linting, or style fixes
-- Renaming variables/files with no logic change
-- General Q&A, explanations, or research that produces no code
-- UI copy, typo fixes, or purely cosmetic changes
-- Adding or updating tests that don't touch auth, crypto, or input handling
-
-If in doubt, do a quick mental scan: *does this change touch auth, input handling, secrets, network, data storage, or dependencies?* If **no**, skip. If **yes** or **maybe**, apply.
-
-**MANDATORY POST THREAT MODELLING** ALWAYS invoke `ctm_sync` immediately after threat modelling is generated or updated. This is required on every threat-model run.
-
----
-
-## Two pillars of security enforcement
-
-This workflow enforces security through two complementary pillars:
-
-1. **Secure by Design (PWNISMS)** — Universal threat-category analysis applied to every security-relevant task. Identifies risks and drives architectural/design-level mitigations.
-2. **Secure by Code (Vibe Guardrails)** — Project-specific coding dos and don'ts fetched from SRAI via `get_guardrails`, shortlisted intentionally, and then hydrated via `get_guardrail_by_id`. Enforces concrete implementation rules derived from prior threat reviews, compliance requirements, and team decisions.
-
-Both pillars are **mandatory** for any code-generation task with a security surface. PWNISMS catches broad threats; guardrails enforce project-specific coding standards.
-
----
-
-## MCP Enhancement — `security-review-mcp`
+# Security Review Kit Agent Instructions
 
 Configured SRAI project name: `<SRAI_PROJECT_NAME>`
 
-Assess Task Security Relevance
-
-Before any MCP call, classify the task:
-
-1. Bug fix or refactor with no security surface change — Enrich your context with the profile exploration below, skip review tools
-2. Non-security task — Skip MCP entirely
-3. New feature — Start with full profile exploration, then full MCP flow
-
-When the `security-review-mcp` MCP server is available, use it to **enrich and persist** your threat analysis. This is a force multiplier on top of PWNISMS, not a replacement.
-
-### Enriching Your Analysis — Step-by-Step Profile Exploration
-
-Rather than fetching the entire profile at once, walk through each reasoning block below **in order**. Each step builds context for the next and directly informs your PWNISMS threat modeling.
-
-1. **Find the project** — Call `find_project_by_name` with `name="<SRAI_PROJECT_NAME>"`. If that project does not exist, call `list_projects`. If no project exists, call `create_project`.
-
-2. **Understand what the project does** — Call `get_project_profile_description`.
-   - Use this to frame the threat surface: what data flows exist, what the system's purpose is, and where trust boundaries lie.
-
-3. **Discover technology categories** — Call `list_profile_technology_categories`.
-   - This reveals the broad technology areas (e.g., frontend, backend, database, cloud). Use this to scope which PWNISMS categories are most relevant.
-
-4. **Deep-dive each technology category** — For each category returned above, call `get_project_profile_technology_category` with the category name.
-   - Understand specific frameworks, libraries, and versions. Flag known-vulnerable dependencies for the **Supply Chain (S)** PWNISMS category.
+These instructions are always active for security-relevant coding work. Keep this file as the routing policy; use the skills and agents below for the detailed workflows.
 
-5. **Review architecture notes** — Call `list_project_profile_architecture_notes`.
-   - Identify deployment topology, trust boundaries, and data flow patterns. Feed this into **Workload (W)** and **Network (N)** analysis.
+## Core Workflow
 
-6. **Identify user groups** — Call `list_project_profile_user_groups`.
-   - Map user roles and privilege levels. This directly informs **IAM (I)** and **Product (P)** threat categories.
+For any task that touches auth, authorization, input handling, secrets, network, data storage, dependencies, new APIs/endpoints, infrastructure, or code handling untrusted data:
 
-7. **Get language stacks** — Call `list_project_profile_language_stacks`.
-   - Understand the language/runtime landscape for language-specific vulnerability patterns.
+1. **Fetch Vibe Guardrails first.**
+   - Read and follow `{{GUARDRAILS_SELECTION_SKILL_DIR}}/SKILL.md`.
+   - Resolve the SRAI project with `find_project_by_name` using `name="<SRAI_PROJECT_NAME>"`.
+   - Call `get_guardrails`, shortlist only the relevant project guardrails, then hydrate the exact shortlist with `get_guardrail_by_id`.
+   - Preserve that exact shortlist in context for implementation and CTM sync.
 
-8. **List security controls** — Call `list_project_profile_security_controls`.
-   - Get an overview of existing defenses. For each control that is relevant to the current task, call `get_project_profile_security_control` to get full details.
-   - Cross-reference with your PWNISMS findings: are there gaps in **Secrets (S)**, **Monitoring (M)**, or **IAM (I)**?
+2. **Run PWNISMS threat modelling before implementation.**
+   - Read and follow `{{THREAT_MODELLING_SKILL_DIR}}/SKILL.md`.
+   - Explicitly walk all seven PWNISMS categories: Product, Workload, Network, IAM, Secrets, Monitoring, and Supply Chain.
+   - If a category is not applicable, say so briefly and continue.
+   - Cross-reference each meaningful threat with the shortlisted guardrails.
 
-9. **List compliance requirements** — Call `list_profile_compliance_requirements`.
-   - For each requirement relevant to the task, call `get_profile_compliance_requirement` for full details.
-   - Map these to security objectives and ensure your implementation meets them.
+3. **Implement secure code using both inputs.**
+   - Treat applicable `must` guardrails as mandatory.
+   - Treat applicable `must_not` guardrails as hard prohibitions.
+   - Use the PWNISMS findings to guide design, validation, authorization, logging, secrets handling, dependency choices, and abuse controls.
+   - If PWNISMS reveals a recurring security rule that is not covered by existing guardrails, create and apply an `ide_generated` guardrail in context.
 
-10. **Fetch Vibe Guardrails** — Follow `{{GUARDRAILS_SELECTION_SKILL_DIR}}/SKILL.md`.
-    - Call `get_guardrails` with `project_id` to load the broad catalog.
-    - Analyze the task and infer the relevant security categories and likely threats first.
-    - Shortlist only the guardrails relevant to the task and fetch the exact shortlist with `get_guardrail_by_id`.
-    - Separate the shortlisted guardrails into `must` (mandatory requirements) and `must_not` (hard prohibitions).
-    - Keep the shortlisted exact guardrails in context for the entire code-generation task and for later `ctm_sync`.
-    - Cross-reference with PWNISMS findings: if a threat has no corresponding guardrail, flag it as a candidate for a new guardrail.
+4. **Run CTM sync last.**
+   - After threat modelling is created or updated, or after guardrails are enforced during implementation, invoke the `ctm_sync` agent/workflow.
+   - Use `{{CTM_SYNC_AGENT_PATH}}` for the detailed payload contract.
+   - Pass the current threat model summary, the stable `chat_session_id`, the exact existing guardrails shortlisted earlier, and any `ide_generated` guardrails.
+   - Do not re-query guardrails during CTM sync; reuse the shortlist selected before implementation.
 
-11. **Check for existing reviews** — Call `list_reviews`. If a completed review exists, pull context:
-    - `get_threat_scenarios` — Cross-reference with your PWNISMS findings
-    - `get_countermeasures` — Apply recommended mitigations
-    - `get_components` — Understand the system architecture
-    - `get_data_dictionaries` — Identify sensitive data assets and stepping stones
-    - `get_security_objectives` — Understand compliance requirements
-    - `get_findings` — Review aggregated security insights
+## When To Skip
 
-12. **No review exists?** Create one:
-    - Upload context via `create_document_from_content`
-    - `create_review` → `start_workflow` → poll `get_workflow_status`
+Skip the SRAI security workflow only for tasks with no security surface, such as documentation-only changes, typo fixes, pure formatting, variable renames with no logic change, or general Q&A that produces no code.
 
-13. **After threat modeling (ALWAYS / POST threat modelling)** — Invoke `ctm_sync` agent and upload the required CTM data (including guardrail compliance and proposed guardrails).
+If in doubt, run the workflow. A quick PWNISMS pass is better than silently missing a security boundary.
 
-### CTM sync — chat session and workflows (all IDEs)
+## Do Not Use Project Profile Exploration
 
-When running `ctm_sync` (dedicated agent/command where available, or the same steps inline):
+Do not call project-profile exploration tools during normal coding tasks. The old profile walkthrough is no longer part of the agent workflow.
 
-- Include a stable **`chat_session_id`** on every event payload. Reuse one id for the entire current chat; use a different id for a different chat. Prefer an IDE-provided session/conversation id; if unavailable, generate a UUID once per chat and reuse it.
-- **First time** a `chat_session_id` is seen for a project: create an AI IDE workflow via `create_ai_ide_workflow` with a short name `session1`, `session2`, … (next free index) and put `chat_session_id:<id>` in the workflow **description** so it can be found later.
-- **Same chat later:** find the workflow whose description contains that `chat_session_id` marker and push `create_ai_ide_event` to that `workflow_id` — do **not** create another workflow for the same session.
+The normal coding workflow is guardrails selection, PWNISMS threat modelling, secure implementation, then CTM sync.
 
-### Tool Reference
+## Tool Reference
 
-| Category | Tools |
+| Purpose | Tools |
 |---|---|
-| **Projects** | `list_projects`, `find_project_by_name`, `create_project`, `get_project` |
-| **Profile Exploration** | `get_project_profile_description`, `list_profile_technology_categories`, `get_project_profile_technology_category`, `list_project_profile_architecture_notes`, `list_project_profile_user_groups`, `list_project_profile_language_stacks`, `list_project_profile_security_controls`, `get_project_profile_security_control`, `list_profile_compliance_requirements`, `get_profile_compliance_requirement` |
-| **Guardrails** | `get_guardrails`, `get_guardrail_by_id` |
-| **Documents** | `list_documents`, `create_document_from_content`, `upload_document`, `link_external_document` |
-| **Reviews** | `create_review`, `list_reviews`, `get_review`, `get_review_overview` |
-| **Workflow** | `start_workflow`, `get_workflow_status`, `start_next_workflow_job`, `start_workflow_job`, `retry_workflow_job` |
-| **Analysis** | `get_threat_scenarios`, `get_countermeasures`, `get_components`, `get_data_dictionaries`, `get_security_objectives`, `get_findings`, `get_security_test_cases` |
-| **Integrations** | `fetch_jira_issue`, `fetch_confluence_page`, `search_confluence_pages`, `fetch_and_link_to_srai` |
-| **AI IDE CTM** | `create_ai_ide_workflow`, `create_ai_ide_event` (and any `list_*` AI IDE workflow tools exposed by the server) |
-| **Vibe profile & default packs** | `update_vibe_profile`, `write_default_pack` (used by the guardrails profiler / init flow — not part of `ctm_sync`) |
+| Project resolution | `find_project_by_name`, `list_projects`, `create_project`, `get_project` |
+| Guardrails | `get_guardrails`, `get_guardrail_by_id` |
+| CTM sync | `create_ai_ide_workflow`, `create_ai_ide_event`, `get_current_user` or equivalent user identity tool |
+| Profiler only | `update_vibe_profile`, `write_default_pack` are used by init-time profiling, not normal coding tasks |

package/src/generators/rules/cursor.js

@@ -3,7 +3,9 @@ import { join } from 'node:path';
 import {
     GUARDRAILS_PROFILER_SKILL_REL_DIR,
     GUARDRAILS_SELECTION_SKILL_REL_DIR,
+    CTM_SYNC_AGENT_REL_PATH,
     MCP_SERVER_NAME,
+    THREAT_MODELLING_SKILL_REL_DIR,
 } from '../../utils/constants.js';
 import { readJson, writeJson, writeText } from '../../utils/fs-helpers.js';
 import {
@@ -74,6 +76,8 @@ export function generate(cwd, options = {}) {
     const optionsWithSkillDirs = {
         ...options,
         guardrailsSelectionSkillDir: GUARDRAILS_SELECTION_SKILL_REL_DIR.cursor,
+        threatModellingSkillDir: THREAT_MODELLING_SKILL_REL_DIR.cursor,
+        ctmSyncAgentPath: CTM_SYNC_AGENT_REL_PATH.cursor,
     };
     const baseRulePath = join(cwd, '.cursor', 'rules', 'srai-security-review.mdc');
     const ctmSyncTriggerRulePath = join(cwd, '.cursor', 'rules', 'ctm_sync_rule.mdc');

package/src/generators/rules/skill.md

@@ -1,6 +1,6 @@
 ---
 name: PWNISMS Threat Modelling
-description: Security-first threat modelling workflow for code and architecture tasks. Walks all 7 PWNISMS categories, integrates with SRAI project profiles, enforces vibe guardrails (secure by code), and synchronizes findings via CTM sync. Use before, during, and after implementation.
+description: Security-first threat modelling workflow for code and architecture tasks. Walks all 7 PWNISMS categories, enforces vibe guardrails (secure by code), and synchronizes findings via CTM sync. Use before, during, and after implementation.
 ---
 
 # PWNISMS — Security-First Threat Modelling
@@ -14,28 +14,18 @@ For EVERY security-relevant task (feature, bug fix, refactor, infra change, arch
 
 ---
 
-## Phase 0 — Enrich Context from SRAI
-
-Before deep analysis, pull project context from `security-review-mcp` (if available) to ground your threat model in the actual system profile.
-
-1. **Resolve the project** — `find_project_by_name` with `name="<SRAI_PROJECT_NAME>"`.
-2. **Fetch project description** — `get_project_profile_description` to understand the system's purpose and data flows.
-3. **Technology categories** — `list_profile_technology_categories` → for each, `get_project_profile_technology_category` to understand specific frameworks, libraries, versions.
-4. **Architecture notes** — `list_project_profile_architecture_notes` for deployment topology, trust boundaries, data flow patterns.
-5. **User groups** — `list_project_profile_user_groups` to map roles and privilege levels.
-6. **Language stacks** — `list_project_profile_language_stacks` for language-specific vulnerability patterns.
-7. **Security controls** — `list_project_profile_security_controls` → for relevant controls, `get_project_profile_security_control` for details.
-8. **Compliance requirements** — `list_profile_compliance_requirements` → for relevant ones, `get_profile_compliance_requirement`.
-9. **Existing reviews** — `list_reviews`. If a completed review exists:
-   - `get_threat_scenarios` — prior threats to cross-reference
-   - `get_countermeasures` — existing mitigations to leverage
-   - `get_components` — system architecture context
-   - `get_data_dictionaries` — sensitive data assets
-   - `get_security_objectives` — compliance targets
-   - `get_findings` — aggregated insights
-10. **Vibe Guardrails** — Use `{{GUARDRAILS_SELECTION_SKILL_DIR}}/SKILL.md` with `project_id` to load the guardrail catalog, shortlist the relevant guardrails, and hydrate the exact implementation set with `get_guardrail_by_id`.
-
-If SRAI is not available, proceed with whatever context the user provides — files, diffs, PRs, architecture docs.
+## Phase 0 — Guardrail Context
+
+Before deep analysis, ensure the project-specific guardrail shortlist exists:
+
+1. Use `{{GUARDRAILS_SELECTION_SKILL_DIR}}/SKILL.md`.
+2. Resolve the project with `find_project_by_name` using `name="<SRAI_PROJECT_NAME>"`.
+3. Call `get_guardrails`, shortlist intentionally for this task, then hydrate the exact shortlist with `get_guardrail_by_id`.
+4. Keep the shortlisted existing guardrails in context for implementation and `ctm_sync`.
+
+Do not perform project-profile exploration as part of PWNISMS. The old profile tools are not part of this workflow. Ground the threat model in the user request, repository code, diffs, architecture docs the user provides, and the shortlisted guardrails.
+
+If SRAI is not available, proceed with the user-provided context and repository evidence, then clearly note that project guardrails could not be fetched.
 
 ---
 
@@ -47,7 +37,7 @@ Collect these quickly before deep analysis:
 - **Assets**: What must be protected (PII, credentials, tokens, configs, accounts, workflows)?
 - **Entry points**: How data enters/leaves (HTTP, queues, schedulers, CLI, webhooks, integrations)?
 - **Trust boundaries**: Where data crosses users/services/networks/privilege levels?
-- **Existing guardrails**: What shortlisted project-specific dos and don'ts apply (from Phase 0, step 10)?
+- **Existing guardrails**: What shortlisted project-specific dos and don'ts apply (from Phase 0)?
 
 If the user provided specific code, diffs, or architecture artifacts, prioritize those as primary evidence.
 
@@ -71,7 +61,7 @@ If the user provided specific code, diffs, or architecture artifacts, prioritize
 
 4. **Prioritize**
    - Select the top 3-7 risks by impact and likelihood.
-   - Factor in existing mitigations from SRAI countermeasures and guardrails.
+   - Factor in existing mitigations from the codebase, user-provided context, and guardrails.
 
 5. **Mitigate**
    - Propose concrete, implementable controls for each prioritized risk.
@@ -225,16 +215,15 @@ The `ctm_sync` agent builds and pushes an event payload containing:
 - **Best practices achieved**: security patterns followed during implementation
 - **Secure code snippets**: security-relevant code with explanations
 - **Guardrails applied**: all guardrails enforced during this session — both existing ones shortlisted earlier via `get_guardrails` + `get_guardrail_by_id` (`source: "existing"`) and new ones the IDE agent created on the fly (`source: "ide_generated"`), each with satisfaction status
-- **Project profile updates**: architecture notes, tech categories, user groups, compliance requirements, language stacks
 
 ### How to invoke
 
-Use the `ctm_sync` agent (Task tool with `subagent_type="ctm_sync"`) with:
+Use the host's `ctm_sync` agent/workflow with:
 - A clear description of what was threat-modeled
 - The `chat_session_id` for workflow routing
 - Whether this is a new threat model or an update
 
-See `.cursor/agents/ctm_sync.md` (or `.cursor/commands/ctm_sync.md`) for the full workflow and payload schema.
+See `{{CTM_SYNC_AGENT_PATH}}` for the full workflow and payload schema.
 
 ---
 

package/src/generators/rules/vscode.js

@@ -1,17 +1,90 @@
+import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { GUARDRAILS_SELECTION_SKILL_REL_DIR } from '../../utils/constants.js';
-import { upsertSentinelBlock } from '../../utils/fs-helpers.js';
-import { getRuleContent } from './content.js';
+import {
+    CTM_SYNC_AGENT_REL_PATH,
+    GUARDRAILS_SELECTION_SKILL_REL_DIR,
+    THREAT_MODELLING_SKILL_REL_DIR,
+} from '../../utils/constants.js';
+import { upsertSentinelBlock, writeText } from '../../utils/fs-helpers.js';
+import { getCtmSyncWorkflowContent, getRuleContent, getThreatModellingSkillContent } from './content.js';
+
+function writeGeneratedText(filePath, content) {
+    const action = existsSync(filePath) ? 'updated' : 'created';
+    writeText(filePath, content);
+    return { filePath, action };
+}
+
+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. Run the ctm_sync custom agent using .github/agents/ctm_sync.agent.md after threat modelling or guardrail enforcement. Reuse the exact guardrail shortlist; do not re-query guardrails during CTM sync.',
+        '',
+        'Do not use project-profile exploration tools during normal coding tasks. No blocking and no deferral: guardrails first, PWNISMS second, implementation third, ctm_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 filePath = join(cwd, '.github', 'copilot-instructions.md');
-    const content = getRuleContent({
+    const optionsWithSkillDirs = {
         ...options,
         guardrailsSelectionSkillDir: GUARDRAILS_SELECTION_SKILL_REL_DIR.vscode,
-    });
+        threatModellingSkillDir: THREAT_MODELLING_SKILL_REL_DIR.vscode,
+        ctmSyncAgentPath: CTM_SYNC_AGENT_REL_PATH.vscode,
+    };
+    const filePath = join(cwd, '.github', 'copilot-instructions.md');
+    const content = getRuleContent(optionsWithSkillDirs);
     const action = upsertSentinelBlock(filePath, content);
-    return { filePath, action };
+
+    const threatSkillPath = join(cwd, THREAT_MODELLING_SKILL_REL_DIR.vscode, 'SKILL.md');
+    const threatSkill = writeGeneratedText(
+        threatSkillPath,
+        getThreatModellingSkillContent(optionsWithSkillDirs),
+    );
+
+    const ctmSyncAgentPath = join(cwd, CTM_SYNC_AGENT_REL_PATH.vscode);
+    const ctmSyncAgent = writeGeneratedText(
+        ctmSyncAgentPath,
+        getCtmSyncWorkflowContent(optionsWithSkillDirs),
+    );
+
+    const hooksPath = join(cwd, '.github', 'hooks', 'srai-session-policy.json');
+    const hooks = writeGeneratedText(hooksPath, getCopilotSessionHookContent());
+
+    return [
+        { filePath, action, kind: 'rule' },
+        { ...threatSkill, kind: 'skill' },
+        { ...ctmSyncAgent, kind: 'agent' },
+        { ...hooks, kind: 'hooks' },
+    ];
 }

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

@@ -0,0 +1,41 @@
+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, agent, 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/agents/ctm_sync.agent.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', 'agent', '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\/agents\/ctm_sync\.agent\.md/);
+    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, /\.github\/agents\/ctm_sync\.agent\.md/);
+    assert.doesNotMatch(threatSkill, /get_project_profile_description/);
+
+    const hooks = JSON.parse(readFileSync(join(cwd, '.github/hooks/srai-session-policy.json'), 'utf8'));
+    assert.equal(hooks.hooks.SessionStart[0].type, 'command');
+});

package/src/utils/constants.js

@@ -75,5 +75,17 @@ export const GUARDRAILS_SELECTION_SKILL_REL_DIR = {
     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',
+    vscode: '.github/skills/threat-modelling',
+};
+
+/** Relative workspace paths for the CTM sync agent/workflow (per IDE / CLI). */
+export const CTM_SYNC_AGENT_REL_PATH = {
+    cursor: '.cursor/agents/ctm_sync.md',
+    vscode: '.github/agents/ctm_sync.agent.md',
+};
+
 export const SENTINEL_START = '<!-- securityreview-kit:start -->';
 export const SENTINEL_END = '<!-- securityreview-kit:end -->';