Skip to content
Back to search

DocSentinel

MCP server for AI agent for cybersecurity: automate assessment of documents, questionnaires & reports. Multi-format parsing, RAG knowledge base,Risks, compliance gaps, remediations.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/arthurpanhku/DocSentinel with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/arthurpanhku/DocSentinel'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/arthurpanhku--docsentinel/badge.svg)](/listings/arthurpanhku--docsentinel)

HTML

<a href="/listings/arthurpanhku--docsentinel"><img src="/api/listings/arthurpanhku--docsentinel/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option A: One-Click Deployment (Recommended)

git clone https://github.com/arthurpanhku/DocSentinel.git
cd DocSentinel
chmod +x deploy.sh
./deploy.sh

- **React Console**: [http://localhost:8000/console](http://localhost:8000/console) - **Agent Integrations**: [http://localhost:8000/console/integrations](http://localhost:8000/console/integrations) - **API Docs**: [http://localhost:8000/api-docs](http://localhost:8000/api-docs) - **A2A Agent Card**: [http://localhost:8000/.well-known/agent-card.json](http://localhost:8000/.well-known/agent-card.json)

To connect an external agent through the published Docker port, set `AGENT_GATEWAY_TOKEN` in `.env` before running `./deploy.sh`.

Option B: Manual Setup

**Prerequisites**: **Python 3.11+** and **Node.js 20+**. Optional: [Ollama](https://ollama.ai) (`ollama pull llama2`).

git clone https://github.com/arthurpanhku/DocSentinel.git
cd DocSentinel
python3 -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install -r requirements.txt
cp .env.example .env        # Edit if needed: LLM_PROVIDER=ollama or openai
npm install --prefix frontend
npm run build --prefix frontend
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

DeepSeek example

Set these values in `.env`, or use the **Settings** page after the server is running. Never commit real API keys.

LLM_PROVIDER=deepseek
DEEPSEEK_BASE_URL=https://api.deepseek.com
DEEPSEEK_MODEL=deepseek-chat
DEEPSEEK_API_KEY=sk-your-deepseek-key

- **API docs**: [http://localhost:8000/api-docs](http://localhost:8000/api-docs) · **Health**: [http://localhost:8000/health](http://localhost:8000/health) - **React Console**: [http://localhost:8000/console](http://localhost:8000/console) - **Agent Integrations**: [http://localhost:8000/console/integrations](http://localhost:8000/console/integrations) - **MCP Streamable HTTP**: `http://localhost:8000/mcp/` - **A2A Agent Card**: [http://localhost:8000/.well-known/agent-card.json](http://localhost:8000/.well-known/agent-card.json) - **Legacy Review Console (HITL)**: [http://localhost:8000/docs/review-console.html](http://localhost:8000/docs/review-console.html)

React Console

DocSentinel includes a React + TypeScript + Vite + Tailwind CSS console for assessments, knowledge base operations, skills, and system status.

npm install --prefix frontend
npm run build --prefix frontend
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

Open [http://localhost:8000/console](http://localhost:8000/console). For frontend-only development, run:

npm run dev --prefix frontend

The Vite dev server proxies `/api`, `/health`, and `/config` to `http://localhost:8000`.

The **Settings** page can update the running server's LLM provider, model, base URL, and API key. API keys are only returned to the UI as masked previews. For persistent startup defaults, set the matching values in `.env`.

---

Example: Submit an SSDLC assessment

# Run a Design phase assessment (threat modeling)
curl -X POST "http://localhost:8000/api/v1/assessments" \
  -F "files=@examples/architecture-doc.pdf" \
  -F "phase=design" \
  -F "scenario_id=threat-modeling"

# Response: { "task_id": "...", "status": "accepted" }
# Get the result
curl "http://localhost:8000/api/v1/assessments/TASK_ID"

Example: Upload to KB and query

# Upload a security policy to the requirements KB collection
curl -X POST "http://localhost:8000/api/v1/kb/documents" \
  -F "file=@examples/sample-policy.txt" \
  -F "collection=kb_requirements"

# Query the KB (RAG)
curl -X POST "http://localhost:8000/api/v1/kb/query" \
  -H "Content-Type: application/json" \
  -d '{"query": "What are the access control requirements?", "top_k": 5}'

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 848 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. [English](README.md) | [简体中文](README_zh.md) | [日本語](README_ja.md) | [한국어](README_ko.md) | [Français](README_fr.md) | [Deutsch](README_de.md) | [Русский](README_ru.md)
  3. </div>
  4. <p align="center">
  5. <img src="docs/images/docsentinel-mascot.png" width="220" alt="DocSentinel anime cyber kitsune sentinel"/>
  6. <br/>
  7. <sub>Anime cyber kitsune sentinel for the DocSentinel console and documentation.</sub>
  8. </p>
  9. <p align="center">
  10. <strong>DocSentinel</strong><br/>
  11. <em>AI-powered SSDLC platform — Secure your software from requirements to operations</em>
  12. </p>
  13. <p align="center">
  14. <a href="https://github.com/arthurpanhku/DocSentinel/releases"><img src="https://img.shields.io/github/v/release/arthurpanhku/DocSentinel?include_prereleases" alt="Latest release"/></a>
  15. <a href="https://github.com/arthurpanhku/DocSentinel/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"/></a>
  16. <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.11+-blue.svg" alt="Python 3.11+"/></a>
  17. <a href="https://github.com/arthurpanhku/DocSentinel"><img src="https://img.shields.io/badge/GitHub-arthurpanhku%2FDocSentinel--Agent-24292e?logo=github" alt="GitHub repo"/></a>
  18. <a href="docs/06-agent-integration.md"><img src="https://img.shields.io/badge/MCP-Ready-green?logo=anthropic" alt="MCP Ready"/></a>
  19. <a href="docs/06-agent-integration.md"><img src="https://img.shields.io/badge/A2A-1.0-blueviolet" alt="A2A 1.0"/></a>
  20. <a href="SECURITY.md"><img src="https://img.shields.io/badge/Human_Review-Required-0f766e" alt="Human review required"/></a>
  21. <a href="https://python.langchain.com/"><img src="https://img.shields.io/badge/LangChain-Powered-orange" alt="LangChain"/></a>
  22. <a href="https://langchain-ai.github.io/langgraph/"><img src="https://img.shields.io/badge/LangGraph-Orchestrated-blue" alt="LangGraph"/></a>
  23. </p>
  24. <p align="center">
  25. <a href="https://glama.ai/mcp/servers/arthurpanhku/DocSentinel">
  26. <img width="380" height="200" src="https://glama.ai/mcp/servers/arthurpanhku/DocSentinel/badge" />
  27. </a>
  28. </p>
  29. ---
  30. ## What is DocSentinel?
  31. **DocSentinel** is an AI-powered **SSDLC (Secure Software Development Lifecycle) platform** for security teams. It automates security activities across all six phases of the software development lifecycle using intelligent AI agents orchestrated by **LangGraph** and powered by **LangChain**. It automates the review of security-related **documents, forms, and reports** — from requirements and design through development, testing, deployment, and operations — comparing inputs against your policy and knowledge base to produce **structured assessment reports** with risks, compliance gaps, and remediation suggestions.
  32. Instead of only reviewing documents at the pre-release stage, DocSentinel embeds security from day one:
  33. | SSDLC Phase | What DocSentinel Does |
  34. | :--- | :--- |
  35. | **Requirements** | Extract security requirements, identify compliance obligations (GDPR, PCI DSS, SOC2) |
  36. | **Design** | Automated threat modeling (STRIDE/DREAD), security architecture review, SDR reports |
  37. | **Development** | Secure coding assessment, SAST findings triage, coding guidance |
  38. | **Testing** | SAST/DAST report analysis, penetration test review, vulnerability prioritization |
  39. | **Deployment** | Configuration security review, hardening assessment, release sign-off |
  40. | **Operations** | Vulnerability monitoring, incident response assistance, log audit |
  41. Built as a **React console + FastAPI service + MCP/A2A agent gateway**,
  42. DocSentinel integrates into local security review workflows, CI/CD pipelines,
  43. AI agents, and multi-agent platforms without giving external agents approval
  44. authority.
  45. - **LangGraph orchestration**: Stateful, graph-based agent workflows with conditional branching per SSDLC stage.
  46. - **Multi-format input**: PDF, Word, Excel, PPT, text — parsed into a unified format for the LLM.
  47. - **Knowledge base (RAG)**: Upload policy and compliance documents; the agent uses them as reference when assessing.
  48. - **Multiple LLMs**: Use OpenAI, Claude, Qwen, or **Ollama** (local) via a single interface.
  49. - **Structured output**: JSON/Markdown reports with risk items, compliance gaps, and actionable remediations.
  50. Ideal for enterprises that need to scale security assessments across many projects and SSDLC stages without proportionally scaling headcount.
  51. ---
  52. ## Product Tour
  53. ![DocSentinel console demo](docs/images/docsentinel-console-demo.gif)
  54. The local React console brings the main workflow into one operational surface:
  55. - **Command Center**: live API and LLM status, assessment throughput, review
  56. demand, remediation queues, and recent activity.
  57. - **Assessment Workbench**: upload project documents, choose SSDLC phase/skill,
  58. inspect AI-generated risks, and complete human review.
  59. - **Governance Portal**: create projects, apply public framework overlays,
  60. generate controls, submit evidence, and track Pallas Lens readiness.
  61. - **Knowledge Base**: ingest policies and standards for RAG-backed review.
  62. - **Agent Integrations**: expose governed MCP and A2A tools to coding agents and
  63. multi-agent platforms without granting approval authority.
  64. - **Settings**: switch providers such as DeepSeek, OpenAI, Anthropic, Qwen, or
  65. Ollama; API keys are accepted locally and only shown as masked previews.
  66. ---
  67. ## Why DocSentinel?
  68. | Pain Point | DocSentinel Solution |
  69. | :--- | :--- |
  70. | **Fragmented SSDLC coverage**<br>Most tools only address testing/deployment. | **Full lifecycle agents** cover all 6 SSDLC phases with dedicated AI personas. |
  71. | **Fragmented criteria**<br>Policies, standards, and precedents are scattered. | Single **knowledge base** ensures consistent findings and traceability. |
  72. | **No automated threat modeling**<br>Threat models are created ad-hoc. | **Design Agent** generates STRIDE/DREAD threat models from architecture docs. |
  73. | **Heavy questionnaire workflow**<br>Endless review cycles. | **Automated first-pass** and gap analysis reduces manual back-and-forth rounds. |
  74. | **SAST/DAST report overload**<br>Too many findings, too little context. | **Testing Agent** triages, prioritizes, and maps findings to threat models. |
  75. | **Pre-release review pressure**<br>Everything lands on security at the end. | **Shift-left** approach catches issues early in requirements and design. **Structured reports** help reviewers focus on decision-making. |
  76. | **Scale vs. consistency**<br>Manual reviews vary by reviewer. | **LangGraph workflows** and **unified pipeline** ensure consistent, auditable assessment across projects. |
  77. | **SSDLC coverage gaps**<br>Security involvement is uneven across lifecycle stages; early stages get less scrutiny. | **Stage-aware assessment** covers all 6 SSDLC stages with dedicated skills and checklists. |
  78. *See the full problem statement and SSDLC phase details in [SPEC.md](./SPEC.md).*
  79. ---
  80. ## Architecture
  81. DocSentinel is a **React Console + FastAPI** application with three governed
  82. entry paths: REST APIs for the console and CI, MCP tools for coding agents, and
  83. A2A JSON-RPC for remote agent delegation. These entry paths converge on the
  84. same `AssessmentService`, LangGraph assessment pipeline, knowledge base, and
  85. human-review lifecycle. Governance workflows from PallasGuard are now a
  86. first-class domain beside assessment, backed by SQLModel records, policy packs,
  87. control evidence, audit trails, and Pallas Lens readiness scoring.
  88. ![DocSentinel Architecture](docsentinel_architecture.png)
  89. ```mermaid
  90. flowchart TB
  91. subgraph Access["Users and Agent Access"]
  92. direction LR
  93. Staff["Security staff"]
  94. Console["React Console<br/>(Vite + Tailwind)"]
  95. RESTClient["REST / CI clients"]
  96. AgentClient["MCP / A2A clients"]
  97. end
  98. subgraph Runtime["FastAPI Runtime"]
  99. direction LR
  100. Security["Security boundary<br/>CORS, rate limit, JWT/RBAC,<br/>gateway token or loopback"]
  101. REST["REST API routers<br/>assessments, KB, skills,<br/>settings, governance"]
  102. Gateway["Agent Gateway<br/>MCP tools + A2A JSON-RPC"]
  103. Tasks["AssessmentService<br/>async tasks, activity log,<br/>human review queue"]
  104. end
  105. subgraph Pipeline["Assessment Pipeline"]
  106. direction LR
  107. Parse["Parse + guardrails<br/>Docling or legacy"]
  108. Graph["LangGraph workflow<br/>skill, isolated document data,<br/>policy/history/evidence context"]
  109. Review["LLM draft + review<br/>via LangChain"]
  110. Validate["Schema validation<br/>+ S2O rule checks"]
  111. Report["Structured report<br/>risks, gaps, remediations"]
  112. end
  113. subgraph Governance["Governance / Pallas Domain"]
  114. direction LR
  115. Projects["Projects + framework selection"]
  116. Controls["Control generator<br/>questionnaires + applicability"]
  117. Evidence["Gate submissions<br/>evidence + audit logs"]
  118. Lens["Pallas Lens<br/>readiness + exports"]
  119. end
  120. subgraph Support["Shared Support Services"]
  121. direction LR
  122. KB["KnowledgeBaseService<br/>Chroma + LightRAG + history"]
  123. Policies["Policy packs + overlays<br/>schema service + S2O ontology"]
  124. LLMFactory["LLM factory<br/>settings + llm_config.json<br/>base_url SSRF guard"]
  125. Providers["OpenAI, Anthropic, Qwen,<br/>DeepSeek, Ollama, local OpenAI"]
  126. DB["SQLModel DB<br/>SQLite or Postgres"]
  127. end
  128. Staff --> Console
  129. Console --> Security
  130. RESTClient --> Security
  131. AgentClient --> Security
  132. Security --> REST
  133. Security --> Gateway
  134. REST --> Tasks
  135. Gateway --> Tasks
  136. REST --> Projects
  137. REST --> KB
  138. Tasks --> Parse --> Graph --> Review --> Validate --> Report
  139. Report --> Tasks
  140. Report -->|project_id present| Evidence
  141. Projects --> Controls --> Evidence --> Lens
  142. Graph --> KB
  143. Graph --> Policies
  144. Review --> LLMFactory --> Providers
  145. Validate --> Policies
  146. Policies --> Controls
  147. Projects --> DB
  148. Controls --> DB
  149. Evidence --> DB
  150. ```
  151. **Data flow (simplified):**
  152. 1. Security staff work in the React console; REST clients call `/api/v1/*`;
  153. coding agents call MCP or A2A through the agent gateway.
  154. 2. REST write paths use JWT/RBAC dependencies. Agent protocols use a bearer
  155. gateway token or loopback-only development access. LLM-costly POST paths are
  156. rate limited by IP or bearer token.
  157. 3. Assessment submissions enter `AssessmentService`, which creates an async
  158. task, parses uploaded or approved local documents, applies guardrails, and
  159. invokes the LangGraph assessment pipeline.
  160. 4. The LangGraph pipeline loads the selected skill, wraps untrusted document
  161. content as data, retrieves policy/history/evidence context from the KB, asks
  162. the LLM for draft/review text, and converts the result into the structured
  163. assessment schema.
  164. 5. Deterministic services remain authoritative for governance decisions:
  165. policy-pack schemas, the S2O rule engine, control applicability, and schema
  166. validation cross-check LLM output before it enters the review queue.
  167. 6. When an assessment is linked to a project, findings are persisted as Gate 3
  168. control evidence. Governance workflows then use the same SQLModel store for
  169. projects, controls, submissions, audit logs, Pallas Lens scoring, and exports.
  170. 7. The KB persists chunks in Chroma, optional graph artifacts in LightRAG, and
  171. prior assessment history for reuse. Runtime LLM settings are loaded from
  172. `.env` plus `llm_config.json`, and every provider base URL is checked by the
  173. network guard before client construction.
  174. *Detailed architecture: [ARCHITECTURE.md](./ARCHITECTURE.md) and [docs/01-architecture-and-tech-stack.md](./docs/01-architecture-and-tech-stack.md).*
  175. ---
  176. ## Core Capabilities
  177. ### SSDLC Full Lifecycle Coverage
  178. Six dedicated AI agents, each with phase-specific skills, prompts, and knowledge base collections. Run individual phases or a full end-to-end SSDLC assessment:
  179. - **Requirements**: Security requirements, compliance mapping, initial risk analysis.
  180. - **Design**: Architecture review, STRIDE/DREAD threat modeling, SDR.
  181. - **Development**: Secure coding standards, code review findings.
  182. - **Testing**: SAST/DAST report triage, pen-test evaluation.
  183. - **Deployment**: Release readiness, config security, hardening.
  184. - **Operations**: Incident response, vulnerability monitoring, log audit.
  185. ### Automated Security Assessment
  186. Submit security questionnaires, design documents, or audit reports. DocSentinel analyzes them using configured LLMs and identifies:
  187. - **Security Risks**: Classified by severity (Critical, High, Medium, Low).
  188. - **Compliance Gaps**: Missing controls against frameworks like ISO 27001, PCI DSS.
  189. - **Remediation Steps**: Actionable advice to fix identified issues.
  190. ### Governance & Compliance Workflows
  191. PallasGuard governance capabilities are merged into DocSentinel as first-class
  192. project workflows:
  193. - **Policy packs**: `generic-ssdlc` plus eight public overlays for NIST SSDF,
  194. MAS TRM, ISO 27001:2022, EU AI Act, ISO 42001, China MLPS 2.0, OWASP SAMM,
  195. and EU CRA.
  196. - **Gate workflows**: Gate 1/3 questionnaire, submission, approval, audit, and
  197. evidence tracking flows backed by SQLModel and Alembic migrations.
  198. - **Control generation**: Framework overlays generate applicable SCD controls
  199. and expected evidence without replacing DocSentinel's existing assessment
  200. engine.
  201. - **Pallas Lens**: Project readiness scoring summarizes control coverage,
  202. evidence depth, and next actions in the React governance portal.
  203. ### Intelligent Agent Orchestration (LangGraph)
  204. - **Structured workflows**: LangGraph nodes separate context collection, drafting,
  205. evidence review, schema conversion, and governance persistence
  206. - **Cross-phase traceability**: Threats from Design link to test cases in Testing and monitoring rules in Operations
  207. - **Conditional routing**: Agents activate based on project risk level, compliance requirements, or user selection
  208. - **Human-in-the-loop**: Agent-created assessments enter a review queue and cannot
  209. approve themselves
  210. - **Planned hardening**: Explicit plan gates, durable LangGraph checkpoints, and
  211. resumable execution are tracked in the development roadmap below
  212. ### Threat Evidence Critic
  213. Design-phase STRIDE threats are independently checked against the currently
  214. uploaded architecture documents in one inference-time pass:
  215. - Every threat receives a `supported`, `contradicted`, or
  216. `insufficient_evidence` verdict with a support score and reviewer-facing
  217. rationale.
  218. - Evidence references use content hashes plus stable line locators and include
  219. the exact source excerpt shown in the Assessment Workbench.
  220. - Only current-project document passages are accepted. Invented, missing, policy,
  221. or historical references cannot make a threat appear supported.
  222. - Verification failures safely abstain as `insufficient_evidence`; all verdicts
  223. still require human review.
  224. - No training or fine-tuning pipeline is required. The critic uses the configured
  225. OpenAI, Anthropic, Qwen, DeepSeek, compatible, or local runtime model.
  226. For a public-demo input and walkthrough, see
  227. [`examples/evidence-critic-architecture.md`](./examples/evidence-critic-architecture.md)
  228. and [`examples/README.md`](./examples/README.md).
  229. ### RAG-Powered Knowledge Base
  230. Upload your organization's security policies, standards, and past audits. Phase-specific collections ensure each agent retrieves the most relevant context:
  231. - Requirements: compliance frameworks, security policies
  232. - Design: threat catalogs, security patterns
  233. - Development: secure coding standards (OWASP)
  234. - Testing: vulnerability databases, remediation guides
  235. - Deployment: CIS benchmarks, hardening guides
  236. - Operations: CVE databases, incident playbooks
  237. ### LangGraph Agent Orchestration
  238. Powered by **LangChain + LangGraph** — stateful, graph-based agent workflows with conditional routing per SSDLC stage. Parallel execution of Policy and Evidence agents, followed by Drafter and Reviewer agents.
  239. ### API-First, MCP & A2A Ready
  240. Use the local React console for human review, integrate CI/CD pipelines through the
  241. REST API, or expose the same assessment capabilities to AI agents (Claude Desktop,
  242. Cursor, OpenClaw) through MCP. A2A-compatible platforms can delegate assessment
  243. tasks to DocSentinel as a specialist security agent.
  244. ### Reproducible Evaluation Harness
  245. DocSentinel includes an `evals/` harness for measuring assessment quality against
  246. public and future golden datasets without going through HTTP or the UI. The first
  247. implemented path covers OWASP Benchmark v1.2 SAST triage:
  248. - **Dataset hygiene**: raw benchmark data is fetched locally into ignored paths;
  249. only the fetch script, checksum, manifest, and tiny test fixture are committed.
  250. - **Direct pipeline execution**: the runner calls `AssessmentService.submit()`
  251. with `phase="testing"` and `skill_id="ssdlc-testing"`, matching production task
  252. semantics while staying self-contained.
  253. - **Hard-key scoring**: M1 scores CWE-based binary triage with accuracy,
  254. precision, recall, F1, and false-positive rate, with no LLM judge.
  255. - **Threat grounding scoring**: the Evidence Critic scorer measures verdict
  256. accuracy, supported precision/recall/F1, contradiction recall, abstention rate,
  257. citation validity, and the full verdict confusion matrix.
  258. - **Scorecards**: every run writes machine-readable `scorecard.json` and a
  259. human-readable `scorecard.md` under `evals/reports/<run_id>/`.
  260. ```bash
  261. python evals/datasets/owasp_benchmark/fetch.py
  262. python -m evals.runner.run_eval \
  263. --dataset-id owasp_benchmark \
  264. --raw-dir evals/datasets/owasp_benchmark/raw/BenchmarkJava-master \
  265. --run-id local-owasp \
  266. --repeats 1
  267. ```
  268. See [docs/07-evaluation-plan.md](./docs/07-evaluation-plan.md) for the full
  269. methodology and milestone roadmap.
  270. ---
  271. ## Agent Architecture Development Roadmap
  272. This roadmap turns the project's agent-safety principles into implementation
  273. work that can be delivered and reviewed incrementally. It is informed by
  274. Microsoft Learn's
  275. [Designing Agent Architecture and SDLC Integration](https://learn.microsoft.com/en-us/training/modules/design-agent-architecture-integration/)
  276. module and follows one governing rule: **agents propose; deterministic policy
  277. and authorized humans accept**.
  278. The target control flow is:
  279. ```text
  280. Task contract -> Visible plan -> Bounded execution -> Objective evaluation
  281. -> Human/policy approval -> Published result
  282. ```
  283. Status legend: `[x]` implemented baseline, `[ ]` planned work. Priorities indicate
  284. delivery order rather than release dates.
  285. ### Current Baseline
  286. - [x] Phase-specific SSDLC skills and a shared assessment pipeline for REST,
  287. MCP, and A2A entry points.
  288. - [x] Human review is mandatory for agent-gateway submissions; external agents
  289. cannot approve their own work.
  290. - [x] MCP document-root confinement, token/loopback boundaries, bounded KB
  291. results, input guardrails, and LLM base-URL network checks.
  292. - [x] Structured reports with citations, document hashes, confidence, threat
  293. evidence verification, and remediation tracking.
  294. - [x] Reproducible evaluation harness with OWASP triage and threat-grounding
  295. scorecards.
  296. ### M0 — Repository Governance (P0)
  297. Goal: make the pull request the enforceable control point for human and
  298. agent-generated changes.
  299. - [ ] Add `CODEOWNERS` for security-sensitive paths, including
  300. `.github/workflows/`, `app/core/`, `app/agent_gateway/`, migrations,
  301. deployment files, and policy packs.
  302. - [ ] Expand the pull request template with required Goal, Scope, Plan, Success
  303. Criteria, Risk/Mitigations, Evidence, and Rollback/Escalation sections.
  304. - [ ] Add a required Plan Gate workflow that validates meaningful PR fields and
  305. classifies changes as low, medium, high, or critical risk.
  306. - [ ] Configure the `main` ruleset to require pull requests, passing CI and Plan
  307. Gate checks, resolved conversations, and CODEOWNERS approval for sensitive
  308. changes.
  309. - [ ] Upload test, coverage, contract, and evaluation outputs as durable GitHub
  310. Actions artifacts named with the workflow run ID and commit SHA.
  311. Exit criteria: a planless change or an unreviewed sensitive-path change cannot
  312. be merged into `main`.
  313. ### M1 — Task Contract and Plan–Act–Evaluate Graph (P1)
  314. Goal: make agent intent, authority, outputs, and success conditions inspectable
  315. before effects occur.
  316. - [ ] Define a versioned `AgentTaskContract` schema containing goal, inputs,
  317. allowed paths/tools, expected outputs, success criteria, risk tier, approval
  318. mode, retry limit, and escalation owner.
  319. - [ ] Persist the task contract and expose it through the assessment API and
  320. review console.
  321. - [ ] Add an explicit read-only planning node and immutable `PlanArtifact` to the
  322. assessment graph.
  323. - [ ] Implement a risk policy: low-risk tasks may use plan + execution in one
  324. review; workflow, authentication, infrastructure, and production-impacting
  325. tasks require plan-first approval.
  326. - [ ] Separate evaluation from generation so schema validation, evidence
  327. grounding, deterministic rules, and evaluation thresholds remain independent
  328. of the drafting agent.
  329. - [ ] Add transition and authorization tests proving that agents cannot skip the
  330. plan/evaluation stages or approve their own output.
  331. Exit criteria: every assessment can answer what was requested, what the agent
  332. was allowed to do, what plan it followed, and which signals determined success.
  333. ### M2 — Durable Execution and Reliability (P1)
  334. Goal: make long-running assessments restart-safe, bounded, and recoverable.
  335. - [ ] Replace in-memory assessment task state with database-backed task,
  336. revision, activity, and review records.
  337. - [ ] Compile LangGraph workflows with a database-backed checkpointer using
  338. `task_id` as the stable execution/thread identifier.
  339. - [ ] Make nodes idempotent and store node input/output hashes to prevent
  340. duplicate side effects during resume.
  341. - [ ] Add bounded retries for transient failures only; after two repeated
  342. failures, stop and escalate with attempted actions, evidence, and a suggested
  343. human next step.
  344. - [ ] Add cancellation, timeout, resume, and disaster-recovery tests.
  345. Exit criteria: a process restart can resume an assessment without losing review
  346. history, duplicating effects, or entering an infinite retry loop.
  347. ### M3 — Observability, Tools, MCP, and Secrets (P2)
  348. Goal: make every meaningful agent action attributable and enforce least
  349. privilege independently of model instructions.
  350. - [ ] Create an evidence manifest for each run containing task and graph-run
  351. IDs, node, source channel, document/output hashes, skill and policy-pack
  352. versions, model/prompt identifiers, citations, timestamps, and reviewer
  353. decision.
  354. - [ ] Define capability profiles: planning and review agents are read-only;
  355. execution agents receive narrow allowlisted tools for the current task.
  356. - [ ] Treat additions or expansions to MCP tools as high-risk governed changes
  357. with explicit security tests and owner review.
  358. - [ ] Add pre-action policy hooks, post-action audit hooks, and error hooks for
  359. escalation; hooks must be able to block actions without relying on the LLM.
  360. - [ ] Scope secrets to the smallest runtime component and environment, prevent
  361. secret values from entering prompts/artifacts, and document network-egress
  362. policy for hosted deployments.
  363. Exit criteria: operators can determine who or what performed an action, against
  364. which inputs and code state, under which capability policy, and with what result.
  365. ### M4 — Evaluation and Release Gates (P2)
  366. Goal: turn assessment quality and production safety into objective release
  367. signals.
  368. - [ ] Expand the evaluation harness across all SSDLC phases and add held-out
  369. expert-labelled cases with inter-annotator agreement.
  370. - [ ] Version approved scorecard baselines and fail CI on agreed grounding,
  371. recall, false-positive, calibration, or latency regressions.
  372. - [ ] Report variance across repeated runs and preserve judge rationales and
  373. human-audit results as reviewable artifacts.
  374. - [ ] Require protected GitHub Environments and authorized reviewers for
  375. production-impacting exports or deployments; agents may prepare but not
  376. approve or execute the final release action.
  377. - [ ] Deploy sensitive configuration from an explicit commit or tag rather than
  378. an unpinned branch head, with a tested rollback procedure.
  379. Exit criteria: releases have reproducible quality evidence, an approved code
  380. reference, a human decision for critical effects, and a verified rollback path.
  381. ### Definition of Done for Roadmap Work
  382. Every roadmap PR must include:
  383. - a bounded plan and changed-path scope;
  384. - verifiable functional and security success criteria;
  385. - automated tests for allowed and denied behavior;
  386. - durable evidence or artifacts linked to the commit under test;
  387. - documentation and migration notes where contracts or persistence change; and
  388. - rollback and escalation guidance for high-risk changes.
  389. Implementation should proceed in milestone order because M0 establishes the
  390. repository controls used to review M1–M4 safely. Each unchecked item is intended
  391. to be small enough to become a dedicated GitHub issue and pull request.
  392. ---
  393. ## Agent Integration (MCP + A2A)
  394. Use MCP to expose bounded tools to Claude Desktop, Cursor, coding agents, and
  395. workflow platforms. Use A2A to expose DocSentinel as a remote specialist agent.
  396. REST, MCP, and A2A submissions share the same task lifecycle and activity log.
  397. Agent-created assessments always remain drafts until a human reviewer approves
  398. them in the console.
  399. | Interface | Endpoint | Purpose |
  400. | :--- | :--- | :--- |
  401. | **MCP stdio** | `python app/mcp_server.py` | Local desktop and coding-agent integration |
  402. | **MCP Streamable HTTP** | `POST /mcp/` | Remote tool discovery and invocation |
  403. | **A2A Agent Card** | `GET /.well-known/agent-card.json` | Standards-based agent discovery |
  404. | **A2A JSON-RPC** | `POST /a2a` | Remote task delegation |
  405. | **Integration status** | `GET /api/v1/integrations/agents/status` | Non-secret protocol and capability status |
  406. | **Console** | `/console/integrations` | Human-readable integration state |
  407. MCP exposes five governed tools:
  408. - `submit_document_assessment`
  409. - `get_assessment_status`
  410. - `assess_document` (compatibility tool)
  411. - `query_knowledge_base`
  412. - `get_agent_gateway_status`
  413. The A2A Agent Card advertises assessment submission, assessment retrieval, and
  414. security knowledge query skills.
  415. ### What can it do?
  416. Once connected, you can ask your AI agent:
  417. > "Analyze the attached `requirements.pdf` for missing security requirements using DocSentinel."
  418. >
  419. > "Run a STRIDE threat model on `system-design.pdf` using the Design Agent."
  420. >
  421. > "Triage these SonarQube SAST findings and prioritize by risk."
  422. ### Configuration Guide
  423. #### 1. Claude Desktop
  424. Add to your `claude_desktop_config.json`:
  425. ```json
  426. {
  427. "mcpServers": {
  428. "docsentinel": {
  429. "command": "/path/to/DocSentinel/.venv/bin/python",
  430. "args": ["/path/to/DocSentinel/app/mcp_server.py"],
  431. "env": {
  432. "OPENAI_API_KEY": "sk-...",
  433. "CHROMA_PERSIST_DIR": "/absolute/path/to/data/chroma",
  434. "MCP_DOCUMENT_ROOTS": "/absolute/path/to/approved/documents"
  435. }
  436. }
  437. }
  438. }
  439. ```
  440. `assess_document` only reads files inside `MCP_DOCUMENT_ROOTS`. Use `:` to
  441. separate multiple roots on macOS/Linux, or `;` on Windows. If unset, the
  442. server only allows `./examples`.
  443. FastAPI also serves Streamable HTTP MCP at `/mcp/` and publishes the A2A Agent
  444. Card at `/.well-known/agent-card.json`. Tokenless protocol access is
  445. loopback-only. External agents cannot approve, reject, or bypass human review.
  446. For network, Docker, or reverse-proxy access, configure:
  447. ```dotenv
  448. AGENT_GATEWAY_TOKEN=generate-a-long-random-value
  449. AGENT_GATEWAY_PUBLIC_URL=https://docsentinel.internal.example
  450. AGENT_GATEWAY_ALLOWED_HOSTS=docsentinel.internal.example
  451. AGENT_GATEWAY_ALLOWED_ORIGINS=https://trusted-agent-console.internal.example
  452. ```
  453. Clients send `Authorization: Bearer <AGENT_GATEWAY_TOKEN>`. Keep
  454. `MCP_DOCUMENT_ROOTS`, allowed hosts, and allowed origins as narrow as possible.
  455. Docker bridge traffic is not treated as loopback, so published MCP/A2A ports
  456. require a token.
  457. #### 2. Cursor
  458. 1. Go to **Settings > Features > MCP**.
  459. 2. Click **+ Add New MCP Server**.
  460. - **Name**: `docsentinel`
  461. - **Type**: `stdio`
  462. - **Command**: `/path/to/DocSentinel/.venv/bin/python`
  463. - **Args**: `/path/to/DocSentinel/app/mcp_server.py`
  464. *See full guide in [docs/06-agent-integration.md](docs/06-agent-integration.md).*
  465. ---
  466. ## Quick Start
  467. ### Option A: One-Click Deployment (Recommended)
  468. ```bash
  469. git clone https://github.com/arthurpanhku/DocSentinel.git
  470. cd DocSentinel
  471. chmod +x deploy.sh
  472. ./deploy.sh
  473. ```
  474. - **React Console**: [http://localhost:8000/console](http://localhost:8000/console)
  475. - **Agent Integrations**: [http://localhost:8000/console/integrations](http://localhost:8000/console/integrations)
  476. - **API Docs**: [http://localhost:8000/api-docs](http://localhost:8000/api-docs)
  477. - **A2A Agent Card**: [http://localhost:8000/.well-known/agent-card.json](http://localhost:8000/.well-known/agent-card.json)
  478. To connect an external agent through the published Docker port, set
  479. `AGENT_GATEWAY_TOKEN` in `.env` before running `./deploy.sh`.
  480. ### Option B: Manual Setup
  481. **Prerequisites**: **Python 3.11+** and **Node.js 20+**. Optional:
  482. [Ollama](https://ollama.ai) (`ollama pull llama2`).
  483. ```bash
  484. git clone https://github.com/arthurpanhku/DocSentinel.git
  485. cd DocSentinel
  486. python3 -m venv .venv
  487. source .venv/bin/activate # Windows: .venv\Scripts\activate
  488. pip install -r requirements.txt
  489. cp .env.example .env # Edit if needed: LLM_PROVIDER=ollama or openai
  490. npm install --prefix frontend
  491. npm run build --prefix frontend
  492. uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
  493. ```
  494. #### DeepSeek example
  495. Set these values in `.env`, or use the **Settings** page after the server is
  496. running. Never commit real API keys.
  497. ```dotenv
  498. LLM_PROVIDER=deepseek
  499. DEEPSEEK_BASE_URL=https://api.deepseek.com
  500. DEEPSEEK_MODEL=deepseek-chat
  501. DEEPSEEK_API_KEY=sk-your-deepseek-key
  502. ```
  503. - **API docs**: [http://localhost:8000/api-docs](http://localhost:8000/api-docs) · **Health**: [http://localhost:8000/health](http://localhost:8000/health)
  504. - **React Console**: [http://localhost:8000/console](http://localhost:8000/console)
  505. - **Agent Integrations**: [http://localhost:8000/console/integrations](http://localhost:8000/console/integrations)
  506. - **MCP Streamable HTTP**: `http://localhost:8000/mcp/`
  507. - **A2A Agent Card**: [http://localhost:8000/.well-known/agent-card.json](http://localhost:8000/.well-known/agent-card.json)
  508. - **Legacy Review Console (HITL)**: [http://localhost:8000/docs/review-console.html](http://localhost:8000/docs/review-console.html)
  509. ### React Console
  510. DocSentinel includes a React + TypeScript + Vite + Tailwind CSS console for assessments, knowledge base operations, skills, and system status.
  511. ![DocSentinel React Console](docs/images/react-console-dashboard.png)
  512. ```bash
  513. npm install --prefix frontend
  514. npm run build --prefix frontend
  515. uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
  516. ```
  517. Open [http://localhost:8000/console](http://localhost:8000/console). For frontend-only development, run:
  518. ```bash
  519. npm run dev --prefix frontend
  520. ```
  521. The Vite dev server proxies `/api`, `/health`, and `/config` to `http://localhost:8000`.
  522. The **Settings** page can update the running server's LLM provider, model, base URL, and API key. API keys are only returned to the UI as masked previews. For persistent startup defaults, set the matching values in `.env`.
  523. ---
  524. ### Example: Submit an SSDLC assessment
  525. ```bash
  526. # Run a Design phase assessment (threat modeling)
  527. curl -X POST "http://localhost:8000/api/v1/assessments" \
  528. -F "files=@examples/architecture-doc.pdf" \
  529. -F "phase=design" \
  530. -F "scenario_id=threat-modeling"
  531. # Response: { "task_id": "...", "status": "accepted" }
  532. # Get the result
  533. curl "http://localhost:8000/api/v1/assessments/TASK_ID"
  534. ```
  535. ### Example: Upload to KB and query
  536. ```bash
  537. # Upload a security policy to the requirements KB collection
  538. curl -X POST "http://localhost:8000/api/v1/kb/documents" \
  539. -F "file=@examples/sample-policy.txt" \
  540. -F "collection=kb_requirements"
  541. # Query the KB (RAG)
  542. curl -X POST "http://localhost:8000/api/v1/kb/query" \
  543. -H "Content-Type: application/json" \
  544. -d '{"query": "What are the access control requirements?", "top_k": 5}'
  545. ```
  546. ---
  547. ## Hosted deployment
  548. A hosted deployment is available on [Fronteir AI](https://fronteir.ai/mcp/arthurpanhku-docsentinel).
  549. ## Project Layout
  550. ```text
  551. DocSentinel/
  552. ├── frontend/ # React + TypeScript + Vite + Tailwind console
  553. ├── app/ # Application code
  554. │ ├── api/ # REST routes: assessments, KB, health, skills
  555. │ ├── agent_gateway/ # MCP/A2A adapters, auth boundary, Agent Card
  556. │ ├── agent/ # LangGraph orchestrator, phase agents, skills
  557. │ │ ├── orchestrator.py # LangGraph state machine & phase routing
  558. │ │ ├── agents/ # Phase-specific agent implementations
  559. │ │ ├── ssdlc/ # SSDLC pipeline: stage router, stage skills, checklists
  560. │ │ ├── skills_registry.py # Built-in skills per SSDLC phase
  561. │ │ └── skills_service.py # Skill CRUD and management
  562. │ ├── core/ # Config, guardrails, security, DB
  563. │ ├── kb/ # Knowledge Base (Chroma + LightRAG graph RAG)
  564. │ ├── llm/ # LangChain LLM abstraction (OpenAI, Ollama)
  565. │ ├── parser/ # Document parsing (Docling + SAST/DAST + legacy)
  566. │ ├── models/ # Pydantic / SQLModel models
  567. │ ├── services/ # Shared assessment task lifecycle
  568. │ ├── main.py # FastAPI app entry point
  569. │ └── mcp_server.py # MCP stdio + Streamable HTTP tools
  570. ├── tests/ # Automated tests (pytest)
  571. ├── evals/ # Reproducible quality eval harness and scorecards
  572. ├── examples/ # Sample files (questionnaires, policies, reports)
  573. ├── docs/ # Design & Spec documentation
  574. │ ├── 01-architecture-and-tech-stack.md
  575. │ ├── 02-api-specification.yaml
  576. │ ├── 03-assessment-report-and-skill-contract.md
  577. │ ├── 04-integration-guide.md
  578. │ ├── 05-deployment-runbook.md
  579. │ ├── 06-agent-integration.md
  580. │ ├── 07-evaluation-plan.md
  581. │ └── schemas/
  582. ├── .github/ # Issue/PR templates, CI (Actions)
  583. ├── Dockerfile
  584. ├── docker-compose.yml
  585. ├── docker-compose.ollama.yml
  586. ├── CONTRIBUTING.md
  587. ├── CODE_OF_CONDUCT.md
  588. ├── CHANGELOG.md
  589. ├── SPEC.md # PRD with SSDLC phase definitions
  590. ├── ARCHITECTURE.md # System architecture with LangGraph design
  591. ├── LICENSE
  592. ├── SECURITY.md
  593. ├── requirements.txt
  594. ├── requirements-dev.txt
  595. └── .env.example
  596. ```
  597. ---
  598. ## Configuration
  599. | Variable | Description | Default |
  600. | :--- | :--- | :--- |
  601. | `LLM_PROVIDER` | `ollama` or `openai` | `ollama` |
  602. | `OLLAMA_BASE_URL` / `OLLAMA_MODEL` | Local LLM | `http://localhost:11434` / `llama2` |
  603. | `OPENAI_API_KEY` / `OPENAI_MODEL` | OpenAI | -- |
  604. | `ANTHROPIC_API_KEY` / `ANTHROPIC_MODEL` | Anthropic Claude | -- / `claude-3-5-sonnet-latest` |
  605. | `QWEN_API_KEY` / `QWEN_MODEL` | Qwen DashScope OpenAI-compatible API | -- / `qwen-plus` |
  606. | `DEEPSEEK_API_KEY` / `DEEPSEEK_MODEL` | DeepSeek OpenAI-compatible API | -- / `deepseek-chat` |
  607. | `COMPAT_API_KEY` / `COMPAT_BASE_URL` / `COMPAT_MODEL` | Any OpenAI-compatible hosted API | -- |
  608. | `LOCAL_API_KEY` / `LOCAL_BASE_URL` / `LOCAL_MODEL` | Local OpenAI-compatible API | -- / `http://localhost:1234/v1` / `local-model` |
  609. | `EVIDENCE_CRITIC_ENABLED` | Verify Design-phase threats against current document evidence | `true` |
  610. | `EVIDENCE_CRITIC_MAX_CANDIDATES` | Candidate passages supplied per threat | `5` |
  611. | `EVIDENCE_CRITIC_MAX_THREATS` | Maximum threats verified in one inference pass | `20` |
  612. | `CHROMA_PERSIST_DIR` | Vector DB path | `./data/chroma` |
  613. | `PARSER_ENGINE` | Parser: `auto`, `docling`, or `legacy` | `auto` |
  614. | `ENABLE_GRAPH_RAG` | Enable LightRAG graph retrieval | `true` |
  615. | `LANGGRAPH_CHECKPOINT_DIR` | LangGraph checkpoint persistence | `./data/checkpoints` |
  616. | `SSDLC_DEFAULT_PHASES` | Default phases for full assessment | `requirements,design,development,testing,deployment,operations` |
  617. | `SSDLC_DEFAULT_STAGE` | Default SSDLC stage if not specified | `auto` |
  618. | `UPLOAD_MAX_FILE_SIZE_MB` / `UPLOAD_MAX_FILES` | Upload limits | `50` / `10` |
  619. | `MCP_DOCUMENT_ROOTS` | Filesystem roots available to document assessment tools | `./examples` |
  620. | `AGENT_GATEWAY_ENABLED` | Enable MCP HTTP and A2A endpoints | `true` |
  621. | `AGENT_GATEWAY_TOKEN` | Bearer token for remote agent access; empty is loopback-only | -- |
  622. | `AGENT_GATEWAY_TENANT_ID` | Tenant assigned to the shared MCP/A2A gateway credential | `default` |
  623. | `AGENT_GATEWAY_PUBLIC_URL` | Public URL advertised by the A2A Agent Card | `http://localhost:8000` |
  624. | `AGENT_GATEWAY_ALLOWED_HOSTS` | MCP DNS-rebinding Host allow-list | local hosts |
  625. | `AGENT_GATEWAY_ALLOWED_ORIGINS` | MCP browser Origin allow-list | local origins |
  626. *See [.env.example](./.env.example) and [docs/05-deployment-runbook.md](./docs/05-deployment-runbook.md) for full options.*
  627. ---
  628. ## Tech Stack
  629. | Layer | Technology | Purpose |
  630. | :--- | :--- | :--- |
  631. | **Frontend** | React, TypeScript, Vite, Tailwind CSS | Local-first assessment and review console |
  632. | **Agent Orchestration** | LangGraph | Stateful graph-based SSDLC workflow engine |
  633. | **LLM Framework** | LangChain | Unified LLM abstraction, prompts, tools, RAG |
  634. | **Web/API** | FastAPI | Async REST API with auto OpenAPI |
  635. | **Agent Protocols** | MCP + A2A 1.0 | Governed tools and cross-agent task delegation |
  636. | **Vector Store** | ChromaDB + LightRAG | Hybrid vector + graph RAG |
  637. | **Parsing** | Docling + legacy fallback | Multi-format document parsing |
  638. | **LLM Providers** | OpenAI, Anthropic, Qwen, DeepSeek, Ollama, OpenAI-compatible APIs | Cloud and local LLM support |
  639. | **Language** | Python 3.11+ | Primary development language |
  640. ---
  641. ## Documentation and PRD
  642. - **[ARCHITECTURE.md](./ARCHITECTURE.md)** — System architecture: LangGraph design, SSDLC agents, data flow, deployment.
  643. - **[SPEC.md](./SPEC.md)** — Product requirements: SSDLC phases, features, security controls.
  644. - **[CHANGELOG.md](./CHANGELOG.md)** — Version history; [Releases](https://github.com/arthurpanhku/DocSentinel/releases).
  645. - **Design docs** [docs/](./docs/): Architecture, API spec (OpenAPI), contracts, integration guides, deployment runbook.
  646. - **[docs/07-evaluation-plan.md](./docs/07-evaluation-plan.md)** — Evaluation methodology and milestone plan for `evals/`.
  647. ---
  648. ## Development & Testing
  649. ### Option A: One-Click Test (Recommended)
  650. ```bash
  651. chmod +x test_integration.sh
  652. ./test_integration.sh
  653. ```
  654. ### Option B: Manual
  655. ```bash
  656. pip install -r requirements-dev.txt
  657. pytest
  658. pytest tests/test_skills_api.py # Run specific test
  659. pytest evals/tests # Run evaluation harness tests
  660. ```
  661. ## Contributing
  662. Issues and Pull Requests are welcome. Please read [CONTRIBUTING.md](CONTRIBUTING.md) for setup, tests, and commit guidelines. By participating you agree to the [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md).
  663. AI-Assisted Contribution: We encourage using AI tools to contribute! Check out [CONTRIBUTING_WITH_AI.md](CONTRIBUTING_WITH_AI.md) for best practices.
  664. Submit a Skill Template: Have a great security persona for an SSDLC phase? Submit a [Skill Template](https://github.com/arthurpanhku/DocSentinel/issues/new?template=new_skill_template.md) or add it to `examples/templates/`.
  665. ---
  666. ## Security
  667. - **Vulnerability reporting**: See [SECURITY.md](./SECURITY.md) for responsible disclosure.
  668. - **Security requirements**: Follows security controls in [SPEC §7.2](./SPEC.md).
  669. - **Document confinement**: MCP/A2A document paths must resolve inside `MCP_DOCUMENT_ROOTS`; symlink escapes are rejected before file reads.
  670. - **Agent authority**: External agents may submit and inspect drafts, but cannot approve their own assessments.
  671. - **Remote access**: Tokenless MCP/A2A access is loopback-only. Network deployments require a bearer token, TLS, and narrow Host/Origin allow-lists.
  672. ---
  673. ## License
  674. This project is licensed under the **MIT License** — see the [LICENSE](./LICENSE) file for details.
  675. ---
  676. ## Star History
  677. [![Star History Chart](https://api.star-history.com/svg?repos=arthurpanhku/DocSentinel&type=Date)](https://star-history.com/#arthurpanhku/DocSentinel&Date)
  678. ---
  679. ## Author and Links
  680. - **Author**: PAN CHAO (Arthur Pan)
  681. - **Repository**: [github.com/arthurpanhku/DocSentinel](https://github.com/arthurpanhku/DocSentinel)
  682. - **SPEC and design docs**: See links above.
  683. If you use DocSentinel in your organization or contribute back, we'd love to hear from you (e.g. via GitHub Discussions or Issues).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.