torusguard 0.9.2

package/skills/torusguard/bootstrap.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""
+TorusGuard Autonomous Workspace Bootstrapper
+Scaffolds the complete .torusguard/ directory into any user project when
+/torusguard init is executed or when npx skills add installs the skill kit.
+"""
+
+import os
+import sys
+import shutil
+import json
+import argparse
+import subprocess
+from pathlib import Path
+
+
+def find_project_root(start_dir=None):
+    """Detect project root directory by searching for standard repo root markers."""
+    current = Path(start_dir or os.getcwd()).resolve()
+    markers = [".git", "package.json", "pyproject.toml", "manage.py", "Pipfile", "requirements.txt"]
+    
+    # First check current directory
+    for m in markers:
+        if (current / m).exists():
+            return current
+            
+    # Search upwards
+    for parent in current.parents:
+        for m in markers:
+            if (parent / m).exists():
+                return parent
+                
+    return current
+
+
+def scaffold_workspace(target_root=None, force=False, full_commands=False):
+    """Scaffold the .torusguard workspace into the target project root."""
+    target_root = Path(target_root or find_project_root()).resolve()
+    torusguard_target = target_root / ".torusguard"
+    script_dir = Path(__file__).resolve().parent
+    payload_dir = script_dir / "payload"
+
+    print("================================================================================")
+    print("TORUSGUARD WORKSPACE BOOTSTRAPPER")
+    print("================================================================================")
+    print(f"Target Directory: {target_root}")
+    print(f"Destination:      {torusguard_target}")
+
+    if torusguard_target.exists() and not force:
+        print(f"\n[INFO] Workspace already exists at {torusguard_target}")
+        config_file = torusguard_target / "config" / "torusguard.json"
+        if config_file.exists():
+            try:
+                with open(config_file, "r", encoding="utf-8") as f:
+                    cfg = json.load(f)
+                print(f"Current Version:   {cfg.get('version', 'unknown')}")
+                print(f"Severity Minimum:  {cfg.get('severity_threshold', 'medium')}")
+            except Exception:
+                pass
+        print("\nUse --force to re-scaffold or refresh templates.")
+        return True
+
+    # 1. Unpack Payload Template
+    if payload_dir.is_dir():
+        print("\n1. Unpacking bundled offline workspace payload...")
+        try:
+            if torusguard_target.exists() and force:
+                shutil.rmtree(torusguard_target)
+            shutil.copytree(
+                payload_dir,
+                torusguard_target,
+                ignore=shutil.ignore_patterns("runs", "*.pyc", "__pycache__", ".git*")
+            )
+            print("  [SUCCESS] Copied template tree from local skill payload.")
+        except Exception as e:
+            print(f"  [ERROR] Failed to unpack payload: {e}")
+            return False
+    else:
+        # Fallback: create base structure
+        print("\n1. Bundled payload not found. Creating core skeleton...")
+        subdirs = [
+            "config", "agents", "workflows", "scripts", "templates",
+            "schemas", "references", "rules/active", "runs"
+        ]
+        for s in subdirs:
+            (torusguard_target / s).mkdir(parents=True, exist_ok=True)
+        print("  [WARN] Bare skeleton created; full assets should be pulled from repository.")
+
+    # 2. Ensure runs and rules/active directories exist
+    runs_dir = torusguard_target / "runs"
+    runs_dir.mkdir(parents=True, exist_ok=True)
+    gitkeep_runs = runs_dir / ".gitkeep"
+    if not gitkeep_runs.exists():
+        gitkeep_runs.write_text("", encoding="utf-8")
+
+    active_rules_dir = torusguard_target / "rules" / "active"
+    active_rules_dir.mkdir(parents=True, exist_ok=True)
+    gitkeep_rules = active_rules_dir / ".gitkeep"
+    if not gitkeep_rules.exists():
+        gitkeep_rules.write_text("", encoding="utf-8")
+
+    # 3. Stack Detection & Tailoring
+    print("\n2. Executing stack detection on target project...")
+    stack_detect_script = torusguard_target / "scripts" / "stack_detect.py"
+    detected_stack = {"language": "Unknown", "framework": "None", "data_layer": "None", "confidence": "Uncertain"}
+    
+    if stack_detect_script.exists():
+        try:
+            res = subprocess.run(
+                [sys.executable, str(stack_detect_script), str(target_root), "--json"],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            if res.returncode == 0 and res.stdout.strip():
+                detected_stack = json.loads(res.stdout)
+                print(f"  [DETECTED] Language:   {detected_stack.get('language')}")
+                print(f"  [DETECTED] Framework:  {detected_stack.get('framework')}")
+                print(f"  [DETECTED] Data Layer: {detected_stack.get('data_layer')}")
+        except Exception as e:
+            print(f"  [WARN] Stack detection encountered error: {e}")
+
+    # 4. Update torusguard.json configuration
+    config_file = torusguard_target / "config" / "torusguard.json"
+    if config_file.exists():
+        try:
+            with open(config_file, "r", encoding="utf-8") as f:
+                cfg = json.load(f)
+            cfg["detected_stack"] = {
+                "language": detected_stack.get("language"),
+                "framework": detected_stack.get("framework"),
+                "data_layer": detected_stack.get("data_layer")
+            }
+            with open(config_file, "w", encoding="utf-8") as f:
+                json.dump(cfg, f, indent=2)
+            print("  [SUCCESS] Configured .torusguard/config/torusguard.json")
+        except Exception as e:
+            print(f"  [WARN] Failed to write stack details to config: {e}")
+
+    # 5. Register Slash Commands for AI IDEs (.agent, .claude, .cursor)
+    print("\n3. Registering slash commands with AI IDE environments...")
+    registered_ides = []
+    tg_workflow_content = """---
+description: TorusGuard Autonomous Security Command Engine — run static security audits, authorized runtime web validation, governed remediation, and SARIF exports.
+version: 0.9.2
+tools: Read, Grep, Glob, Bash, Edit, Write
+agent: auditor
+---
+
+# /torusguard — Autonomous Application Security Guardrails
+
+$ARGUMENTS
+
+## Objective
+Execute TorusGuard security workflows across Python and TypeScript codebases.
+
+## Execution
+Parse the requested action from `$ARGUMENTS` (e.g. `audit`, `verify`, `web-validate`, `exploit-check`, `harden`, `apply`, `recheck`, `report`, `status`, `init`):
+1. **If action is omitted or 'status':** View `.torusguard/workflows/status.md` and report posture.
+2. **If action is specified:** Load the dedicated workflow from `.torusguard/workflows/<action>.md` and matching skill from `.torusguard/skills/torusguard-<action>/SKILL.md`.
+3. Follow the phase execution steps defined in the workflow.
+"""
+
+    # Ensure .agent/workflows and .agents/workflows are created
+    dest_workflow_dirs = []
+    if (target_root / ".agents").exists():
+        agents_wf = target_root / ".agents" / "workflows"
+        agents_wf.mkdir(parents=True, exist_ok=True)
+        (agents_wf / "torusguard.md").write_text(tg_workflow_content, encoding="utf-8")
+        dest_workflow_dirs.append(agents_wf)
+        registered_ides.append("Antigravity / Gemini (.agents/workflows/torusguard.md)")
+
+    agent_wf = target_root / ".agent" / "workflows"
+    agent_wf.mkdir(parents=True, exist_ok=True)
+    (agent_wf / "torusguard.md").write_text(tg_workflow_content, encoding="utf-8")
+    dest_workflow_dirs.append(agent_wf)
+    registered_ides.append("Antigravity / Tribunal (.agent/workflows/torusguard.md)")
+
+    # When full_commands is requested (e.g. via NPM package npx torusguard init),
+    # unlock and register all 11 individual slash commands (/torusguard-audit, /torusguard-harden, etc.)
+    if full_commands:
+        src_wf = torusguard_target / "workflows"
+        if src_wf.is_dir():
+            count = 0
+            for wf_file in src_wf.glob("*.md"):
+                if wf_file.name == "torusguard.md":
+                    continue
+                cmd_filename = f"torusguard-{wf_file.name}"
+                for d in dest_workflow_dirs:
+                    shutil.copy2(wf_file, d / cmd_filename)
+                count += 1
+            registered_ides.append(f"Unlocked {count} Individual Slash Commands (/torusguard-audit, /torusguard-apply, etc.)")
+
+    # Claude Code (.claude/commands)
+    claude_dir = target_root / ".claude"
+    if claude_dir.exists():
+        claude_commands = claude_dir / "commands"
+        claude_commands.mkdir(parents=True, exist_ok=True)
+        (claude_commands / "torusguard.md").write_text(tg_workflow_content, encoding="utf-8")
+        registered_ides.append("Claude Code (.claude/commands/torusguard.md)")
+
+    # Cursor (.cursor/rules)
+    cursor_dir = target_root / ".cursor"
+    if cursor_dir.exists():
+        cursor_rules = cursor_dir / "rules"
+        cursor_rules.mkdir(parents=True, exist_ok=True)
+        (cursor_rules / "torusguard.mdc").write_text(tg_workflow_content, encoding="utf-8")
+        registered_ides.append("Cursor (.cursor/rules/torusguard.mdc)")
+
+    # Windsurf (.windsurfrules)
+    if (target_root / ".windsurfrules").exists() or (target_root / ".windsurf").exists():
+        windsurf_rules = target_root / ".windsurfrules"
+        current_content = windsurf_rules.read_text(encoding="utf-8") if windsurf_rules.exists() else ""
+        if "TorusGuard" not in current_content:
+            windsurf_rules.write_text(current_content + "\n\n" + tg_workflow_content, encoding="utf-8")
+        registered_ides.append("Windsurf (.windsurfrules)")
+
+    # VS Code / GitHub Copilot (.github/copilot-instructions.md)
+    github_dir = target_root / ".github"
+    if github_dir.exists():
+        copilot_file = github_dir / "copilot-instructions.md"
+        current_content = copilot_file.read_text(encoding="utf-8") if copilot_file.exists() else ""
+        if "TorusGuard" not in current_content:
+            copilot_file.write_text(current_content + "\n\n# TorusGuard Security Instructions\n" + tg_workflow_content, encoding="utf-8")
+        registered_ides.append("VS Code / Copilot (.github/copilot-instructions.md)")
+
+    # Universal AGENTS.md (Kimi, Codex, Open Agent Standard)
+    agents_md = target_root / "AGENTS.md"
+    current_agents = agents_md.read_text(encoding="utf-8") if agents_md.exists() else ""
+    if "TorusGuard" not in current_agents:
+        agents_md.write_text(current_agents + ("\n\n" if current_agents else "") + "# TorusGuard Security Guardrails\n\nRun `/torusguard audit` to scan the codebase or refer to `.torusguard/` for security guidelines.\n", encoding="utf-8")
+        registered_ides.append("Universal Agent Standard (AGENTS.md for Kimi / Open Agents)")
+
+    for r in registered_ides:
+        print(f"  [REGISTERED] {r}")
+
+    print("\n================================================================================")
+    print("[SUCCESS] TORUSGUARD WORKSPACE SCAFFOLDED SUCCESSFULLY!")
+    print("================================================================================")
+    print(f"Workspace Path: {torusguard_target}")
+    print("\nNext Steps:")
+    print("  1. Run `/torusguard audit` in your AI IDE to scan the project.")
+    print("  2. Run `/torusguard status` to verify active security posture.")
+    print("================================================================================")
+    return True
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="TorusGuard Autonomous Workspace Bootstrapper")
+    parser.add_argument("--target", type=str, help="Target project root directory")
+    parser.add_argument("--force", action="store_true", help="Force overwrite existing workspace")
+    parser.add_argument("--full-commands", action="store_true", help="Unlock and register all 11 individual slash commands")
+    args = parser.parse_args()
+
+    success = scaffold_workspace(target_root=args.target, force=args.force, full_commands=args.full_commands)
+    sys.exit(0 if success else 1)

package/skills/torusguard/payload/.manifest.json

@@ -0,0 +1,95 @@
+{
+  "ARCHITECTURE.md": "0ecacc797932daaf95ccf5032c47f11550c9b6fe07cdfece5c075e11ec5e9cf7",
+  "TORUSGUARD.md": "c980b0ddd3778d5981f6c16c64015c60dc713b6f151fc531bc5681ecd770fb50",
+  "agents/auditor.md": "4ba2c92982823d0886c7ae369126cd5ddd322085a85d3b7e7fa23154f8753314",
+  "agents/profiler.md": "0ee9ebbddf4ebd557d454dda8472fffea471e263abeccf40298163084b7ce9a9",
+  "agents/remediator.md": "f708a0e315760e8d519bd640d22bdf6b7ec61ed7de3da69bd038bd60dc3d5b47",
+  "agents/reviewer.md": "69b280bb8a7b2fe425644d01a6f9cb454f9629f348782cd14968657076977c28",
+  "agents/validator.md": "79fc4431de5c5507f8730aee6c5c3e61fd238cbf8cf8c7c6aac462eee9761ed6",
+  "config/scope.json": "b198a86186b4c6d5e1af516bf4e3a6afa8878e622ca1d57a5bf72d294f8c6f25",
+  "config/slash-commands.json": "5390f0d26f8117a62e56c58147d3a0d2deab1a20956302b212703281d13fa84e",
+  "config/torusguard.json": "5f775da1f77aaffcd8173fac6a8f422ecc4d754627cb1f3c71d014dad299101d",
+  "references/django-security.md": "a15b7eb11b51dd1970d3d65544cf79ebea91fb99dc0e085e58a56532a718dce7",
+  "references/drf-security.md": "c7a7af3acaef895bf4798590acc88b3a2e9831a49eb2d23b4d8f31540ab264cc",
+  "references/express-security.md": "dff1db15e614d29d8c272f9da345b418077e62dc883fe210c7a50c552c76493f",
+  "references/fastapi-security.md": "933a08a3f096f70cb75c6a1e6d887c96a1613bb9f9def3904bb76e8c21cc7668",
+  "references/firebase-security.md": "11b1c51d530ff70230e2419475fceb9382f05c4334145366c66bb1304448f5b5",
+  "references/flask-security.md": "96d438980272f6fa95c825ef01baae55989c19618470b044dde1458a421a92f4",
+  "references/nextjs-security.md": "57f17d00ce24bf06d2826ab9d774177342ff892f6c9bc4193d6b65345d6c7661",
+  "references/react-vite-security.md": "d6468a6f623f02e58250a43327e27825b5dc7df34edf6ee27da2398bab94d6a4",
+  "references/sqlalchemy-security.md": "50421be1fba477721f9f1f5a877d4359420cf61ee9bda136e21998a3c1338e1c",
+  "references/supabase-security.md": "52a53aff66b3d94e5d07484f458252015ad3d713fa07162f59db89581ee597b6",
+  "rules/README.md": "a1b80344b0ca199a4917bdbd00463a8ae1459187f65467dbd627ce93a103042e",
+  "rules/TORUSGUARD.md": "fc7e0852ae0a92c45017f11dbc83c562b94ab957e7816d9903b95fb6849a9e5b",
+  "rules/active/TG-DIFF-001.md": "f67be0f2725eb23c3d11a8a7a4c29dcee648d3f9743e122a2197e8892f4da4de",
+  "rules/active/TG-DIFF-002.md": "1058cf5ba4e700176cf74eb55fb6304d320d3be5fdd011c5c61780d2a99c1a0e",
+  "rules/active/TG-DIFF-003.md": "0ffc0872ba4e0db9d087d5f2764d5d178401d2fab3cb1d129b387452ca489741",
+  "schemas/authorization.schema.json": "59af3c6038270e0bc3541a353b2a4a53b7f5d11a37e0012875d6a69c0f1d0bab",
+  "schemas/confidence.schema.json": "08b3a564d7370e123dd5bfadde9fb077d2954e36b523685b9e1d7bdd2aa4b8cb",
+  "schemas/evidence.schema.json": "d3dcaa10fd2420a4046ea68836fb836a55d003ada4cdc6682229f232881182bf",
+  "schemas/finding.schema.json": "e0a7c28fa4a5f84bdedb5cf5223da26348250d633479d2dbf7ce3ebd6790a852",
+  "schemas/provenance.schema.json": "781215801249532414643638b6608dc8f52febc9bca43ae03827b90aecc03256",
+  "schemas/remediation.schema.json": "217cb2743ae1a912dc074382e9f05634da93f2e30a880c03f6020600ef7e43d3",
+  "schemas/retest.schema.json": "773b764082f6d2e8c3656ea105e0ce09febd1020520bf262bbcd17f5924da11e",
+  "schemas/runtime-evidence.schema.json": "dbe13741a7fb68cca2a044d47a644ee0bdaacb83a28621dc2a98bffdd59989a6",
+  "scripts/diff_guard.py": "227bf56d2e6c9aef293a51ad1a3209782e6d9204dc1775956d372c3a6851a736",
+  "scripts/finding_scorer.py": "b78c6315f22000fb64f5d4e6ff1f3467439769d3d5507aaa99380453df4eb464",
+  "scripts/manifest_builder.py": "b759131592966053db17ef710dc5f313127a9583295cb867a39ab22a7c996580",
+  "scripts/monorepo_detector.py": "38f1eb948ee2856f175e1212956bce211effdd1327d3a31f7303d32ba9478ebe",
+  "scripts/run_manager.py": "e853874e4fb0cb697596ea338f71ba7e955f2b41a6fc649733b45fa755e94768",
+  "scripts/safety_gate.py": "3379b7534b2590cf563717a448983ad8ed7e8f174f0ad65683d33e8a10f51558",
+  "scripts/sarif_exporter.py": "35c66637413afc4b72d5bd426638447c77231d2a8594dce5addceffd4803a20d",
+  "scripts/stack_detect.py": "99b7bdf9829d58ff5b8c59afd6e8b6429bbb11d830ac73dec491101cbbc41574",
+  "skills/torusguard/SKILL.md": "70094a7ee80c3d827f9f9437effe3433fe0da53c0389f9ad28aed199a0e3f3d4",
+  "skills/torusguard/bootstrap.py": "7e348065a622089ab1d51e9bf4864e5b0022aaee1ccb2ecbf7057c14e792e2c7",
+  "skills/torusguard/references/auth-and-sessions.md": "34c2843f8c0dbe3574e54f00a39a92a1f431527ec5f69b2d64c84240d424a39e",
+  "skills/torusguard/references/business-logic-and-abuse.md": "0d6088936bc1a01023070332fccef0f2e0734358a5119379055f3d2895c22567",
+  "skills/torusguard/references/cache-and-sensitive-responses.md": "8f920cacde29c50b1f5f98de341a60db0bc607fe8c212a7e618ef7af08c86511",
+  "skills/torusguard/references/client-code-exposure.md": "1810b18c3b89a25d3f5ef9bc53a721b9d05179bcd2086d6679ad1f29f5403bb9",
+  "skills/torusguard/references/csrf-and-cross-origin.md": "1bab49feee1f31fa6b280ddba893fe5ffa0c3c9ac0a46fc4d6c96c1206b32204",
+  "skills/torusguard/references/dependency-and-supply-chain.md": "3b429214af8d1271f5e6dc24ac5ecc9a7bdaff6116a96dc60a89a2057d8d1d2a",
+  "skills/torusguard/references/django-security.md": "a15b7eb11b51dd1970d3d65544cf79ebea91fb99dc0e085e58a56532a718dce7",
+  "skills/torusguard/references/drf-security.md": "c7a7af3acaef895bf4798590acc88b3a2e9831a49eb2d23b4d8f31540ab264cc",
+  "skills/torusguard/references/fastapi-security.md": "933a08a3f096f70cb75c6a1e6d887c96a1613bb9f9def3904bb76e8c21cc7668",
+  "skills/torusguard/references/flask-security.md": "96d438980272f6fa95c825ef01baae55989c19618470b044dde1458a421a92f4",
+  "skills/torusguard/references/frontend-no-db.md": "a543c8107605777a16a0abfd5ebbaca6f216ac50f078a8c3ef485a5afe6bfdca",
+  "skills/torusguard/references/graphql-security.md": "486e7a54e9ad677ff6d08016f0d4e1f173ccbba5c89e7e806a7097e3265442cd",
+  "skills/torusguard/references/input-and-injection.md": "e632ab3031088f3f13be826886430ea7f0abf02922e29c26507f3c234c00f00d",
+  "skills/torusguard/references/mass-assignment-and-property-auth.md": "fcddd881573c1bc8fc703a796b1ddc9ba9bd8e0cc0d51d8e9a59e79cc9a5ebd9",
+  "skills/torusguard/references/platform-hardening.md": "c58d1a86536cbaeb548d8cfeaa298e3662a4367854512858bbf594735dc6f717",
+  "skills/torusguard/references/python-dependencies.md": "34969226665d60d22e658a1801cb6857a56ea669859abcf617a8b985a26f952d",
+  "skills/torusguard/references/python-security-overview.md": "2165747d64b86b12a744ee4f21ea918678bd6a179793a37bd02b2c0953190a9b",
+  "skills/torusguard/references/rate-limit-and-abuse.md": "77c5c982d9e28d7e3c1871172bdbfe76542e356d97f2197f5df0a4f56405bc21",
+  "skills/torusguard/references/secrets-and-config.md": "9abe5fe9e6556a2ffc1460876e9c98f6eacf683cd0d8a7dba82eaeef825133c6",
+  "skills/torusguard/references/sqlalchemy-security.md": "50421be1fba477721f9f1f5a877d4359420cf61ee9bda136e21998a3c1338e1c",
+  "skills/torusguard/references/ssrf-and-outbound-requests.md": "31c6c69ba14ca4a1fb866654f6c89a5c8edd636724c9d349be94c160c976749c",
+  "skills/torusguard/references/webhook-security.md": "a0c7efb663c664dd840ba99b689cb67d4688643106f8b6e80d18a424c6add386",
+  "skills/torusguard/references/websocket-security.md": "5624a84abd75bbb4eed029cd217e0c794ee452cbecc0730a8ab4d0f371537cd7",
+  "skills/torusguard-apply/SKILL.md": "9436fa5cdefa661677ada22936a3949de06aca276e4f4bb27e0ef5b7ea34edc3",
+  "skills/torusguard-audit/SKILL.md": "d0e0c21d6c36d9d128ccce6ad628b978ff771d27552ba80e0a4981e18b9f5a51",
+  "skills/torusguard-authorize/SKILL.md": "da849585f2e46c08ef528b89737be14647f1109fd365fd27f3f6da57a396724b",
+  "skills/torusguard-exploit-check/SKILL.md": "e9a173e154a88cc9cb929c59d79a65ab13d5cf9567b4112bd7f272746cf9c3f9",
+  "skills/torusguard-full/SKILL.md": "cc97684d37de378e51fefd12f6f9a7cd15cc469ce46079a0599440aa7b073f7b",
+  "skills/torusguard-harden/SKILL.md": "86a8dee6c614477e2122287752f5c16e3688c0451d0e7ae9bfd2a23802bcdde3",
+  "skills/torusguard-init/SKILL.md": "1f7844d66219955581fdb266029eefdc355dbebb5741b848daf0062e606202a2",
+  "skills/torusguard-recheck/SKILL.md": "4725a9be6a6ddedb3d389d1957c7ce3e0f9ce288107816fce85b5953951e13e5",
+  "skills/torusguard-report/SKILL.md": "bde44d114bdc85c04472644a644a7796ed2f182a23e0c057838a3251e4910a09",
+  "skills/torusguard-status/SKILL.md": "4e71d03c71b240afd7f6108569530b7da3702634c512a74ca8dc3174f3c6b0fb",
+  "skills/torusguard-verify/SKILL.md": "10c19e0926255686351e3b75ae774880cf35562d42bd30b87a877bb8f284fc1f",
+  "skills/torusguard-web-validate/SKILL.md": "0d159f0d75f06ca97f64a52f3e414c873f8bb84b87a8230693237cde302e76ac",
+  "templates/audit-report.template.md": "71149dd05b01a74287a47781fdc71fd2d1b4b70337da303bf78767d0410a6c90",
+  "templates/authorization.template.md": "81ef843d42a19412c369f383b787465ac24173c0b14c1f5f211786eab3d10e8b",
+  "templates/finding-card.template.md": "8f756edbd3e4139d3da2fb96f35bd2d2b267b33b754f187b590a89584265c1e6",
+  "templates/remediation-bundle.template.md": "4d85a540e3a2e74f9b21fc8a2a1072e27ca03e97cd67ca482f529cfe722acc4d",
+  "workflows/apply.md": "ca7fe662f5af462d036d17ecc7e82ab8a08e1989325e9e037df6364af96e2706",
+  "workflows/audit.md": "d924b7c02d7a380c68e5c8faa69103194b098119e34c5b427585eec66f8081ca",
+  "workflows/authorize.md": "a797addf98eb0cf29acbc9dc8f21f0d61ea93cc83255379d4722ab5ce86a4c29",
+  "workflows/exploit-check.md": "9684009b835a61d5aca8827a971ee686a24c800425d86ef96f963dd27de845b8",
+  "workflows/harden.md": "509484f844c9dcd10dd14c8bb6e3456021928e6cf6abd374faaf34be8fc34ce2",
+  "workflows/init.md": "3d1668a9f6b87417c31f47c887c495f863595ed4a29074e0c5a8ee1ece1d4a35",
+  "workflows/recheck.md": "7d374c29a5585c31b81f84fb32d6a466f2e9cb339726dc0523dba25e57bc5d13",
+  "workflows/report.md": "56b3449cff362172c63093ee6150446d11bf05e3c8143661966dad9d42df1470",
+  "workflows/status.md": "921129646518c592cb47ad8e8ccf3d703e8d11ea6eb89bd21a206f545e022dba",
+  "workflows/verify.md": "e1041c38e8ada59788f66ac1bc754313a4c966c36f4c13aa6d9d9a2b90d9e06c",
+  "workflows/web-validate.md": "d3db1fea264cd89addffbc227d8452987b050e533993c394d537f50c177224d4"
+}

package/skills/torusguard/payload/ARCHITECTURE.md

@@ -0,0 +1,168 @@
+# 🛡️ TorusGuard Security Kit v0.9.1 — System Architecture
+
+TorusGuard works natively in **Antigravity**, **Cursor**, **Windsurf**, **Claude Code**, **Cline**, and any AI IDE or coding assistant that indexes workspace security guardrails.
+
+---
+
+## 1. System Flow & Execution Lifecycle
+
+Every security operation, static scan, runtime probe, and remediation patch progresses through an auditable, deterministic 7-stage closed-loop pipeline:
+
+```mermaid
+flowchart TD
+    A["User Request / Slash Command"] --> B{"Classify Action"}
+    
+    B -->|/torusguard init| C["Phase 0: Baseline Discovery"]
+    B -->|/torusguard authorize| D["Phase 1: Legal Scope Gate"]
+    B -->|/torusguard audit| E["Phase 2: Static Scan & Cluster"]
+    B -->|/torusguard verify| F["Phase 3a: Evidence Verification"]
+    B -->|/torusguard web-validate| G["Phase 3b: Runtime Probing"]
+    B -->|/torusguard exploit-check| H["Phase 3c: Exploitability Check"]
+    B -->|/torusguard harden| I["Phase 4: Remediation Bundles"]
+    B -->|/torusguard apply| J["Phase 5: Governed Patch Apply"]
+    B -->|/torusguard recheck| K["Phase 6: Regression Re-scan"]
+    B -->|/torusguard report| L["Phase 7: Report & SARIF Export"]
+    B -->|/torusguard status| M["Diagnostic Overview"]
+    B -->|/torusguard full| N["End-to-End Orchestrator"]
+
+    C --> C1["Detect Stack & Activate TG-* Rules"]
+    D --> D1["Validate Ownership & Write scope.json"]
+    E --> E1["AST Matching + Line Hash Fingerprints + Root-Cause Clustering"]
+    
+    E1 --> F1{"Confidence Score"}
+    F1 -->|Medium / High| G1{"Authorized for Runtime?"}
+    G1 -->|Yes| G
+    G1 -->|No| I
+    
+    G --> H1["Redact Tokens & Capture Replay Trace"]
+    H --> H2["Update Confidence with Runtime Verdict"]
+    H2 --> I
+    
+    I --> I1["Enforce Ponytail Limits (<=35 add, <=25 del)"]
+    I1 --> I2{"Human Gate Review"}
+    I2 -->|Approved| J
+    I2 -->|Rejected / Revised| I
+    
+    J --> J1["Save Pre-Apply Snapshot & Apply Surgical Diffs"]
+    J1 --> K
+    
+    K --> K1{"Classify Outcome"}
+    K1 -->|Fixed| L
+    K1 -->|Partially Fixed| I
+    K1 -->|Regression| J2["Rollback Snapshot & Alert"]
+    
+    L --> L1["Emit summary.md + OASIS SARIF v2.1.0"]
+```
+
+---
+
+## 2. Decoupled Specialist Skills & Lazy Routing
+
+TorusGuard enforces **strict context budget discipline**. Rather than dumping monolithic rules into the LLM context, each task routes to an atomic specialist skill:
+
+- **Startup Overhead**: ~50–150 tokens per specialized task vs 85,000+ tokens for full-repo manual review.
+- **Zero Hallucination Grounding**: Every specialist skill embeds its own execution steps, safety constraints, and scoring models inline.
+- **Lazy Resolution**: The root `torusguard` router intercepts commands and loads exclusively the matching specialist file.
+
+| Specialist Skill | Agent Role | Focus Area | Context Budget |
+| :--- | :--- | :--- | :---: |
+| `torusguard-init` | `profiler` | Framework & data layer discovery | 120 lines |
+| `torusguard-authorize` | `reviewer` | Ownership confirmation & scope limits | 94 lines |
+| `torusguard-audit` | `auditor` | Static AST scanning & root-cause clustering | 150 lines |
+| `torusguard-verify` | `validator` | Fresh disk state check & score computation | 90 lines |
+| `torusguard-web-validate`| `validator` | Bounded HTTP probing & token redaction | 124 lines |
+| `torusguard-exploit-check`| `validator` | Safe canary verification for SQLi/XSS/SSRF | 100 lines |
+| `torusguard-harden` | `remediator` | Ponytail-bounded remediation bundles | 105 lines |
+| `torusguard-apply` | `remediator` | Pre-apply snapshots & surgical application | 71 lines |
+| `torusguard-recheck` | `reviewer` | Differential regression detection | 89 lines |
+| `torusguard-report` | `reviewer` | Executive posture & OASIS SARIF v2.1.0 | 102 lines |
+| `torusguard-status` | *System* | Read-only configuration & history ledger | 80 lines |
+| `torusguard-full` | *All Roles* | 7-stage master pipeline orchestrator | 165 lines |
+
+---
+
+## 3. Authority Separation & Role Handoff Contracts
+
+To prevent self-confirming bias, security responsibilities are divided across 5 formal roles:
+
+1. **Profiler (`profiler.md`)**:
+   - Discovers project languages, frameworks, dependency manifests, and database layers.
+   - *Authority Boundary*: Read-only inspection; never alters source code.
+2. **Auditor (`auditor.md`)**:
+   - Scans source ASTs, computes line-shift invariant fingerprints, groups findings by root-cause cluster, and scores initial confidence.
+   - *Authority Boundary*: Read-only; cannot mark findings as "Confirmed" without exact AST source citations.
+3. **Validator (`validator.md`)**:
+   - Executes authorized runtime HTTP probes, performs safe canary checks, redacts secrets, and assigns exploitability verdicts.
+   - *Authority Boundary*: Bound strictly by `scope.json`; cannot execute destructive write mutations.
+4. **Remediator (`remediator.md`)**:
+   - Packages minimal unified diffs constrained by Ponytail Protocol bounds and applies governed patches.
+   - *Authority Boundary*: Must obtain Human Gate approval before disk modification; must save pre-apply snapshots.
+5. **Reviewer (`reviewer.md`)**:
+   - Re-scans modified files to verify fix integrity, audits evidence sufficiency, detects regressions, and exports SARIF logs.
+   - *Authority Boundary*: Independent audit of remediator outputs; cannot apply code modifications.
+
+---
+
+## 4. Governance & Safety Enforcement
+
+### The Ponytail Protocol
+```
+┌────────────────────────────────────────────────────────┐
+│               PONYTAIL PROTOCOL BOUNDS                 │
+├────────────────────────────────────────────────────────┤
+│ • Additions: <= 35 lines per bundle                    │
+│ • Deletions: <= 25 lines per bundle                    │
+│ • Zero full-file rewrites                              │
+│ • Preserve all existing tenant isolation & auth checks │
+│ • Preserve all existing logging & error handling       │
+└────────────────────────────────────────────────────────┘
+```
+Any remediation exceeding these thresholds is partitioned into sequential atomic sub-bundles or flagged as `Requires Manual Architectural Refactor`.
+
+### Universal Safety Constraints
+- **Folder-Per-Run Isolation**: All logs, findings, bundles, and reports are saved to `.torusguard/runs/<run-id>/`. The project root is never polluted.
+- **Rollback Assurance**: A byte-for-byte pre-apply snapshot is archived in `patches/<bundle-id>/pre_apply/` prior to any code edit.
+- **Credential Redaction**: Raw secrets, Bearer JWTs, and database credentials are automatically redacted with SHA-256 prefix digests before disk persistence.
+
+---
+
+## 5. Objective 0–100 Confidence Scoring Rubric
+
+Finding confidence is scored objectively across 5 verifiable factors:
+
+| Dimension | Max Points | Criteria |
+| :--- | :---: | :--- |
+| **Evidence Quality** | **35** | Exact AST match (35) · Regex pattern (20) · Indirect indicator (10) |
+| **Reproduction Success** | **25** | Deterministic test reproduction (25) · Partial trace (15) · Static only (0) |
+| **Independent Confirmations** | **15** | Corroborated in 3+ files (15) · 2 files (10) · Single file (5) |
+| **Environmental Clarity** | **15** | Direct route mapping (15) · Minor ambiguity (8) · Complex unknown proxy (0) |
+| **Manual Review Status** | **10** | Security engineer verified (10) · Secondary agent consensus (5) · Unreviewed (0) |
+
+- **`90–100` (`Confirmed`)**: Indisputable proof with code citation or deterministic trace.
+- **`70–89` (`High Confidence`)**: Strong direct indicators; prioritized remediation.
+- **`50–69` (`Medium Confidence`)**: Probable flaw; runtime confirmation recommended.
+- **`< 50` (`Needs Review`)**: Architectural ambiguity or potential delegated control.
+
+---
+
+## 6. Directory Topology
+
+```text
+.torusguard/
+├── TORUSGUARD.md                      # Master always-on security rules
+├── ARCHITECTURE.md                    # System architecture & lifecycle blueprint
+├── .manifest.json                     # Cryptographic SHA-256 integrity ledger
+├── config/                            # Project configuration & command registry
+├── agents/                            # 5 Specialist AI Agent definitions
+├── workflows/                         # 11 Slash command execution guides
+├── scripts/                           # 5 Pure Python automation utilities
+├── skills/                            # Mirrored specialist skills
+├── templates/                         # 4 Standard Markdown report templates
+├── schemas/                           # 9 Validated JSON Schemas
+├── references/                        # 10 Framework security reference guides
+├── rules/                             # Rule taxonomy & active tailored rules
+│   ├── active/                        # Project-tailored rules
+│   ├── README.md                      # Rule catalog & guide
+│   └── TORUSGUARD.md                  # Dual-path master rules copy
+└── runs/                              # Execution artifacts directory (gitignored)
+```