@topy-ai/maggie 0.7.56 → 0.7.58

package/README-zh-TW.md

@@ -29,7 +29,11 @@ npx @topy-ai/maggie init --scope project --agent all
 npx @topy-ai/maggie doctor --scope project --project .
 ```
 
-目前 npm 版本為 `0.7.56`：新增 Maggie Security（`maggie-security` skill 與 `maggie security` 指令，共 46 個指令、29 個 MCP 工具），涵蓋套件、runtime、資料庫、Web server、Linux 發行版與 WordPress 的漏洞公告與 end-of-life 日期，以及 secrets、程式碼、網站與主機檢查、報告、CI gate 與每日監控。
+目前 npm 版本為 `0.7.58`：新增 `maggie security fix-plan`（由發現整理出的修復 runbook：檔案權限、防火牆、套件/apt 更新、入侵防護、Web server 設定、EOL；產生一份你自己在 host lock 下、備份後執行的 shell script，Maggie 從不代為套用），並把 lynis tarball 以 sha256 pin 住，讓 `host-audit` 能透過 SSH 做深度主機稽核。
+
+0.7.57 新增 `maggie security public-check`，對你**無法控制**的站點做被動、等同瀏覽器的檢查（安全 headers、TLS、首頁洩漏的版本與其已知 CVE、SPF/DMARC、security.txt），讓你能通知站主；只限真人互動執行，絕不探測、提交或掃描，主動掃描（web-scan、zap-baseline）與主機檢查仍須先驗證域名。
+
+0.7.56 新增 Maggie Security（`maggie-security` skill 與 `maggie security` 指令，共 46 個指令、29 個 MCP 工具），涵蓋套件、runtime、資料庫、Web server、Linux 發行版與 WordPress 的漏洞公告與 end-of-life 日期，以及 secrets、程式碼、網站與主機檢查、報告、CI gate 與每日監控。
 
 0.7.55 完成 feedback batch 31，共 16 條，來自一個以排程 AI agent 操作自家行銷產品、同時維護 PHP 主機的團隊，並同步發布 MaggieDash 0.2.15。
 
@@ -139,7 +143,7 @@ structure drift 或重複 treatment product 時 fail closed。
 deployment、memory、feedback 和 MaggieDash。內容先 draft/review，外部寫入、
 publish 與 production deployment 需要明確確認。
 
-目前 npm 版本為 `0.7.56`，包含 Maggie Security、batch 31 排程 agent routines、報告收件匣與無人值守 agent 限制、PHP runtime 盤點與主機鎖、pull 網站改寫、query 點子與社群佇列檢查，batch 30 MaggieDash 先裝核心、release privacy gate、feedback 備援、社群連結與圖片檢查、大量頁面產生與 app 檢查，batch 29 預約規則、部署、app QA、助理與社群功能，以及 batch 28 產品 app、assistant tools、mobile、product release、skills catalog 與 bridge host 功能、batch 26、27 feedback 修正與 idempotent `maggie update`與 Booking email-template 合約/CLI validator 同步。本版完成 2026-09-24 booking feedback batch：Calendar grid/free-slot entry 與 host modal focus-restoration evidence。本版新增 Starter marketplace provisioning plan；本版完成 feedback batches 22、23：加入 declarative browser interaction evidence、design markup/style/content-key gate、compiler source anchoring、entity double-escape protection、`update --help` read-only、noindex hypothetical indexability、可過期 baseline acknowledgement、DOM-only link extraction regression，以及 MaggieDash 0.2.10 的 content override、短期 browser session、CDN-safe public-session cache contracts。authentication 和 isolated dev server 仍由 host 負責。`maggie-booking` workflow、傳統 email/password、Stripe、Resend、public booking flow 及既有安全邊界維持不變；provider-bound video generation 與 transactional delivery 仍記錄在 issue #39，前一批延後功能仍在 issue #38，不會直接成為 active memory。0.7.33 記錄並審查一筆更正回饋；確認 0.7.32 已正確處理 batch index，沒有修改已驗證的 shared behavior。0.7.32 加入 feedback 一基索引支援、MaggieDash panel 的 source/freshness/error evidence、Consent Mode 與實際 write/no-op reconciliation、SEO baseline recapture、sitemap origin rebasing、content-diff scope、migration ledger reconciliation、deployment credential preflight、release provenance/runtime preflight、icon release gate、opt-in blog auto-publish gate，以及 least-privilege VPS deployer。也修復 top-level `maggie feedback` dispatcher parity。0.7.31 加入 update 差異摘要、atomic installer copy、subset install manifest merge，以及 inventory drift 時 doctor non-zero。0.7.30 補上 feedback tracking issue closeout gate 與 batch 14/15 audit ledger。0.7.29 修正 npm package landing page 使用英文 README；0.7.28 加入 versioned Gemini model policy、明確 fallback 與 provenance、bundled-first CLI
+目前 npm 版本為 `0.7.58`，包含 fix-plan、public-check、Maggie Security、batch 31 排程 agent routines、報告收件匣與無人值守 agent 限制、PHP runtime 盤點與主機鎖、pull 網站改寫、query 點子與社群佇列檢查，batch 30 MaggieDash 先裝核心、release privacy gate、feedback 備援、社群連結與圖片檢查、大量頁面產生與 app 檢查，batch 29 預約規則、部署、app QA、助理與社群功能，以及 batch 28 產品 app、assistant tools、mobile、product release、skills catalog 與 bridge host 功能、batch 26、27 feedback 修正與 idempotent `maggie update`與 Booking email-template 合約/CLI validator 同步。本版完成 2026-09-24 booking feedback batch：Calendar grid/free-slot entry 與 host modal focus-restoration evidence。本版新增 Starter marketplace provisioning plan；本版完成 feedback batches 22、23：加入 declarative browser interaction evidence、design markup/style/content-key gate、compiler source anchoring、entity double-escape protection、`update --help` read-only、noindex hypothetical indexability、可過期 baseline acknowledgement、DOM-only link extraction regression，以及 MaggieDash 0.2.10 的 content override、短期 browser session、CDN-safe public-session cache contracts。authentication 和 isolated dev server 仍由 host 負責。`maggie-booking` workflow、傳統 email/password、Stripe、Resend、public booking flow 及既有安全邊界維持不變；provider-bound video generation 與 transactional delivery 仍記錄在 issue #39，前一批延後功能仍在 issue #38，不會直接成為 active memory。0.7.33 記錄並審查一筆更正回饋；確認 0.7.32 已正確處理 batch index，沒有修改已驗證的 shared behavior。0.7.32 加入 feedback 一基索引支援、MaggieDash panel 的 source/freshness/error evidence、Consent Mode 與實際 write/no-op reconciliation、SEO baseline recapture、sitemap origin rebasing、content-diff scope、migration ledger reconciliation、deployment credential preflight、release provenance/runtime preflight、icon release gate、opt-in blog auto-publish gate，以及 least-privilege VPS deployer。也修復 top-level `maggie feedback` dispatcher parity。0.7.31 加入 update 差異摘要、atomic installer copy、subset install manifest merge，以及 inventory drift 時 doctor non-zero。0.7.30 補上 feedback tracking issue closeout gate 與 batch 14/15 audit ledger。0.7.29 修正 npm package landing page 使用英文 README；0.7.28 加入 versioned Gemini model policy、明確 fallback 與 provenance、bundled-first CLI
 dispatch、`maggie --version`、feedback batch review 聚合與重複偵測、marketplace enrichment evidence、booking
 worker/resolver evidence，以及 read-only migration preflight。它也包含 host-owned mobile app surface contract、signed-in
 camera-state QA、直接 Astro route resolution、correlated feedback batch，以及

package/README.md

@@ -89,8 +89,22 @@ Maggie keeps the existing project foundation and asks for decisions before
 shared routes, analytics, or publishing boundaries change. The current
 package ships 23 installable skills and a local-first MaggieDash foundation.
 
-This package is `0.7.56`. It adds Maggie Security, a new
-`maggie-security` skill and `maggie security` command family (46 commands, 29
+This package is `0.7.58`. It adds `maggie security fix-plan` — a
+reviewed remediation runbook built from the open findings (file permissions,
+firewall, package/apt updates, intrusion prevention, web-server config, end of
+life). It writes a shell script you run yourself, under a host lock, after a
+backup; Maggie never applies it. This release also pins the `lynis` tarball
+(sha256) so `host-audit` can run the deep host audit over SSH.
+
+The 0.7.57 release added `maggie security public-check`: passive,
+browser-equivalent checks of sites you do **not** control (security headers,
+TLS, versions disclosed on the home page and their known CVEs, SPF/DMARC,
+`security.txt`), so you can tell an owner about a visible problem. It is
+interactive-only and never probes, submits or scans; the active scanners
+(`web-scan`, `zap-baseline`) and host checks stay verified-only.
+
+The 0.7.56 release added Maggie Security, a new
+`maggie-security` skill and `maggie security` command family (48 commands, 30
 MCP tools, 7 contracts under `contracts/maggie-security/`).
 
 - **Advisories for the whole stack.** Packages (npm, pnpm, Yarn, Bun,
@@ -837,8 +851,8 @@ artifact schemas.
 Recommended upgrade sequence for the current release:
 
 ```bash
-npx @topy-ai/maggie@0.7.56 update --scope project --project . --force
-npx @topy-ai/maggie@0.7.56 cleanup --scope project --project .
+npx @topy-ai/maggie@0.7.58 update --scope project --project . --force
+npx @topy-ai/maggie@0.7.58 cleanup --scope project --project .
 ```
 
 Maintainers should pass npm credentials through the repository helper, never

package/bundled-skills/maggie-security/SKILL.md

@@ -46,9 +46,11 @@ Follow [Maggie Memory Hook](../../references/memory-hook.md) at invocation and c
 | "are my dependencies safe?" | `maggie security deps` (every lockfile ecosystem + JavaScript copied into the site) | `security_deps_scan` |
 | "is my site configured safely?" | verify first: `maggie security domain-verify start --domain example.com` (the person adds the TXT record) then `maggie security domain-verify check --domain example.com`; then `maggie security headers --url https://example.com` and `maggie security tls --host example.com`; weekly `maggie security web-scan --url https://example.com` | `security_domain_verify_start`, `security_domain_verify_check`, `security_headers_check`, `security_tls_check`, `security_web_scan` |
 | "check my code before I commit" | `maggie security code-scan --changed-since HEAD` (full: `maggie security code-scan`) | `security_code_scan` |
+| "check a site we don't own (so we can tell them)" | `maggie security public-check --url https://example.com --outreach notes/` — passive only (headers, TLS, visible versions + known CVEs, SPF/DMARC, security.txt); interactive-only; never scan or probe a site you don't control (that's `web-scan`/`zap-baseline`, verified domains only) | `security_public_check` |
 | "are we being attacked / were we hacked?" | `maggie security logs-traffic --file access.log`, `maggie security logs-sigma --file access.log`, `maggie security logs-ioc --file access.log`; servers: `maggie security logs-remote --ssh web1=user@host` | `security_logs_check` |
 | "is my server hardened?" | `maggie security host-quick --ssh web1=user@host` (or `--print-collector` for the person to run), `maggie security host-nginx-config --ssh web1=user@host`, deep: `maggie security host-audit --ssh web1=user@host` | `security_host_check` |
 | "protect my server" (CrowdSec / fail2ban / Cloudflare) | `maggie security protect-plan --host web1 [--engine crowdsec\|fail2ban]` → the person reviews and runs it under the host lock; afterwards `maggie security protect-plan verify --plan FILE --ssh web1=user@host` | `security_protect_plan` |
+| "give me the fixes to run" | after the checks: `maggie security fix-plan --script fix.sh --output RUNBOOK.md` — a reviewed runbook (file permissions, firewall, apt updates, intrusion prevention, nginx, EOL) built from the findings; the person reviews it and runs it themselves under the host lock. Maggie never applies it. | — |
 | "monitor uptime / tell me when the site is down" | `maggie security uptime-init` (verified domains) → `maggie security uptime-deploy --hostname status.example.com` (plan) → `maggie security uptime-status --gatus URL`; jobs report with `maggie security uptime-push` | `security_uptime_status` |
 | "how do we compare to OWASP?" / "threat model" | `maggie security checklist --level 1`, `maggie security threat-model --include-findings` | `security_checklist_get`, `security_threat_model` |
 | "is this npm package safe to add?" | `maggie security preinstall PKG[@VERSION]` before installing (W5); never install on `block` | `security_package_vet` |

package/bundled-skills/maggie-security/references/commands.md

@@ -53,6 +53,20 @@ findings never leave the machine.
 | `maggie security web-scan --url U [--profile safe\|full-safe]` | httpx fingerprint, then nuclei with the safe profile (no intrusive, fuzz, DoS, brute-force, OAST templates; ≤ 10 req/s; one scan per domain at a time) | the site |
 | `maggie security zap-baseline --url U` | weekly passive ZAP baseline in Docker; header rules skipped (headers covers them) | the site |
 
+## Public check (sites you do NOT control — passive only)
+
+`public-check` is the one web command that does not need domain verification,
+because it only does what any visitor already does: one GET of the home page, a
+TLS handshake, and public DNS. It never probes paths, never submits anything,
+and never runs an active scanner. Use it to spot a visible problem on someone
+else's site and tell them. It is interactive-only (refused under `--ci` or in a
+routine) and never writes to the ledger. `web-scan`, `zap-baseline` and the host
+checks stay verified-only — do not run them against a site you do not control.
+
+| Command | What it does | Contacted |
+|---|---|---|
+| `maggie security public-check --url U` / `--domain D` (repeatable) / `--domains FILE` `[--outreach DIR] [--rate N] [--max-sites N]` | per site: security headers + cookies, TLS certificate and protocols, versions disclosed on the home page (`generator` meta, `Server`/`X-Powered-By`, JS libraries) matched to known CVEs (OSV, WPVulnerability, KEV, EPSS), missing/weak SPF and DMARC, and missing `security.txt`. `--outreach` writes a disclosure-ready note per domain (what is visible, no exploit detail). | the site, system resolver, cloudflare-dns.com, api.osv.dev, wpvulnerability.net, KEV, api.first.org |
+
 ## Code
 
 | Command | What it does |
@@ -108,4 +122,5 @@ Formats: nginx/Apache combined and vcombined, Caddy JSON, Cloudflare Logpush JSO
 | Command | What it does |
 |---|---|
 | `maggie security report --kind weekly\|daily_ops\|incident\|gate [--audience owner\|technical] [--save]` | Markdown + JSON report from the latest runs; `--save` writes the `report_save` payload |
+| `maggie security fix-plan [--priority p0..p4] [--script fix.sh] [--output RUNBOOK.md]` | a reviewed remediation runbook from the open findings: grouped by category (file permissions, firewall, package/apt updates, intrusion prevention, web-server config, EOL), each step the commands the findings themselves carry (never invented). Writes a shell script you run yourself, under `maggie deployment host-lock`, after a backup and with a second SSH session open. Maggie never applies it. |
 | `maggie security mcp [--tools p0\|all] [--print-config claude\|codex]` | local stdio MCP server |

package/bundled-skills/maggie-security/registry/security-tools.registry.json

@@ -12,6 +12,10 @@
     "project-files": {
       "label": "Reads your project files",
       "modelNote": "Local server only."
+    },
+    "interactive-only": {
+      "label": "A person must run it",
+      "modelNote": "Refused under --ci or in a scheduled routine; it checks sites you do not control, so a person decides to run it."
     }
   },
   "cantDo": [
@@ -189,7 +193,7 @@
     },
     {
       "name": "security_secrets_scan",
-      "description": "Find API keys, passwords and tokens in git history, project files and served build output (dist/, public/ \u2026), including .env values copied into the build. Values are never returned: only the file, line and a 4+4 character preview. Reads project files only; contacts nothing.",
+      "description": "Find API keys, passwords and tokens in git history, project files and served build output (dist/, public/ …), including .env values copied into the build. Values are never returned: only the file, line and a 4+4 character preview. Reads project files only; contacts nothing.",
       "risk": "read",
       "scope": "workspace",
       "channels": [
@@ -353,6 +357,28 @@
         "verified-domain"
       ]
     },
+    {
+      "name": "security_public_check",
+      "description": "Passively check sites you do NOT control, the way a visitor's browser does: grade security headers, the TLS certificate, versions disclosed on the home page and their known CVEs, SPF/DMARC and security.txt. One home-page GET, a TLS handshake and public DNS only; never probes paths, submits anything or runs an active scanner. For telling an owner about a visible problem; interactive use only.",
+      "risk": "read",
+      "scope": "workspace",
+      "channels": [
+        "in-app",
+        "mcp",
+        "claude",
+        "chatgpt",
+        "cli"
+      ],
+      "idempotent": true,
+      "openWorld": true,
+      "user": {
+        "label": "Check another site passively",
+        "detail": "Browser-equivalent checks of a site you do not own, so you can tell its owner. No scanning."
+      },
+      "gates": [
+        "interactive-only"
+      ]
+    },
     {
       "name": "security_code_scan",
       "description": "Look for unsafe code patterns in the project (unescaped HTML, server-side requests to user URLs, SQL built from strings, open redirects, insecure cookies, eval, secrets in public build variables, root containers) with semgrep and Maggie's own rules. Reads project files only; no rules are downloaded.",

package/bundled-tools/clis/maggie_security_host.py

@@ -329,9 +329,14 @@ def remote_lynis(ctx: core.Context, alias: str, target: str) -> dict:
         subprocess.run(["ssh", "-o", "BatchMode=yes", target, f"umask 077 && mkdir -p {remote_dir}"], check=True, timeout=60)
         subprocess.run(["scp", "-q", "-o", "BatchMode=yes", str(tarball), f"{target}:{remote_dir}/lynis.tar.gz"], check=True, timeout=300)
         profile = shlex.quote(LYNIS_PROFILE)
-        script = (f"cd {remote_dir} && tar xzf lynis.tar.gz && printf %s {profile} > maggie.prf && cd lynis && "
-                  f"$( [ $(id -u) != 0 ] && sudo -n true 2>/dev/null && echo sudo -n ) ./lynis audit system --quick --no-colors --no-log "
-                  f"--profile {remote_dir}/maggie.prf --report-file {remote_dir}/report.dat --logfile /dev/null >/dev/null 2>&1; cat {remote_dir}/report.dat")
+        # Run lynis with sudo when available (a full audit needs root); read the
+        # report back with the SAME sudo, because a root run writes report.dat
+        # root-owned and 0600 — a plain `cat` as the login user reads nothing.
+        script = (f"SUDO=$( [ $(id -u) != 0 ] && sudo -n true 2>/dev/null && echo 'sudo -n' ); "
+                  f"cd {remote_dir} && tar xzf lynis.tar.gz && printf %s {profile} > maggie.prf && cd lynis && "
+                  f"$SUDO ./lynis audit system --quick --no-colors --no-log "
+                  f"--profile {remote_dir}/maggie.prf --report-file {remote_dir}/report.dat --logfile /dev/null >/dev/null 2>&1; "
+                  f"$SUDO cat {remote_dir}/report.dat")
         proc = subprocess.run(["ssh", "-o", "BatchMode=yes", target, script], capture_output=True, text=True, timeout=1800, check=False)
         report = proc.stdout
     finally:
@@ -385,7 +390,8 @@ def nginx_findings(ctx: core.Context, nginx: str, php: str, key_perms: str, host
     findings = []
     seen = set()
 
-    def add(fid: str, title: str, severity: str, summary: str, snippet: str | None = None, where: str = "", asvs: list[str] | None = None) -> None:
+    def add(fid: str, title: str, severity: str, summary: str, snippet: str | None = None, where: str = "", asvs: list[str] | None = None,
+            steps: list[str] | None = None) -> None:
         key = (fid, where)
         if key in seen:
             return
@@ -393,7 +399,7 @@ def nginx_findings(ctx: core.Context, nginx: str, php: str, key_perms: str, host
         findings.append(core.make_finding(kind="misconfiguration", command="host-nginx-config", primary_id=fid, site=ctx.site,
                                           title=title + (f" ({where})" if where else ""), severity=severity, severity_source="maggie",
                                           confidence="likely", target={"host": host, "path": where or None}, asvs_ids=asvs or [], rule_id=fid,
-                                          remediation={"summary": summary, "steps": ["sudo nginx -t && sudo systemctl reload nginx"],
+                                          remediation={"summary": summary, "steps": steps or ["sudo nginx -t && sudo systemctl reload nginx"],
                                                        "snippets": [{"kind": "nginx", "text": snippet}] if snippet else [],
                                                        "references": ["https://nginx.org/en/docs/"], "cheat_sheet": None}))
 
@@ -471,7 +477,7 @@ def nginx_findings(ctx: core.Context, nginx: str, php: str, key_perms: str, host
         parts = line.split(None, 2)
         if len(parts) == 3 and (int(parts[0][-1]) > 0 or int(parts[0][-2]) > 4 or parts[1] != "root"):
             add("ngx-tls-key-perms", f"TLS private key is readable by others ({parts[0]} {parts[1]})", "high", "chmod 600 the key and chown root.",
-                where=parts[2], asvs=["V13.3.1"])
+                where=parts[2], asvs=["V13.3.1"], steps=[f"sudo chmod 600 {shlex.quote(parts[2])} && sudo chown root:root {shlex.quote(parts[2])}"])
     return findings
 
 

package/bundled-tools/clis/maggie_security_mcp.py

@@ -64,6 +64,9 @@ SCHEMAS: dict[str, dict] = {
         "host": {"type": "string", "pattern": DOMAIN}, "port": {"type": "integer", "minimum": 1, "maximum": 65535}}},
     "security_web_scan": {"type": "object", "required": ["url"], "additionalProperties": False, "properties": {
         "url": {"type": "string", "pattern": r"^https?://[A-Za-z0-9.-]+(:\d+)?(/[^\s]*)?$"}, "profile": {"enum": ["safe", "full-safe"]}}},
+    "security_public_check": {"type": "object", "additionalProperties": False, "properties": {
+        "url": {"type": "string", "pattern": r"^https?://[A-Za-z0-9.-]+(:\d+)?(/[^\s]*)?$"},
+        "domains": {"type": "array", "items": {"type": "string", "pattern": DOMAIN}, "minItems": 1, "maxItems": 50}}},
     "security_code_scan": {"type": "object", "additionalProperties": False, "properties": {
         "changed_since": {"type": "string", "pattern": r"^[A-Za-z0-9._/~^-]{1,80}$"}}},
     "security_logs_check": {"type": "object", "required": ["mode"], "additionalProperties": False, "properties": {
@@ -94,7 +97,8 @@ SCHEMAS: dict[str, dict] = {
         "confirm": {"type": "boolean"}, "confirmation": {"type": "string", "maxLength": 80}}},
 }
 NETWORK_TOOLS = {"security_vuln_watch", "security_osv_query", "security_wp_check", "security_eol_check", "security_deps_scan",
-                 "security_domain_verify_check", "security_headers_check", "security_tls_check", "security_web_scan", "security_uptime_status",
+                 "security_domain_verify_check", "security_headers_check", "security_tls_check", "security_web_scan", "security_public_check",
+                 "security_uptime_status",
                  "security_checklist_get", "security_package_vet", "security_exposure_check", "security_image_scan"}
 
 
@@ -207,6 +211,13 @@ class Server:
             return ["tls", "--host", args.get("host", "x.invalid"), "--port", str(args.get("port", 443))]
         if name == "security_web_scan":
             return ["web-scan", "--url", args.get("url", "https://x.invalid"), "--profile", args.get("profile", "safe")]
+        if name == "security_public_check":
+            argv = ["public-check"]
+            if args.get("url"):
+                argv += ["--url", args["url"]]
+            for domain in args.get("domains") or []:
+                argv += ["--domain", domain]
+            return argv
         if name == "security_code_scan":
             return ["code-scan"] + (["--changed-since", args["changed_since"]] if args.get("changed_since") else [])
         if name == "security_logs_check":

package/bundled-tools/clis/maggie_security_report.py

@@ -153,6 +153,9 @@ def why(finding: dict) -> str:
         return "Anyone who sees the file can use this key."
     if kev:
         return "Attackers are already using this flaw (on the KEV list)."
+    if kind in ("misconfiguration", "header", "tls", "exposure", "attack-signal"):
+        sev = {"critical": "A serious", "high": "A serious", "medium": "A moderate", "low": "A minor", "info": "A minor"}[finding["severity"]]
+        return f"{sev} configuration weakness an attacker could use."
     severity = {"critical": "A serious", "high": "A serious", "medium": "A moderate", "low": "A minor", "info": "A minor"}[finding["severity"]]
     return f"{severity} known flaw (CVE) affects the version you run."
 
@@ -184,8 +187,10 @@ def group_actions(findings: list[dict]) -> list[dict]:
         items = core.sort_findings(groups[key])
         lead = items[0]
         if key[0] == "single" or len(items) == 1:
+            la = lead.get("affected") or {}
             actions.append({"priority": lead["priority"], "title": action_title(lead), "why": why(lead), "how": how(lead),
-                            "ids": [lead["id"]], "count": 1, "lead": lead})
+                            "ids": [lead["id"]], "count": 1, "lead": lead,
+                            "package": la.get("name"), "ecosystem": la.get("ecosystem"), "fix_version": (lead.get("fix") or {}).get("recommended")})
             continue
         affected = lead["affected"]
         eco = affected.get("ecosystem")
@@ -205,7 +210,8 @@ def group_actions(findings: list[dict]) -> list[dict]:
                   + ("; attackers are using at least one (on the KEV list)." if exploited else "."))
         step_from = next((f for f in items if (f.get("fix") or {}).get("recommended") == target_version), lead)
         actions.append({"priority": lead["priority"], "title": title, "why": reason, "how": how(step_from),
-                        "ids": [f["id"] for f in items], "count": len(items), "lead": lead})
+                        "ids": [f["id"] for f in items], "count": len(items), "lead": lead,
+                        "package": affected.get("name"), "ecosystem": eco, "fix_version": target_version})
     return sorted(actions, key=lambda a: (core.PRIORITIES.index(a["priority"]), -a["count"]))
 
 
@@ -219,19 +225,25 @@ def explain_jargon(text: str, used: set[str]) -> str:
     return re.sub(r"\b(" + "|".join(JARGON) + r")\b", sub, text)
 
 
-def build(ctx: core.Context) -> dict:
-    args = ctx.args
-    since = args.since
-    if args.kind == "gate" and since in (None, "last-report"):
-        since = "6h"  # the gate reads this deploy's runs only
+def resolve_since(ctx: core.Context, since: str | None, kind: str = "weekly") -> str:
+    if kind == "gate" and since in (None, "last-report"):
+        return "6h"  # the gate reads this deploy's runs only
     if since in (None, "last-report"):
         last = last_report_time(ctx.state)
         if last:
             hours = max(1, int((core.utcnow() - core.parse_time(last)).total_seconds() // 3600) + 1)
-            since = f"{hours}h"
-        else:
-            since = "7d"
-    runs = latest_runs(ctx.state, since, args.runs)
+            return f"{hours}h"
+        return "7d"
+    return since
+
+
+def collect_findings(ctx: core.Context, since: str, run_ids: list[str] | None) -> tuple[list[dict], list[dict], set[str]]:
+    """The current findings for a site: the latest run per command merged with the ledger.
+
+    Returns (findings with their derived status, the runs used, the set of fixed ids).
+    Shared by `report` and `fix-plan` so both see exactly the same state.
+    """
+    runs = latest_runs(ctx.state, since, run_ids)
     if not runs:
         raise core.UsageError(f"no security runs in the last {since}; run e.g. `maggie security vuln-watch` first")
     ledger = core.Ledger(ctx.state.path("ledger.jsonl"))
@@ -254,7 +266,13 @@ def build(ctx: core.Context) -> dict:
         first_seen = (state or {}).get("first_seen") or finding.get("first_seen")
         finding = dict(finding, status="new" if first_seen and core.parse_time(first_seen) >= floor and status in ("new", "open") else status)
         findings.append(finding)
-    findings = core.sort_findings(findings)
+    return core.sort_findings(findings), runs, fixed_ids
+
+
+def build(ctx: core.Context) -> dict:
+    args = ctx.args
+    since = resolve_since(ctx, args.since, args.kind)
+    findings, runs, fixed_ids = collect_findings(ctx, since, args.runs)
     actionable = [f for f in findings if f["status"] in ("new", "open")]
     grouped = group_actions([f for f in actionable if f["priority"] in ("p0", "p1")])
     p0 = sum(1 for a in grouped if a["priority"] == "p0")
@@ -271,7 +289,7 @@ def build(ctx: core.Context) -> dict:
 
     built = set(maggie_security.area_commands())
     missing = [c for c in EXPECTED.get(site_type, EXPECTED["unknown"]) if c not in ran and c in built]
-    period = {"from": core.iso(floor), "to": core.iso()}
+    period = {"from": core.iso(core.utcnow() - core.parse_duration(since)), "to": core.iso()}
     actions = [f for f in actionable if f["priority"] in ("p0", "p1")]
     report_id = f"{core.iso()[:10]}-{args.kind}-{core.sha256_bytes(json.dumps(sorted(f['id'] for f in findings)).encode())[:6]}"
     data = {
@@ -490,6 +508,160 @@ def incident_cmd(ctx: core.Context) -> dict:
     return data
 
 
+# --------------------------------------------------------------------------- fix-plan (a reviewed remediation runbook)
+
+# A fix-plan turns the open findings into an ordered runbook of the fixes the
+# findings themselves already carry. It never connects to a host and never runs
+# anything — the operator reviews it and runs it under a host lock. It only
+# emits remediation text the checks authored; it does not invent commands.
+
+FIX_CATEGORIES = [
+    ("secrets-permissions", "Secrets and file permissions", "Quick, high-value fixes — do these first."),
+    ("firewall", "Firewall", "Close everything except the ports you actually serve."),
+    ("packages", "Package updates", "Apply in a maintenance window; reboot if the kernel or libc changed."),
+    ("intrusion-prevention", "Intrusion prevention", "Use `maggie security protect-plan` for a reviewed fail2ban/CrowdSec setup."),
+    ("web-server", "Web server configuration", "Edit the server/vhost files, then `sudo nginx -t && sudo systemctl reload nginx`."),
+    ("end-of-life", "End-of-life upgrades", "Plan a move to a supported release line."),
+    ("other", "Other", "Review and apply as appropriate."),
+]
+
+
+def fix_category(finding: dict) -> str:
+    kind = finding.get("kind")
+    rule = (finding.get("source") or {}).get("rule_id") or ""
+    command = (finding.get("source") or {}).get("command") or ""
+    title = finding.get("title", "").lower()
+    if kind == "secret" or "readable by others" in title or "world-readable" in title or "permission" in title:
+        return "secrets-permissions"
+    if "firewall" in title or rule.startswith("hq-firewall"):
+        return "firewall"
+    if "fail2ban" in title or "crowdsec" in title or "intrusion" in title:
+        return "intrusion-prevention"
+    if kind == "vulnerability":
+        return "packages"
+    if kind == "eol":
+        return "end-of-life"
+    if command in ("host-nginx-config", "headers", "tls") or kind in ("header", "tls"):
+        return "web-server"
+    return "other"
+
+
+def fix_commands(action: dict) -> tuple[list[str], list[tuple[str, str]], list[str]]:
+    """(shell commands, (kind, snippet) paste-ins, TODO notes) faithfully from the lead finding."""
+    lead = action["lead"]
+    rem = lead.get("remediation") or {}
+    steps = [s for s in (rem.get("steps") or []) if not s.startswith(("Listed by CISA", "Check you can log in"))]
+    snippets = [(s.get("kind") or "text", s.get("text") or "") for s in (rem.get("snippets") or []) if s.get("text")]
+    commands = [s for s in steps if re.match(r"^\s*(sudo |apt|chmod|chown|ufw|systemctl|nginx |visudo|sed |install )", s)]
+    todos = [] if (commands or snippets) else [rem.get("summary") or action["title"]]
+    return commands, snippets, todos
+
+
+def fix_plan(ctx: core.Context) -> dict:
+    args = ctx.args
+    since = resolve_since(ctx, args.since)
+    findings, _runs, _fixed = collect_findings(ctx, since, args.runs)
+    actionable = [f for f in findings if f["status"] in ("new", "open")]
+    if args.priority:
+        floor = core.PRIORITIES.index(args.priority)
+        actionable = [f for f in actionable if core.PRIORITIES.index(f["priority"]) <= floor]
+    actions = group_actions(actionable)
+    buckets: dict[str, list[dict]] = {key: [] for key, _, _ in FIX_CATEGORIES}
+    for action in actions:
+        buckets[fix_category(action["lead"])].append(action)
+
+    host = next((f.get("target", {}).get("host") for f in actionable if (f.get("target") or {}).get("host")), None)
+    lock_target = host or "<user@host>"
+    sh: list[str] = [
+        "#!/usr/bin/env bash",
+        f"# Remediation runbook for {ctx.site}" + (f" ({host})" if host else "") + f" — generated {core.iso()[:10]} by maggie security fix-plan.",
+        "#",
+        "# REVIEW EVERY LINE BEFORE RUNNING. Maggie did not and will not run any of this.",
+        "# Run it yourself, as the operator, after:",
+        "#   1. taking a snapshot/backup of the server,",
+        "#   2. opening a SECOND SSH session (so a bad sshd/firewall change cannot lock you out),",
+        f"#   3. taking the change lock: maggie deployment host-lock acquire --host {lock_target} --purpose fix-plan",
+        "# Package upgrades belong in a maintenance window. Test nginx with `nginx -t` before every reload.",
+        "set -euo pipefail",
+        "",
+    ]
+    md: list[str] = [f"# Remediation runbook — {ctx.site}" + (f" ({host})" if host else ""), "",
+                     "Generated by `maggie security fix-plan`. **Review before running — Maggie never runs these.** "
+                     "Take a backup, keep a second SSH session open, and work under "
+                     f"`maggie deployment host-lock acquire --host {lock_target} --purpose fix-plan`.", ""]
+    apt_packages: list[str] = []
+    total = 0
+    for key, label, note in FIX_CATEGORIES:
+        items = buckets.get(key) or []
+        if not items:
+            continue
+        sh += [f"# =================== {label} ===================", f"# {note}", ""]
+        md += [f"## {label}", f"_{note}_", ""]
+        for action in items:
+            total += 1
+            sh.append(f"# [{action['priority']}] {action['title']} — {action['why']}")
+            md.append(f"- **{action['title']}** — {action['why']}")
+            if key == "packages":
+                # Build the fix command ourselves; never copy the finding's step text
+                # (it reads "apt-get install --only-upgrade X  (fixed in Y)" — not valid shell).
+                name = action.get("package")
+                osfam = (action.get("ecosystem") or "").split(":")[0]
+                if name and osfam in ("Ubuntu", "Debian") and action.get("fix_version"):
+                    apt_packages.append(name)
+                    sh.append(f"#   {name} -> {action['fix_version']} (in the apt batch above)")
+                else:
+                    sh.append(f"#   TODO (manual): {action['how']}")
+                    md.append(f"  - {action['how']}")
+                sh.append("")
+                continue
+            commands, snippets, todos = fix_commands(action)
+            for cmd in commands:
+                sh.append(cmd)
+            for kind, text in snippets:
+                sh.append(f"#   {kind} config — paste into the right block:")
+                sh += [f"#     {line}" for line in text.splitlines()]
+                md.append(f"  - `{kind}`: `{text}`")
+            for todo in todos:
+                sh.append(f"#   TODO (manual): {todo}")
+                md.append(f"  - {todo}")
+            if commands:
+                md.append("  - run: " + "; ".join(f"`{c}`" for c in commands))
+            sh.append("")
+        md.append("")
+    if apt_packages:
+        pkgs = " ".join(sorted(set(apt_packages)))
+        insert = ["# Apply available Ubuntu/Debian security updates for the affected packages:",
+                  "sudo apt-get update",
+                  f"sudo apt-get install --only-upgrade {pkgs}",
+                  "# Or apply all pending security updates at once:",
+                  "# sudo unattended-upgrade -d    # or: sudo apt-get upgrade", ""]
+        anchor = sh.index("# =================== Package updates ===================") + 3
+        sh[anchor:anchor] = insert
+        md.append("### apt batch")
+        md.append(f"```\nsudo apt-get update && sudo apt-get install --only-upgrade {pkgs}\n```\n")
+    runbook = "\n".join(md).rstrip() + "\n"
+    script = "\n".join(sh).rstrip() + "\n"
+    if args.script:
+        path = Path(args.script)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(script, encoding="utf-8")
+        path.chmod(0o755)
+    if getattr(args, "output", None):
+        out = Path(args.output)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(runbook, encoding="utf-8")
+    return {"schema": "maggie-security-fix-plan.v1", "site": ctx.site, "host": host, "generated_at": core.iso(),
+            "actions": total, "apt_packages": sorted(set(apt_packages)),
+            "script_path": str(args.script) if args.script else None,
+            "note": "Review before running. Maggie never applies these changes.", "markdown": runbook}
+
+
+def _fix(p: argparse.ArgumentParser) -> None:
+    p.add_argument("--priority", choices=["p0", "p1", "p2", "p3", "p4"], help="only include findings at or above this priority")
+    p.add_argument("--script", help="write the runnable shell runbook to this path (chmod 755)")
+    p.add_argument("--runs", action="append", help="use these run ids instead of the latest per command")
+
+
 def _incident(p: argparse.ArgumentParser) -> None:
     p.add_argument("action", choices=["start", "log", "close", "show", "list"])
     p.add_argument("--id")
@@ -503,4 +675,6 @@ def _incident(p: argparse.ArgumentParser) -> None:
 COMMANDS = [core.Command("report", "one per-site report from the latest runs and the ledger (Markdown + JSON, report_save payload)", [],
                          configure, run, findings=False),
             core.Command("incident", "timeline for a CVE response or other incident (local records; used by report --kind incident)", [], _incident,
-                         incident_cmd, findings=False)]
+                         incident_cmd, findings=False),
+            core.Command("fix-plan", "a reviewed remediation runbook from the open findings (Markdown + a shell script); never applied by Maggie",
+                         [], _fix, fix_plan, findings=False, routine_safe=False)]

package/bundled-tools/clis/maggie_security_web.py

@@ -30,6 +30,7 @@ import ssl
 import struct
 import subprocess
 import tempfile
+import time
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -883,6 +884,303 @@ def zap_baseline(ctx: core.Context):
     return ctx.finish(findings, covered=[f"url:{url}"])
 
 
+# --------------------------------------------------------------------------- public-check (passive, browser-equivalent)
+
+# A public check only looks at what any visitor already sees: one GET of the
+# home page, a TLS handshake, and public DNS. It never probes paths, never
+# submits anything and never runs an active scanner (that is `web-scan` /
+# `zap-baseline`, which stay verified-only). The point is to spot a problem on
+# a site you do NOT control so you can tell its owner.
+
+# <meta name="generator"> product -> how to record it in a stack.
+GENERATORS = [
+    (re.compile(r"WordPress\s+([0-9]+(?:\.[0-9]+){1,2})", re.I), "wordpress-core"),
+    (re.compile(r"Drupal\s+([0-9]+(?:\.[0-9]+){0,2})", re.I), ("npm", "drupal")),
+    (re.compile(r"Joomla!?\s*-?\s*([0-9]+(?:\.[0-9]+){1,2})", re.I), ("npm", "joomla")),
+]
+# Server / X-Powered-By token -> runtime or service name used by the matchers.
+SERVER_RUNTIMES = [
+    (re.compile(r"nginx/([0-9]+(?:\.[0-9]+){1,2})", re.I), "nginx"),
+    (re.compile(r"Apache/([0-9]+(?:\.[0-9]+){1,2})", re.I), "apache"),
+    (re.compile(r"PHP/([0-9]+(?:\.[0-9]+){1,2})", re.I), "php"),
+    (re.compile(r"OpenSSL/([0-9]+(?:\.[0-9]+){1,2}[a-z]?)", re.I), "openssl"),
+]
+ASSET_RE = re.compile(r"""(?:src|href)\s*=\s*['"]([^'"]+?\.(?:js|css))(?:\?[^'"]*)?['"]""", re.I)
+GENERATOR_RE = re.compile(r"""<meta[^>]+name\s*=\s*['"]generator['"][^>]+content\s*=\s*['"]([^'"]+)['"]""", re.I)
+
+
+def resolve_txt(ctx: core.Context, name: str) -> list[str]:
+    """Best-effort TXT lookup: the system resolver, then public DoH. Never raises."""
+    values: list[str] = []
+    try:
+        servers = system_resolvers()
+        if servers:
+            values = dns_txt_udp(name, servers[0])
+    except OSError:
+        values = []
+    if not values:
+        try:
+            values = dns_txt_doh(ctx, name) or []
+        except (core.DegradedError, OSError, ValueError):
+            values = []
+    return values
+
+
+def remote_fingerprint(host: str, response: dict, site: str) -> dict:
+    """A maggie-security-stack.v1 built only from the home page a visitor receives."""
+    body = response.get("body") or b""
+    text = body.decode("utf-8", errors="replace") if isinstance(body, (bytes, bytearray)) else str(body)
+    headers = response.get("headers") or {}
+    components: list[dict] = []
+    runtimes: list[dict] = []
+    wordpress: dict = {}
+    seen: set[tuple] = set()
+
+    generator = ""
+    match = GENERATOR_RE.search(text)
+    if match:
+        generator = match.group(1)
+        for rx, target in GENERATORS:
+            got = rx.search(generator)
+            if not got:
+                continue
+            if target == "wordpress-core":
+                wordpress = {"core": got.group(1), "plugins": [], "themes": []}
+            else:
+                eco, cname = target
+                key = (eco, cname, got.group(1))
+                if key not in seen:
+                    seen.add(key)
+                    components.append({"purl": core.make_purl(eco, cname, got.group(1)), "ecosystem": eco, "name": cname,
+                                       "version": got.group(1), "scope": "runtime", "direct": True, "location": f"https://{host}/ (generator)"})
+            break
+
+    for header in ("server", "x-powered-by"):
+        value = " ".join(headers.get(header) or [])
+        for rx, name in SERVER_RUNTIMES:
+            got = rx.search(value)
+            if got and ("runtime", name) not in seen:
+                seen.add(("runtime", name))
+                runtimes.append({"name": name, "version": got.group(1), "source": f"{header} header", "host": None})
+
+    import maggie_security_inventory as inventory
+
+    extractors = inventory._retire_extractors()
+    assets = 0
+    for raw in ASSET_RE.findall(text):
+        if assets >= 40:
+            break
+        assets += 1
+        basename = raw.rstrip("/").rsplit("/", 1)[-1]
+        for lib, (name_res, _content_res, npm) in extractors.items():
+            version = None
+            for rx in name_res:
+                got = rx.search(basename)
+                if got:
+                    version = got.group(1)
+                    break
+            if not version:
+                continue
+            version = re.sub(r"([.-](min|slim|pack|prod|production|umd|esm|bundle|js))+$", "", version).rstrip(".-_")
+            key = ("npm", npm, version)
+            if key in seen:
+                break
+            seen.add(key)
+            components.append({"purl": core.make_purl("npm", npm, version), "ecosystem": "npm", "name": npm, "version": version,
+                               "scope": "runtime", "direct": None, "location": f"https://{host}/{basename}"})
+            break
+
+    site_type = "wordpress" if wordpress else "custom"
+    digest = core.sha256_bytes(core.canonical_json([components, runtimes, wordpress]).encode("utf-8"))
+    return {"schema": "maggie-security-stack.v1", "site": {"id": site, "type": site_type, "domains": [host], "hosting": None},
+            "collected_at": core.iso(), "hash": f"sha256:{digest}", "sources": [{"kind": "homepage", "path": f"https://{host}/"}],
+            "components": components, "runtimes": runtimes, "wordpress": wordpress, "images": [], "hosts": [],
+            "watch": {"products": []}, "generator": generator}
+
+
+def email_dns_findings(ctx: core.Context, host: str, site: str) -> list[dict]:
+    """Passive email-spoofing hygiene from public DNS: SPF and DMARC on the registrable domain."""
+    domain = registrable(host)
+    findings: list[dict] = []
+    spf = [v for v in resolve_txt(ctx, domain) if v.lower().startswith("v=spf1")]
+    if not spf:
+        findings.append(core.make_finding(
+            kind="misconfiguration", command="public-check", primary_id="email-spf-missing", site=site, title=f"{domain} has no SPF record",
+            severity="low", severity_source="maggie", confidence="confirmed", target={"host": domain}, asvs_ids=[],
+            remediation={"summary": "Publish an SPF TXT record so receivers can reject mail forged from this domain.", "steps": [],
+                         "snippets": [{"kind": "dns", "text": f'{domain}. TXT "v=spf1 -all"  # tighten to your real senders'}],
+                         "references": ["https://datatracker.ietf.org/doc/html/rfc7208"], "cheat_sheet": None}))
+    elif any("+all" in v.lower() for v in spf):
+        findings.append(core.make_finding(
+            kind="misconfiguration", command="public-check", primary_id="email-spf-permissive", site=site,
+            title=f"{domain} SPF ends in +all (anyone may send as this domain)", severity="medium", severity_source="maggie",
+            confidence="confirmed", target={"host": domain}, evidence=[{"path": "SPF", "excerpt": core.clean_excerpt(spf[0], 200)}],
+            remediation={"summary": "Replace +all with -all (or ~all) so forged senders are rejected.", "steps": [], "snippets": [],
+                         "references": [], "cheat_sheet": None}))
+    dmarc = [v for v in resolve_txt(ctx, f"_dmarc.{domain}") if v.lower().startswith("v=dmarc1")]
+    if not dmarc:
+        findings.append(core.make_finding(
+            kind="misconfiguration", command="public-check", primary_id="email-dmarc-missing", site=site, title=f"{domain} has no DMARC record",
+            severity="low", severity_source="maggie", confidence="confirmed", target={"host": f"_dmarc.{domain}"}, asvs_ids=[],
+            remediation={"summary": "Publish a DMARC record so spoofed mail is reported and (later) rejected.", "steps": [],
+                         "snippets": [{"kind": "dns", "text": f'_dmarc.{domain}. TXT "v=DMARC1; p=none; rua=mailto:dmarc@{domain}"'}],
+                         "references": ["https://datatracker.ietf.org/doc/html/rfc7489"], "cheat_sheet": None}))
+    elif any(re.search(r"\bp\s*=\s*none\b", v, re.I) for v in dmarc):
+        findings.append(core.make_finding(
+            kind="misconfiguration", command="public-check", primary_id="email-dmarc-none", site=site,
+            title=f"{domain} DMARC policy is p=none (monitoring only, no enforcement)", severity="info", severity_source="maggie",
+            confidence="confirmed", target={"host": f"_dmarc.{domain}"}, evidence=[{"path": "DMARC", "excerpt": core.clean_excerpt(dmarc[0], 200)}],
+            remediation={"summary": "Once reports look clean, move the policy to quarantine then reject.", "steps": [], "snippets": [],
+                         "references": [], "cheat_sheet": None}))
+    return findings
+
+
+def securitytxt_finding(ctx: core.Context, base: str, host: str, site: str) -> dict | None:
+    """One GET of /.well-known/security.txt; a missing file is an info nudge, not a risk."""
+    try:
+        response = fetch(urllib.parse.urljoin(base + "/", "/.well-known/security.txt"), follow=False, timeout=10)
+    except (OSError, ssl.SSLError):
+        return None
+    if response.get("status") == 200 and b"contact" in (response.get("body") or b"").lower():
+        return None
+    return core.make_finding(
+        kind="misconfiguration", command="public-check", primary_id="no-security-txt", site=site,
+        title="No security.txt: no published way to report a vulnerability", severity="info", severity_source="maggie",
+        confidence="confirmed", target={"url": f"https://{host}/.well-known/security.txt", "host": host}, asvs_ids=[],
+        remediation={"summary": "Publish /.well-known/security.txt with a Contact: line so researchers can reach you.", "steps": [],
+                     "snippets": [{"kind": "text", "text": f"Contact: mailto:security@{registrable(host)}\nExpires: <date>"}],
+                     "references": ["https://www.rfc-editor.org/rfc/rfc9116"], "cheat_sheet": None})
+
+
+def advisory_findings_remote(ctx: core.Context, stack: dict) -> tuple[list[dict], list[str]]:
+    """Run the same advisory engine as vuln-watch over the passively-built remote stack."""
+    import maggie_security_intel as intel
+
+    findings: list[dict] = []
+    notes: list[str] = []
+    try:
+        osv, ok = intel.match_osv(ctx, stack, "public-check")
+        findings += osv
+        if not ok:
+            notes.append("OSV lookup was degraded; version advisories may be incomplete")
+        soft, _cov = intel.software_findings(ctx, stack, "public-check")
+        findings += soft
+        if stack.get("wordpress", {}).get("core"):
+            wp, wp_ok = intel.wordpress_findings(ctx, stack, "public-check", budget=1)
+            findings += wp
+            if not wp_ok:
+                notes.append("WordPress advisory lookup was degraded")
+        kev = intel.load_kev(ctx)
+        intel.apply_kev(findings, kev, stack)
+        intel.join_epss(ctx, findings)
+    except core.DegradedError as error:
+        notes.append(f"advisory lookup degraded: {core.clean_excerpt(str(error), 160)}")
+    return findings, notes
+
+
+SEVERITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}
+
+
+def outreach_markdown(host: str, findings: list[dict]) -> str:
+    """A disclosure-ready note for the site owner: what is visible, not how to exploit it."""
+    by_sev: dict[str, list[dict]] = {}
+    for f in findings:
+        by_sev.setdefault(f["severity"], []).append(f)
+    lines = [f"# Security notes for {host}", "",
+             "We ran only passive checks — the same requests any visitor's browser makes "
+             "(your home page, a TLS handshake, and public DNS). We did not probe, log in, "
+             "or scan. Here is what is publicly visible, so you can decide what to fix.", ""]
+    actionable = [s for s in ("critical", "high", "medium", "low") if by_sev.get(s)]
+    if not actionable:
+        lines += ["Nothing notable was visible from the outside. ", ""]
+    for sev in ("critical", "high", "medium", "low", "info"):
+        items = sorted(by_sev.get(sev) or [], key=lambda f: f["title"])
+        if not items:
+            continue
+        lines.append(f"## {sev.title()}")
+        for f in items:
+            fix = (f.get("remediation") or {}).get("summary") or ""
+            lines.append(f"- **{f['title']}**" + (f" — {fix}" if fix else ""))
+        lines.append("")
+    lines += ["---",
+              "_Sent by <your name / company>. We have no affiliation with this site and "
+              "hold no further details beyond the public observations above. If you would "
+              "rather not hear from us again, just reply and we will stop._"]
+    return "\n".join(lines)
+
+
+def _public_targets(args) -> list[str]:
+    """Base URLs to check, de-duplicated; a bare domain becomes https://domain/."""
+    raw: list[str] = []
+    if getattr(args, "url", None):
+        raw.append(args.url)
+    raw += list(getattr(args, "domain", None) or [])
+    if getattr(args, "domains", None):
+        for line in Path(args.domains).read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line and not line.startswith("#"):
+                raw.append(line)
+    bases = [(item if "://" in item else f"https://{item}") for item in raw]
+    return list(dict.fromkeys(b for b in bases if host_of(b)))
+
+
+def public_check(ctx: core.Context):
+    args = ctx.args
+    ctx.args.no_ledger = True  # these are other people's sites: never touch the local ledger
+    bases = _public_targets(args)
+    if not bases:
+        raise core.UsageError("give --url, one or more --domain, or --domains FILE")
+    if len(bases) > args.max_sites:
+        raise core.PolicyError(f"{len(bases)} domains exceeds --max-sites {args.max_sites}; raise it deliberately")
+    outreach_dir = Path(args.outreach) if args.outreach else None
+    if outreach_dir:
+        outreach_dir.mkdir(parents=True, exist_ok=True)
+    all_findings: list[dict] = []
+    sites: list[dict] = []
+    for index, base in enumerate(bases):
+        host = host_of(base)
+        if index:
+            time.sleep(max(0.0, 1.0 / max(args.rate, 0.2)))  # be a polite visitor between sites
+        require_ownership(ctx, host, public_check=True)  # interactive-only; refuses in CI/routines
+        entry = {"host": host, "notes": []}
+        try:
+            response = fetch(urllib.parse.urljoin(base + "/", "/"), timeout=15)
+        except (OSError, ssl.SSLError) as error:
+            entry["notes"].append(f"home page not reachable: {core.clean_excerpt(str(error), 160)}")
+            sites.append(entry)
+            continue
+        if response.get("left_domain"):
+            entry["notes"].append(f"redirects off-domain to {response['left_domain']}; checked only the first response")
+        # The remote site is unrelated to the local project, so detect the serving
+        # layer from its response headers alone, never from files on this machine.
+        layer = detect_serving(Path("/nonexistent-maggie-prospect"), response["headers"], "auto")
+        findings = grade_response(ctx, response["url"], response, layer, response["url"].startswith("https://"))
+        findings += native_tls(ctx, host, 443, None)
+        stack = remote_fingerprint(host, response, ctx.site)
+        entry["detected"] = {"generator": stack.get("generator") or None,
+                             "components": [f"{c['name']} {c['version']}" for c in stack["components"]],
+                             "runtimes": [f"{r['name']} {r['version']}" for r in stack["runtimes"]]}
+        advisories, notes = advisory_findings_remote(ctx, stack)
+        findings += advisories
+        entry["notes"] += notes
+        findings += email_dns_findings(ctx, host, ctx.site)
+        sec = securitytxt_finding(ctx, base, host, ctx.site)
+        if sec:
+            findings.append(sec)
+        for f in findings:
+            f.setdefault("target", {}).setdefault("host", host)
+        entry["counts"] = {s: sum(1 for f in findings if f["severity"] == s) for s in SEVERITY_ORDER if any(x["severity"] == s for x in findings)}
+        all_findings += findings
+        if outreach_dir:
+            report = outreach_dir / f"{registrable(host)}.md"
+            report.write_text(outreach_markdown(host, findings), encoding="utf-8")
+            entry["outreach"] = str(report)
+        sites.append(entry)
+    all_findings.sort(key=lambda f: (SEVERITY_ORDER.get(f["severity"], 9), f["title"]))
+    ctx.run["inputs"].update({"mode": "public-check (passive, unverified)", "sites": sites, "label": "unverified domains (public check)"})
+    return ctx.finish(all_findings, covered=[f"url:{host_of(b)}" for b in bases])
+
+
 # --------------------------------------------------------------------------- registration
 
 
@@ -923,6 +1221,15 @@ def _zap(p: argparse.ArgumentParser) -> None:
     p.add_argument("--image", help="pinned ZAP image reference (default ghcr.io/zaproxy/zaproxy:stable)")
 
 
+def _public(p: argparse.ArgumentParser) -> None:
+    p.add_argument("--url", help="one site to check")
+    p.add_argument("--domain", action="append", help="a domain to check (repeatable)")
+    p.add_argument("--domains", help="file with one domain per line")
+    p.add_argument("--outreach", help="write a disclosure-ready note per domain into this directory")
+    p.add_argument("--rate", type=float, default=0.5, help="sites per second between domains (default 0.5)")
+    p.add_argument("--max-sites", type=int, default=50, help="refuse a run with more domains than this")
+
+
 COMMANDS = [
     core.Command("domain-verify", "prove you control a domain (DNS TXT or a token file) before any active check", ["doh", "dns", "target-site"], _dv,
                  domain_verify, findings=False),
@@ -933,4 +1240,8 @@ COMMANDS = [
                  _scan, web_scan),
     core.Command("zap-baseline", "weekly passive ZAP baseline scan of your verified site (Docker)", ["target-site", "doh", "dns"], _zap, zap_baseline,
                  routine_safe=False),
+    core.Command("public-check",
+                 "passive, browser-equivalent checks of sites you do not control (headers, TLS, visible versions and their known CVEs, SPF/DMARC, "
+                 "security.txt) so you can tell the owner; never probes or scans",
+                 ["target-site", "doh", "dns", "osv-api", "wpvulnerability", "kev", "epss"], _public, public_check, routine_safe=False),
 ]

package/bundled-tools/clis/security_data/tools.lock.json

@@ -202,7 +202,13 @@
       "forbidden_flags": [
         "--upload"
       ],
-      "notes": "GPL: run from the upstream tarball on the host; never vendored."
+      "notes": "GPL: downloaded on use, sha256-verified, uploaded to a private /tmp dir on the host and removed after; never vendored into the package.",
+      "assets": {
+        "any": {
+          "url": "https://downloads.cisofy.com/lynis/lynis-3.1.5.tar.gz",
+          "sha256": "8d2c6652ba60116a82514522b666ca77293f4bfc69f1e581028769f7ebb52ba4"
+        }
+      }
     },
     "goaccess": {
       "version": "1.9.4",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@topy-ai/maggie",
-  "version": "0.7.56",
+  "version": "0.7.58",
   "description": "Install and manage Maggie Skills for AI coding agents",
   "license": "MIT",
   "type": "module",