torusguard 0.9.2

package/skills/torusguard/payload/workflows/authorize.md

@@ -0,0 +1,95 @@
+---
+description: Legal scope definition, target ownership proof verification, and safety boundary enforcement for runtime validation.
+tools: Read, Grep, Glob, Bash, Write
+version: 0.9.2
+agent: reviewer
+lifecycle-phase: Phase 1 (Authorization Gate)
+required-skills:
+  - torusguard-authorize
+scripts-binding:
+  - .torusguard/scripts/safety_gate.py
+---
+
+# /torusguard authorize — Legal Scope & Safety Gate
+
+$ARGUMENTS
+
+---
+
+## Objective
+Legal scope definition, target ownership proof verification, and safety boundary enforcement.
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect authorization parameters and environment safety before executing:
+1. **Config Record (`.torusguard/config/torusguard.json`):** Assert repository is initialized.
+2. **Current Scope (`.torusguard/config/scope.json`):** Inspect active allowed targets, paths, and TTL expiry.
+3. **Environment Classification:** Assert target is local or staging (`localhost`, `127.0.0.1`, `*.local`, `*.staging.*`). Production targets require explicit approval.
+4. **Destructive Guard:** Ensure state-changing operations (`DELETE`, bulk drops) remain blocked by default.
+5. **Ownership Proof:** Verify target ownership token or local process binding.
+6. **TTL Window:** Ensure authorization window does not exceed 24 hours.
+
+---
+
+## When to Use /torusguard authorize
+
+| Trigger Scenario | Recommended Action |
+| :--- | :--- |
+| Preparing for live HTTP probes or API validation | Run `/torusguard authorize` |
+| Updating allowed hosts, path prefixes, or rate limits | Run `/torusguard authorize` |
+| Static-only security audit | Skip authorize; run `/torusguard audit` |
+| Checking active legal scope status | Run `/torusguard status` |
+| Expired authorization window | Re-run `/torusguard authorize` |
+
+---
+
+## Execution Steps
+
+1. **Capture Scope Parameters:** Collect target URL, allowed paths, forbidden prefixes, and max request budget.
+2. **Validate Host Ownership:** Verify target is local or matches authorized test domains.
+3. **Invoke Safety Gate:**
+   ```bash
+   python .torusguard/scripts/safety_gate.py check --url <target_url>
+   ```
+4. **Write Scope File (`.torusguard/config/scope.json`):** Save authorized targets, valid TTL timestamp, and request rate caps.
+5. **Confirm Scope Binding:** Verify `.torusguard/config/scope.json` parses as valid JSON against schema.
+
+---
+
+## Failure Recovery
+
+- **Unreachable Host:** Verify local server is running on the specified port.
+- **Production Target Warning:** If target resolves to an external production host, halt and request operator override.
+- **Malformed JSON:** Re-initialize `scope.json` from `.torusguard/schemas/auth-boundary.schema.json`.
+- **Halt Trigger:** Abort immediately if user provides wildcard target (`*`) or third-party domain.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never proceed with runtime probing without an explicit, valid `.torusguard/config/scope.json`.
+- ❌ Never authorize destructive HTTP methods (`DELETE`, `DROP`) under default non-destructive policy.
+- ✅ Always validate targets through `.torusguard/scripts/safety_gate.py`.
+
+---
+
+## Output Card Format
+
+```markdown
+### 🔒 TorusGuard Authorization Gate
+- **Target URL:** [Target Host or URL]
+- **Environment:** [Localhost / Staging / Container]
+- **Allowed Paths:** [Path prefixes or all authorized]
+- **Rate Limit:** [Max requests / concurrency limit]
+- **Scope File:** `.torusguard/config/scope.json`
+- **Status:** AUTHORIZED — ready for `/torusguard web-validate`
+```
+
+---
+
+## Next Steps
+
+1. Run `/torusguard audit` to scan codebase for AST security vulnerabilities.
+2. Run `/torusguard web-validate` to begin safe, authorized endpoint validation.

package/skills/torusguard/payload/workflows/exploit-check.md

@@ -0,0 +1,97 @@
+---
+description: Safe, bounded, single-step exploitability confirmation across 5 standard verification statuses.
+tools: Read, Grep, Glob, Bash, Write
+version: 0.9.2
+agent: validator
+lifecycle-phase: Phase 3c (Exploitability Check)
+required-skills:
+  - torusguard-exploit-check
+scripts-binding:
+  - .torusguard/scripts/safety_gate.py
+  - .torusguard/scripts/finding_scorer.py
+---
+
+# /torusguard exploit-check — Bounded Exploitability Confirmation
+
+$ARGUMENTS
+
+---
+
+## Objective
+Safe, bounded, single-step exploitability confirmation across 5 standard verification statuses.
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect authorization parameters and probe safety constraints:
+1. **Scope Check (`scope.json`):** Assert endpoint is authorized.
+2. **Approved Probes:** Use benign canaries (SQLi math, HTML marker, unauth read).
+3. **Destructive Ban:** Strictly prohibit drops, DOS, or weaponized payloads.
+4. **Safety Gate:** Verify probe with `safety_gate.py` prior to dispatch.
+5. **Bound:** Limit to single non-destructive HTTP request per finding.
+6. **Audit Trail:** Inject `X-TorusGuard-AuthID` header on all outbound requests.
+
+---
+
+## When to Use /torusguard exploit-check
+
+| Trigger Scenario | Recommended Action |
+| :--- | :--- |
+| Confirming whether a flaw is practically exploitable | Run `/torusguard exploit-check` |
+| Upgrading Medium confidence finding to Confirmed | Run `/torusguard exploit-check` |
+| Verifying IDOR or tenant isolation boundaries | Run `/torusguard exploit-check` |
+| Routine endpoint header inspection | Run `/torusguard web-validate` |
+| Applying approved remediation patch | Run `/torusguard apply` |
+
+---
+
+## Execution Steps
+
+1. **Verify Authorization Scope:** Confirm target host and route in `scope.json`.
+2. **Select Safe Canary:** Choose inert mathematical sentinel or unauth GET.
+3. **Validate With Safety Gate:**
+   ```bash
+   python .torusguard/scripts/safety_gate.py check --url <target_url> --payload <canary>
+   ```
+4. **Dispatch Bounded Single Probe:** Send request with header `X-TorusGuard-AuthID`.
+5. **Classify Status:** Evaluate response against 5 outcomes: `Confirmed`, `Needs Review`, `Not Reproducible`, `Blocked by Controls`, `Out of Scope`.
+6. **Emit Artifacts:** Write `exploit-check.md` and update `findings.json`.
+
+---
+
+## Failure Recovery
+
+- **Connection Refused:** Verify target server is running locally on port.
+- **Safety Gate Block:** If `Manual Only`, halt automated probe and request human review.
+- **Ambiguous Response:** Mark finding as `Needs Review`; never assume exploit without proof.
+- **Halt Trigger:** Abort if probe causes server 500 error or unexpected crash.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never classify a vulnerability as `Confirmed` without direct sentinel reflection.
+- ❌ Never execute brute force attacks or automated password spraying.
+- ✅ Always provide reproducible curl commands with redacted credentials.
+
+---
+
+## Output Card Format
+
+```markdown
+### 🎯 TorusGuard Exploitability Confirmation
+- **Target Route:** `[METHOD] /path`
+- **Finding ID:** `TG-XXX-HASH`
+- **Canary Used:** [Inert Math Sentinel / Unauth Read]
+- **Status:** [Confirmed / Not Reproducible / Blocked]
+- **Evidence:** [Response snippet demonstrating leak or block]
+- **Replay Curl:** `curl -X [METHOD] http://localhost:PORT/path ...`
+```
+
+---
+
+## Next Steps
+
+1. Run `/torusguard harden` to formulate surgical patch bundles for confirmed flaws.
+2. Run `/torusguard report` to export findings into SARIF v2.1.0 format.

package/skills/torusguard/payload/workflows/harden.md

@@ -0,0 +1,93 @@
+---
+description: Governed remediation formulation under strict Ponytail Protocol bounds (<= 35 additions, <= 25 deletions) and bundle packaging.
+tools: Read, Grep, Glob, Bash, Write
+version: 0.9.2
+agent: remediator
+lifecycle-phase: Phase 4 (Remediation Formulation)
+required-skills:
+  - torusguard-harden
+scripts-binding:
+  - .torusguard/scripts/run_manager.py
+  - .torusguard/scripts/diff_guard.py
+---
+
+# /torusguard harden — Governed Remediation & Bundle Packaging
+
+$ARGUMENTS
+
+---
+
+## Objective
+Governed remediation formulation under strict Ponytail Protocol bounds (<=35 add, <=25 del).
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect finding targets and patch constraints before generating diffs:
+1. **Target Finding (`findings.md`):** Identify prioritized verified findings.
+2. **Ponytail Protocol:** Enforce hard limit ($\le 35$ additions, $\le 25$ deletions). Ban rewrites.
+3. **Sensitive Path Review:** Flag changes touching `auth/` or `settings.py` for human sign-off.
+4. **Behavior Preservation:** Ensure patch addresses flaw without breaking public APIs.
+5. **Dry-Run Rule:** Do NOT apply changes to disk during harden; emit bundle for review.
+6. **Backup Readiness:** Ensure rollback procedures are prepared before staging patch.
+
+---
+
+## When to Use /torusguard harden
+
+| Trigger Scenario | Recommended Action |
+| :--- | :--- |
+| Formulating minimal patches for verified findings | Run `/torusguard harden` |
+| Packaging a 4-artifact remediation bundle for review | Run `/torusguard harden` |
+| Writing and applying changes to code files | Run `/torusguard apply` |
+| Differentially re-scanning code after patch application | Run `/torusguard recheck` |
+| Discovering new vulnerabilities | Run `/torusguard audit` |
+
+---
+
+## Execution Steps
+
+1. **Select Target Finding:** Choose verified flaw from active run directory.
+2. **Examine Live Code Context:** Read surrounding lines (±15) of vulnerable sink.
+3. **Draft Unified Diff:** Formulate minimal fix adhering to Ponytail Protocol limits.
+4. **Audit Patch Safety:** Run `python .torusguard/scripts/diff_guard.py <patch.diff>`.
+5. **Package 4-Artifact Bundle:** Write `patch.diff`, `plan.md`, `verification.md`, `rollback.md` to `.torusguard/runs/<run_id>/remediation/<finding_id>/`.
+
+---
+
+## Failure Recovery
+
+- **Line Churn Exceeded (>35 add or >25 del):** Decompose patch into smaller sequential sub-fixes.
+- **Sensitive Path Conflict:** Mark bundle with `Requires Sensitive-Path Sign-Off` in `plan.md`.
+- **Finding Not Found:** Ensure finding ID exists in active `findings.md`.
+- **Halt Trigger:** Abort if target source file cannot be read from disk.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never generate full-file replacements or unconstrained cosmetic code refactoring.
+- ❌ Never modify imports, variables, or functions unrelated to the vulnerability.
+- ✅ Always calculate addition and deletion line counts before emitting `patch.diff`.
+
+---
+
+## Output Card Format
+
+```markdown
+### 🛠️ TorusGuard Remediation Bundle
+- **Finding Target:** `TG-XXX-HASH` ([Vulnerability Name])
+- **File Affected:** `src/path/to/file.py`
+- **Line Churn:** +[Additions] / -[Deletions] (Ponytail: PASS)
+- **Sensitive Path:** [Yes (Sign-Off Needed) / No (Standard)]
+- **Bundle Path:** `.torusguard/runs/<run_id>/remediation/<finding_id>/`
+- **Status:** READY FOR REVIEW — run `/torusguard apply` to execute
+```
+
+---
+
+## Next Steps
+
+1. Review proposed diff in `.torusguard/runs/<run_id>/remediation/<finding_id>/patch.diff`.
+2. Run `/torusguard apply` to execute the governed patch with automatic rollback backup.

package/skills/torusguard/payload/workflows/init.md

@@ -0,0 +1,95 @@
+---
+description: Baseline project discovery, workspace scaffolding, stack detection, and framework-tailored security rule activation.
+tools: Read, Grep, Glob, Bash, Write
+version: 0.9.2
+agent: profiler
+lifecycle-phase: Phase 0 (Baseline Setup)
+required-skills:
+  - torusguard-init
+scripts-binding:
+  - .torusguard/scripts/stack_detect.py
+---
+
+# /torusguard init — Project Baseline & Workspace Initialization
+
+$ARGUMENTS
+
+---
+
+## Objective
+Baseline project discovery, workspace scaffolding, stack detection, and security rule activation.
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect workspace state before running initialization:
+1. **Config State (`.torusguard/config/torusguard.json`):** Check if workspace is already initialized. If active, prompt before re-writing.
+2. **Project Manifests:** Check root for `package.json`, `manage.py`, `requirements.txt`, `pyproject.toml`, `go.mod`, or `Cargo.toml`.
+3. **Disclosure Policy (`SECURITY.md`):** Check for existing responsible disclosure policy.
+4. **Bootstrapper:** If `.torusguard/` is absent, invoke `python skills/torusguard/bootstrap.py` to unpack offline assets.
+5. **Runtime Preconditions:** Ensure Python 3.10+ is available in the current execution shell.
+
+---
+
+## When to Use /torusguard init
+
+| Trigger Scenario | Recommended Command |
+| :--- | :--- |
+| First-time onboarding in any repository | Run `/torusguard init` |
+| Framework upgrade or major dependency changes | Run `/torusguard init` to refresh tailored rules |
+| Repository already configured | Run `/torusguard audit` |
+| Inspecting existing configuration | Run `/torusguard status` |
+| Testing legal boundaries | Run `/torusguard authorize` |
+
+---
+
+## Execution Steps
+
+1. **Scaffold Directory Topology:** Verify `.torusguard/` structure (`config/`, `rules/active/`, `runs/`, `scripts/`, `workflows/`, `templates/`, `schemas/`).
+2. **Execute Stack Detection:**
+   ```bash
+   python .torusguard/scripts/stack_detect.py .
+   ```
+3. **Activate Tailored Rules:** Symlink or copy matching security rules from `.torusguard/rules/` into `.torusguard/rules/active/`.
+4. **Write Configuration (`.torusguard/config/torusguard.json`):**
+   Record detected stack, enabled rules count, timestamp, and runtime constraints.
+5. **Verify Initialization:** Assert `.torusguard/config/torusguard.json` and `.torusguard/config/scope.json` exist.
+
+---
+
+## Failure Recovery
+
+- **Script Exit 1 (Detection Failed):** Check Python version (`python --version` >= 3.10) and verify read access to root manifests.
+- **Permission Error:** Verify write permissions for `.torusguard/config/` and `.torusguard/rules/active/`.
+- **Missing Directories:** Re-run directory scaffolding if any subfolder creation fails.
+- **Halt Condition:** If root directory is empty, halt and prompt user to open the project root.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never invent framework dependencies not present in `package.json` or `requirements.txt`.
+- ❌ Never overwrite an existing `.torusguard/config/scope.json` containing authorized domains.
+- ✅ Always execute `.torusguard/scripts/stack_detect.py` to ground detected technologies.
+
+---
+
+## Output Card Format
+
+```markdown
+### 🛡️ TorusGuard Workspace Initialization
+- **Primary Framework:** [Detected Stack or None]
+- **Components:** [Backend / Frontend / Database]
+- **Active Rules:** [Count] rules enabled in `.torusguard/rules/active/`
+- **Config:** `.torusguard/config/torusguard.json` generated
+- **Scope Template:** `.torusguard/config/scope.json` ready
+- **Status:** READY — run `/torusguard audit` to scan codebase
+```
+
+---
+
+## Next Steps
+
+1. Run `/torusguard authorize` to define allowed target URLs and legal scan boundaries.
+2. Run `/torusguard audit` to execute the baseline static security audit.

package/skills/torusguard/payload/workflows/recheck.md

@@ -0,0 +1,95 @@
+---
+description: Targeted differential AST re-scan, fix closure verification, and regression state machine transitions.
+tools: Read, Grep, Glob, Bash, Write
+version: 0.9.2
+agent: reviewer
+lifecycle-phase: Phase 6 (Targeted Recheck & Verification)
+required-skills:
+  - torusguard-recheck
+scripts-binding:
+  - .torusguard/scripts/run_manager.py
+  - .torusguard/scripts/finding_scorer.py
+---
+
+# /torusguard recheck — Targeted Differential Recheck & Regression Audit
+
+$ARGUMENTS
+
+---
+
+## Objective
+Targeted differential AST re-scan, fix closure verification, and regression state transitions.
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect applied patch history and target file scope before re-checking:
+1. **Applied Patch Record:** Verify `apply-log.json` or modified file list exists in the active run.
+2. **Scope Limitation:** Restrict differential scan strictly to modified files to conserve token budget.
+3. **Rollback Availability:** Confirm `.bak` snapshot exists in `pre_apply/` in case regression is detected.
+4. **4-State Transition Engine:** Prepare to transition findings to `Fixed`, `Partially Fixed`, `Not Fixed`, or `Regression`.
+5. **Fresh Syntax Validation:** Ensure no compiler or syntax errors exist before re-evaluating rules.
+6. **AST Consistency:** Ensure imported dependencies on modified lines resolve correctly.
+
+---
+
+## When to Use /torusguard recheck
+
+| Trigger Scenario | Recommended Action |
+| :--- | :--- |
+| Immediately after applying a remediation patch | Run `/torusguard recheck` |
+| Verifying that a specific finding is eliminated | Run `/torusguard recheck` |
+| Checking whether a patch introduced new security flaws | Run `/torusguard recheck` |
+| Whole repository baseline audit | Run `/torusguard audit` |
+| Generating final signed release report | Run `/torusguard report` |
+
+---
+
+## Execution Steps
+
+1. **Identify Modified Files:** Extract list of altered files from latest apply step.
+2. **Execute Differential AST Scan:** Re-run active security rules exclusively against modified files.
+3. **Evaluate Finding Status:**
+   - If original vulnerable AST pattern is absent and no new sink appears: transition to `Fixed`.
+   - If new security rule triggers on altered lines: classify as `Regression`.
+4. **Update Finding State:** Record verified resolution status into `findings.json`.
+5. **Emit Recheck Report:** Write `recheck-report.md` into the active run folder.
+
+---
+
+## Failure Recovery
+
+- **Finding Still Present (`Not Fixed`):** Review patch diff; the remediation did not neutralize the AST sink.
+- **New Vulnerability Detected (`Regression`):** Alert operator; prompt to revert from `.bak` snapshot.
+- **File Not Found:** Verify file path matches git repository layout.
+- **Halt Trigger:** Abort if diff shows changes outside approved patch scope.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never mark a finding as `Fixed` without re-scanning the actual AST of the patched file.
+- ❌ Never ignore new warnings introduced in modified lines.
+- ✅ Always provide before/after line comparisons confirming sink removal.
+
+---
+
+## Output Card Format
+
+```markdown
+### ✅ TorusGuard Differential Recheck
+- **Files Re-scanned:** [List of modified files]
+- **Target Finding:** `TG-XXX-HASH`
+- **Result:** [FIXED / REGRESSION / PARTIAL]
+- **Regressions Introduced:** 0
+- **Report:** `.torusguard/runs/<run_id>/recheck-report.md`
+- **Status:** VERIFIED — ready for `/torusguard report`
+```
+
+---
+
+## Next Steps
+
+1. Run `/torusguard report` to generate executive summary and export OASIS SARIF v2.1.0 data.
+2. Commit the verified patch to version control.

package/skills/torusguard/payload/workflows/report.md

@@ -0,0 +1,95 @@
+---
+description: Executive posture reporting, cluster analysis, signed compliance audit, and OASIS SARIF v2.1.0 structured export.
+tools: Read, Grep, Glob, Bash, Write
+version: 0.9.2
+agent: reviewer
+lifecycle-phase: Phase 7 (Reporting & SARIF Export)
+required-skills:
+  - torusguard-report
+scripts-binding:
+  - .torusguard/scripts/sarif_exporter.py
+  - .torusguard/scripts/run_manager.py
+---
+
+# /torusguard report — Unified Security Posture Report & SARIF Export
+
+$ARGUMENTS
+
+---
+
+## Objective
+Executive posture reporting, cluster analysis, signed compliance audit, and SARIF v2.1.0 export.
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect run records and reporting parameters before generating release artifacts:
+1. **Active Run Records:** Ensure target run folder contains `findings.json` or `findings.md`.
+2. **SARIF v2.1.0 Schema:** Validate output structure against official OASIS SARIF standard.
+3. **Multi-Analysis Category:** Tag static findings under category `torusguard/static` to prevent CI collision.
+4. **Secret Masking:** Ensure zero unredacted authorization tokens or API keys appear in report.
+5. **Role Boundary:** Enforce reviewer agent sign-off before archiving run results.
+
+---
+
+## When to Use /torusguard report
+
+| Trigger Scenario | Recommended Action |
+| :--- | :--- |
+| Concluding a security review cycle or audit milestone | Run `/torusguard report` |
+| Exporting SARIF v2.1.0 logs for GitHub Code Scanning | Run `/torusguard report` |
+| Sharing executive posture summaries with stakeholders | Run `/torusguard report` |
+| Applying code modifications | Run `/torusguard apply` |
+| Re-checking modified files | Run `/torusguard recheck` |
+
+---
+
+## Execution Steps
+
+1. **Aggregate Lifecycle Data:** Load all finding cards, verification traces, and recheck logs.
+2. **Export OASIS SARIF v2.1.0:**
+   ```bash
+   python .torusguard/scripts/sarif_exporter.py --run <run_dir> --output <run_dir>/results.sarif
+   ```
+3. **Compile Executive Markdown Report:** Generate `report.md` with executive summary, posture score, and metrics.
+4. **Sign Off Run Manifest:** Update `.torusguard/runs/<run_id>/manifest.json` with final status counts.
+5. **Archive Results:** Confirm artifacts (`report.md`, `results.sarif`, `summary.md`) are saved on disk.
+
+---
+
+## Failure Recovery
+
+- **SARIF Schema Error:** Re-run `sarif_exporter.py` with schema validation flag to locate invalid properties.
+- **Empty Findings List:** Emit valid clean report indicating zero security vulnerabilities detected.
+- **Missing Run Folder:** Point script to latest valid timestamped run in `.torusguard/runs/`.
+- **Halt Trigger:** Abort if unredacted private secrets are detected in output text.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never invent vulnerability counts not backed by actual findings in the run ledger.
+- ❌ Never generate invalid SARIF JSON with missing physical location URIs.
+- ✅ Always export standard-compliant SARIF v2.1.0 with AST line fingerprints.
+
+---
+
+## Output Card Format
+
+```markdown
+### 📊 TorusGuard Security Posture Report
+- **Run ID:** `run-YYYYMMDD-HHMMSS`
+- **Total Findings:** [Count] ([Fixed] Fixed, [Open] Open)
+- **Security Posture Score:** [Score]/100
+- **SARIF v2.1.0 Export:** `.torusguard/runs/<run_id>/results.sarif`
+- **Executive Report:** `.torusguard/runs/<run_id>/report.md`
+- **Status:** COMPLETE — report published
+```
+
+---
+
+## Next Steps
+
+1. Upload `results.sarif` to GitHub Code Scanning via `.github/workflows/`.
+2. Share `report.md` with engineering stakeholders and project maintainers.

package/skills/torusguard/payload/workflows/status.md

@@ -0,0 +1,95 @@
+---
+description: Read-only diagnostic overview of workspace security posture, active configuration, rules catalog, and run history.
+tools: Read, Grep, Glob, Bash
+version: 0.9.2
+agent: reviewer
+lifecycle-phase: System / Diagnostics
+required-skills:
+  - torusguard-status
+scripts-binding:
+  - .torusguard/scripts/run_manager.py
+---
+
+# /torusguard status — Workspace Security Posture & Diagnostic Overview
+
+$ARGUMENTS
+
+---
+
+## Objective
+Read-only diagnostic overview of workspace security posture, active configuration, and run history.
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect workspace state and configuration records prior to status display:
+1. **Config State (`.torusguard/config/torusguard.json`):** Confirm workspace initialization and read detected stack.
+2. **Active Rules Directory (`.torusguard/rules/active/`):** Count active rule files.
+3. **Run Folder Ledger (`.torusguard/runs/`):** Check run history and locate latest `manifest.json`.
+4. **Scope Record (`.torusguard/config/scope.json`):** Check whether runtime authorization TTL is active or expired.
+5. **Read-Only Invariant:** Ensure command performs zero file modifications or disk mutations.
+
+---
+
+## When to Use /torusguard status
+
+| Trigger Scenario | Recommended Action |
+| :--- | :--- |
+| Checking workspace configuration and active security posture | Run `/torusguard status` |
+| Reviewing recent audit runs and finding counts | Run `/torusguard status` |
+| Checking active legal scope authorization TTL | Run `/torusguard status` |
+| Initializing workspace for the first time | Run `/torusguard init` |
+| Executing full security scan | Run `/torusguard audit` |
+
+---
+
+## Execution Steps
+
+1. **Read Configuration:** Load `.torusguard/config/torusguard.json`; extract stack, version, and enabled rule count.
+2. **Enumerate Active Rules:** Count rule files physically present in `.torusguard/rules/active/`.
+3. **Inspect Run History:**
+   ```bash
+   python .torusguard/scripts/run_manager.py list
+   ```
+4. **Evaluate Scope Expiry:** Parse `.torusguard/config/scope.json`; report if TTL is valid or expired.
+5. **Print Status Overview:** Render complete workspace diagnostic overview card.
+
+---
+
+## Failure Recovery
+
+- **Uninitialized Workspace:** If config is missing, prompt user to execute `/torusguard init`.
+- **Zero Runs Found:** Display clean status card noting no historical audit runs exist yet.
+- **Corrupt Config File:** Report parsing error and recommend re-running `/torusguard init`.
+- **Halt Trigger:** Abort command if read access to `.torusguard/` is denied.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never display fabricated finding counts not substantiated by run manifests.
+- ❌ Never execute modifying shell commands or edit source code during status inspection.
+- ✅ Always report factual file counts from `.torusguard/rules/active/` and `.torusguard/runs/`.
+
+---
+
+## Output Card Format
+
+```markdown
+### 🛡️ TorusGuard Workspace Status
+- **Version:** v0.9.2
+- **Framework Detected:** [Stack or None]
+- **Active Rules:** [Count] rules active in `.torusguard/rules/active/`
+- **Total Runs:** [Count] historical runs recorded
+- **Latest Run:** `run-YYYYMMDD-HHMMSS` ([Findings Count] findings)
+- **Scope Status:** [Authorized (TTL Active) / Expired / Unconfigured]
+- **Health Posture:** [GOOD / ACTION NEEDED]
+```
+
+---
+
+## Next Steps
+
+1. Run `/torusguard audit` to scan codebase for security vulnerabilities.
+2. Run `/torusguard authorize` to configure or refresh live target scope.