just-vibe 0.7.0

package/plugins/just-vibe/skills/review/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: review
+description: "Review a change for actionable bugs and regressions Use for evidence-backed findings on a change; security or domain audits inspect a particular risk surface."
+---
+
+# review
+
+Review a change for actionable bugs and regressions
+
+## Choose this workflow
+
+Use for evidence-backed findings on a change; security or domain audits inspect a particular risk surface.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; diff, branch/base, or files and review priorities. Requires the actual comparison target.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Actionable defects introduced by the change; no unsolicited edits or external review submission.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Read the diff and surrounding contracts, trace affected callers, assess severity, and suppress speculative or duplicate findings.
+- Establish the exact diff/base, trace affected callers and identify a concrete triggering input; separate changed-code regressions from pre-existing issues.
+
+## Decision branches
+
+- **When the head changed while reviewing:** Recheck the finding against the new diff before reporting or posting it.
+
+## Deliver and verify
+
+- Prioritized findings with locations, triggering conditions, impact, and verification gaps; explicitly state when none are found.
+- Severity, location, trigger, impact, proposed correction and verification gap per finding.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A demonstrated regression includes a reproducible trigger; a pre-existing unrelated issue is not attributed to the patch.
+
+## Stop and recover
+
+- Missing base revisions block confident change attribution. Do not manufacture findings to fill a template.
+
+## Example requests
+
+- **Normal (inspect):** Review this branch against main for behavioral regressions.
+- **edge (inspect):** Review a PR with unrelated pre-existing warnings and a recently rebased head.
+- **blocked (inspect):** Review supplied diff only; mark missing surrounding source and tests as coverage limits.

package/plugins/just-vibe/skills/scope/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: scope
+description: "Separate the essential release from optional work Use to choose a feasible release boundary under constraints; spec defines behavior within that boundary."
+---
+
+# scope
+
+Separate the essential release from optional work
+
+## Choose this workflow
+
+Use to choose a feasible release boundary under constraints; spec defines behavior within that boundary.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; proposed work, must-have outcomes, deadline/resources, and constraints.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Resolve any task-specific tools, target identity and evidence before dependent actions. No external connection is assumed.
+
+## Scope
+
+Release boundaries and sequencing; no removal of already required behavior without identifying that tradeoff.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Identify user outcomes, map dependencies, distinguish essentials from enhancements, and assess what remains viable under the limits.
+- Trace each proposed cut through a complete user journey and its operational dependencies; preserve the smallest usable outcome.
+
+## Decision branches
+
+- **When the remaining scope still exceeds a hard limit:** Offer concrete tradeoffs in outcome, deadline or resources instead of unsupported estimates.
+
+## Deliver and verify
+
+- Included/excluded work, minimum release criteria, later phases, and consequences of cuts.
+- Included journeys, explicit cuts, dependency consequences and minimum release checks.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Deferred work does not break an included journey; an impossible deadline is exposed with concrete options.
+
+## Stop and recover
+
+- Do not quietly reinterpret a hard requirement as optional. Mark unresolved priority choices and continue dependency analysis.
+
+## Example requests
+
+- **Normal (plan):** Scope a first release of team billing that three people can maintain.
+- **edge (plan):** Reduce a launch scope while preserving signup, purchase and refund recovery.
+- **blocked (inspect):** Scope this feature without effort history; identify estimates requiring a spike.

package/plugins/just-vibe/skills/security/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: security
+description: "Examine concrete security risks in a defined scope Use for a scoped security review; security-* commands investigate one specific attack surface."
+---
+
+# security
+
+Examine concrete security risks in a defined scope
+
+## Choose this workflow
+
+Use for a scoped security review; security-* commands investigate one specific attack surface.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; application boundary, threat concerns, and authorized environment.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Concrete security risks in the specified system; no intrusive remote scanning or automatic remediation.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Identify trust boundaries, follow untrusted input and access checks, use safe evidence, and prioritize exploitable paths over generic advice.
+- Identify entry points, assets and trust boundaries, then trace the complete attacker-controlled path to a sensitive effect and existing controls.
+
+## Decision branches
+
+- **When suspicious code is protected by an earlier verified boundary:** Explain the effective protection and avoid a confirmed-vulnerability label.
+
+## Deliver and verify
+
+- Findings with prerequisites, impact, evidence, and remediation options.
+- Findings with attacker prerequisites, reachable path, evidence, impact and remediation.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A reachable authorization gap is explained; a suspicious function with effective protections is not automatically labeled vulnerable.
+
+## Stop and recover
+
+- Do not expose secrets or user records as proof. Missing environment access narrows confidence and coverage.
+
+## Example requests
+
+- **Normal (inspect):** Audit authorization around invoice exports using source evidence only.
+- **edge (inspect):** Audit an export endpoint with tenant filtering and an alternate download route.
+- **blocked (inspect):** Review source only without probing real accounts or using suspected credentials.

package/plugins/just-vibe/skills/security-authz/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: security-authz
+description: "Test access decisions and cross-user or cross-tenant exposure Use for permission bypass inspection; backend-permissions implements an accepted access matrix."
+---
+
+# security-authz
+
+Test access decisions and cross-user or cross-tenant exposure
+
+## Choose this workflow
+
+Use for permission bypass inspection; backend-permissions implements an accepted access matrix.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Security methods](../../references/packs/security.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; access matrix, endpoints/resources, roles/tenants, and authorized test identities.
+
+defined application boundary, authorized code/environment, relevant trust/access rules, and evidence sources. Default to defensive inspection; active tests use owned or explicitly authorized isolated targets. Minimize sensitive evidence and never print usable credentials.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Authorization bypass, object ownership, privilege escalation, and cross-tenant access.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Trace checks at server/data boundaries, compare alternate endpoints and methods, design negative cases, and execute only permitted isolated probes.
+- Test policy at server/data boundaries across direct IDs, alternate methods, exports and background tasks using synthetic identities and known allowed/denied cases.
+
+## Decision branches
+
+- **When policy itself is unspecified:** Separate demonstrated missing enforcement from an unresolved product permission decision.
+
+## Deliver and verify
+
+- Access findings with safe reproduction and remediation/check proposals.
+- Subject/action/resource cases, enforcement paths and evidence-backed findings.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Direct object references cannot bypass tenant policy; privileged and ordinary roles are tested distinctly.
+
+## Stop and recover
+
+- Do not use unauthorized real accounts or retrieve private records as proof. Missing policy prevents judging ambiguous access as a confirmed vulnerability.
+
+## Example requests
+
+- **Normal (inspect):** Audit direct API access to another organization's records using isolated identities.
+- **edge (inspect):** Audit an endpoint that hides buttons but accepts cross-tenant direct requests.
+- **blocked (inspect):** Review source without real accounts or retrieving private records as proof.

package/plugins/just-vibe/skills/security-config/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: security-config
+description: "Review application, container, and deployment configuration Use for effective security-relevant settings; vercel-audit is a deployment-specific configuration comparison."
+---
+
+# security-config
+
+Review application, container, and deployment configuration
+
+## Choose this workflow
+
+Use for effective security-relevant settings; vercel-audit is a deployment-specific configuration comparison.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Security methods](../../references/packs/security.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; app/container/deployment configuration and exact environment.
+
+defined application boundary, authorized code/environment, relevant trust/access rules, and evidence sources. Default to defensive inspection; active tests use owned or explicitly authorized isolated targets. Minimize sensitive evidence and never print usable credentials.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Debug settings, permissions, network exposure, cookies/headers, transport assumptions, and default credentials.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Compare effective configuration with intended boundaries, distinguish dev from production requirements, trace high-impact settings, and verify available deployment evidence.
+- Compare declared and effective settings for the exact environment, inspect trust boundaries and distinguish local development exceptions from public production exposure.
+
+## Decision branches
+
+- **When effective deployment configuration is unavailable:** Report source-established risks conditionally instead of asserting the live setting.
+
+## Deliver and verify
+
+- Configuration findings with target-specific fixes and validation steps.
+- Setting/environment/evidence/impact table and focused remediation.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Public debug exposure is identified; intentionally local development settings are not mislabeled as production incidents.
+
+## Stop and recover
+
+- No infrastructure edits or broad hardening that breaks required behavior. Unknown effective settings remain unknown.
+
+## Example requests
+
+- **Normal (inspect):** Audit production configuration without changing infrastructure settings.
+- **edge (inspect):** Review debug exposure and cross-origin settings in separate dev and production configurations.
+- **blocked (inspect):** Audit configuration files without infrastructure access or changing live settings.

package/plugins/just-vibe/skills/security-dependencies/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: security-dependencies
+description: "Assess findings against actual application exposure Use for advisory-driven dependency risk; deps covers general maintenance and compatibility."
+---
+
+# security-dependencies
+
+Assess findings against actual application exposure
+
+## Choose this workflow
+
+Use for advisory-driven dependency risk; deps covers general maintenance and compatibility.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Security methods](../../references/packs/security.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; manifests/lockfiles, advisory evidence, deployment use, and update constraints.
+
+defined application boundary, authorized code/environment, relevant trust/access rules, and evidence sources. Default to defensive inspection; active tests use owned or explicitly authorized isolated targets. Minimize sensitive evidence and never print usable credentials.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Dependency vulnerability relevance and remediation feasibility.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Verify resolved versions against current authoritative advisories, inspect reachable use/configuration, distinguish runtime/dev exposure, and recommend compatible updates or mitigations.
+- Match advisories to resolved versions and configurations, trace deployed/reachable usage and distinguish development-only tooling from production exposure.
+
+## Decision branches
+
+- **When a fix requires a breaking upgrade:** Compare supported mitigation and migration paths; do not suppress the advisory or force unrelated upgrades.
+
+## Deliver and verify
+
+- Prioritized findings with advisory references, exposure rationale, and remediation checks.
+- Advisory/version/reachability matrix and tested remediation options.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A transitive runtime exposure is traced; an advisory mismatch or mitigated precondition is explained accurately.
+
+## Stop and recover
+
+- No forced major upgrades or automatic suppression. Missing advisory access means unknown coverage, not a clean security bill.
+
+## Example requests
+
+- **Normal (inspect):** Assess advisories against resolved versions and reachable runtime use.
+- **edge (inspect):** Assess a transitive vulnerability behind an unused optional feature.
+- **blocked (inspect):** Inspect the lockfile without current advisory access; report unknown coverage.

package/plugins/just-vibe/skills/security-fix/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: security-fix
+description: "Implement and verify remediation for an identified vulnerability Use to repair a confirmed scoped vulnerability; security produces findings before remediation."
+---
+
+# security-fix
+
+Implement and verify remediation for an identified vulnerability
+
+## Choose this workflow
+
+Use to repair a confirmed scoped vulnerability; security produces findings before remediation.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Security methods](../../references/packs/security.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply; confirmed vulnerability, affected versions/paths, desired compatibility, and safe reproduction.
+
+defined application boundary, authorized code/environment, relevant trust/access rules, and evidence sources. Default to defensive inspection; active tests use owned or explicitly authorized isolated targets. Minimize sensitive evidence and never print usable credentials.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Remediation of the identified weakness and necessary regression coverage.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Verify the vulnerable path, implement the control at the correct boundary, test abuse and legitimate behavior, inspect alternate paths, and document remaining operational work.
+- Reproduce the affected path in a safe fixture, enforce the control at the owning boundary and test legitimate behavior plus alternate bypass routes.
+
+## Decision branches
+
+- **When a code fix leaves historical credential exposure or persisted bad data:** Report the remaining rotation/recovery work separately from the repaired path.
+
+## Deliver and verify
+
+- Patch, safe proof of remediation, tests, and residual exposure notes.
+- Vulnerable trigger, boundary correction, abuse/legitimate checks and residual operational tasks.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- The original attack path no longer works; valid authorized behavior remains functional.
+
+## Stop and recover
+
+- Credential rotation, history rewriting, production changes, and public disclosure require their explicit scope. Do not claim historical exposure was erased by a code fix.
+
+## Example requests
+
+- **Normal (apply):** Fix the demonstrated authorization bypass and verify legitimate owner access.
+- **edge (apply):** Fix an object-ownership bypass without preventing legitimate shared access.
+- **blocked (inspect):** Plan remediation with no safe reproduction environment; do not claim exploitation was eliminated.

package/plugins/just-vibe/skills/security-inputs/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: security-inputs
+description: "Audit validation and injection risks at input boundaries Use for injection and unsafe interpreter boundaries; llm-injection handles model instruction confusion."
+---
+
+# security-inputs
+
+Audit validation and injection risks at input boundaries
+
+## Choose this workflow
+
+Use for injection and unsafe interpreter boundaries; llm-injection handles model instruction confusion.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Security methods](../../references/packs/security.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; entry points, input formats, interpreters/sinks, and relevant source.
+
+defined application boundary, authorized code/environment, relevant trust/access rules, and evidence sources. Default to defensive inspection; active tests use owned or explicitly authorized isolated targets. Minimize sensitive evidence and never print usable credentials.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Injection, unsafe parsing, traversal, and validation gaps along reachable paths.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Trace untrusted values through transformations to sensitive sinks, assess contextual escaping/parameterization, distinguish validation from authorization, and propose safe regression cases.
+- Trace source, transformations, validation and final sink; assess parameterization or contextual encoding at the actual interpreter boundary.
+
+## Decision branches
+
+- **When the input reaches a safe parameterized sink:** Do not flag injection solely because the input is user controlled; inspect other reachable sinks separately.
+
+## Deliver and verify
+
+- Evidence-backed findings or justified protections with focused remediation.
+- Source-to-sink path, required conditions and safe regression fixture.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A concatenated query path is assessed end to end; safe parameterization is not flagged solely due to user input presence.
+
+## Stop and recover
+
+- No destructive payloads or third-party probing. Unsupported exploitability remains a risk hypothesis rather than a confirmed breach.
+
+## Example requests
+
+- **Normal (inspect):** Trace untrusted filters to SQL and template sinks without active remote probing.
+- **edge (inspect):** Review SQL and template paths where only one uses unsafe concatenation.
+- **blocked (inspect):** Inspect source without sending destructive payloads or probing third parties.

package/plugins/just-vibe/skills/security-secrets/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: security-secrets
+description: "Locate exposed credentials without printing secret values Use to locate possible exposed credentials; security-config inspects deployment settings."
+---
+
+# security-secrets
+
+Locate exposed credentials without printing secret values
+
+## Choose this workflow
+
+Use to locate possible exposed credentials; security-config inspects deployment settings.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Security methods](../../references/packs/security.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; repository/history/log scope and approved scanner capability.
+
+defined application boundary, authorized code/environment, relevant trust/access rules, and evidence sources. Default to defensive inspection; active tests use owned or explicitly authorized isolated targets. Minimize sensitive evidence and never print usable credentials.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Locate likely exposed secrets and identify containment needs; no implicit credential rotation or history rewrite.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Scan the specified sources with redacted output, distinguish placeholders from plausible secrets, map exposure surfaces, and propose owner/provider-specific remediation.
+- Run approved scanners with redacted output over the requested scope, classify placeholders and locate exposure surfaces without copying values into reports.
+
+## Decision branches
+
+- **When a plausible credential is found:** Record location/type and rotation owner/provider steps; do not test it against a live service by default.
+
+## Deliver and verify
+
+- Redacted locations/types, confidence, exposure context, and containment plan.
+- Redacted findings, exposure scope, uncertainty and remediation sequence.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A committed credential is reported without its value; test placeholders do not inflate findings blindly.
+
+## Stop and recover
+
+- Never test suspected credentials against live providers without authorization. Do not copy secrets into reports, shell history, or external scanners.
+
+## Example requests
+
+- **Normal (inspect):** Scan the requested repository scope with redacted findings only.
+- **edge (inspect):** Scan history containing both test placeholders and a plausible credential.
+- **blocked (inspect):** Assess secret handling without an approved scanner; do not upload the repository.

package/plugins/just-vibe/skills/security-threat-model/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: security-threat-model
+description: "Identify assets, trust boundaries, attack paths, and mitigations Use for systematic threats to a scoped system; security-authz or security-inputs investigates a concrete path."
+---
+
+# security-threat-model
+
+Identify assets, trust boundaries, attack paths, and mitigations
+
+## Choose this workflow
+
+Use for systematic threats to a scoped system; security-authz or security-inputs investigates a concrete path.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Security methods](../../references/packs/security.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; system architecture, assets, actors, trust boundaries, and critical outcomes.
+
+defined application boundary, authorized code/environment, relevant trust/access rules, and evidence sources. Default to defensive inspection; active tests use owned or explicitly authorized isolated targets. Minimize sensitive evidence and never print usable credentials.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Plausible attack paths and proportionate mitigations for this system.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Trace data and privilege boundaries, identify entry points, model misuse scenarios, assess existing controls, and prioritize gaps by realistic impact/exposure.
+- Enumerate assets, actors, entry points and trust transitions, then connect realistic misuse chains to existing controls and observable impact.
+
+## Decision branches
+
+- **When a threat depends on an unverified deployment assumption:** State the condition and required evidence instead of declaring an incident or guaranteed exploit.
+
+## Deliver and verify
+
+- Threat model, assumptions, prioritized mitigations, and verification scenarios.
+- Boundary diagram, threat/control/gap matrix and prioritized validation.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A sensitive export path has explicit access/data-handling controls; mitigations map to concrete threats rather than generic checklists.
+
+## Stop and recover
+
+- Do not claim all threats are covered or infer deployment controls without evidence. Unknown architecture remains a documented gap.
+
+## Example requests
+
+- **Normal (plan):** Model threats around invoice exports and background processing.
+- **edge (plan):** Threat-model a tenant export service with signed download links.
+- **blocked (inspect):** Model threats from partial architecture without probing live systems.

package/plugins/just-vibe/skills/security-uploads/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: security-uploads
+description: "Review file validation, storage, processing, and download access Use for file receipt, processing and download safety; backend-permissions handles general resource access."
+---
+
+# security-uploads
+
+Review file validation, storage, processing, and download access
+
+## Choose this workflow
+
+Use for file receipt, processing and download safety; backend-permissions handles general resource access.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Security methods](../../references/packs/security.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; upload/download/processing paths, storage policy, file types, and access rules.
+
+defined application boundary, authorized code/environment, relevant trust/access rules, and evidence sources. Default to defensive inspection; active tests use owned or explicitly authorized isolated targets. Minimize sensitive evidence and never print usable credentials.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+File validation, size limits, names/paths, processing isolation, storage exposure, and download authorization.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Trace file lifecycle, inspect content/type trust, object ownership, parser behavior, and resource limits; define safe malicious/invalid-file fixtures.
+- Follow filename/content/type trust, storage ownership, parser invocation, resource limits and download authorization across the complete file lifecycle.
+
+## Decision branches
+
+- **When scanning occurs asynchronously after upload:** Define quarantine/access state so unverified files cannot be consumed through another route.
+
+## Deliver and verify
+
+- Upload threat findings, remediation priorities, and isolated test scenarios.
+- Lifecycle/trust map and path, size, type, processing and access test cases.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- User-supplied filenames cannot escape storage boundaries; private files require authorization at download as well as upload.
+
+## Stop and recover
+
+- Do not execute hostile files or upload dangerous content to public services. Missing processor configuration limits assurance.
+
+## Example requests
+
+- **Normal (inspect):** Audit file validation, processing, private storage, and download access.
+- **edge (inspect):** Audit private uploads with user filenames and an asynchronous processor.
+- **blocked (inspect):** Review upload source without executing hostile files or publishing dangerous test content.