torusguard 0.9.2

package/.torusguard/workflows/apply.md

@@ -0,0 +1,95 @@
+---
+description: Governed patch application with pre-apply rollback snapshots and Human Gate authorization.
+tools: Read, Grep, Glob, Bash, Edit, Write
+version: 0.9.2
+agent: remediator
+lifecycle-phase: Phase 5 (Patch Application)
+required-skills:
+  - torusguard-apply
+scripts-binding:
+  - .torusguard/scripts/run_manager.py
+  - .torusguard/scripts/diff_guard.py
+---
+
+# /torusguard apply — Governed Patch Application & Rollback Snapshot
+
+$ARGUMENTS
+
+---
+
+## Objective
+Governed patch application with pre-apply rollback snapshots and Human Gate authorization.
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect bundle validity and file safety before modifying disk code:
+1. **Bundle Verification:** Assert `patch.diff` exists in active run's remediation folder.
+2. **Pre-Apply Snapshot:** Save a byte-for-byte backup copy (`.bak` or `pre_apply/`) prior to editing.
+3. **Uncommitted Changes:** Check git status; ensure target file has clean baseline.
+4. **Ponytail Check:** Re-verify that patch additions $\le 35$ and deletions $\le 25$.
+5. **Human Gate:** Confirm operator approval before committing edits to disk.
+6. **Workspace Cleanliness:** Verify git working tree has no uncommitted merge conflicts.
+7. **Execution Privilege:** Verify write access to targeted file locations.
+
+---
+
+## When to Use /torusguard apply
+
+| Trigger Scenario | Recommended Action |
+| :--- | :--- |
+| Applying an approved remediation patch to disk | Run `/torusguard apply` |
+| Generating patch diff without modifying disk | Run `/torusguard harden` |
+| Verifying that patch eliminated flaw without regression | Run `/torusguard recheck` |
+| Reverting an applied patch | Restore from `.bak` snapshot |
+| Checking workspace status | Run `/torusguard status` |
+
+---
+
+## Execution Steps
+
+1. **Load Remediation Bundle:** Read `patch.diff` and metadata from active run directory.
+2. **Audit Patch Invariants:** Run `python .torusguard/scripts/diff_guard.py <patch.diff>`.
+3. **Create Rollback Backup:** Copy target file to `.torusguard/runs/<run_id>/pre_apply/<filename>.bak`.
+4. **Apply Minimal Diff:** Execute precise surgical edit using `replace_file_content` or `patch`.
+5. **Assert Syntax & Integrity:** Check that modified file compiles cleanly without syntax errors.
+6. **Log Application Ledger:** Record timestamp, original SHA-256, and patched SHA-256 in `apply-log.json`.
+
+---
+
+## Failure Recovery
+
+- **Syntax Error After Patch:** Instantly revert target file from `.bak` backup snapshot.
+- **Merge / Context Conflict:** Re-run `/torusguard harden` to regenerate diff against latest disk lines.
+- **Missing Backup File:** Do not apply patch if backup copy cannot be written.
+- **Halt Trigger:** Abort if git working tree is dirty on conflicting lines.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never apply code changes without creating an exact pre-apply rollback backup first.
+- ❌ Never touch files not explicitly listed in the approved `patch.diff`.
+- ✅ Always verify syntax compilation immediately after modifying source files.
+
+---
+
+## Output Card Format
+
+```markdown
+### 🚀 TorusGuard Patch Application
+- **Finding Addressed:** `TG-XXX-HASH`
+- **File Patched:** `src/path/to/file.py`
+- **Rollback Backup:** `.torusguard/runs/<run_id>/pre_apply/<file>.bak`
+- **Churn Applied:** +[Additions] / -[Deletions] lines
+- **Syntax Check:** PASSED (clean compile)
+- **Status:** APPLIED — run `/torusguard recheck` to verify fix
+```
+
+---
+
+## Next Steps
+
+1. Run `/torusguard recheck` to perform differential audit on the modified file.
+2. Run test suites to verify that business logic and regressions remain intact.

package/.torusguard/workflows/audit.md

@@ -0,0 +1,93 @@
+---
+description: Static security AST scanning, stable line-shift invariant fingerprinting, root-cause clustering, and 0-100 confidence scoring.
+tools: Read, Grep, Glob, Bash, Write
+version: 0.9.2
+agent: auditor
+lifecycle-phase: Phase 2 (Static Audit & Clustering)
+required-skills:
+  - torusguard-audit
+scripts-binding:
+  - .torusguard/scripts/run_manager.py
+  - .torusguard/scripts/finding_scorer.py
+---
+
+# /torusguard audit — Static Security Code Scan & Clustering
+
+$ARGUMENTS
+
+---
+
+## Objective
+Static security AST scanning, stable fingerprinting, root-cause clustering, and 0-100 scoring.
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect workspace prerequisites before launching static audit:
+1. **Init State (`torusguard.json`):** Assert repository is initialized.
+2. **Active Rules (`rules/active/`):** Confirm rule definitions exist.
+3. **Exclusions:** Assert `node_modules/`, `.venv/`, `dist/`, `.git/` are skipped.
+4. **Run Folder:** Allocate isolated folder in `.torusguard/runs/`.
+5. **Syntax Check:** Check for syntax errors before parsing ASTs.
+
+---
+
+## When to Use /torusguard audit
+
+| Trigger Scenario | Recommended Action |
+| :--- | :--- |
+| First-time scan of repository or new branch | Run `/torusguard audit` |
+| Pre-commit review and PR security checks | Run `/torusguard audit` |
+| Uninitialized project | Run `/torusguard init` first |
+| Live endpoint or runtime probing | Run `/torusguard web-validate` |
+| Differential check after patch | Run `/torusguard recheck` |
+
+---
+
+## Execution Steps
+
+1. **Allocate Run Folder:** Run `python .torusguard/scripts/run_manager.py create audit`.
+2. **Scan Codebase ASTs:** Match active rules against source trees.
+3. **Compute Stable Fingerprints:** Hash AST context to produce stable IDs.
+4. **Cluster Root Causes:** Group findings sharing identical sinks.
+5. **Score Confidence (0–100):** Run `python .torusguard/scripts/finding_scorer.py --run <run_dir>`.
+6. **Emit Artifacts:** Write `findings.md`, `findings.json`, and `summary.md`.
+
+---
+
+## Failure Recovery
+
+- **Zero Rules Active:** Re-run `/torusguard init` to activate rules.
+- **AST Parse Error:** Log syntax error on malformed file, skip, and continue.
+- **Scorer Failure:** Ensure Python 3.10+; verify finding JSON structure.
+- **Halt Trigger:** Abort if run folder cannot be allocated or disk write fails.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never invent finding IDs without AST line hashing.
+- ❌ Never flag test fixtures as critical security flaws.
+- ✅ Always calculate scores using `.torusguard/scripts/finding_scorer.py`.
+
+---
+
+## Output Card Format
+
+```markdown
+### 🔎 TorusGuard Static Audit Results
+- **Run ID:** `run-YYYYMMDD-HHMMSS-audit`
+- **Files Scanned:** [Count] source files
+- **Total Findings:** [Count] ([Critical] Critical, [High] High)
+- **Root Cause Clusters:** [Count] architectural issues
+- **Confidence:** [Score]/100
+- **Artifact:** `.torusguard/runs/<run_id>/findings.md`
+```
+
+---
+
+## Next Steps
+
+1. Run `/torusguard verify` to validate exploitability and review evidence.
+2. Run `/torusguard harden` to generate minimal surgical remediation plans.

package/.torusguard/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/.torusguard/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/.torusguard/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/.torusguard/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/.torusguard/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.