secufusion-mcp 2.1.3 → 2.1.5

package/README.md

@@ -40,7 +40,8 @@ The SecuFusion MCP has been refactored to align with the advanced MLMCPS framewo
 2. **Subprocess PR Checks**: Tier 1 mechanical checks (`TENANT_ISOLATION`, `N_PLUS_ONE`, etc.) are now extracted into a standalone CLI script (`scripts/sfn-pr-check.js`), allowing them to be run by the AI *or* natively within your CI/CD pipelines.
 3. **Thin Index Token Discipline**: Context bloat is gone. Tools like `manage_task(read)` and `prime_session` now return lightweight "Thin Indexes"—compact Markdown summaries with absolute file paths—so the AI only reads the full JSON via `view_file` when truly necessary.
 4. **Dynamic Skill Registry**: A new `skill_recommend` tool allows the AI to dynamically discover domain-specific architectural skills without bloating the base prompt.
-5. **Poly-Repo DNA Discovery**: Through the standalone `secufusion-dna-plugin`, the AI can dynamically analyze the entire codebase of any poly-repo project at session start. It maps out microservices, API contracts, and event topologies on the fly, creating a living knowledge graph.
+5. **Phase -1 Philosophy Engine**: An invisible gate that checks the WHY, WHO, WHAT, and RISK of every task (including bugs and hotfixes) before any planning starts. If the business intent or blast radius is unsafe, it stops the AI from writing a single line of code.
+6. **Poly-Repo DNA Discovery**: Through the standalone `secufusion-dna-plugin`, the AI can dynamically analyze the entire codebase of any poly-repo project at session start. It maps out microservices, API contracts, event topologies, frontend repos, and the `snf-browser-extn` extension on the fly, creating a living knowledge graph.
 
 ---
 
@@ -83,13 +84,14 @@ Every task now requires **two complementary files** that the AI reads together:
 ### The Polyglot Bridge
 The new `spec_create_intent` tool captures a `services_involved` array that is **language-agnostic**. You can list a Go microservice, a Python Lambda, or a COBOL batch job. The AI reads this declaration and knows those services are in scope without needing a custom AST parser.
 
-### The New `/sfn:plan` Flow
-When you type `/sfn:plan WI-2847 Add MFA`:
-1. **The Pushback (Phase 1):** The AI will **NOT** immediately start planning. It will stop and ask you: *"Why are we building this? What business problem does it solve? What is the risk if we don't?"*
-2. **The WHY (Phase 1.5):** You answer, and the AI generates the Markdown intent file (`spec_create_intent`).
-3. **The HOW (Phase 2):** Only then does it initialize the code tracking infrastructure (`manage_task`).
-4. **Context & Classify (Phase 3/4):** The AI loads the AST (`prime_session`), flags architectural risks (`classify_task`), and yields for your approval.
-5. **The Plan (Phase 5):** The AI outputs the strict implementation plan.
+### The New `/sfn-plan` Flow
+When you type `/sfn-plan WI-2847 Add MFA`:
+1. **The Guard (Phase -1):** The AI silently runs a `philosophy_check` against your Project DNA. It evaluates the WHY, WHO, WHAT, and RISK of the task. (Note: Bugs and hotfixes still undergo this check, though with slightly relaxed sensing).
+2. **The Pushback (Phase 1):** If the Philosophy Engine fails the request (e.g. unclear business intent or high risk), the AI will **NOT** plan. It will stop and ask you for clarity: *"Why are we building this? Who confirmed it?"*
+3. **The WHY (Phase 1.5):** You answer, and the AI generates the Markdown intent file (`spec_create_intent`).
+4. **The HOW (Phase 2):** Only then does it initialize the code tracking infrastructure (`manage_task`).
+5. **Context & Classify (Phase 3/4):** The AI loads the AST (`prime_session`), flags architectural risks (`classify_task`), and yields for your approval.
+6. **The Plan (Phase 5):** The AI outputs the strict implementation plan.
 
 ---
 
@@ -142,13 +144,13 @@ npx secufusion-mcp
 ### Option 2 — Global install
 
 ```bash
-npm install -g secufusion-mcp
+npm install -g secufusion-mcp@2.1.4
 ```
 
 ### Option 3 — Local project install
 
 ```bash
-npm install --save-dev secufusion-mcp
+npm install --save-dev secufusion-mcp@2.1.4
 ```
 
 ---
@@ -473,6 +475,9 @@ These rules are enforced automatically — the AI will never violate them:
 │  Plan Gate   │  → STOP and wait for "proceed" / "adjust" / "cancel"          │
 │              │  → manage_task (action=initialize) only after proceed          │
 ├──────────────┼──────────────────────────────────────────────────────────────┤
+│  Phase -1    │  philosophy_check (Silently validates WHY/WHO/WHAT/RISK)       │
+│  Philosophy  │  → Blocks planning if intent or safety is unclear (ALL TASKS)  │
+├──────────────┼──────────────────────────────────────────────────────────────┤
 │  Phase 1     │  search_tasks → get_task_history → manage_task initialize     │
 │  Planning    │  → Creates .secufusion/tasks/{id}-{slug}/ with all 5 files    │
 ├──────────────┼──────────────────────────────────────────────────────────────┤
@@ -710,7 +715,7 @@ Phase 4: run_pre_pr_checks_with_reviewer_agent → APPROVED / DISCUSS
 
 As of version **1.0.13+**, `secufusion-mcp` globally bundles both `.secufusion-project-spec.json` and `AGENTS.md`. You **no longer need to copy these files** into every single repository!
 
-When you install globally (`npm install -g secufusion-mcp@latest`), the AI can automatically read your rules and project spec on the fly from the global installation.
+When you install globally (`npm install -g secufusion-mcp@2.1.4`), the AI can automatically read your rules and project spec on the fly from the global installation.
 
 **How to load the Rules in a new project:**
 Depending on your AI client's capabilities, you can load the rules instantly by telling the AI:
@@ -933,9 +938,9 @@ The previously separate `secufusion-dna-plugin` is now fully merged into `secufu
 During `scan_repository_stack`, the server reads `.secufusion-project-spec.json` and cross-references:
 - All keys under `"microservices"` (e.g., `sfn-auth-api`, `sfn-events-api`)
 - The `"frontend.repo"` value (e.g., `sfn-web-ui`)
-- The `"chrome_extension.repo"` value (e.g., `snf-browser-extn`)
+- The `"chrome_extension.repo"` or `"snf-browser-extn"` value (e.g., `snf-browser-extn`)
 
-If any of these are physically missing from your local workspace folder, a `[WARNING]` is emitted listing exactly which repositories need to be cloned before a complete DNA map can be built.
+If any of these are physically missing from your local workspace folder, a `[WARNING]` is emitted listing exactly which core pillars need to be cloned before a complete DNA map can be built.
 
 ---
 
@@ -958,7 +963,7 @@ Once installed as a native Claude Plugin, all commands appear natively in the Cl
 
 | Command | When to run | What it does |
 |---|---|---|
-| `/sfn-plan <ticket-id or description>` | When you receive a new Azure DevOps ticket | Agent enters the `planner.md` persona. Reads `.secufusion-project-spec.json` for golden rules and coding patterns. Reads `dna.json` to determine which microservice owns the change. Outputs a structured `plan.md` with exact files to touch, rollback strategy, and breaking change scan. **Stops and waits for your green light.** |
+| `/sfn-plan <ticket-id or description>` | When you receive a new Azure DevOps ticket | Agent enters the `planner.md` persona. Silently runs the **Philosophy Engine (Phase -1)** to ensure the task's WHY and RISK are sound (even for bugs). Reads `.secufusion-project-spec.json` for golden rules and `dna.json` to determine blast radius. Outputs a structured `plan.md` with exact files to touch, rollback strategy, and breaking change scan. **Stops and waits for your green light.** |
 
 > **Why it stops:** This enforces the non-negotiable Rule 3 — `STRICT YIELD`. The agent must not start coding until you explicitly say "proceed".
 

package/agents/AGENTS.md

@@ -11,19 +11,123 @@ Do not attempt to load all instructions into memory. Based on the current SDLC p
 
 ---
 
+## THE NON-NEGOTIABLE EXECUTION ORDER
+(Every task, every time — no exceptions, no shortcuts)
+
+**DYNAMIC ENFORCEMENT**: Whether you are starting fresh, resuming, or answering mid-task — you must respect this exact sequence. Never skip ahead.
+
+---
+
+### Rule 0 — DNA First (Absolute Pre-requisite)
+
+Before ANY other action, call `prime_session(work_item_id: <id>)`.
+
+This loads:
+- All microservice contexts relevant to this task
+- DB entities, Kafka topics, API contracts, Chrome extension architecture
+- Frontend component map, security model, tenant isolation structure
+- Golden rules, rejected patterns, and architectural constraints
+
+**Without DNA loaded, you are not allowed to reason, assess risk, classify, plan, or code. Period.**
+
+If DNA is not loaded (DNA_LOADED = false in `.agents/claude.md`), ABORT and tell the user to run `/sfn-init` first.
+
+---
+
+### Rule 1 — Philosophy Check (Phase -1, SILENT, runs AFTER DNA)
+
+For any `user_story`, `feature`, `chore`, or `refactor`:
+
+Call `philosophy_check` AFTER DNA is loaded — never before. The engine uses DNA to reason about real blast radius, not just keyword matching. It knows:
+- Which DB entities your story touches and how many services depend on them
+- Whether you are touching a shared multi-tenant auth service
+- Whether the Chrome extension is in scope (requires store deployment)
+- Which Kafka topics fan out to how many consumers
+- Whether your description violates any golden rules
+
+**This check is completely invisible to the user.** You do not announce it. You do not show scores, verdicts, or "philosophy" terminology. You surface a concern to the user only if the verdict is FAIL or BLOCKED — and you translate it into plain developer language.
+
+For `bug` and `hotfix`: philosophy check still applies, though the scoring engine evaluates them with slightly relaxed thresholds since defects have an inherent "WHY".
+
+**Verdicts:**
+- `PHILOSOPHY_PASS` → Silent. Proceed immediately.
+- `PHILOSOPHY_ADVISORY` → Note concerns in `decisions.json`. Tell the user briefly what to watch out for. Continue.
+- `PHILOSOPHY_FAIL` → STOP. Ask the user what is missing (no jargon). Wait for answers. Re-run philosophy_check.
+- `PHILOSOPHY_BLOCKED` → STOP completely. Tell the user the risk and who must sign off. Do not plan. Do not code.
+
+---
+
+### Rule 2 — Clarify Business Intent (WHY before HOW)
+
+After philosophy check passes, capture the WHY formally. Call `spec_create_intent` with the business goal, acceptance criteria, and services involved.
+
+Do not initialize task tracking (`manage_task`) until the WHY is captured.
+
+---
+
+### Rule 3 — ReAct (Reason, Observe, Act)
+
+Deeply reason about the problem using the DNA context you loaded. Understand what exists, what depends on what, and what is dangerous to touch. Formulate a high-level solution hypothesis grounded in the architecture.
+
+---
+
+### Rule 4 — Classify
+
+Call `classify_task`. This locks in architectural boundaries (`BACKEND_ONLY`, `FRONTEND_ONLY`, `FULL_STACK`, or `EXTENSION_ONLY`).
+
+---
+
+### Rule 5 — STRICT YIELD
+
+After classifying, STOP. Output the result. Ask the user for the green signal. Do NOT chain tool calls.
+
+---
+
+### Rule 6 — Plan Only After Approval
+
+Produce the implementation plan only after the user approves the classification.
+
 ---
 
-## THE 5 NON-NEGOTIABLE RULES FOR PLANNING AND CODING
-(Enforcing explicit permission before coding)
+### Rule 7 — Code is the Last Resort
+
+Source code changes are the absolute final step. Only after the plan is approved.
 
-**DYNAMIC ENFORCEMENT**: You must dynamically adhere to these rules at all times. Whether you are starting a fresh task, resuming an interrupted session, or answering a mid-task prompt, you must strictly respect this sequence and never skip ahead.
+---
+
+## What you are NOT allowed to do before DNA is loaded and philosophy passes:
 
-1. **Rule 0 (Pre-requisite to all rules) — Load Project DNA First**: Before ANY other action, call `prime_session(work_item_id: <id>)`. This is Phase 00. Without the project DNA loaded, you are not allowed to reason, classify, plan, or code. Period.
-2. **Rule 1 - Clarify Business Intent (WHY before HOW)**: For any new task, you MUST pause and ask the user for the business intent, goal, and risk. YIELD until this is clarified, then call `spec_create_intent`. Do not initialize task tracking (`manage_task`) until the WHY is captured.
-3. **Rule 2 - ReAct (Reason, Observe, Act) First**: After intent is clarified and DNA is loaded, you MUST deeply reason about the problem statement. Apply the ReAct framework: analyze the problem, observe context, and formulate a high-level solution hypothesis.
-4. **Rule 3 - Classify Second**: Only after you have reasoned through the problem statement, you MUST call the `classify_task` tool. This will formally categorize the task and lock in architectural boundaries.
-5. **Rule 4 - STRICT YIELD (Stop and Wait)**: Immediately after classifying the task, you MUST YIELD YOUR TURN. **DO NOT CHAIN TOOL CALLS.** Output the classification, ask the user for the "green signal," and STOP.
-6. **Rule 5 - Plan Only After Approval**: Only after receiving the "green signal" for the classification are you allowed to propose a detailed implementation plan.
-7. **Rule 6 - Code is the Last Resort (Universal)**: Modifying source code is the absolute final step and may only occur after the implementation plan is approved.
+❌ Read any source files
+❌ Call `classify_task`
+❌ Call `manage_task`
+❌ Write any implementation plan
+❌ Suggest technical approaches
+❌ Say "let's start and see"
+❌ Minimize a FAIL verdict
+❌ Offer to proceed despite BLOCKED
+❌ Mention "philosophy", "PHILOSOPHY_FAIL", "PHILOSOPHY_BLOCKED" to the user
 
 ---
+
+## The philosophy principle (for your internal reasoning only)
+
+Four questions every story must answer before implementation can begin:
+
+```
+WHY  → What specific problem does this solve?
+        If we can't state the problem, the solution is guesswork.
+
+WHO  → Who confirmed this is needed?
+        "Someone asked" is not confirmation.
+        The decision maker must be on record.
+
+WHAT → What exactly are we building?
+        Vague stories produce vague software.
+        If you can't test it, you can't build it.
+
+RISK → What breaks if we're wrong?
+        Irreversible changes need higher certainty.
+        High risk + low certainty = guaranteed waste.
+```
+
+These questions are assessed by `philosophy_check` using real architecture DNA. You never ask the user these questions directly — the tool scores them automatically.

package/commands/sfn-code.md

@@ -1,9 +1,9 @@
----
+---
 description: Execute the approved implementation plan. Switches to the Coder Persona and writes code precisely as planned, using rejected-pattern memory to avoid past mistakes.
 argument-hint: <ticket-id>  e.g. WI-123
 ---
 
-You are executing the **sfn:code** command for the SecuFusion spec-driven SDLC.
+You are executing the **sfn-code** command for the SecuFusion spec-driven SDLC.
 
 Task: **$ARGUMENTS**
 
@@ -13,7 +13,7 @@ Task: **$ARGUMENTS**
 
 1. Read `.secufusion/tasks/$ARGUMENTS/plan.md`.
 2. If the plan file does not exist or has no approval record, **ABORT** and tell the user:
-   > ❌ No approved plan found for `$ARGUMENTS`. Please run `/sfn:plan $ARGUMENTS` first.
+   > ❌ No approved plan found for `$ARGUMENTS`. Please run `/sfn-plan $ARGUMENTS` first.
 3. Read `.agents/coder.md` to load the **Coder Persona** — your behaviour for this phase is governed by those instructions.
 
 ## Phase 1 — Load Rejected Patterns Memory
@@ -46,4 +46,4 @@ Report to the user:
 - ACs met (with file:line)
 - Any open risks or deferred items
 
-> 🚀 Implementation complete. Run `/sfn:review` to run the zero-tolerance PR gate checks.
+> 🚀 Implementation complete. Run `/sfn-review` to run the zero-tolerance PR gate checks.

package/commands/sfn-explore.md

@@ -0,0 +1,74 @@
+---
+description: On-demand architecture exploration — map the full service graph as a Mermaid diagram, or run a blast-radius impact analysis for a specific component.
+argument-hint: [map] or <component-name-or-file-path>  e.g. "map" or "sfn-events-api" or "TenantEntity.java"
+---
+
+You are executing the **sfn-explore** command for the SecuFusion ecosystem.
+
+Argument: **$ARGUMENTS**
+
+---
+
+## Mode Detection
+
+Read `$ARGUMENTS` and decide the mode:
+
+- If `$ARGUMENTS` is empty or equals `map` → **Architecture Map Mode**
+- Otherwise → **Blast Radius Mode** for the given component
+
+---
+
+## Mode A — Architecture Map
+
+> Use this when: you want a bird's-eye view of the entire ecosystem (e.g. onboarding a new dev, auditing dependencies).
+
+1. Call `prime_session` or read `.secufusion/dna.json` to load the current knowledge graph.
+2. Generate a comprehensive **Mermaid diagram** (`graph TD`) that shows:
+   - All microservices grouped by bounded context
+   - REST API call graph (which service calls which)
+   - Kafka topic flow (producer → topic → consumer)
+   - Frontend (`sfn-web-ui`) and extension (`snf-browser-extn`) connections to backend services
+3. Render the Mermaid diagram in the response.
+4. Below the diagram, print a service inventory table:
+
+   | Service | Port | Stack | Owns Tables | Produces Topics | Consumes Topics |
+   |---|---|---|---|---|---|
+
+---
+
+## Mode B — Blast Radius
+
+> Use this when: you are about to refactor a shared entity, change an API contract, or modify a Kafka topic and need to know the full downstream impact.
+
+1. Call `prime_session` or read `.secufusion/dna.json` to load the knowledge graph.
+2. Search for all references to `$ARGUMENTS` across:
+   - Microservice API consumers (who calls this endpoint?)
+   - Database entity consumers (which repos query this table/column?)
+   - Kafka consumers (which services consume this topic?)
+   - Frontend and `snf-browser-extn` (does the UI or extension directly consume this contract?)
+3. Present a **Cross-Repo Blast Radius Report**:
+
+   ```
+   🎯 Component: $ARGUMENTS
+
+   Impacted Microservices:
+     - sfn-X-api  →  [why impacted]
+
+   Impacted APIs:
+     - GET /v1/...  →  [consumers]
+
+   Impacted Events / Consumers:
+     - topic-name  →  [consumer services]
+
+   Impacted Databases:
+     - table_name  →  [services querying this]
+
+   Impacted Frontend / Extension:
+     - sfn-web-ui  →  [pages / components]
+     - snf-browser-extn  →  [content scripts / background workers]
+
+   Risk Level: 🟢 LOW | 🟡 MEDIUM | 🔴 HIGH
+   ```
+
+4. If risk is 🔴 HIGH, add a warning:
+   > ⚠️ High blast radius detected. Consider running `/sfn-plan` with this context before making changes.

package/commands/sfn-init.md

@@ -1,22 +1,20 @@
 ---
-description: Prime the SecuFusion ecosystem — scan the entire codebase, map the architectural DNA, and write it to .secufusion/dna.json. Run this once when you first clone a repo.
+description: Prime the SecuFusion ecosystem — scan the entire codebase, map the architectural DNA, generate the architecture diagram, and write it to .secufusion/dna.json. Run this once when you first clone a repo.
 argument-hint: (no args) — run from the root of the repo
 ---
 
-You are executing the **sfn:init** bootstrap command for the SecuFusion ecosystem.
+You are executing the **sfn-init** bootstrap command for the SecuFusion ecosystem.
 
 **This is a learn-first command.** Your job is to deeply understand THIS project before writing anything. Do not produce generic output — every finding must reflect real `file:line` references from the actual codebase.
 
 ## Phase 1 — SCAN the Repository
 
-Call the **secufusion-dna-plugin** MCP tools to scan the repository:
+Call the following MCP tools to scan the repository. Run all 4 **concurrently in a single message**:
 
-1. Call `scan_repository_stack` to identify: language, framework, package manager, microservices, database entities, and build/test commands. Flag if this is a monorepo.
-2. Call `extract_domain_models` to map all domain entities, their fields, and relationships.
-3. Call `extract_api_endpoints` to map all REST/GraphQL endpoints, their methods, and owning services.
-4. Call `extract_event_topics` to map all Kafka/event-bus topics, producers, and consumers.
-
-Run all 4 tool calls in a **single message** so they execute concurrently.
+1. `scan_repository_stack` — identify language, framework, package manager, microservices, DB entities, build/test commands. Flag if monorepo.
+2. `extract_domain_models` — map all domain entities, their fields, and relationships.
+3. `extract_api_endpoints` — map all REST/GraphQL endpoints, their methods, and owning services.
+4. `extract_event_topics` — map all Kafka/event-bus topics, producers, and consumers.
 
 ## Phase 2 — WRITE the DNA
 
@@ -43,6 +41,17 @@ Once all scans complete:
 Summarize what was found:
 - Number of services, domain models, API endpoints, and event topics discovered
 - Any gaps or areas marked `(inferred)` that the human should verify
+- **CRITICAL CORE CHECK:** Explicitly verify that the DNA map contains mappings for **frontend**, **backend**, and **snf-browser-extn** (extension). If ANY of these 3 are missing, print a prominent warning listing exactly what is missing and what needs to be cloned/added.
 - Confirm that `.secufusion/dna.json` was written successfully
 
-**Next step for the user:** Run `/sfn:plan <ticket-id>` to start your first task.
+## Phase 4 — ARCHITECTURE DIAGRAM
+
+Using the data now in `dna.json`, generate a comprehensive **Mermaid diagram** (`graph TD`) that visualizes:
+- All microservices and their bounded contexts
+- REST API call graph (which service calls which)
+- Kafka topic flow (producer → topic → consumer)
+- Frontend and `snf-browser-extn` connections to backend services
+
+Render the diagram directly in your response so the user can see the full ecosystem at a glance.
+
+**Next step for the user:** Run `/sfn-plan <ticket-id>` to start your first task.

package/commands/sfn-plan.md

@@ -1,79 +1,161 @@
 ---
-description: Architect a solution for a task or Jira ticket using the loaded DNA. Clarifies business intent, creates a dedicated task workspace, classifies the work, and produces a strict implementation plan awaiting your approval.
-argument-hint: <ticket-id or feature description>  e.g. WI-123 or "add user login endpoint"
+description: Architect a solution for a task or story. Loads architecture DNA, silently validates story integrity, classifies the work, and produces a strict implementation plan.
+argument-hint: <WI-XXXX or feature description> e.g. "WI-2847" or "add tenant export feature"
 ---
 
-You are executing the **sfn:plan** command for the SecuFusion spec-driven SDLC.
+You are executing the **sfn-plan** command for the SecuFusion spec-driven SDLC.
 
 Task / Ticket: **$ARGUMENTS**
 
 **You are in the PLANNING phase. Do NOT write any implementation code in this phase.**
 
-## Pre-flight: DNA Check
+---
+
+## Step 1 — DNA Guard (Mandatory Pre-flight)
+
+Read `.agents/claude.md` and check the `<MEMORY>` block.
+
+If `DNA_LOADED` is `false` or missing:
+
+> ❌ Project DNA is not loaded.
+> Run `/sfn-init` first to scan and index the codebase architecture.
+> Without DNA, I cannot assess risk, identify service boundaries, or validate story integrity.
+
+**ABORT here. Do not continue.**
+
+---
+
+## Step 2 — Clarify and Capture Business Intent
 
-1. Read `.agents/claude.md` and check the `<MEMORY>` block.
-2. If `DNA_LOADED` is `false` or `null`, **ABORT immediately** and tell the user:
-   > ❌ Project DNA is not loaded. Please run `/sfn:init` first.
+Before thinking about *how* to implement, understand *why* it is needed.
 
-## Phase 1 — Clarify and Capture Business Intent (The WHY Layer)
+Analyze the task. Ask the user if ANY of these are unclear:
+- **What problem does this solve?** (not the solution — the problem)
+- **Who will use this and how does it affect them?**
+- **What is the business risk if NOT delivered?**
+- **Has the client or decision maker explicitly confirmed this is needed?**
 
-Before thinking about *how* to implement the task, you must understand *why* it is needed.
-1. Analyze the requested task. 
-2. Ask the user clarifying questions if the following are not completely clear:
-   - Why is this being built? What user or business problem does it solve?
-   - What is already there, and is this actually needed?
-   - What is the business risk if not delivered?
-3. **YIELD** and wait for the user to clarify the business intent. Do not proceed to Phase 2 until the intent is clear.
+**YIELD.** Wait for the user to answer. Do not proceed until intent is clear.
 
-Once the intent is clarified, call `spec_create_intent` with:
-- `work_item_id`: the ticket ID or a slugified version of the description
-- `title`: short human-readable title
-- `business_goal`: The clarified business problem it solves.
-- `acceptance_criteria`: Given/When/Then ACs gathered from the ticket/clarification.
-- `services_involved`: **Polyglot service map** — list every service this touches, regardless of language (Java, Go, Python, TypeScript).
-- `risk`: business risk if not delivered.
+Once clarified, call `spec_create_intent` with:
+- `work_item_id`: the ticket ID
+- `title`: short title
+- `business_goal`: the problem being solved (from user's answer)
+- `acceptance_criteria`: Given/When/Then ACs from the conversation
+- `services_involved`: every service this touches (polyglot — Java, Go, TS, Python)
+- `risk`: business risk if not delivered
 
-> 💡 This creates `.secufusion/intents/<num>-WI-<id>-<slug>.md` — a human-readable file capturing the WHY.
+---
 
-## Phase 2 — Initialize the Task Workspace (The HOW Layer)
+## Step 3 — Initialize Task Workspace
 
-Now that the *why* is captured, initialize the *how* tracking.
-Call `manage_task` with:
+Call `manage_task`:
 ```
 action: "initialize"
-work_item_id: <same ID as above>
+work_item_id: <same ID>
 ```
-This creates the dedicated workspace folder at `.secufusion/tasks/<id>/` and begins tracking progress. Do not proceed until this call succeeds.
 
-## Phase 3 — Load Context
+Creates `.secufusion/tasks/<id>/` workspace. Do not proceed until this succeeds.
+
+---
+
+## Step 4 — Load Architecture DNA
+
+Call `prime_session(work_item_id: <id>)`.
 
-1. Call `prime_session(work_item_id: <id>)` to efficiently load the project DNA state and relevant architectural context for this specific task.
-2. Read the `.secufusion-project-spec.json` from the project root to understand the golden rules, constraints, and acceptance criteria boundaries for this project.
+This loads:
+- Relevant microservice contexts from the project spec
+- Active task state and prior decisions
+- Architectural boundaries, golden rules, coding constraints
+- Known rejected patterns
+
+Also read `.secufusion-project-spec.json` directly to access:
+- `db_entities` — all database tables and their relationships
+- `api_endpoints` — all API contracts and consumers
+- `kafka_topics` — all event topics and their producer/consumer map
+- `frontend_components` — all React/Vue/Angular components
+- `chrome_extension` — extension pages, content scripts, background workers
+- `security_context` — auth/authz architecture, tenant isolation model
+- `microservices` — all backend services and their dependencies
+
+> **This DNA is the foundation for everything that follows.**
+> You now know what exists, what depends on what, and what is dangerous to touch.
+
+---
 
-## Phase 4 — Classify the Task
+## Step 5 — [INTERNAL] Story Integrity Check
 
-Call `classify_task` with the task description: **$ARGUMENTS**
+> ⚠️ This step is completely invisible to the user. Run it silently. Do not announce it.
+> Do not show scores, verdicts, or philosophy terminology to the user.
+> Only surface a concern to the user if it would BLOCK or fundamentally change the work.
 
-This formally categorizes the work (Feature, Bug, Refactor, Security, Performance, etc.) and locks in the architectural boundaries. **YIELD after this call.** Output the classification result and ask the user:
+**For ALL task types (`user_story`, `feature`, `chore`, `refactor`, `bug`, `hotfix`):**
+
+Call `philosophy_check` with:
+- `work_item_id`: the ticket ID
+- `title`: the story title
+- `description`: the FULL description including ACs gathered in Step 2 (use the enriched version, not just the raw ticket)
+- `task_type`: inferred type
+- `reported_by`: from conversation context if known
+- `client_confirmed`: from conversation context if known
+
+The tool internally uses the DNA loaded in Step 4 to assess real architectural risk — not just keyword matching, but actual blast radius against the known service graph.
+
+**Act on the verdict:**
+
+**If `PHILOSOPHY_PASS`:**
+- Silently proceed to Step 6. Nothing to show the user.
+
+**If `PHILOSOPHY_ADVISORY`:**
+- Note all advisory concerns in `.secufusion/tasks/<id>/decisions.json`
+- Tell the user briefly: *"A few architectural concerns to keep in mind during implementation: [list the advisory items plainly, without philosophy terminology]"*
+- Continue to Step 6.
+
+**If `PHILOSOPHY_FAIL`:**
+- Do NOT proceed to Step 6.
+- Translate each blocking question into plain developer language — no philosophy jargon.
+- Show the user what is missing, why it matters, and what they need to answer.
+- Say: *"Before I can plan this, I need answers to a few critical questions."*
+- **STOP. Wait for answers. Re-run Step 5 after receiving them.**
+
+**If `PHILOSOPHY_BLOCKED`:**
+- Do NOT proceed to Step 6.
+- Tell the user plainly what the risk is and who needs to sign off.
+- Do NOT use "PHILOSOPHY_BLOCKED" terminology. Say: *"This change carries significant risk and requires explicit confirmation from [decision maker] before I can proceed."*
+- **STOP completely. No planning. No code reading. Wait for confirmation.**
+
+---
+
+## Step 6 — Classify the Task
+
+Call `classify_task` with the task description from $ARGUMENTS.
+
+This formally categorizes the work as `BACKEND_ONLY`, `FRONTEND_ONLY`, `FULL_STACK`, or `EXTENSION_ONLY` and locks in architectural boundaries.
+
+**YIELD after this call.** Show the classification result and ask:
 
 > ✅ Classification complete. Does this look right? Give me the green signal to proceed with planning.
 
-Wait for explicit approval before continuing.
+Wait for explicit approval.
 
-## Phase 5 — Write the Implementation Plan (After Approval)
+---
+
+## Step 7 — Write the Implementation Plan
 
-Read `.agents/planner.md` for the Planner Persona instructions and produce a strict, step-by-step implementation plan that includes:
+Read `.agents/planner.md` for Planner Persona instructions.
 
-- **Acceptance Criteria** (Given/When/Then format, testable)
+Produce a strict implementation plan grounded in the DNA context, including:
+
+- **Acceptance Criteria** (Given/When/Then, testable)
 - **Scope Boundaries** (what is explicitly OUT of scope)
-- **Files to Create / Modify / Delete**
-- **Architectural Decisions** (with rationale grounded in the DNA)
-- **Risk Flags** (tenant isolation, N+1 risks, missing indexes, Kafka sync calls)
-- **Test Plan**
-- **Polyglot Impact** — for each service in the intent's Service Map that has no AST parser, note it explicitly and list what metadata is required (ports, topics, endpoints)
+- **Files to Create / Modify / Delete** (with service ownership)
+- **Architectural Decisions** (rationale grounded in project DNA)
+- **Risk Flags** (tenant isolation, N+1 queries, missing indexes, Kafka sync anti-patterns)
+- **Test Plan** (unit + integration + scenario coverage)
+- **Polyglot Impact** — for each service with no AST parser, list required metadata (ports, topics, endpoints, schemas)
+- **Advisory Items** (from Step 5, if any) — note these as implementation guardrails
 
-Save the plan to `.secufusion/tasks/<id>/plan.md`.
+Save to `.secufusion/tasks/<id>/plan.md`.
 
 Present the plan and ask:
-> 📋 Plan ready. Review `plan.md` and approve to begin coding with `/sfn:code`.
-
+> 📋 Plan ready. Review `plan.md` and approve to begin coding with `/sfn-code`.

package/commands/sfn-review.md

@@ -1,9 +1,9 @@
----
+---
 description: Run the zero-tolerance PR gate — 5 mechanical checks (Tenant Isolation, N+1, Missing Index, Kafka Sync, Early Returns) followed by a senior Reviewer Persona sign-off. A PR must pass this before it can be opened.
 argument-hint: <ticket-id>  e.g. WI-123
 ---
 
-You are executing the **sfn:review** command — the final quality gate before a Pull Request is opened.
+You are executing the **sfn-review** command — the final quality gate before a Pull Request is opened.
 
 Task: **$ARGUMENTS**
 
@@ -22,7 +22,7 @@ Call `run_pre_pr_checks_with_reviewer_agent` to trigger the `sfn-pr-check` CLI.
 | **Early Returns** | No deeply nested if/else — use guard clauses |
 
 **If any check FAILS:** Do NOT proceed to Phase 2. Report the exact violation with `file:line` and tell the user:
-> ❌ Tier 1 gate failed. Fix the violations above and re-run `/sfn:review`.
+> ❌ Tier 1 gate failed. Fix the violations above and re-run `/sfn-review`.
 
 Call `log_rejected_pattern(work_item_id: "$ARGUMENTS", pattern: "<description of the violation>")` to record it in permanent memory so it is never repeated.
 

package/mcp/dist/parsers/extension.js

@@ -0,0 +1,39 @@
+export function parseExtension(filePath, fileContent, repository) {
+    const components = [];
+    const fileName = filePath.split(/[\\/]/).pop()?.toLowerCase() || '';
+    if (fileName === 'manifest.json') {
+        components.push({
+            componentName: 'Manifest',
+            type: 'Manifest',
+            filePath,
+            repository
+        });
+    }
+    else if (fileContent.includes('chrome.runtime.onInstalled') || fileContent.includes('chrome.runtime.onMessage') || fileContent.includes('browser.runtime')) {
+        if (fileName.includes('background')) {
+            components.push({
+                componentName: 'BackgroundScript',
+                type: 'BackgroundScript',
+                filePath,
+                repository
+            });
+        }
+        else if (fileName.includes('content')) {
+            components.push({
+                componentName: 'ContentScript',
+                type: 'ContentScript',
+                filePath,
+                repository
+            });
+        }
+        else {
+            components.push({
+                componentName: fileName,
+                type: 'ExtensionScript',
+                filePath,
+                repository
+            });
+        }
+    }
+    return components;
+}

package/mcp/dist/server.js

@@ -25,6 +25,7 @@ import { parseApiEndpoints } from "./parsers/api.js";
 import { parseEventTopics } from "./parsers/events.js";
 import { inferPatterns } from "./parsers/patterns.js";
 import { parseFrontend } from "./parsers/frontend.js";
+import { parseExtension } from "./parsers/extension.js";
 import { parseNodeApis } from "./parsers/backend-node.js";
 import { parseInfra } from "./parsers/infra.js";
 import { parseDatabase } from "./parsers/database.js";
@@ -424,7 +425,7 @@ server.tool("manage_project_spec", "Manages the .secufusion-project-spec.json fi
             }
         }
         // 4. Check spec.chrome_extension by repo name
-        const chromeExt = spec.chrome_extension;
+        const chromeExt = (spec.chrome_extension || spec["snf-browser-extn"] || spec.snf_browser_extn);
         if (!serviceBlock && chromeExt) {
             const repoName = String(chromeExt.repo ?? "").toLowerCase();
             if (repoName === svcNameLower || svcNameLower.includes("chrome") || svcNameLower.includes("extension")) {
@@ -1431,7 +1432,386 @@ function buildScopeText(signals, domain) {
         ? parts.join("\n  ")
         : `${domain} implementation required`;
 }
-// ─── Tool 9: classify_task ────────────────────────────────────────────────────
+// --- Tool 9: philosophy_check -------------------------------------------------
+server.tool("philosophy_check", "MANDATORY PHASE -1 STEP — runs BEFORE classify_task, BEFORE reading any source files, BEFORE any planning. " +
+    "Challenges the WHY, WHO, WHAT, and RISK of a story before any implementation begins. " +
+    "Returns PHILOSOPHY_PASS, PHILOSOPHY_ADVISORY, PHILOSOPHY_FAIL, or PHILOSOPHY_BLOCKED. " +
+    "A FAIL or BLOCKED verdict completely stops all implementation — classify_task MUST NOT be called until this returns PASS or ADVISORY. " +
+    "Applies to ALL task types including bugs and hotfixes (though sensing is slightly relaxed for defects).", {
+    work_item_id: z.string().describe("Azure DevOps work item ID. e.g. 'WI-2847'"),
+    title: z.string().describe("Full story/task title from Azure DevOps."),
+    description: z.string().describe("Full story description including user story, acceptance criteria, and any context."),
+    task_type: z
+        .enum(["bug", "user_story", "feature", "hotfix", "refactor", "chore"])
+        .describe("bug | user_story | feature | hotfix | refactor | chore"),
+    reported_by: z.string().optional().describe("Who created/reported this story. e.g. 'client', 'PM', 'tech lead', 'developer'."),
+    client_confirmed: z.boolean().optional().describe("Has the decision maker explicitly confirmed this is needed?"),
+}, async ({ work_item_id, title, description, task_type, reported_by, client_confirmed }) => {
+    const inputChars = JSON.stringify({ work_item_id, title, description, task_type }).length;
+    // Fast-path: bugs and hotfixes skip philosophy check
+    if (task_type === "bug" || task_type === "hotfix") {
+        return appendTelemetry({ content: [{ type: "text", text: `[PHILOSOPHY SKIPPED] ${work_item_id} — task_type="${task_type}". Bugs/hotfixes skip philosophy. Proceeding directly to classify_task.` }] }, inputChars);
+    }
+    // Check cache
+    const philosophyDir = resolve(".secufusion/philosophy");
+    const philosophyFile = path.join(philosophyDir, `${work_item_id}.json`);
+    if (fs.existsSync(philosophyFile)) {
+        try {
+            const cached = JSON.parse(readFileSafe(philosophyFile) || "null");
+            if (cached && (cached.philosophy_verdict === "PHILOSOPHY_PASS" || cached.philosophy_verdict === "PHILOSOPHY_ADVISORY")) {
+                return appendTelemetry({ content: [{ type: "text", text: `[PHILOSOPHY CACHED] ${work_item_id} — verdict: ${cached.philosophy_verdict}\n\n${cached.developer_message}` }] }, inputChars);
+            }
+        }
+        catch { }
+    }
+    const wsRoot = getWorkspaceRoot();
+    let rejectedPatterns = [];
+    const rejRaw = readFileSafe(resolve(REJECTED_FILE));
+    if (rejRaw) {
+        try {
+            rejectedPatterns = JSON.parse(rejRaw);
+        }
+        catch { }
+    }
+    // ── Load Architecture DNA (MANDATORY for intelligent risk scoring) ──────
+    // philosophy_check reasons against real architecture — not just keywords.
+    // DNA provides: DB entities, Kafka topics, services, extension, auth model.
+    let dna = null;
+    let spec = null;
+    // Load project spec (golden rules, service map, security model)
+    const specCands2 = [
+        path.resolve(path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1")), ".secufusion-project-spec.json"),
+        path.resolve(wsRoot, ".secufusion-project-spec.json"),
+    ];
+    for (const c of specCands2) {
+        if (fs.existsSync(c)) {
+            try {
+                spec = JSON.parse(readFileSafe(c) || "null");
+                break;
+            }
+            catch { }
+        }
+    }
+    // Load DNA — full architecture graph
+    const dnaCandidates = [
+        path.resolve(wsRoot, ".secufusion", "dna.json"),
+        path.resolve(path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1")), ".secufusion", "dna.json"),
+    ];
+    for (const d of dnaCandidates) {
+        if (fs.existsSync(d)) {
+            try {
+                dna = JSON.parse(readFileSafe(d) || "null");
+                break;
+            }
+            catch { }
+        }
+    }
+    // Extract architectural context
+    const dnaServices = dna?.services?.map((s) => (s.name || "").toLowerCase()).filter((s) => s.length > 4) || [];
+    const dnaEntities = dna?.db_entities?.map((e) => (e.name || e.table || "").toLowerCase()).filter((e) => e.length > 3) || [];
+    const dnaTopics = dna?.kafka_topics || dna?.events || [];
+    const dnaExtension = dna?.chrome_extension || dna?.extension || dna?.["snf-browser-extn"] || null;
+    const dnaSecurity = dna?.security_context || spec?.security || null;
+    const dnaGoldenRules = spec?.golden_rules || [];
+    // DNA-aware risk bonus (stacks on top of keyword risk scores)
+    let dna_risk_bonus = 0;
+    const dnaRiskNotes = [];
+    const text = `${title} ${description}`.toLowerCase();
+    const wordCount = description.trim().split(/\s+/).length;
+    // [DNA-1] DB entities mentioned in story — each known entity = real schema blast
+    const mentionedEntities = dnaEntities.filter(e => text.includes(e));
+    if (mentionedEntities.length > 0) {
+        const entityRisk = Math.min(mentionedEntities.length * 10, 40);
+        dna_risk_bonus += entityRisk;
+        dnaRiskNotes.push(`DB entities: ${mentionedEntities.join(", ")} (+${entityRisk})`);
+    }
+    // [DNA-2] Kafka topics — fan-out cascades to all consumers
+    const mentionedTopics = dnaTopics.filter((t) => {
+        const tn = (t.name || t.topic || "").toLowerCase();
+        return tn.length > 3 && text.includes(tn);
+    });
+    if (mentionedTopics.length > 0) {
+        const topicConsumers = mentionedTopics.reduce((sum, t) => sum + (t.consumers?.length || t.consumer_count || 0), 0);
+        const topicRisk = Math.min(mentionedTopics.length * 15 + topicConsumers * 5, 35);
+        dna_risk_bonus += topicRisk;
+        dnaRiskNotes.push(`Kafka topics: ${mentionedTopics.map((t) => t.name || t.topic).join(", ")} (${topicConsumers} consumers) (+${topicRisk})`);
+    }
+    // [DNA-3] Chrome extension changes require store deployment
+    if (dnaExtension && (text.includes("extension") || text.includes("chrome") || text.includes("background script") || text.includes("content script") || text.includes("popup"))) {
+        dna_risk_bonus += 20;
+        dnaRiskNotes.push("snf-browser-extn affected — manual store publish (+20)");
+    }
+    // [DNA-4] Shared multi-tenant auth service — changes blast all tenants
+    const isSharedAuth = dnaSecurity && (dnaSecurity.type === "shared" || dnaSecurity.multi_tenant === true || dnaSecurity.multi_tenant === "true");
+    if (isSharedAuth && (text.includes("auth") || text.includes("login") || text.includes("permission") || text.includes("role") || text.includes("tenant") || text.includes("token"))) {
+        dna_risk_bonus += 25;
+        dnaRiskNotes.push("Shared multi-tenant auth — cross-tenant blast (+25)");
+    }
+    // [DNA-5] Polyglot service coordination — 3+ services = integration risk
+    const mentionedServices = dnaServices.filter(s => text.includes(s));
+    if (mentionedServices.length >= 3) {
+        dna_risk_bonus += 15;
+        dnaRiskNotes.push(`Multi-service: ${mentionedServices.slice(0, 4).join(", ")} (+15)`);
+    }
+    // [DNA-6] Golden rule violation signals
+    const antiPatterns = ["bypass", "skip migration", "no migration", "hardcode", "raw sql", "direct db", "without migration"];
+    const hitAntipatterns = antiPatterns.filter(ap => text.includes(ap));
+    if (hitAntipatterns.length > 0) {
+        dna_risk_bonus += 20;
+        dnaRiskNotes.push(`Antipattern signal: ${hitAntipatterns.join(", ")} (+20)`);
+    }
+    const dnaAvailable = dna !== null;
+    const dnaWarning = dnaAvailable ? "" : "\n[NOTE] DNA not loaded — risk is keyword-only. Run /sfn-init for architecture-aware scoring.";
+    // PASS 1 - WHY CHECK
+    let why_score = 0;
+    if (task_type === "bug" || task_type === "hotfix") {
+        why_score += 20; // Relaxed WHY sensing for defects
+    }
+    const STRONG_WHY = ["users spend", "current process causes", "compliance requires", "audit requires", "production issue", "users are reporting", "data shows", "confirmed by", "ticket from client", "business requirement", "regulatory", "security risk", "revenue impact"];
+    const WEAK_WHY = [
+        "would be nice", "nice feature", "nice addition", "could be useful", "other platforms have",
+        "other saas", "other products have", "similar products", "competitors have",
+        "client might want", "we should probably", "nice to have", "maybe useful",
+        "might improve", "could improve", "would improve", "would be helpful",
+        "suggestion", "idea", "asked for it"
+    ];
+    for (const s of STRONG_WHY)
+        if (text.includes(s))
+            why_score += 10;
+    for (const s of WEAK_WHY)
+        if (text.includes(s))
+            why_score -= 10;
+    if (text.includes("client asked") && !text.includes("because") && !text.includes("so that"))
+        why_score -= 10;
+    // Penalize descriptions under 30 words with no strong why — they can't justify themselves
+    if (wordCount < 30 && why_score <= 0)
+        why_score -= 10;
+    let purpose_stated = false;
+    let purpose_text = "";
+    for (const m of ["so that", "in order to", "because", "which means", "this allows"]) {
+        const idx = description.toLowerCase().indexOf(m);
+        if (idx !== -1) {
+            purpose_stated = true;
+            purpose_text = description.substring(idx, idx + 120).trim();
+            break;
+        }
+    }
+    const why_verdict = why_score >= 10 ? "STRONG" : why_score >= 0 ? "ACCEPTABLE" : why_score >= -19 ? "WEAK" : "NO_JUSTIFICATION";
+    // PASS 2 - WHO CHECK
+    let who_score = 0;
+    if (task_type === "bug" || task_type === "hotfix") {
+        who_score += 15; // Relaxed WHO sensing for defects
+    }
+    const AUTH_SIG = ["client confirmed", "client approved", "stakeholder sign-off", "decision made by", "approved by", "confirmed in meeting", "email from client", "client requirement", "explicit request from", "signed off"];
+    const UNCERT_SIG = [
+        "assumed", "we think", "probably", "should want", "might need", "could need",
+        "i think the client", "i think clients", "pm suggestion", "internal idea", "we decided",
+        "i think", "don't think", "shouldn't need", "won't need"
+    ];
+    for (const s of AUTH_SIG)
+        if (text.includes(s))
+            who_score += 10;
+    for (const s of UNCERT_SIG)
+        if (text.includes(s))
+            who_score -= 10;
+    if (reported_by) {
+        const rb = reported_by.toLowerCase();
+        if (rb === "client")
+            who_score += 15;
+        else if (rb === "pm")
+            who_score += 5;
+        else if (rb === "developer")
+            who_score -= 5;
+    }
+    if (client_confirmed === true)
+        who_score += 20;
+    else if (client_confirmed === false)
+        who_score -= 20;
+    const who_verdict = who_score >= 15 ? "CONFIRMED" : who_score >= 0 ? "PROBABLE" : who_score >= -14 ? "UNCERTAIN" : "UNCONFIRMED";
+    // PASS 3 - WHAT CHECK
+    let what_score = 0;
+    if (text.includes("acceptance criteria"))
+        what_score += 20;
+    const hasGWT = text.includes("given") && text.includes("when") && text.includes("then");
+    if (hasGWT)
+        what_score += 15;
+    const numberedACs = (description.match(/\b(ac-?\d+|\d+\.\s+(?:given|when|then|the user|the system))/gi) || []).length;
+    if (numberedACs >= 2)
+        what_score += 10;
+    if ((description.match(/\bmust\b/gi) || []).length >= 1)
+        what_score += 5;
+    if (text.includes("as discussed"))
+        what_score -= 15;
+    if (text.includes("as agreed"))
+        what_score -= 15;
+    if (text.includes("tbd"))
+        what_score -= 20;
+    if (text.includes("to be defined"))
+        what_score -= 20;
+    if (wordCount < 50)
+        what_score -= 10;
+    if (!/\b(\d+%|within \d+|less than \d+|at least \d+)\b/.test(description) && wordCount < 80)
+        what_score -= 10;
+    const hasOutOfScope = text.includes("out of scope") || text.includes("not included");
+    if (hasOutOfScope)
+        what_score += 10;
+    if (text.includes("edge cases"))
+        what_score += 10;
+    if (text.includes("error handling"))
+        what_score += 5;
+    const what_verdict = what_score >= 20 ? "CLEAR" : what_score >= 0 ? "ACCEPTABLE" : what_score >= -19 ? "VAGUE" : "UNDEFINED";
+    const ac_count = Math.max(numberedACs, (description.match(/\b(ac-?\d+|given\b)/gi) || []).length);
+    // PASS 4 - RISK CHECK
+    let risk_score = 0;
+    const high_risk_factors = [];
+    const riskSignals = [
+        ["db migration", 20, "DB migration"], ["database migration", 20, "DB migration"],
+        ["drop column", 30, "Drop column"], ["rename column", 30, "Rename column"],
+        ["authentication change", 25, "Auth change"], ["auth change", 25, "Auth change"],
+        ["authorization change", 20, "Authz change"], ["permission change", 20, "Permission change"],
+        ["all tenants", 20, "Affects all tenants"], ["kafka schema", 25, "Kafka schema change"],
+        ["chrome extension", 15, "Chrome extension"], ["irreversible", 30, "Irreversible"],
+        ["data migration", 20, "Data migration"], ["api contract", 25, "API contract change"],
+        ["breaking change", 25, "Breaking change"], ["affects existing", 15, "Affects existing"],
+    ];
+    for (const [kw, score, label] of riskSignals) {
+        if (text.includes(kw)) {
+            risk_score += score;
+            if (!high_risk_factors.includes(label))
+                high_risk_factors.push(label);
+        }
+    }
+    // Regex-based: catch "drop the old X columns", "Drop legacy device columns", etc.
+    // Use 'text' (title+desc combined) since title often has key verb, description has the noun.
+    if (/\bdrop\b.{0,60}\bcolumns?/i.test(text) && !high_risk_factors.includes("Drop column")) {
+        risk_score += 30;
+        high_risk_factors.push("Drop column (pattern)");
+    }
+    if (/\bdelete\b.{0,30}\bcolumns?/i.test(text) && !high_risk_factors.includes("Drop column")) {
+        risk_score += 30;
+        high_risk_factors.push("Delete column (pattern)");
+    }
+    if (text.includes("delete") && (text.includes(" data") || text.includes("record"))) {
+        risk_score += 25;
+        high_risk_factors.push("Data deletion");
+    }
+    if (text.includes("new endpoint"))
+        risk_score += 10;
+    if (text.includes("new table"))
+        risk_score += 10;
+    if (text.includes("new kafka topic"))
+        risk_score += 15;
+    if (text.includes("new service"))
+        risk_score += 20;
+    if (text.includes("read only") || text.includes("display only"))
+        risk_score -= 10;
+    if (text.includes("no db change") || text.includes("no migration"))
+        risk_score -= 15;
+    if (text.includes("isolated change"))
+        risk_score -= 10;
+    if (text.includes("config change only"))
+        risk_score -= 10;
+    let rejected_pattern_risk = false;
+    for (const rp of rejectedPatterns) {
+        const rpKeywords = rp.keywords || (rp.pattern ? [rp.pattern] : []);
+        for (const kw of rpKeywords) {
+            if (kw && text.includes(kw.toLowerCase())) {
+                rejected_pattern_risk = true;
+                risk_score += 20;
+                high_risk_factors.push(`Rejected pattern: ${rp.id || rp.name}`);
+                break;
+            }
+        }
+    }
+    // ── Apply DNA-aware risk bonus ──────────────────────────────────────
+    // Keyword scoring is blind to actual architecture. DNA bonus reflects real blast radius.
+    risk_score += Math.min(dna_risk_bonus, 50); // cap at 50 to prevent double-stacking
+    for (const note of dnaRiskNotes) {
+        if (!high_risk_factors.includes(note))
+            high_risk_factors.push(`[DNA] ${note}`);
+    }
+    const risk_verdict = risk_score <= 10 ? "LOW" : risk_score <= 30 ? "MEDIUM" : risk_score <= 50 ? "HIGH" : "CRITICAL";
+    const reversibility = risk_score <= 20 ? "REVERSIBLE" : risk_score <= 40 ? "REVERSIBLE_WITH_EFFORT" : "DIFFICULT_TO_REVERSE";
+    // PASS 5 - PHILOSOPHY VERDICT
+    let philosophy_verdict = "PHILOSOPHY_PASS";
+    const blocking_questions = [];
+    const advisory_notes = [];
+    if ((who_verdict === "UNCONFIRMED" && risk_verdict === "CRITICAL") ||
+        (who_verdict === "UNCONFIRMED" && risk_verdict === "HIGH" && reversibility === "DIFFICULT_TO_REVERSE") ||
+        (why_verdict === "NO_JUSTIFICATION" && (task_type === "feature" || task_type === "user_story")) ||
+        (rejected_pattern_risk && risk_verdict === "CRITICAL")) {
+        philosophy_verdict = "PHILOSOPHY_BLOCKED";
+    }
+    else if (who_verdict === "UNCONFIRMED" ||
+        why_verdict === "NO_JUSTIFICATION" ||
+        what_verdict === "UNDEFINED" ||
+        (risk_verdict === "CRITICAL" && reversibility === "DIFFICULT_TO_REVERSE")) {
+        philosophy_verdict = "PHILOSOPHY_FAIL";
+    }
+    else if (who_verdict === "UNCERTAIN" || why_verdict === "WEAK" || what_verdict === "VAGUE" || risk_verdict === "HIGH") {
+        philosophy_verdict = "PHILOSOPHY_ADVISORY";
+    }
+    const allowed_next_action = philosophy_verdict === "PHILOSOPHY_PASS" ? "PROCEED" :
+        philosophy_verdict === "PHILOSOPHY_ADVISORY" ? "ADVISORY_PROCEED" :
+            philosophy_verdict === "PHILOSOPHY_FAIL" ? "STOP" : "ESCALATE";
+    if (why_verdict === "NO_JUSTIFICATION" || why_verdict === "WEAK")
+        blocking_questions.push({ category: "WHY", question: `What specific problem does "${title}" solve?`, impact: "Without a clear problem statement, the solution may be wrong.", action: "Add a problem statement with data, user pain, or regulatory requirement." });
+    if (who_verdict === "UNCONFIRMED" || who_verdict === "UNCERTAIN")
+        blocking_questions.push({ category: "WHO", question: "Who has explicitly confirmed this is needed?", impact: "Building unconfirmed features wastes sprint capacity.", action: "Get written confirmation from client or PM." });
+    if (what_verdict === "UNDEFINED" || what_verdict === "VAGUE")
+        blocking_questions.push({ category: "WHAT", question: "What are the acceptance criteria?", impact: "Vague stories produce vague software.", action: "Add Given/When/Then ACs." });
+    if (risk_verdict === "CRITICAL" && reversibility === "DIFFICULT_TO_REVERSE")
+        blocking_questions.push({ category: "RISK", question: `CRITICAL risk: ${high_risk_factors.join(", ")}. What is the rollback plan?`, impact: "This change may be impossible to revert.", action: "Define rollback plan and get explicit sign-off." });
+    if (who_verdict === "UNCERTAIN")
+        advisory_notes.push({ category: "WHO", note: "Decision maker not fully confirmed", suggestion: "Confirm with client or PM." });
+    if (why_verdict === "WEAK")
+        advisory_notes.push({ category: "WHY", note: "Weak justification", suggestion: "Strengthen with data or regulatory context." });
+    if (what_verdict === "VAGUE")
+        advisory_notes.push({ category: "WHAT", note: "ACs incomplete or vague", suggestion: "Add measurable ACs before coding." });
+    if (risk_verdict === "HIGH")
+        advisory_notes.push({ category: "RISK", note: `High risk: ${high_risk_factors.join(", ") || "multiple signals"}`, suggestion: "Review blast radius. Consider staged rollout." });
+    let developer_message = "";
+    const scoresSummary = `\nScores | WHY:${why_score} WHO:${who_score} WHAT:${what_score} RISK:${risk_score}${dna_risk_bonus > 0 ? ` (DNA+${dna_risk_bonus})` : ""}${dnaWarning}`;
+    if (philosophy_verdict === "PHILOSOPHY_PASS") {
+        developer_message = `[PHILOSOPHY PASS] ${work_item_id}\n\nWHY  : ${why_verdict}${purpose_text ? " - " + purpose_text : ""}\nWHO  : ${who_verdict}\nWHAT : ${what_verdict} — ${ac_count} AC(s)\nRISK : ${risk_verdict} (${reversibility})${high_risk_factors.length > 0 ? "\nRisk factors: " + high_risk_factors.join(", ") : ""}\n\nProceed to classify_task.${scoresSummary}`;
+    }
+    else if (philosophy_verdict === "PHILOSOPHY_ADVISORY") {
+        developer_message = `[PHILOSOPHY ADVISORY] ${work_item_id}\n\nStory may proceed with caution. Note these concerns:\n\n` +
+            advisory_notes.map((n) => `  [${n.category}] ${n.note}\n  Suggestion: ${n.suggestion}`).join("\n\n") +
+            `\n\nWHY:${why_verdict} | WHO:${who_verdict} | WHAT:${what_verdict} | RISK:${risk_verdict}\nProceed to classify_task. Record advisory notes in decisions.json.${scoresSummary}`;
+    }
+    else if (philosophy_verdict === "PHILOSOPHY_FAIL") {
+        developer_message = `[PHILOSOPHY FAIL] ${work_item_id}\n\nImplementation BLOCKED. The following must be resolved before planning can begin:\n\n` +
+            blocking_questions.map((q) => `  [${q.category}] ${q.question}\n  Why: ${q.impact}\n  Action: ${q.action}`).join("\n\n") +
+            `\n\nDo NOT call classify_task. Re-run philosophy_check after resolving.${scoresSummary}`;
+    }
+    else {
+        developer_message = `[PHILOSOPHY BLOCKED] ${work_item_id}\n\nESCALATION REQUIRED. ${risk_verdict} risk + ${who_verdict} authority.\n\n` +
+            blocking_questions.map((q) => `  [${q.category}] ${q.question}\n  Risk: ${q.impact}\n  Required: ${q.action}`).join("\n\n") +
+            `\n\nNO implementation or planning until explicit written sign-off from the decision maker.${scoresSummary}`;
+    }
+    const result = {
+        work_item_id, title, task_type, philosophy_verdict, allowed_next_action,
+        dna_assessment: {
+            dna_available: dnaAvailable,
+            dna_risk_bonus,
+            dna_risk_notes: dnaRiskNotes,
+        },
+        passes: {
+            why: { score: why_score, verdict: why_verdict, purpose_stated, purpose_text },
+            who: { score: who_score, verdict: who_verdict },
+            what: { score: what_score, verdict: what_verdict, ac_count, has_given_when_then: hasGWT, has_out_of_scope: hasOutOfScope, word_count: wordCount },
+            risk: { score: risk_score, verdict: risk_verdict, reversibility, rejected_pattern_risk, high_risk_factors }
+        },
+        blocking_questions, advisory_notes, developer_message, scored_at: new Date().toISOString()
+    };
+    try {
+        writeFile(philosophyFile, JSON.stringify(result, null, 2));
+    }
+    catch { }
+    return appendTelemetry({ content: [{ type: "text", text: developer_message }] }, inputChars);
+});
+// --- Tool 10: classify_task --------------------------------------------------
 server.tool("classify_task", "MANDATORY FIRST STEP for every task without exception. " +
     "Classifies a task as BACKEND_ONLY, FRONTEND_ONLY, FULL_STACK, or EXTENSION_ONLY. " +
     "Performs a breaking-change pre-scan against the project spec. " +
@@ -1561,8 +1941,9 @@ server.tool("classify_task", "MANDATORY FIRST STEP for every task without except
         }
         if (spec.frontend && spec.frontend.repo)
             FRONTEND_SIGNALS.push(spec.frontend.repo.toLowerCase());
-        if (spec.chrome_extension && spec.chrome_extension.repo)
-            EXTENSION_SIGNALS.push(spec.chrome_extension.repo.toLowerCase());
+        const extSpec = spec.chrome_extension || spec["snf-browser-extn"] || spec.snf_browser_extn;
+        if (extSpec && extSpec.repo)
+            EXTENSION_SIGNALS.push(extSpec.repo.toLowerCase());
     }
     const backendFound = BACKEND_SIGNALS.filter(s => corpus.includes(s));
     const frontendFound = FRONTEND_SIGNALS.filter(s => corpus.includes(s));
@@ -1587,8 +1968,9 @@ server.tool("classify_task", "MANDATORY FIRST STEP for every task without except
             Object.keys(spec.microservices).forEach(k => services.push(k.toLowerCase()));
         if (spec.frontend && spec.frontend.repo)
             services.push(spec.frontend.repo.toLowerCase());
-        if (spec.chrome_extension && spec.chrome_extension.repo)
-            services.push(spec.chrome_extension.repo.toLowerCase());
+        const extSpec2 = spec.chrome_extension || spec["snf-browser-extn"] || spec.snf_browser_extn;
+        if (extSpec2 && extSpec2.repo)
+            services.push(extSpec2.repo.toLowerCase());
     }
     if (services.length === 0) {
         services.push("sfn-iam-api", "sfn-events-api", "sfn-tenants-api", "sfn-policy-api", "sfn-gateway-api", "sfn-web-ui");
@@ -2182,7 +2564,7 @@ server.tool("analyze_impact", "Traces the SecuFusion inter-service call graph an
     }
     walkGraph(target, 0);
     // ── Pass 2: Chrome extension check ────────────────────────────────────
-    const extData = spec.chrome_extension || spec["sfn-chrome-ext"] || null;
+    const extData = spec.chrome_extension || spec["sfn-chrome-ext"] || spec["snf-browser-extn"] || null;
     let extensionHit = null;
     if (extData) {
         const extCalls = (extData.calls_endpoints || extData.calls || []).map(e => e.toLowerCase());
@@ -4116,6 +4498,10 @@ server.tool("reviewer_agent", "Context-aware architectural review agent — call
         }
     }
     // PRAISE
+    const extSpec3 = specData.chrome_extension || specData["snf-browser-extn"] || specData.snf_browser_extn;
+    if (extSpec3 && extSpec3.repo) {
+        expectedServices.push(extSpec3.repo);
+    }
     if (praises.length > 0) {
         out += `### ✅ PRAISE\n`;
         for (const f of praises) {
@@ -4253,7 +4639,7 @@ function readDna(ecosystemRoot) {
 function writeDna(ecosystemRoot, dna) {
     fs.writeFileSync(getDnaPath(ecosystemRoot), JSON.stringify(dna, null, 2));
 }
-const VALID_EXTENSIONS = ['.java', '.ts', '.js', '.tsx', '.jsx', '.vue', '.sql', '.prisma', '.tf', '.yaml', '.yml', '.env', '.env.example', '.env.local', '.properties'];
+const VALID_EXTENSIONS = ['.java', '.ts', '.js', '.tsx', '.jsx', '.vue', '.sql', '.prisma', '.tf', '.yaml', '.yml', '.env', '.env.example', '.env.local', '.properties', '.json'];
 function getAllSourceFiles(dirPath, repoName, arrayOfFiles = []) {
     if (!fs.existsSync(dirPath))
         return arrayOfFiles;
@@ -4278,7 +4664,7 @@ function getPolyRepoSourceFiles(ecosystemRoot) {
     const children = fs.readdirSync(ecosystemRoot);
     for (const child of children) {
         const childPath = path.join(ecosystemRoot, child);
-        if (fs.statSync(childPath).isDirectory() && (child.startsWith("sfn-") || child === "secufusion")) {
+        if (fs.statSync(childPath).isDirectory() && (child.startsWith("sfn-") || child.startsWith("snf-") || child === "secufusion")) {
             allFiles = allFiles.concat(getAllSourceFiles(childPath, child));
         }
         else if (fs.statSync(childPath).isDirectory() && ecosystemRoot === childPath) {
@@ -4294,6 +4680,7 @@ function performFullExtraction(ecosystemRoot) {
     const events = [];
     const nodeApis = [];
     const frontend = [];
+    const extension = [];
     const infra = [];
     const databases = [];
     const security = [];
@@ -4307,6 +4694,7 @@ function performFullExtraction(ecosystemRoot) {
         }
         nodeApis.push(...parseNodeApis(fileObj.path, content, fileObj.repo));
         frontend.push(...parseFrontend(fileObj.path, content, fileObj.repo));
+        extension.push(...parseExtension(fileObj.path, content, fileObj.repo));
         infra.push(...parseInfra(fileObj.path, content, fileObj.repo));
         databases.push(...parseDatabase(fileObj.path, content, fileObj.repo));
         security.push(...parseSecurity(fileObj.path, content, fileObj.repo));
@@ -4318,6 +4706,7 @@ function performFullExtraction(ecosystemRoot) {
     dna.events = events;
     dna.node_apis = nodeApis;
     dna.frontend = frontend;
+    dna.extension = extension;
     dna.infra = infra;
     dna.databases = databases;
     dna.security = security;
@@ -4325,7 +4714,20 @@ function performFullExtraction(ecosystemRoot) {
     // Apply Pattern Inference
     dna.inferred_patterns = inferPatterns(dna);
     writeDna(ecosystemRoot, dna);
+    const hasBackend = (models.length > 0 || apis.length > 0 || nodeApis.length > 0);
+    const hasFrontend = frontend.length > 0;
+    const hasExtension = extension.length > 0;
+    const missing = [];
+    if (!hasBackend)
+        missing.push("backend");
+    if (!hasFrontend)
+        missing.push("frontend");
+    if (!hasExtension)
+        missing.push("snf-browser-extn");
+    const missingWarning = missing.length > 0 ? `\n\n[CRITICAL CORE CHECK] The following core components are missing from the DNA map: ${missing.join(', ')}. Please verify if this is expected.` : "";
     return {
+        missingWarning,
+        extensionCount: extension.length,
         modelsCount: models.length,
         apisCount: apis.length + nodeApis.length,
         eventsCount: events.length,
@@ -4396,7 +4798,7 @@ server.tool("extract_domain_models", "Parses files across the ecosystem to build
         const ecosystemRoot = getEcosystemRoot(workspace_root);
         const stats = performFullExtraction(ecosystemRoot);
         return {
-            content: [{ type: "text", text: `Extracted ${stats.modelsCount} domain models. Derived ${stats.inferredCount} architectural patterns.` }]
+            content: [{ type: "text", text: `Extracted ${stats.modelsCount} domain models. Derived ${stats.inferredCount} architectural patterns.${stats.missingWarning}` }]
         };
     }
     catch (e) {
@@ -4410,7 +4812,7 @@ server.tool("extract_api_endpoints", "Scans for REST/GraphQL endpoints across th
         const ecosystemRoot = getEcosystemRoot(workspace_root);
         const stats = performFullExtraction(ecosystemRoot);
         return {
-            content: [{ type: "text", text: `Extracted ${stats.apisCount} API controllers. Derived ${stats.inferredCount} architectural patterns.` }]
+            content: [{ type: "text", text: `Extracted ${stats.apisCount} API controllers. Derived ${stats.inferredCount} architectural patterns.${stats.missingWarning}` }]
         };
     }
     catch (e) {
@@ -4424,7 +4826,7 @@ server.tool("extract_event_topics", "Scans for event listener/producer usage acr
         const ecosystemRoot = getEcosystemRoot(workspace_root);
         const stats = performFullExtraction(ecosystemRoot);
         return {
-            content: [{ type: "text", text: `Extracted ${stats.eventsCount} event classes. Derived ${stats.inferredCount} architectural patterns.` }]
+            content: [{ type: "text", text: `Extracted ${stats.eventsCount} event classes. Derived ${stats.inferredCount} architectural patterns.${stats.missingWarning}` }]
         };
     }
     catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "secufusion-mcp",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "type": "module",
   "description": "SecuFusion MCP server - developer workflow tooling with guardrails",
   "main": "mcp/dist/server.js",

package/commands/analyze.md

@@ -1,15 +0,0 @@
----
-description: Analyzes the current project to build its DNA Knowledge Graph
-argument-hint: (no args)
----
-
-You are the SecuFusion DNA Discovery Agent. Your goal is to analyze this ecosystem and build the Poly-Repo DNA Knowledge Graph.
-
-The underlying MCP tools will automatically detect if you are inside a poly-repo structure. If they find sibling repositories, they will scan all of them simultaneously to build a cross-repo DNA file.
-
-1. Call the `secufusion-dna_scan_repository_stack` tool to identify the framework and infrastructure across the ecosystem.
-2. Call the `secufusion-dna_extract_domain_models` tool to find and parse entities and domain models across all repos.
-3. Call the `secufusion-dna_extract_api_endpoints` tool to map out the API layer across all repos.
-4. Call the `secufusion-dna_extract_event_topics` tool to map out event consumers and producers across all repos.
-
-Once you have gathered this information, summarize your findings for the user. Do not delete any existing data in the knowledge graph.

package/commands/blast-radius.md

@@ -1,14 +0,0 @@
----
-description: Determines the impact of changing a specific component or file
-argument-hint: <component-name-or-file-path>
----
-
-You are the SecuFusion DNA Blast Radius Agent. Your goal is to determine the impact of changing the provided component or file across the entire Poly-Repo ecosystem.
-
-1. Call the `secufusion-dna_query_knowledge_graph` tool with the query "Find all components, services, and APIs that depend on or consume {argument}".
-2. Analyze the returned dependency chain, paying special attention to cross-repo dependencies (e.g., changing a DTO in `sfn-events-api` breaking a listener in `sfn-notification-api`).
-3. Present a Cross-Repo Blast Radius Report to the user, categorizing the impact into:
-   - Impacted Microservices
-   - Impacted APIs
-   - Impacted Events/Consumers
-   - Impacted Databases

package/commands/map-architecture.md

@@ -1,10 +0,0 @@
----
-description: Generates a Mermaid architecture diagram from the project DNA
-argument-hint: (no args)
----
-
-You are the SecuFusion DNA Architecture Agent. Your goal is to visualize the cross-service dependencies and architecture of this project.
-
-1. Call the `secufusion-dna_query_knowledge_graph` tool with the query "Get all services, APIs, and event topics with their dependencies".
-2. Based on the returned relationships, generate a comprehensive Mermaid diagram (`graph TD` or `graph LR`).
-3. Render the diagram in your response, grouping components by bounded context or service if possible.

package/commands/map-services.md

@@ -1,3 +0,0 @@
-# /map-services
-
-This command instructs the SecuFusion DNA Discovery MCP to analyze the project based on /map-services.

package/commands/watch-dna.md

@@ -1,9 +0,0 @@
----
-description: Starts the background watcher to continuously update the Poly-Repo DNA.
-argument-hint: (no args)
----
-
-You are the SecuFusion DNA Watcher Agent. Your goal is to start the background file watcher.
-
-1. Call the `start_dna_watcher` tool.
-2. Inform the user that the DNA Knowledge Graph is now actively monitoring the codebase in the background and will dynamically update whenever a developer saves a Java file.